Implement ui::ClipboardMus.

ui/base/clipboard/clipboard.h

 // Copyright (c) 2012 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_H_
 #define UI_BASE_CLIPBOARD_CLIPBOARD_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
@@ skipping 31 matching lines @@
 class ClipboardTest;
 class TestClipboard;
 class ScopedClipboardWriter;
 
 class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
  public:
   // MIME type constants.
   static const char kMimeTypeText[];
   static const char kMimeTypeURIList[];
   static const char kMimeTypeDownloadURL[];
+  static const char kMimeTypeMozillaURL[];
   static const char kMimeTypeHTML[];
   static const char kMimeTypeRTF[];
   static const char kMimeTypePNG[];
+  static const char kMimeTypeWebCustomData[];
+  static const char kMimeTypeWebkitSmartPaste[];
+  static const char kMimeTypePepperCustomData[];
 
   // Platform neutral holder for native data representation of a clipboard type.
   struct UI_BASE_EXPORT FormatType {
     FormatType();
     ~FormatType();
 
     // Serializes and deserializes a FormatType for use in IPC messages.
     std::string Serialize() const;
     static FormatType Deserialize(const std::string& serialization);
 
@@ skipping 54 matching lines @@
   }
 
   static ClipboardType FromInt(int32_t type) {
     return static_cast<ClipboardType>(type);
   }
 
   // Sets the list of threads that are allowed to access the clipboard.
   static void SetAllowedThreads(
       const std::vector<base::PlatformThreadId>& allowed_threads);
 
+  // Sets the clipboard for the current thread. Previously, there was only
+  // one clipboard implementation on a platform; now that mus exists, during
+  // mus app startup, we need to specifically initialize mus instead of the
+  // current platform clipboard. We take ownership of |platform_clipboard|.
+  static void SetClipboardForCurrentThread(
+      std::unique_ptr<Clipboard> platform_clipboard);
+
   // Returns the clipboard object for the current thread.
   //
   // Most implementations will have at most one clipboard which will live on
   // the main UI thread, but Windows has tricky semantics where there have to
   // be two clipboards: one that lives on the UI thread and one that lives on
   // the IO thread.
   static Clipboard* GetForCurrentThread();
 
   // Destroys the clipboard for the current thread. Usually, this will clean up
   // all clipboards, except on Windows. (Previous code leaks the IO thread
@@ skipping 151 matching lines @@
   virtual void WriteWebSmartPaste() = 0;
 
   virtual void WriteBitmap(const SkBitmap& bitmap) = 0;
 
   virtual void WriteData(const FormatType& format,
                          const char* data_data,
                          size_t data_len) = 0;
 
  private:
   // For access to WriteObjects().
+  friend class ForwardingTestingClipboard;
   friend class ScopedClipboardWriter;
   friend class TestClipboard;
+  // For SetClipboardForCurrentThread's argument.
+  friend struct std::default_delete<Clipboard>;
+
+  static base::PlatformThreadId GetAndValidateThreadID();
 
   // A list of allowed threads. By default, this is empty and no thread checking
   // is done (in the unit test case), but a user (like content) can set which
   // threads are allowed to call this method.
   typedef std::vector<base::PlatformThreadId> AllowedThreadsVector;
   static base::LazyInstance<AllowedThreadsVector> allowed_threads_;
 
   // Mapping from threads to clipboard objects.
-  typedef std::map<base::PlatformThreadId, Clipboard*> ClipboardMap;
+  typedef std::map<base::PlatformThreadId, std::unique_ptr<Clipboard>>
+      ClipboardMap;
   static base::LazyInstance<ClipboardMap> clipboard_map_;
 
   // Mutex that controls access to |g_clipboard_map|.
   static base::LazyInstance<base::Lock>::Leaky clipboard_map_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_