Add FakeClipboard implementation for unit tests.

ui/base/test/fake_clipboard.cc

Index: ui/base/test/fake_clipboard.cc
diff --git a/ui/base/test/fake_clipboard.cc b/ui/base/test/fake_clipboard.cc
new file mode 100644
index 0000000000000000000000000000000000000000..99b92500489f7e5d005fc0fc711d30aec046d406
--- /dev/null
+++ b/ui/base/test/fake_clipboard.cc
@@ -0,0 +1,194 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/base/test/fake_clipboard.h"
+
+#include <stddef.h>
+#include "base/strings/utf_string_conversions.h"
+
+namespace ui {
+
+void Clipboard::UseFakeForCurrentThreadForTest() {
+  base::AutoLock lock(clipboard_map_lock_.Get());
+  clipboard_map_.Get()[base::PlatformThread::CurrentId()] = new FakeClipboard;
+}
+
+FakeClipboard::FakeClipboard()
+    : default_store_type_(CLIPBOARD_TYPE_COPY_PASTE) {
+}
+
+FakeClipboard::~FakeClipboard() {
+}
+
+uint64 FakeClipboard::GetSequenceNumber(ClipboardType type) const {
+  return GetStore(type).sequence_number;
+}
+
+bool FakeClipboard::IsFormatAvailable(const FormatType& format,
+                                      ClipboardType type) const {
+  const DataStore& store = GetStore(type);
+  return store.data.find(format) != store.data.end();
+}
+
+void FakeClipboard::Clear(ClipboardType type) {
+  GetStore(type).Clear();
+}
+
+void FakeClipboard::ReadAvailableTypes(ClipboardType type,
+                                       std::vector<base::string16>* types,
+                                       bool* contains_filenames) const {
+}
+
+void FakeClipboard::ReadText(ClipboardType type, base::string16* result) const {
+  std::string result8;
+  ReadAsciiText(type, &result8);
+  *result = base::UTF8ToUTF16(result8);
+}
+
+void FakeClipboard::ReadAsciiText(ClipboardType type,
+                                  std::string* result) const {
+  result->clear();
+  const DataStore& store = GetStore(type);
+  auto it = store.data.find(GetPlainTextFormatType());
+  if (it != store.data.end())
+    *result = it->second;
+}
+
+void FakeClipboard::ReadHTML(ClipboardType type,
+                             base::string16* markup,
+                             std::string* src_url,
+                             uint32* fragment_start,
+                             uint32* fragment_end) const {
+  markup->clear();
+  src_url->clear();
+  const DataStore& store = GetStore(type);
+  auto it = store.data.find(GetHtmlFormatType());
+  if (it != store.data.end())
+    *markup = base::UTF8ToUTF16(it->second);
+  *fragment_start = 0;
+  *fragment_end = markup->size();
+}
+
+void FakeClipboard::ReadRTF(ClipboardType type, std::string* result) const {
+  result->clear();
+  const DataStore& store = GetStore(type);
+  auto it = store.data.find(GetRtfFormatType());
+  if (it != store.data.end())
+    *result = it->second;
+}
+
+SkBitmap FakeClipboard::ReadImage(ClipboardType type) const {
+  return GetStore(type).image;
+}
+
+void FakeClipboard::ReadCustomData(ClipboardType clipboard_type,
+                                   const base::string16& type,
+                                   base::string16* result) const {
+}
+
+void FakeClipboard::ReadBookmark(base::string16* title,
+                                 std::string* url) const {
+  const DataStore& store = GetDefaultStore();
+  auto it = store.data.find(GetUrlWFormatType());
+  if (it != store.data.end())
+    *url = it->second;
+  *title = base::UTF8ToUTF16(store.url_title);
+}
+
+void FakeClipboard::ReadData(const FormatType& format,
+                             std::string* result) const {
+  result->clear();
+  const DataStore& store = GetDefaultStore();
+  auto it = store.data.find(format);
+  if (it != store.data.end())
+    *result = it->second;
+}
+
+void FakeClipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
+  Clear(type);
+  default_store_type_ = type;
+  for (const auto& kv : objects)
+    DispatchObject(static_cast<ObjectType>(kv.first), kv.second);
+  default_store_type_ = CLIPBOARD_TYPE_COPY_PASTE;
+}
+
+void FakeClipboard::WriteText(const char* text_data, size_t text_len) {
+  std::string text(text_data, text_len);
+  GetDefaultStore().data[GetPlainTextFormatType()] = text;
+  if (IsSupportedClipboardType(CLIPBOARD_TYPE_SELECTION))
+    GetStore(CLIPBOARD_TYPE_SELECTION).data[GetPlainTextFormatType()] = text;
+}
+
+void FakeClipboard::WriteHTML(const char* markup_data,
+                              size_t markup_len,
+                              const char* url_data,
+                              size_t url_len) {
+  base::string16 markup;
+  base::UTF8ToUTF16(markup_data, markup_len, &markup);
+  GetDefaultStore().data[GetHtmlFormatType()] = base::UTF16ToUTF8(markup);
+}
+
+void FakeClipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+  GetDefaultStore().data[GetRtfFormatType()] = std::string(rtf_data, data_len);
+}
+
+void FakeClipboard::WriteBookmark(const char* title_data,
+                                  size_t title_len,
+                                  const char* url_data,
+                                  size_t url_len) {
+  GetDefaultStore().data[GetUrlWFormatType()] = std::string(url_data, url_len);
+  GetDefaultStore().url_title = std::string(title_data, title_len);
+}
+
+void FakeClipboard::WriteWebSmartPaste() {
+  // Create a dummy entry.
+  GetDefaultStore().data[GetWebKitSmartPasteFormatType()];
+}
+
+void FakeClipboard::WriteBitmap(const SkBitmap& bitmap) {
+  // Create a dummy entry.
+  GetDefaultStore().data[GetBitmapFormatType()];
+  bitmap.copyTo(&GetDefaultStore().image);
+}
+
+void FakeClipboard::WriteData(const FormatType& format,
+                              const char* data_data,
+                              size_t data_len) {
+  GetDefaultStore().data[format] = std::string(data_data, data_len);
+}
+
+FakeClipboard::DataStore::DataStore() : sequence_number(0) {
+}
+
+FakeClipboard::DataStore::~DataStore() {
+}
+
+void FakeClipboard::DataStore::Clear() {
+  data.clear();
+  url_title.clear();
+  image = SkBitmap();
+}
+
+const FakeClipboard::DataStore& FakeClipboard::GetStore(
+    ClipboardType type) const {
+  CHECK(IsSupportedClipboardType(type));
+  return stores_[type];
+}
+
+FakeClipboard::DataStore& FakeClipboard::GetStore(ClipboardType type) {
+  CHECK(IsSupportedClipboardType(type));
+  DataStore& store = stores_[type];
+  ++store.sequence_number;
+  return store;
+}
+
+const FakeClipboard::DataStore& FakeClipboard::GetDefaultStore() const {
+  return GetStore(default_store_type_);
+}
+
+FakeClipboard::DataStore& FakeClipboard::GetDefaultStore() {
+  return GetStore(default_store_type_);
+}
+
+}  // namespace ui