Try 2 - Change how ui::Clipboard is accessed so there's only one per thread.

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 "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
 
 namespace {
 
 // A compromised renderer could send us bad data, so validate it.
 // This function only checks that the size parameter makes sense, the caller
 // is responsible for further validating the bitmap buffer against
 // |bitmap_bytes|.
@@ skipping 46 matching lines @@
   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 =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Mapping from threads to clipboard objects.
+typedef std::map<base::PlatformThreadId, Clipboard*> ClipboardMap;
+static base::LazyInstance<ClipboardMap> g_clipboard_map =
+    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
 
 const char Clipboard::kMimeTypeText[] = "text/plain";
 const char Clipboard::kMimeTypeURIList[] = "text/uri-list";
 const char Clipboard::kMimeTypeDownloadURL[] = "downloadurl";
 const char Clipboard::kMimeTypeHTML[] = "text/html";
 const char Clipboard::kMimeTypeRTF[] = "text/rtf";
 const char Clipboard::kMimeTypePNG[] = "image/png";
 
+// static
+void Clipboard::SetAllowedThreads(
+    const std::vector<base::PlatformThreadId>& allowed_threads) {
+  base::AutoLock lock(g_clipboard_map_lock.Get());
+
+  g_allowed_threads.Get().clear();
+  std::copy(allowed_threads.begin(), allowed_threads.end(),
+            std::back_inserter(g_allowed_threads.Get()));
+}
+
+// static
+Clipboard* Clipboard::GetForCurrentThread() {
+  base::AutoLock lock(g_clipboard_map_lock.Get());
+
+  base::PlatformThreadId id = base::PlatformThread::CurrentId();
+
+  AllowedThreadsVector* allowed_threads = g_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);
+  if (it != clipboard_map->end())
+    return it->second;
+
+  Clipboard* clipboard = new ui::Clipboard;
+  clipboard_map->insert(std::make_pair(id, clipboard));
+  return clipboard;
+}
+
+void Clipboard::DestroyClipboardForCurrentThread() {
+  base::AutoLock lock(g_clipboard_map_lock.Get());
+
+  ClipboardMap* clipboard_map = g_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.
   if (type != CBF_WEBKIT && (params.empty() || params[0].empty()))
     return;
   // Some other types need a non-empty 2nd param.
   if ((type == CBF_BOOKMARK || type == CBF_BITMAP ||
        type == CBF_SMBITMAP || type == CBF_DATA) &&
       (params.size() != 2 || params[1].empty()))
     return;
   switch (type) {
@@ skipping 92 matching lines @@
       // UI thread (see DispatchObject()).
       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;
     }
   }
 }
 
 }  // namespace ui