Change ui::Clipboard to use virtual methods for testing purposes.

Platform-specific implementations now have their own derived classes.
This allows some cleanup of platform-specific hackery in clipboard.h,
and paves the way for adding a fake clipboard implementation in the
future for testing.

BUG=319285

Review URL: https://codereview.chromium.org/658963003

Cr-Commit-Position: refs/heads/master@{#300063}

ui/base/BUILD.gn

@@ -37,13 +37,15 @@ component("base") {
     "clipboard/clipboard.cc",
     "clipboard/clipboard.h",
     "clipboard/clipboard_android.cc",
-    "clipboard/clipboard_android_initialization.h",
+    "clipboard/clipboard_android.h",
     "clipboard/clipboard_constants.cc",
+    "clipboard/clipboard_mac.h",
     "clipboard/clipboard_mac.mm",
     "clipboard/clipboard_types.h",
     "clipboard/clipboard_util_win.cc",
     "clipboard/clipboard_util_win.h",
     "clipboard/clipboard_win.cc",
+    "clipboard/clipboard_win.h",
     "clipboard/custom_data_helper.cc",
     "clipboard/custom_data_helper.h",
     "clipboard/custom_data_helper_linux.cc",

ui/base/android/ui_base_jni_registrar.cc

@@ -8,7 +8,7 @@
 #include "base/android/jni_registrar.h"
 #include "ui/base/android/view_android.h"
 #include "ui/base/android/window_android.h"
-#include "ui/base/clipboard/clipboard_android_initialization.h"
+#include "ui/base/clipboard/clipboard_android.h"
 #include "ui/base/device_form_factor_android.h"
 #include "ui/base/l10n/l10n_util_android.h"
 #include "ui/base/resource/resource_bundle_android.h"

ui/base/clipboard/clipboard.cc

@@ -88,7 +88,7 @@ Clipboard* Clipboard::GetForCurrentThread() {
   if (it != clipboard_map->end())
     return it->second;
 
-  Clipboard* clipboard = new ui::Clipboard;
+  Clipboard* clipboard = Clipboard::Create();
   clipboard_map->insert(std::make_pair(id, clipboard));
   return clipboard;
 }

ui/base/clipboard/clipboard.h

@@ -11,7 +11,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
@@ -22,15 +21,6 @@
 
 #if defined(OS_WIN)
 #include <objidl.h>
-#elif defined(OS_ANDROID)
-#include <jni.h>
-
-#include "base/android/jni_android.h"
-#include "base/android/scoped_java_ref.h"
-#endif
-
-#if defined(USE_AURA) && defined(USE_X11)
-#include "base/memory/scoped_ptr.h"
 #endif
 
 namespace base {
@@ -88,7 +78,7 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
 
 #if defined(OS_WIN)
     const FORMATETC& ToFormatEtc() const { return data_; }
-#elif defined(USE_AURA)
+#elif defined(USE_AURA) || defined(OS_ANDROID)
     const std::string& ToString() const { return data_; }
 #elif defined(OS_MACOSX)
     NSString* ToNSString() const { return data_; }
@@ -113,19 +103,13 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
 #if defined(OS_WIN)
     explicit FormatType(UINT native_format);
     FormatType(UINT native_format, LONG index);
-    UINT ToUINT() const { return data_.cfFormat; }
     FORMATETC data_;
-#elif defined(USE_AURA)
+#elif defined(USE_AURA) || defined(OS_ANDROID)
     explicit FormatType(const std::string& native_format);
-    const std::string& data() const { return data_; }
     std::string data_;
 #elif defined(OS_MACOSX)
     explicit FormatType(NSString* native_format);
     NSString* data_;
-#elif defined(OS_ANDROID)
-    explicit FormatType(const std::string& native_format);
-    const std::string& data() const { return data_; }
-    std::string data_;
 #else
 #error No FormatType definition.
 #endif
@@ -211,51 +195,53 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
   // Returns a sequence number which uniquely identifies clipboard state.
   // This can be used to version the data on the clipboard and determine
   // whether it has changed.
-  uint64 GetSequenceNumber(ClipboardType type);
+  virtual uint64 GetSequenceNumber(ClipboardType type) = 0;
 
   // Tests whether the clipboard contains a certain format
-  bool IsFormatAvailable(const FormatType& format, ClipboardType type) const;
+  virtual bool IsFormatAvailable(const FormatType& format,
+                                 ClipboardType type) const = 0;
 
   // Clear the clipboard data.
-  void Clear(ClipboardType type);
+  virtual void Clear(ClipboardType type) = 0;
 
-  void ReadAvailableTypes(ClipboardType type,
-                          std::vector<base::string16>* types,
-                          bool* contains_filenames) const;
+  virtual void ReadAvailableTypes(ClipboardType type,
+                                  std::vector<base::string16>* types,
+                                  bool* contains_filenames) const = 0;
 
   // Reads UNICODE text from the clipboard, if available.
-  void ReadText(ClipboardType type, base::string16* result) const;
+  virtual void ReadText(ClipboardType type, base::string16* result) const = 0;
 
   // Reads ASCII text from the clipboard, if available.
-  void ReadAsciiText(ClipboardType type, std::string* result) const;
+  virtual void ReadAsciiText(ClipboardType type, std::string* result) const = 0;
 
   // Reads HTML from the clipboard, if available. If the HTML fragment requires
   // context to parse, |fragment_start| and |fragment_end| are indexes into
   // markup indicating the beginning and end of the actual fragment. Otherwise,
   // they will contain 0 and markup->size().
-  void ReadHTML(ClipboardType type,
-                base::string16* markup,
-                std::string* src_url,
-                uint32* fragment_start,
-                uint32* fragment_end) const;
+  virtual void ReadHTML(ClipboardType type,
+                        base::string16* markup,
+                        std::string* src_url,
+                        uint32* fragment_start,
+                        uint32* fragment_end) const = 0;
 
   // Reads RTF from the clipboard, if available. Stores the result as a byte
   // vector.
-  void ReadRTF(ClipboardType type, std::string* result) const;
+  virtual void ReadRTF(ClipboardType type, std::string* result) const = 0;
 
   // Reads an image from the clipboard, if available.
-  SkBitmap ReadImage(ClipboardType type) const;
+  virtual SkBitmap ReadImage(ClipboardType type) const = 0;
 
-  void ReadCustomData(ClipboardType clipboard_type,
-                      const base::string16& type,
-                      base::string16* result) const;
+  virtual void ReadCustomData(ClipboardType clipboard_type,
+                              const base::string16& type,
+                              base::string16* result) const = 0;
 
   // Reads a bookmark from the clipboard, if available.
-  void ReadBookmark(base::string16* title, std::string* url) const;
+  virtual void ReadBookmark(base::string16* title, std::string* url) const = 0;
 
   // Reads raw data from the clipboard with the given format type. Stores result
   // as a byte vector.
-  void ReadData(const FormatType& format, std::string* result) const;
+  virtual void ReadData(const FormatType& format,
+                        std::string* result) const = 0;
 
   // Gets the FormatType corresponding to an arbitrary format string,
   // registering it with the system if needed. Due to Windows/Linux
@@ -298,73 +284,48 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
   static const FormatType& GetIDListFormatType();
 #endif
 
- private:
-  FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
-  FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
-  friend class ClipboardTest;
-  // For access to WriteObjects().
-  // TODO(dcheng): Remove the temporary exception for content.
-  friend class content::ClipboardMessageFilter;
-  friend class ScopedClipboardWriter;
+ protected:
+  static Clipboard* Create();
 
-  Clipboard();
-  ~Clipboard();
+  Clipboard() {}
+  virtual ~Clipboard() {}
 
   // Write a bunch of objects to the system clipboard. Copies are made of the
   // contents of |objects|.
-  void WriteObjects(ClipboardType type, const ObjectMap& objects);
+  virtual void WriteObjects(ClipboardType type, const ObjectMap& objects) = 0;
 
   void DispatchObject(ObjectType type, const ObjectMapParams& params);
 
-  void WriteText(const char* text_data, size_t text_len);
+  virtual void WriteText(const char* text_data, size_t text_len) = 0;
 
-  void WriteHTML(const char* markup_data,
-                 size_t markup_len,
-                 const char* url_data,
-                 size_t url_len);
+  virtual void WriteHTML(const char* markup_data,
+                         size_t markup_len,
+                         const char* url_data,
+                         size_t url_len) = 0;
 
-  void WriteRTF(const char* rtf_data, size_t data_len);
+  virtual void WriteRTF(const char* rtf_data, size_t data_len) = 0;
 
-  void WriteBookmark(const char* title_data,
-                     size_t title_len,
-                     const char* url_data,
-                     size_t url_len);
+  virtual void WriteBookmark(const char* title_data,
+                             size_t title_len,
+                             const char* url_data,
+                             size_t url_len) = 0;
 
-  void WriteWebSmartPaste();
+  virtual void WriteWebSmartPaste() = 0;
 
-  void WriteBitmap(const SkBitmap& bitmap);
+  virtual void WriteBitmap(const SkBitmap& bitmap) = 0;
 
-  void WriteData(const FormatType& format,
-                 const char* data_data,
-                 size_t data_len);
-#if defined(OS_WIN)
-  void WriteBitmapFromHandle(HBITMAP source_hbitmap,
-                             const gfx::Size& size);
+  virtual void WriteData(const FormatType& format,
+                         const char* data_data,
+                         size_t data_len) = 0;
 
-  // Safely write to system clipboard. Free |handle| on failure.
-  void WriteToClipboard(unsigned int format, HANDLE handle);
-
-  static void ParseBookmarkClipboardFormat(const base::string16& bookmark,
-                                           base::string16* title,
-                                           std::string* url);
-
-  // Free a handle depending on its type (as intuited from format)
-  static void FreeData(unsigned int format, HANDLE data);
-
-  // Return the window that should be the clipboard owner, creating it
-  // if neccessary.  Marked const for lazily initialization by const methods.
-  HWND GetClipboardWindow() const;
-
-  // Mark this as mutable so const methods can still do lazy initialization.
-  mutable scoped_ptr<base::win::MessageWindow> clipboard_owner_;
-
-#elif defined(USE_CLIPBOARD_AURAX11)
  private:
-  // We keep our implementation details private because otherwise we bring in
-  // the X11 headers and break chrome compile.
-  class AuraX11Details;
-  scoped_ptr<AuraX11Details> aurax11_details_;
-#endif
+  FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
+  FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
+  friend class ClipboardTest;
+  // For access to WriteObjects().
+  // TODO(dcheng): Remove the temporary exception for content.
+  friend class content::ClipboardMessageFilter;
+  friend class ScopedClipboardWriter;
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };

ui/base/clipboard/clipboard_android.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/clipboard_android.h"
 
 #include "base/android/jni_string.h"
 #include "base/lazy_instance.h"
@@ -11,7 +11,6 @@
 #include "base/synchronization/lock.h"
 #include "jni/Clipboard_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/base/clipboard/clipboard_android_initialization.h"
 #include "ui/gfx/size.h"
 
 // TODO:(andrewhayden) Support additional formats in Android: Bitmap, URI, HTML,
@@ -258,16 +257,22 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   return type;
 }
 
-// Clipboard implementation.
-Clipboard::Clipboard() {
+// Clipboard factory method.
+// static
+Clipboard* Clipboard::Create() {
+  return new ClipboardAndroid;
+}
+
+// ClipboardAndroid implementation.
+ClipboardAndroid::ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
-Clipboard::~Clipboard() {
+ClipboardAndroid::~ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
-uint64 Clipboard::GetSequenceNumber(ClipboardType /* type */) {
+uint64 ClipboardAndroid::GetSequenceNumber(ClipboardType /* type */) {
   DCHECK(CalledOnValidThread());
   // TODO: implement this. For now this interface will advertise
   // that the clipboard never changes. That's fine as long as we
@@ -275,22 +280,22 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType /* type */) {
   return 0;
 }
 
-bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
-                                  ClipboardType type) const {
+bool ClipboardAndroid::IsFormatAvailable(const Clipboard::FormatType& format,
+                                         ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
-  return g_map.Get().HasFormat(format.data());
+  return g_map.Get().HasFormat(format.ToString());
 }
 
-void Clipboard::Clear(ClipboardType type) {
+void ClipboardAndroid::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   g_map.Get().Clear();
 }
 
-void Clipboard::ReadAvailableTypes(ClipboardType type,
-                                   std::vector<base::string16>* types,
-                                   bool* contains_filenames) const {
+void ClipboardAndroid::ReadAvailableTypes(ClipboardType type,
+                                          std::vector<base::string16>* types,
+                                          bool* contains_filenames) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
@@ -305,7 +310,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
   *contains_filenames = false;
 }
 
-void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
+void ClipboardAndroid::ReadText(ClipboardType type,
+                                base::string16* result) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   std::string utf8;
@@ -313,18 +319,19 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
   *result = base::UTF8ToUTF16(utf8);
 }
 
-void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
+void ClipboardAndroid::ReadAsciiText(ClipboardType type,
+                                     std::string* result) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   *result = g_map.Get().Get(kPlainTextFormat);
 }
 
 // Note: |src_url| isn't really used. It is only implemented in Windows
-void Clipboard::ReadHTML(ClipboardType type,
-                         base::string16* markup,
-                         std::string* src_url,
-                         uint32* fragment_start,
-                         uint32* fragment_end) const {
+void ClipboardAndroid::ReadHTML(ClipboardType type,
+                                base::string16* markup,
+                                std::string* src_url,
+                                uint32* fragment_start,
+                                uint32* fragment_end) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   if (src_url)
@@ -337,12 +344,12 @@ void Clipboard::ReadHTML(ClipboardType type,
   *fragment_end = static_cast<uint32>(markup->length());
 }
 
-void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
+void ClipboardAndroid::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-SkBitmap Clipboard::ReadImage(ClipboardType type) const {
+SkBitmap ClipboardAndroid::ReadImage(ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   std::string input = g_map.Get().Get(kBitmapFormat);
@@ -361,66 +368,70 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const {
   return bmp;
 }
 
-void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const base::string16& type,
-                               base::string16* result) const {
+void ClipboardAndroid::ReadCustomData(ClipboardType clipboard_type,
+                                      const base::string16& type,
+                                      base::string16* result) const {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
+void ClipboardAndroid::ReadBookmark(base::string16* title,
+                                    std::string* url) const {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
-void Clipboard::ReadData(const Clipboard::FormatType& format,
-                         std::string* result) const {
+void ClipboardAndroid::ReadData(const Clipboard::FormatType& format,
+                                std::string* result) const {
   DCHECK(CalledOnValidThread());
-  *result = g_map.Get().Get(format.data());
+  *result = g_map.Get().Get(format.ToString());
 }
 
 // Main entry point used to write several values in the clipboard.
-void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
+void ClipboardAndroid::WriteObjects(ClipboardType type,
+                                    const ObjectMap& objects) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   g_map.Get().Clear();
-  for (ObjectMap::const_iterator iter = objects.begin();
-       iter != objects.end(); ++iter) {
+  for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
+       ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
 
-void Clipboard::WriteText(const char* text_data, size_t text_len) {
+void ClipboardAndroid::WriteText(const char* text_data, size_t text_len) {
   g_map.Get().Set(kPlainTextFormat, std::string(text_data, text_len));
 }
 
-void Clipboard::WriteHTML(const char* markup_data,
-                          size_t markup_len,
-                          const char* url_data,
-                          size_t url_len) {
+void ClipboardAndroid::WriteHTML(const char* markup_data,
+                                 size_t markup_len,
+                                 const char* url_data,
+                                 size_t url_len) {
   g_map.Get().Set(kHTMLFormat, std::string(markup_data, markup_len));
 }
 
-void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+void ClipboardAndroid::WriteRTF(const char* rtf_data, size_t data_len) {
   NOTIMPLEMENTED();
 }
 
 // Note: according to other platforms implementations, this really writes the
 // URL spec.
-void Clipboard::WriteBookmark(const char* title_data, size_t title_len,
-                              const char* url_data, size_t url_len) {
+void ClipboardAndroid::WriteBookmark(const char* title_data,
+                                     size_t title_len,
+                                     const char* url_data,
+                                     size_t url_len) {
   g_map.Get().Set(kBookmarkFormat, std::string(url_data, url_len));
 }
 
 // Write an extra flavor that signifies WebKit was the last to modify the
 // pasteboard. This flavor has no data.
-void Clipboard::WriteWebSmartPaste() {
+void ClipboardAndroid::WriteWebSmartPaste() {
   g_map.Get().Set(kWebKitSmartPasteFormat, std::string());
 }
 
 // Note: we implement this to pass all unit tests but it is currently unclear
 // how some code would consume this.
-void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
+void ClipboardAndroid::WriteBitmap(const SkBitmap& bitmap) {
   gfx::Size size(bitmap.width(), bitmap.height());
 
   std::string packed(reinterpret_cast<const char*>(&size), sizeof(size));
@@ -432,12 +443,12 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
   g_map.Get().Set(kBitmapFormat, packed);
 }
 
-void Clipboard::WriteData(const Clipboard::FormatType& format,
-                          const char* data_data, size_t data_len) {
-  g_map.Get().Set(format.data(), std::string(data_data, data_len));
+void ClipboardAndroid::WriteData(const Clipboard::FormatType& format,
+                                 const char* data_data,
+                                 size_t data_len) {
+  g_map.Get().Set(format.ToString(), std::string(data_data, data_len));
 }
 
-// See clipboard_android_initialization.h for more information.
 bool RegisterClipboardAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }

ui/base/clipboard/clipboard_android.h

+// 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.
+
+#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_H_
+#define UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+#include <jni.h>
+
+namespace ui {
+
+bool RegisterClipboardAndroid(JNIEnv* env);
+
+class ClipboardAndroid : public Clipboard {
+ private:
+  friend class Clipboard;
+
+  ClipboardAndroid();
+  ~ClipboardAndroid() override;
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardAndroid);
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_H_

ui/base/clipboard/clipboard_android_initialization.h

-// Copyright (c) 2013 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.
-
-// This file exists to help bind the Android clipboard implementation's JNI
-// methods statically. Since the JNI header file that contains the static
-// registration method is autogenerated and since the general clipboard.h
-// file is platform-independent, a new header file (this) is the cleanest
-// option for holding this function (as it is specific to Android).
-
-#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_
-#define UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_
-
-#include <jni.h>
-
-namespace ui {
-
-bool RegisterClipboardAndroid(JNIEnv* env);
-
-}  // namespace ui
-
-#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_

ui/base/clipboard/clipboard_aura.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/clipboard_aura.h"
 
 #include <list>
 
@@ -406,7 +406,7 @@ ClipboardData* ClipboardDataBuilder::current_data_ = NULL;
 
 }  // namespace
 
-// Clipboard FormatType implementation.
+// Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() {
 }
 
@@ -511,25 +511,30 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   return type;
 }
 
-// Clipboard implementation.
-Clipboard::Clipboard() {
+// Clipboard factory method.
+Clipboard* Clipboard::Create() {
+  return new ClipboardAura;
+}
+
+// ClipboardAura implementation.
+ClipboardAura::ClipboardAura() {
   DCHECK(CalledOnValidThread());
   // Make sure clipboard is created.
   GetClipboard();
 }
 
-Clipboard::~Clipboard() {
+ClipboardAura::~ClipboardAura() {
   DCHECK(CalledOnValidThread());
   DeleteClipboard();
 }
 
-uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
+uint64 ClipboardAura::GetSequenceNumber(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   return GetClipboard()->sequence_number();
 }
 
-bool Clipboard::IsFormatAvailable(const FormatType& format,
-                                  ClipboardType type) const {
+bool ClipboardAura::IsFormatAvailable(const FormatType& format,
+                                      ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
@@ -552,16 +557,16 @@ bool Clipboard::IsFormatAvailable(const FormatType& format,
   return false;
 }
 
-void Clipboard::Clear(ClipboardType type) {
+void ClipboardAura::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
   clipboard->Clear();
 }
 
-void Clipboard::ReadAvailableTypes(ClipboardType type,
-                                   std::vector<base::string16>* types,
-                                   bool* contains_filenames) const {
+void ClipboardAura::ReadAvailableTypes(ClipboardType type,
+                                       std::vector<base::string16>* types,
+                                       bool* contains_filenames) const {
   DCHECK(CalledOnValidThread());
   if (!types || !contains_filenames) {
     NOTREACHED();
@@ -586,95 +591,98 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
   }
 }
 
-void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
+void ClipboardAura::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadText(result);
 }
 
-void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
+void ClipboardAura::ReadAsciiText(ClipboardType type,
+                                  std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadAsciiText(result);
 }
 
-void Clipboard::ReadHTML(ClipboardType type,
-                         base::string16* markup,
-                         std::string* src_url,
-                         uint32* fragment_start,
-                         uint32* fragment_end) const {
+void ClipboardAura::ReadHTML(ClipboardType type,
+                             base::string16* markup,
+                             std::string* src_url,
+                             uint32* fragment_start,
+                             uint32* fragment_end) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
 }
 
-void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
+void ClipboardAura::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadRTF(result);
 }
 
-SkBitmap Clipboard::ReadImage(ClipboardType type) const {
+SkBitmap ClipboardAura::ReadImage(ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   return GetClipboard()->ReadImage();
 }
 
-void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const base::string16& type,
-                               base::string16* result) const {
+void ClipboardAura::ReadCustomData(ClipboardType clipboard_type,
+                                   const base::string16& type,
+                                   base::string16* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadCustomData(type, result);
 }
 
-void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
+void ClipboardAura::ReadBookmark(base::string16* title,
+                                 std::string* url) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadBookmark(title, url);
 }
 
-void Clipboard::ReadData(const FormatType& format, std::string* result) const {
+void ClipboardAura::ReadData(const FormatType& format,
+                             std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadData(format.ToString(), result);
 }
 
-void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
+void ClipboardAura::WriteObjects(ClipboardType type, const ObjectMap& objects) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
-  for (ObjectMap::const_iterator iter = objects.begin();
-       iter != objects.end(); ++iter) {
+  for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
+       ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
   ClipboardDataBuilder::CommitToClipboard();
 }
 
-void Clipboard::WriteText(const char* text_data, size_t text_len) {
+void ClipboardAura::WriteText(const char* text_data, size_t text_len) {
   ClipboardDataBuilder::WriteText(text_data, text_len);
 }
 
-void Clipboard::WriteHTML(const char* markup_data,
-                          size_t markup_len,
-                          const char* url_data,
-                          size_t url_len) {
+void ClipboardAura::WriteHTML(const char* markup_data,
+                              size_t markup_len,
+                              const char* url_data,
+                              size_t url_len) {
   ClipboardDataBuilder::WriteHTML(markup_data, markup_len, url_data, url_len);
 }
 
-void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+void ClipboardAura::WriteRTF(const char* rtf_data, size_t data_len) {
   ClipboardDataBuilder::WriteRTF(rtf_data, data_len);
 }
 
-void Clipboard::WriteBookmark(const char* title_data,
-                              size_t title_len,
-                              const char* url_data,
-                              size_t url_len) {
+void ClipboardAura::WriteBookmark(const char* title_data,
+                                  size_t title_len,
+                                  const char* url_data,
+                                  size_t url_len) {
   ClipboardDataBuilder::WriteBookmark(title_data, title_len, url_data, url_len);
 }
 
-void Clipboard::WriteWebSmartPaste() {
+void ClipboardAura::WriteWebSmartPaste() {
   ClipboardDataBuilder::WriteWebSmartPaste();
 }
 
-void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
+void ClipboardAura::WriteBitmap(const SkBitmap& bitmap) {
   ClipboardDataBuilder::WriteBitmap(bitmap);
 }
 
-void Clipboard::WriteData(const FormatType& format,
-                          const char* data_data,
-                          size_t data_len) {
+void ClipboardAura::WriteData(const FormatType& format,
+                              const char* data_data,
+                              size_t data_len) {
   ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
 }
 

ui/base/clipboard/clipboard_aura.h

+// 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.
+
+#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_AURA_H_
+#define UI_BASE_CLIPBOARD_CLIPBOARD_AURA_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+namespace ui {
+
+class ClipboardAura : public Clipboard {
+ private:
+  friend class Clipboard;
+
+  ClipboardAura();
+  ~ClipboardAura() override;
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardAura);
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_AURA_H_

ui/base/clipboard/clipboard_aurax11.h

+// 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.
+
+#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_AURAX11_H_
+#define UI_BASE_CLIPBOARD_CLIPBOARD_AURAX11_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+#include "base/memory/scoped_ptr.h"
+
+namespace ui {
+
+class ClipboardAuraX11 : public Clipboard {
+ private:
+  friend class Clipboard;
+
+  ClipboardAuraX11();
+  ~ClipboardAuraX11() override;
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  // TODO(dcheng): Is this still needed now that each platform clipboard has its
+  // own class derived from Clipboard?
+  class AuraX11Details;
+  scoped_ptr<AuraX11Details> aurax11_details_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardAuraX11);
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_AURAX11_H_

ui/base/clipboard/clipboard_mac.h

+// 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.
+
+#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_MAC_H_
+#define UI_BASE_CLIPBOARD_CLIPBOARD_MAC_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+namespace ui {
+
+class ClipboardMac : public Clipboard {
+ private:
+  friend class Clipboard;
+
+  ClipboardMac();
+  ~ClipboardMac() override;
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardMac);
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_MAC_H_

ui/base/clipboard/clipboard_win.h

+// 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.
+
+#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_WIN_H_
+#define UI_BASE_CLIPBOARD_CLIPBOARD_WIN_H_
+
+#include "ui/base/clipboard/clipboard.h"
+
+#include "base/memory/scoped_ptr.h"
+
+namespace ui {
+
+class ClipboardWin : public Clipboard {
+ private:
+  friend class Clipboard;
+
+  ClipboardWin();
+  ~ClipboardWin() override;
+
+  // Clipboard overrides:
+  uint64 GetSequenceNumber(ClipboardType type) override;
+  bool IsFormatAvailable(const FormatType& format,
+                         ClipboardType type) const override;
+  void Clear(ClipboardType type) override;
+  void ReadAvailableTypes(ClipboardType type,
+                          std::vector<base::string16>* types,
+                          bool* contains_filenames) const override;
+  void ReadText(ClipboardType type, base::string16* result) const override;
+  void ReadAsciiText(ClipboardType type, std::string* result) const override;
+  void ReadHTML(ClipboardType type,
+                base::string16* markup,
+                std::string* src_url,
+                uint32* fragment_start,
+                uint32* fragment_end) const override;
+  void ReadRTF(ClipboardType type, std::string* result) const override;
+  SkBitmap ReadImage(ClipboardType type) const override;
+  void ReadCustomData(ClipboardType clipboard_type,
+                      const base::string16& type,
+                      base::string16* result) const override;
+  void ReadBookmark(base::string16* title, std::string* url) const override;
+  void ReadData(const FormatType& format, std::string* result) const override;
+  void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
+  void WriteText(const char* text_data, size_t text_len) override;
+  void WriteHTML(const char* markup_data,
+                 size_t markup_len,
+                 const char* url_data,
+                 size_t url_len) override;
+  void WriteRTF(const char* rtf_data, size_t data_len) override;
+  void WriteBookmark(const char* title_data,
+                     size_t title_len,
+                     const char* url_data,
+                     size_t url_len) override;
+  void WriteWebSmartPaste() override;
+  void WriteBitmap(const SkBitmap& bitmap) override;
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len) override;
+
+  void WriteBitmapFromHandle(HBITMAP source_hbitmap, const gfx::Size& size);
+
+  // Safely write to system clipboard. Free |handle| on failure.
+  void WriteToClipboard(unsigned int format, HANDLE handle);
+
+  // Return the window that should be the clipboard owner, creating it
+  // if neccessary.  Marked const for lazily initialization by const methods.
+  HWND GetClipboardWindow() const;
+
+  // Mark this as mutable so const methods can still do lazy initialization.
+  mutable scoped_ptr<base::win::MessageWindow> clipboard_owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardWin);
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CLIPBOARD_CLIPBOARD_WIN_H_

ui/base/ui_base.gyp

@@ -61,15 +61,19 @@
         'clipboard/clipboard.cc',
         'clipboard/clipboard.h',
         'clipboard/clipboard_android.cc',
-        'clipboard/clipboard_android_initialization.h',
+        'clipboard/clipboard_android.h',
         'clipboard/clipboard_aura.cc',
+        'clipboard/clipboard_aura.h',
         'clipboard/clipboard_aurax11.cc',
+        'clipboard/clipboard_aurax11.h',
         'clipboard/clipboard_constants.cc',
+        'clipboard/clipboard_mac.h',
         'clipboard/clipboard_mac.mm',
         'clipboard/clipboard_types.h',
         'clipboard/clipboard_util_win.cc',
         'clipboard/clipboard_util_win.h',
         'clipboard/clipboard_win.cc',
+        'clipboard/clipboard_win.h',
         'clipboard/custom_data_helper.cc',
         'clipboard/custom_data_helper.h',
         'clipboard/custom_data_helper_linux.cc',