Add FakeClipboard implementation for unit tests.

ui/base/clipboard/clipboard.cc

 // 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.
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <iterator>
 #include <limits>
 
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/synchronization/lock.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
 
 namespace {
 
 // Valides a shared bitmap on the clipboard.
 // Returns true if the clipboard data makes sense and it's safe to access the
 // bitmap.
 bool ValidateAndMapSharedBitmap(size_t bitmap_bytes,
                                 base::SharedMemory* bitmap_data) {
   using base::SharedMemory;
 
   if (!bitmap_data || !SharedMemory::IsHandleValid(bitmap_data->handle()))
     return false;
 
   if (!bitmap_data->Map(bitmap_bytes)) {
     PLOG(ERROR) << "Failed to map bitmap memory";
     return false;
   }
   return true;
 }
 
-// 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> g_allowed_threads =
+}  // namespace
+
+base::LazyInstance<Clipboard::AllowedThreadsVector>
+    Clipboard::allowed_threads_ = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<Clipboard::ClipboardMap> Clipboard::clipboard_map_ =
     LAZY_INSTANCE_INITIALIZER;
-
-// Mapping from threads to clipboard objects.
-typedef std::map<base::PlatformThreadId, Clipboard*> ClipboardMap;
-static base::LazyInstance<ClipboardMap> g_clipboard_map =
+base::LazyInstance<base::Lock>::Leaky Clipboard::clipboard_map_lock_ =
     LAZY_INSTANCE_INITIALIZER;
 
-// Mutex that controls access to |g_clipboard_map|.
-static base::LazyInstance<base::Lock>::Leaky
-    g_clipboard_map_lock = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
 // static
 void Clipboard::SetAllowedThreads(
     const std::vector<base::PlatformThreadId>& allowed_threads) {
-  base::AutoLock lock(g_clipboard_map_lock.Get());
+  base::AutoLock lock(clipboard_map_lock_.Get());
 
-  g_allowed_threads.Get().clear();
+  allowed_threads_.Get().clear();
   std::copy(allowed_threads.begin(), allowed_threads.end(),
-            std::back_inserter(g_allowed_threads.Get()));
+            std::back_inserter(allowed_threads_.Get()));
 }
 
 // static
 Clipboard* Clipboard::GetForCurrentThread() {
-  base::AutoLock lock(g_clipboard_map_lock.Get());
+  base::AutoLock lock(clipboard_map_lock_.Get());
 
   base::PlatformThreadId id = base::PlatformThread::CurrentId();
 
-  AllowedThreadsVector* allowed_threads = g_allowed_threads.Pointer();
+  AllowedThreadsVector* allowed_threads = allowed_threads_.Pointer();
   if (!allowed_threads->empty()) {
     bool found = false;
     for (AllowedThreadsVector::const_iterator it = allowed_threads->begin();
          it != allowed_threads->end(); ++it) {
       if (*it == id) {
         found = true;
         break;
       }
     }
 
     DCHECK(found);
   }
 
-  ClipboardMap* clipboard_map = g_clipboard_map.Pointer();
-  ClipboardMap::iterator it = clipboard_map->find(id);
+  ClipboardMap* clipboard_map = clipboard_map_.Pointer();
+  ClipboardMap::const_iterator it = clipboard_map->find(id);
   if (it != clipboard_map->end())
     return it->second;
 
   Clipboard* clipboard = Clipboard::Create();
   clipboard_map->insert(std::make_pair(id, clipboard));
   return clipboard;
 }
 
 void Clipboard::DestroyClipboardForCurrentThread() {
-  base::AutoLock lock(g_clipboard_map_lock.Get());
+  base::AutoLock lock(clipboard_map_lock_.Get());
 
-  ClipboardMap* clipboard_map = g_clipboard_map.Pointer();
+  ClipboardMap* clipboard_map = clipboard_map_.Pointer();
   base::PlatformThreadId id = base::PlatformThread::CurrentId();
   ClipboardMap::iterator it = clipboard_map->find(id);
   if (it != clipboard_map->end()) {
     delete it->second;
     clipboard_map->erase(it);
   }
 }
 
 void Clipboard::DispatchObject(ObjectType type, const ObjectMapParams& params) {
   // All types apart from CBF_WEBKIT need at least 1 non-empty param.
@@ skipping 114 matching lines @@
       iter->second[0].clear();
       for (size_t i = 0; i < sizeof(SharedMemory*); ++i)
         iter->second[0].push_back(reinterpret_cast<char*>(&bitmap)[i]);
       has_shared_bitmap = true;
     }
   }
   return true;
 }
 
 }  // namespace ui