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