content/test/mock_webclipboard_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/test/mock_webclipboard_impl.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/stl_util.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "content/renderer/clipboard_utils.h"
  13 #include "third_party/WebKit/public/platform/WebCommon.h"
  14 #include "third_party/WebKit/public/platform/WebDragData.h"
  15 #include "third_party/WebKit/public/platform/WebImage.h"
  16 #include "third_party/WebKit/public/platform/WebURL.h"
  17 #include "ui/base/clipboard/clipboard.h"
  18 #include "ui/gfx/codec/png_codec.h"
  19 #include "ui/gfx/geometry/size.h"
  20
  21 using blink::WebDragData;
  22 using blink::WebString;
  23 using blink::WebURL;
  24 using blink::WebVector;
  25
  26 namespace content {
  27
  28 MockWebClipboardImpl::MockWebClipboardImpl()
  29   : m_sequenceNumber(0),
  30     m_writeSmartPaste(false) {}
  31
  32 MockWebClipboardImpl::~MockWebClipboardImpl() {}
  33
  34 uint64_t MockWebClipboardImpl::sequenceNumber(Buffer) {
  35   return m_sequenceNumber;
  36 }
  37
  38 bool MockWebClipboardImpl::isFormatAvailable(Format format, Buffer buffer) {
  39   switch (format) {
  40     case FormatPlainText:
  41       return !m_plainText.is_null();
  42
  43     case FormatHTML:
  44       return !m_htmlText.is_null();
  45
  46     case FormatSmartPaste:
  47       return m_writeSmartPaste;
  48
  49     default:
  50       NOTREACHED();
  51       return false;
  52   }
  53 }
  54
  55 WebVector<WebString> MockWebClipboardImpl::readAvailableTypes(
  56     Buffer buffer,
  57     bool* containsFilenames) {
  58   *containsFilenames = false;
  59   std::vector<WebString> results;
  60   if (!m_plainText.string().empty()) {
  61     results.push_back(WebString("text/plain"));
  62   }
  63   if (!m_htmlText.string().empty()) {
  64     results.push_back(WebString("text/html"));
  65   }
  66   if (!m_image.isNull()) {
  67     results.push_back(WebString("image/png"));
  68   }
  69   for (std::map<base::string16, base::string16>::const_iterator it =
  70            m_customData.begin();
  71        it != m_customData.end(); ++it) {
  72     CHECK(std::find(results.begin(), results.end(), it->first) ==
  73           results.end());
  74     results.push_back(it->first);
  75   }
  76   return results;
  77 }
  78
  79 blink::WebString MockWebClipboardImpl::readPlainText(
  80     blink::WebClipboard::Buffer buffer) {
  81   return m_plainText;
  82 }
  83
  84 // TODO(wtc): set output argument *url.
  85 blink::WebString MockWebClipboardImpl::readHTML(
  86     blink::WebClipboard::Buffer buffer,
  87     blink::WebURL* url,
  88     unsigned* fragmentStart,
  89     unsigned* fragmentEnd) {
  90   *fragmentStart = 0;
  91   *fragmentEnd = static_cast<unsigned>(m_htmlText.string().length());
  92   return m_htmlText;
  93 }
  94
  95 blink::WebData MockWebClipboardImpl::readImage(
  96     blink::WebClipboard::Buffer buffer) {
  97   std::string data;
  98   std::vector<unsigned char> encoded_image;
  99   // TODO(dcheng): Verify that we can assume the image is ARGB8888. Note that
 100   // for endianess reasons, it will be BGRA8888 on Windows.
 101   const SkBitmap& bitmap = m_image.getSkBitmap();
 102   SkAutoLockPixels lock(bitmap);
 103   gfx::PNGCodec::Encode(static_cast<unsigned char*>(bitmap.getPixels()),
 104 #if defined(OS_ANDROID)
 105                         gfx::PNGCodec::FORMAT_RGBA,
 106 #else
 107                         gfx::PNGCodec::FORMAT_BGRA,
 108 #endif
 109                         gfx::Size(bitmap.width(), bitmap.height()),
 110                         static_cast<int>(bitmap.rowBytes()),
 111                         false /* discard_transparency */,
 112                         std::vector<gfx::PNGCodec::Comment>(),
 113                         &encoded_image);
 114   data.assign(reinterpret_cast<char*>(vector_as_array(&encoded_image)),
 115               encoded_image.size());
 116   return data;
 117 }
 118
 119 blink::WebString MockWebClipboardImpl::readCustomData(
 120     blink::WebClipboard::Buffer buffer,
 121     const blink::WebString& type) {
 122   std::map<base::string16, base::string16>::const_iterator it =
 123       m_customData.find(type);
 124   if (it != m_customData.end())
 125     return it->second;
 126   return blink::WebString();
 127 }
 128
 129 void MockWebClipboardImpl::writeHTML(const blink::WebString& htmlText,
 130                                      const blink::WebURL& url,
 131                                      const blink::WebString& plainText,
 132                                      bool writeSmartPaste) {
 133   clear();
 134
 135   m_htmlText = htmlText;
 136   m_plainText = plainText;
 137   m_writeSmartPaste = writeSmartPaste;
 138   ++m_sequenceNumber;
 139 }
 140
 141 void MockWebClipboardImpl::writePlainText(const blink::WebString& plain_text) {
 142   clear();
 143
 144   m_plainText = plain_text;
 145   ++m_sequenceNumber;
 146 }
 147
 148 void MockWebClipboardImpl::writeURL(const blink::WebURL& url,
 149                                     const blink::WebString& title) {
 150   clear();
 151
 152   m_htmlText = WebString::fromUTF8(URLToMarkup(url, title));
 153   m_plainText = url.spec().utf16();
 154   ++m_sequenceNumber;
 155 }
 156
 157 void MockWebClipboardImpl::writeImage(const blink::WebImage& image,
 158                                       const blink::WebURL& url,
 159                                       const blink::WebString& title) {
 160   if (!image.isNull()) {
 161     clear();
 162
 163     m_plainText = m_htmlText;
 164     m_htmlText = WebString::fromUTF8(URLToImageMarkup(url, title));
 165     m_image = image;
 166     ++m_sequenceNumber;
 167   }
 168 }
 169
 170 void MockWebClipboardImpl::writeDataObject(const WebDragData& data) {
 171   clear();
 172
 173   const WebVector<WebDragData::Item>& itemList = data.items();
 174   for (size_t i = 0; i < itemList.size(); ++i) {
 175     const WebDragData::Item& item = itemList[i];
 176     switch (item.storageType) {
 177       case WebDragData::Item::StorageTypeString: {
 178         ++m_sequenceNumber;
 179         base::string16 type(item.stringType);
 180         if (base::EqualsASCII(type, ui::Clipboard::kMimeTypeText)) {
 181           m_plainText = item.stringData;
 182           continue;
 183         }
 184         if (base::EqualsASCII(type, ui::Clipboard::kMimeTypeHTML)) {
 185           m_htmlText = item.stringData;
 186           continue;
 187         }
 188         m_customData.insert(std::make_pair(type, item.stringData));
 189         continue;
 190       }
 191       default:
 192         // Currently other types are unused by the clipboard implementation.
 193         NOTREACHED();
 194     }
 195   }
 196 }
 197
 198 void MockWebClipboardImpl::clear() {
 199   m_plainText = base::NullableString16();
 200   m_htmlText = base::NullableString16();
 201   m_image.reset();
 202   m_customData.clear();
 203   m_writeSmartPaste = false;
 204 }
 205
 206 }  // namespace content