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

Currently, there can be any number of Clipboard objects, which can be massively simplified. This removes interfaces for fetching the Clipboard and makes everyone go through a single static ui::Clipboard::GetForCurrentThread() access point.

BUG=130805
TBR=tc (change in webkit/ is trivial)

Review URL: https://chromiumcodereview.appspot.com/10911074

TBR=erg@chromium.org
Review URL: https://chromiumcodereview.appspot.com/10919180

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@155615 0039d316-1c4b-4281-b951-d872f2087c98

37 files changed, 297 insertions, 221 deletions

diff --git a/ash/drag_drop/drag_drop_controller_unittest.cc b/ash/drag_drop/drag_drop_controller_unittest.cc
index b7c94e8..044b496 100644
--- a/ash/drag_drop/drag_drop_controller_unittest.cc
+++ b/ash/drag_drop/drag_drop_controller_unittest.cc
@@ -503,7 +503,7 @@ TEST_F(DragDropControllerTest, ViewRemovedWhileInDragDropTest) {
 }
 
 TEST_F(DragDropControllerTest, DragLeavesClipboardAloneTest) {
-  ui::Clipboard* cb = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard* cb = views::ViewsDelegate::views_delegate->GetClipboard();
   std::string clip_str("I am on the clipboard");
   {
     // We first copy some text to the clipboard.
diff --git a/chrome/browser/bookmarks/bookmark_node_data.cc b/chrome/browser/bookmarks/bookmark_node_data.cc
index bcd45d6..c6a2615 100644
--- a/chrome/browser/bookmarks/bookmark_node_data.cc
+++ b/chrome/browser/bookmarks/bookmark_node_data.cc
@@ -19,6 +19,8 @@
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/bookmarks/bookmark_pasteboard_helper_mac.h"
+#else
+#include "chrome/browser/browser_process.h"
 #endif
 
 const char* BookmarkNodeData::kClipboardFormatString =
@@ -139,7 +141,7 @@ bool BookmarkNodeData::ReadFromTuple(const GURL& url, const string16& title) {
 
 #if !defined(OS_MACOSX)
 void BookmarkNodeData::WriteToClipboard(Profile* profile) const {
-  ui::ScopedClipboardWriter scw(ui::Clipboard::GetForCurrentThread(),
+  ui::ScopedClipboardWriter scw(g_browser_process->clipboard(),
                                 ui::Clipboard::BUFFER_STANDARD);
 
   // If there is only one element and it is a URL, write the URL to the
@@ -167,7 +169,7 @@ void BookmarkNodeData::WriteToClipboard(Profile* profile) const {
 
 bool BookmarkNodeData::ReadFromClipboard() {
   std::string data;
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard* clipboard = g_browser_process->clipboard();
   clipboard->ReadData(ui::Clipboard::GetFormatType(kClipboardFormatString),
                       &data);
 
@@ -195,7 +197,7 @@ bool BookmarkNodeData::ReadFromClipboard() {
 }
 
 bool BookmarkNodeData::ClipboardContainsBookmarks() {
-  return ui::Clipboard::GetForCurrentThread()->IsFormatAvailable(
+  return g_browser_process->clipboard()->IsFormatAvailable(
       ui::Clipboard::GetFormatType(kClipboardFormatString),
       ui::Clipboard::BUFFER_STANDARD);
 }
diff --git a/chrome/browser/bookmarks/bookmark_utils_unittest.cc b/chrome/browser/bookmarks/bookmark_utils_unittest.cc
index 9b4100b..565f60f 100644
--- a/chrome/browser/bookmarks/bookmark_utils_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_utils_unittest.cc
@@ -10,6 +10,10 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 
+#if !defined(OS_MACOSX)
+#include "chrome/browser/browser_process.h"
+#endif
+
 using std::string;
 
 namespace bookmark_utils {
@@ -138,9 +142,8 @@ TEST(BookmarkUtilsTest, CopyPaste) {
 
   // Write some text to the clipboard.
   {
-    ui::ScopedClipboardWriter clipboard_writer(
-        ui::Clipboard::GetForCurrentThread(),
-        ui::Clipboard::BUFFER_STANDARD);
+    ui::ScopedClipboardWriter clipboard_writer(g_browser_process->clipboard(),
+                                               ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(ASCIIToUTF16("foo"));
   }
 
diff --git a/chrome/browser/browser_process.h b/chrome/browser/browser_process.h
index bc5a56b..b31ae0a 100644
--- a/chrome/browser/browser_process.h
+++ b/chrome/browser/browser_process.h
@@ -71,6 +71,10 @@ namespace safe_browsing {
 class ClientSideDetectionService;
 }
 
+namespace ui {
+class Clipboard;
+}
+
 // NOT THREAD SAFE, call only from the main thread.
 // These functions shouldn't return NULL unless otherwise noted.
 class BrowserProcess {
@@ -91,6 +95,7 @@ class BrowserProcess {
   virtual MetricsService* metrics_service() = 0;
   virtual ProfileManager* profile_manager() = 0;
   virtual PrefService* local_state() = 0;
+  virtual ui::Clipboard* clipboard() = 0;
   virtual net::URLRequestContextGetter* system_request_context() = 0;
   virtual chrome_variations::VariationsService* variations_service() = 0;
 
diff --git a/chrome/browser/browser_process_impl.cc b/chrome/browser/browser_process_impl.cc
index d4f3366..6e53b75 100644
--- a/chrome/browser/browser_process_impl.cc
+++ b/chrome/browser/browser_process_impl.cc
@@ -78,6 +78,7 @@
 #include "content/public/common/pepper_plugin_info.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "ui/base/clipboard/clipboard.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if !defined(ENABLE_CONFIGURATION_POLICY)
@@ -141,6 +142,7 @@ BrowserProcessImpl::BrowserProcessImpl(const CommandLine& command_line)
       thumbnail_generator_(new ThumbnailGenerator),
       download_status_updater_(new DownloadStatusUpdater) {
   g_browser_process = this;
+  clipboard_.reset(new ui::Clipboard);
 
 #if defined(ENABLE_PRINTING)
   // Must be created after the NotificationService.
@@ -386,6 +388,11 @@ PrefService* BrowserProcessImpl::local_state() {
   return local_state_.get();
 }
 
+ui::Clipboard* BrowserProcessImpl::clipboard() {
+  DCHECK(CalledOnValidThread());
+  return clipboard_.get();
+}
+
 net::URLRequestContextGetter* BrowserProcessImpl::system_request_context() {
   DCHECK(CalledOnValidThread());
   return io_thread()->system_url_request_context_getter();
diff --git a/chrome/browser/browser_process_impl.h b/chrome/browser/browser_process_impl.h
index 404db25..607cc4f 100644
--- a/chrome/browser/browser_process_impl.h
+++ b/chrome/browser/browser_process_impl.h
@@ -64,6 +64,7 @@ class BrowserProcessImpl : public BrowserProcess,
   virtual WatchDogThread* watchdog_thread() OVERRIDE;
   virtual ProfileManager* profile_manager() OVERRIDE;
   virtual PrefService* local_state() OVERRIDE;
+  virtual ui::Clipboard* clipboard() OVERRIDE;
   virtual net::URLRequestContextGetter* system_request_context() OVERRIDE;
   virtual chrome_variations::VariationsService* variations_service() OVERRIDE;
 #if defined(OS_CHROMEOS)
@@ -177,6 +178,8 @@ class BrowserProcessImpl : public BrowserProcess,
 
   scoped_ptr<printing::BackgroundPrintingManager> background_printing_manager_;
 
+  scoped_ptr<ui::Clipboard> clipboard_;
+
   scoped_ptr<chrome_variations::VariationsService> variations_service_;
 
   // Manager for desktop notification UI.
diff --git a/chrome/browser/tab_contents/render_view_context_menu.cc b/chrome/browser/tab_contents/render_view_context_menu.cc
index fc46a87..daa5fb4 100644
--- a/chrome/browser/tab_contents/render_view_context_menu.cc
+++ b/chrome/browser/tab_contents/render_view_context_menu.cc
@@ -81,7 +81,6 @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebContextMenuData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerAction.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginAction.h"
-#include "ui/base/clipboard/clipboard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/favicon_size.h"
@@ -2015,7 +2014,7 @@ void RenderViewContextMenu::WriteURLToClipboard(const GURL& url) {
   chrome_common_net::WriteURLToClipboard(
       url,
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
-      ui::Clipboard::GetForCurrentThread());
+      g_browser_process->clipboard());
 }
 
 void RenderViewContextMenu::MediaPlayerActionAt(
diff --git a/chrome/browser/ui/omnibox/omnibox_view.cc b/chrome/browser/ui/omnibox/omnibox_view.cc
index e8bd344..d87fc18 100644
--- a/chrome/browser/ui/omnibox/omnibox_view.cc
+++ b/chrome/browser/ui/omnibox/omnibox_view.cc
@@ -11,6 +11,7 @@
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
+#include "chrome/browser/browser_process.h"
 #include "ui/base/clipboard/clipboard.h"
 
 // static
@@ -26,7 +27,7 @@ string16 OmniboxView::StripJavascriptSchemas(const string16& text) {
 // static
 string16 OmniboxView::GetClipboardText() {
   // Try text format.
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard* clipboard = g_browser_process->clipboard();
   if (clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                    ui::Clipboard::BUFFER_STANDARD)) {
     string16 text;
diff --git a/chrome/browser/ui/omnibox/omnibox_view_unittest.cc b/chrome/browser/ui/omnibox/omnibox_view_unittest.cc
index ae932b5..4346fca 100644
--- a/chrome/browser/ui/omnibox/omnibox_view_unittest.cc
+++ b/chrome/browser/ui/omnibox/omnibox_view_unittest.cc
@@ -40,14 +40,14 @@ TEST_F(OmniboxViewTest, TestStripSchemasUnsafeForPaste) {
 }
 
 TEST_F(OmniboxViewTest, GetClipboardText) {
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard clipboard;
 
   const string16 kPlainText(ASCIIToUTF16("test text"));
   const std::string kURL("http://www.example.com/");
 
   // Can we pull straight text off the clipboard?
   {
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(kPlainText);
   }
@@ -57,8 +57,8 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
   // ObjectMap is empty.  http://crbug.com/133848
 #if !defined(USE_AURA)
   // Does an empty clipboard get empty text?
-  clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD,
-                          ui::Clipboard::ObjectMap());
+  clipboard.WriteObjects(ui::Clipboard::BUFFER_STANDARD,
+                         ui::Clipboard::ObjectMap());
   EXPECT_EQ(string16(), OmniboxView::GetClipboardText());
 #endif
 
@@ -68,7 +68,7 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
   const string16 kTitle(ASCIIToUTF16("The Example Company"));
   // Can we pull a bookmark off the clipboard?
   {
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBookmark(kTitle, kURL);
   }
@@ -76,7 +76,7 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
 
   // Do we pull text in preference to a bookmark?
   {
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(kPlainText);
     clipboard_writer.WriteBookmark(kTitle, kURL);
@@ -87,7 +87,7 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
   // Do we get nothing if there is neither text nor a bookmark?
   {
     const string16 kMarkup(ASCIIToUTF16("<strong>Hi!</string>"));
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHTML(kMarkup, kURL);
   }
@@ -98,7 +98,7 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
     const string16 kWrappedURL(ASCIIToUTF16(
         "http://www.chromium.org/developers/testing/chromium-\n"
         "build-infrastructure/tour-of-the-chromium-buildbot"));
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(kWrappedURL);
   }
@@ -112,7 +112,7 @@ TEST_F(OmniboxViewTest, GetClipboardText) {
   {
     const string16 kWrappedAddress(ASCIIToUTF16(
         "1600 Amphitheatre Parkway\nMountain View, CA"));
-    ui::ScopedClipboardWriter clipboard_writer(clipboard,
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
                                                ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(kWrappedAddress);
   }
diff --git a/chrome/browser/ui/views/accessibility/accessibility_event_router_views_unittest.cc b/chrome/browser/ui/views/accessibility/accessibility_event_router_views_unittest.cc
index b093b95..b15609a 100644
--- a/chrome/browser/ui/views/accessibility/accessibility_event_router_views_unittest.cc
+++ b/chrome/browser/ui/views/accessibility/accessibility_event_router_views_unittest.cc
@@ -36,6 +36,7 @@ class AccessibilityViewsDelegate : public views::ViewsDelegate {
   virtual ~AccessibilityViewsDelegate() {}
 
   // Overridden from views::ViewsDelegate:
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE { return NULL; }
   virtual void SaveWindowPlacement(const views::Widget* window,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
diff --git a/chrome/browser/ui/views/bookmarks/bookmark_bar_view_test.cc b/chrome/browser/ui/views/bookmarks/bookmark_bar_view_test.cc
index 5e6967c..981cf92 100644
--- a/chrome/browser/ui/views/bookmarks/bookmark_bar_view_test.cc
+++ b/chrome/browser/ui/views/bookmarks/bookmark_bar_view_test.cc
@@ -58,6 +58,7 @@ void MoveMouseAndPress(const gfx::Point& screen_pos,
 class ViewsDelegateImpl : public views::ViewsDelegate {
  public:
   ViewsDelegateImpl() {}
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE { return NULL; }
   virtual void SaveWindowPlacement(const views::Widget* window,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
diff --git a/chrome/browser/ui/views/chrome_views_delegate.cc b/chrome/browser/ui/views/chrome_views_delegate.cc
index e4cadc3..73b734b 100644
--- a/chrome/browser/ui/views/chrome_views_delegate.cc
+++ b/chrome/browser/ui/views/chrome_views_delegate.cc
@@ -14,6 +14,7 @@
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/views/accessibility/accessibility_event_router_views.h"
 #include "chrome/common/pref_names.h"
+#include "ui/base/clipboard/clipboard.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/native_widget.h"
@@ -55,6 +56,10 @@ PrefService* GetPrefsForWindow(const views::Widget* window) {
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeViewsDelegate, views::ViewsDelegate implementation:
 
+ui::Clipboard* ChromeViewsDelegate::GetClipboard() const {
+  return g_browser_process->clipboard();
+}
+
 void ChromeViewsDelegate::SaveWindowPlacement(const views::Widget* window,
                                               const std::string& window_name,
                                               const gfx::Rect& bounds,
diff --git a/chrome/browser/ui/views/chrome_views_delegate.h b/chrome/browser/ui/views/chrome_views_delegate.h
index d1da9a8..c568d2e 100644
--- a/chrome/browser/ui/views/chrome_views_delegate.h
+++ b/chrome/browser/ui/views/chrome_views_delegate.h
@@ -17,6 +17,7 @@ class ChromeViewsDelegate : public views::ViewsDelegate {
   virtual ~ChromeViewsDelegate() {}
 
   // Overridden from views::ViewsDelegate:
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE;
   virtual void SaveWindowPlacement(const views::Widget* window,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
diff --git a/chrome/browser/ui/views/find_bar_host_interactive_uitest.cc b/chrome/browser/ui/views/find_bar_host_interactive_uitest.cc
index a5a4eaa..ded923b 100644
--- a/chrome/browser/ui/views/find_bar_host_interactive_uitest.cc
+++ b/chrome/browser/ui/views/find_bar_host_interactive_uitest.cc
@@ -352,7 +352,7 @@ IN_PROC_BROWSER_TEST_F(FindInPageTest, MAYBE_PasteWithoutTextChange) {
       browser(), ui::VKEY_C, true, false, false, false));
 
   string16 str;
-  ui::Clipboard::GetForCurrentThread()->
+  views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
 
   // Make sure the text is copied successfully.
diff --git a/chrome/browser/ui/views/menu_model_adapter_test.cc b/chrome/browser/ui/views/menu_model_adapter_test.cc
index c1ff355..94c00be 100644
--- a/chrome/browser/ui/views/menu_model_adapter_test.cc
+++ b/chrome/browser/ui/views/menu_model_adapter_test.cc
@@ -35,6 +35,10 @@ class TestViewsDelegate : public views::ViewsDelegate {
   }
 
   // views::ViewsDelegate implementation
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE {
+    return NULL;
+  }
+
   virtual void SaveWindowPlacement(const views::Widget* widget,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
diff --git a/chrome/browser/ui/views/omnibox/omnibox_view_views.cc b/chrome/browser/ui/views/omnibox/omnibox_view_views.cc
index ff24a09..de46181 100644
--- a/chrome/browser/ui/views/omnibox/omnibox_view_views.cc
+++ b/chrome/browser/ui/views/omnibox/omnibox_view_views.cc
@@ -760,7 +760,7 @@ void OmniboxViewViews::OnAfterUserAction(views::Textfield* sender) {
 void OmniboxViewViews::OnAfterCutOrCopy() {
   ui::Range selection_range;
   textfield_->GetSelectedRange(&selection_range);
-  ui::Clipboard* cb = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard* cb = views::ViewsDelegate::views_delegate->GetClipboard();
   string16 selected_text;
   cb->ReadText(ui::Clipboard::BUFFER_STANDARD, &selected_text);
   const string16 text = textfield_->text();
diff --git a/chrome/browser/ui/views/omnibox/omnibox_view_win.cc b/chrome/browser/ui/views/omnibox/omnibox_view_win.cc
index 68ed871..d620d9e 100644
--- a/chrome/browser/ui/views/omnibox/omnibox_view_win.cc
+++ b/chrome/browser/ui/views/omnibox/omnibox_view_win.cc
@@ -27,6 +27,7 @@
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/profiles/profile.h"
@@ -1332,7 +1333,7 @@ void OmniboxViewWin::OnCopy() {
   // GetSel() doesn't preserve selection direction, so sel.cpMin will always be
   // the smaller value.
   model()->AdjustTextForCopy(sel.cpMin, IsSelectAll(), &text, &url, &write_url);
-  ui::ScopedClipboardWriter scw(ui::Clipboard::GetForCurrentThread(),
+  ui::ScopedClipboardWriter scw(g_browser_process->clipboard(),
                                 ui::Clipboard::BUFFER_STANDARD);
   scw.WriteText(text);
   if (write_url)
diff --git a/chrome/test/base/testing_browser_process.cc b/chrome/test/base/testing_browser_process.cc
index e1fc242..d8d7a80 100644
--- a/chrome/test/base/testing_browser_process.cc
+++ b/chrome/test/base/testing_browser_process.cc
@@ -17,6 +17,7 @@
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/clipboard/clipboard.h"
 
 #if !defined(ENABLE_CONFIGURATION_POLICY)
 #include "chrome/browser/policy/policy_service_stub.h"
@@ -124,6 +125,14 @@ chromeos::OomPriorityManager* TestingBrowserProcess::oom_priority_manager() {
 }
 #endif  // defined(OS_CHROMEOS)
 
+ui::Clipboard* TestingBrowserProcess::clipboard() {
+  if (!clipboard_.get()) {
+    // Note that we need a MessageLoop for the next call to work.
+    clipboard_.reset(new ui::Clipboard);
+  }
+  return clipboard_.get();
+}
+
 extensions::EventRouterForwarder*
 TestingBrowserProcess::extension_event_router_forwarder() {
   return NULL;
diff --git a/chrome/test/base/testing_browser_process.h b/chrome/test/base/testing_browser_process.h
index 8fc1990..e5c573b 100644
--- a/chrome/test/base/testing_browser_process.h
+++ b/chrome/test/base/testing_browser_process.h
@@ -38,6 +38,10 @@ namespace prerender {
 class PrerenderTracker;
 }
 
+namespace ui {
+class Clipboard;
+}
+
 class TestingBrowserProcess : public BrowserProcess {
  public:
   TestingBrowserProcess();
@@ -66,6 +70,7 @@ class TestingBrowserProcess : public BrowserProcess {
   virtual chromeos::OomPriorityManager* oom_priority_manager() OVERRIDE;
 #endif  // defined(OS_CHROMEOS)
 
+  virtual ui::Clipboard* clipboard() OVERRIDE;
   virtual extensions::EventRouterForwarder*
       extension_event_router_forwarder() OVERRIDE;
   virtual NotificationUIManager* notification_ui_manager() OVERRIDE;
@@ -110,6 +115,7 @@ class TestingBrowserProcess : public BrowserProcess {
  private:
   scoped_ptr<content::NotificationService> notification_service_;
   unsigned int module_ref_count_;
+  scoped_ptr<ui::Clipboard> clipboard_;
   std::string app_locale_;
 
   // Weak pointer.
diff --git a/chrome_frame/test/chrome_frame_test_utils.cc b/chrome_frame/test/chrome_frame_test_utils.cc
index d8d1e13..ec79019 100644
--- a/chrome_frame/test/chrome_frame_test_utils.cc
+++ b/chrome_frame/test/chrome_frame_test_utils.cc
@@ -491,17 +491,19 @@ std::wstring GetPathAndQueryFromUrl(const std::wstring& url) {
 }
 
 std::wstring GetClipboardText() {
+  ui::Clipboard clipboard;
   string16 text16;
-  ui::Clipboard::GetForCurrentThread()->ReadText(
-      ui::Clipboard::BUFFER_STANDARD, &text16);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &text16);
   return UTF16ToWide(text16);
 }
 
 void SetClipboardText(const std::wstring& text) {
-  ui::ScopedClipboardWriter clipboard_writer(
-      ui::Clipboard::GetForCurrentThread(),
-      ui::Clipboard::BUFFER_STANDARD);
-  clipboard_writer.WriteText(WideToUTF16(text));
+  ui::Clipboard clipboard;
+  {
+    ui::ScopedClipboardWriter clipboard_writer(&clipboard,
+                                               ui::Clipboard::BUFFER_STANDARD);
+    clipboard_writer.WriteText(WideToUTF16(text));
+  }
 }
 
 bool AddCFMetaTag(std::string* html_data) {
diff --git a/content/browser/browser_main_loop.cc b/content/browser/browser_main_loop.cc
index c9a409a..faed5fc 100644
--- a/content/browser/browser_main_loop.cc
+++ b/content/browser/browser_main_loop.cc
@@ -46,7 +46,6 @@
 #include "net/base/ssl_config_service.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/tcp_client_socket.h"
-#include "ui/base/clipboard/clipboard.h"
 
 #if defined(USE_AURA)
 #include "content/browser/renderer_host/image_transport_factory.h"
@@ -237,7 +236,6 @@ BrowserMainLoop::BrowserMainLoop(const content::MainFunctionParams& parameters)
 
 BrowserMainLoop::~BrowserMainLoop() {
   DCHECK_EQ(this, g_current_browser_main_loop);
-  ui::Clipboard::DestroyClipboardForCurrentThread();
   g_current_browser_main_loop = NULL;
 }
 
diff --git a/content/browser/renderer_host/clipboard_message_filter.cc b/content/browser/renderer_host/clipboard_message_filter.cc
index 542ec1f..1de011e 100644
--- a/content/browser/renderer_host/clipboard_message_filter.cc
+++ b/content/browser/renderer_host/clipboard_message_filter.cc
@@ -31,8 +31,8 @@ namespace {
 // clipboard's contents.  // See http://crbug.com/5823.
 void WriteObjectsHelper(const ui::Clipboard::ObjectMap* objects) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ui::Clipboard::GetForCurrentThread()->WriteObjects(
-      ui::Clipboard::BUFFER_STANDARD, *objects);
+  static ui::Clipboard* clipboard = new ui::Clipboard;
+  clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD, *objects);
 }
 
 }  // namespace
@@ -244,6 +244,7 @@ void ClipboardMessageFilter::OnReadCustomData(
 ui::Clipboard* ClipboardMessageFilter::GetClipboard() {
   // We have a static instance of the clipboard service for use by all message
   // filters.  This instance lives for the life of the browser processes.
-  static ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  static ui::Clipboard* clipboard = new ui::Clipboard;
+
   return clipboard;
 }
diff --git a/content/shell/shell_aura.cc b/content/shell/shell_aura.cc
index ee4efad..b956aec 100644
--- a/content/shell/shell_aura.cc
+++ b/content/shell/shell_aura.cc
@@ -52,6 +52,13 @@ class ShellViewsDelegateAura : public ViewsDelegate {
   }
 
   // Overridden from ViewsDelegate:
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE {
+    if (!clipboard_.get()) {
+      clipboard_.reset(new ui::Clipboard);
+    }
+    return clipboard_.get();
+  }
+
   virtual void SaveWindowPlacement(const Widget* window,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
@@ -104,6 +111,7 @@ class ShellViewsDelegateAura : public ViewsDelegate {
   }
 
  private:
+  mutable scoped_ptr<ui::Clipboard> clipboard_;
   bool use_transparent_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellViewsDelegateAura);
diff --git a/ui/base/clipboard/clipboard.cc b/ui/base/clipboard/clipboard.cc
index b793f6e..d20d854 100644
--- a/ui/base/clipboard/clipboard.cc
+++ b/ui/base/clipboard/clipboard.cc
@@ -4,10 +4,8 @@
 
 #include "ui/base/clipboard/clipboard.h"
 
-#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 {
@@ -74,15 +72,6 @@ bool ValidateAndMapSharedBitmap(const Clipboard::ObjectMapParams& params,
   return true;
 }
 
-// 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";
@@ -92,33 +81,6 @@ const char Clipboard::kMimeTypeHTML[] = "text/html";
 const char Clipboard::kMimeTypeRTF[] = "text/rtf";
 const char Clipboard::kMimeTypePNG[] = "image/png";
 
-// static
-Clipboard* Clipboard::GetForCurrentThread() {
-  base::AutoLock lock(g_clipboard_map_lock.Get());
-
-  base::PlatformThreadId id = base::PlatformThread::CurrentId();
-  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()))
diff --git a/ui/base/clipboard/clipboard.h b/ui/base/clipboard/clipboard.h
index 82cdb91..b98cfc4 100644
--- a/ui/base/clipboard/clipboard.h
+++ b/ui/base/clipboard/clipboard.h
@@ -46,7 +46,6 @@ class NSString;
 #endif
 
 namespace ui {
-class ClipboardTest;
 
 class UI_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
  public:
@@ -183,18 +182,8 @@ class UI_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
     return static_cast<Buffer>(buffer);
   }
 
-  // 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
-  // clipboard, so it shouldn't be a problem.)
-  static void DestroyClipboardForCurrentThread();
+  Clipboard();
+  ~Clipboard();
 
   // Write a bunch of objects to the system clipboard. Copies are made of the
   // contents of |objects|. On Windows they are copied to the system clipboard.
@@ -295,10 +284,6 @@ class UI_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
  private:
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
-  friend class ClipboardTest;
-
-  Clipboard();
-  ~Clipboard();
 
   void DispatchObject(ObjectType type, const ObjectMapParams& params);
 
diff --git a/ui/base/clipboard/clipboard_unittest.cc b/ui/base/clipboard/clipboard_unittest.cc
index 1653313..1b7eb4c 100644
--- a/ui/base/clipboard/clipboard_unittest.cc
+++ b/ui/base/clipboard/clipboard_unittest.cc
@@ -8,7 +8,6 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ -20,6 +19,7 @@
 #include "ui/gfx/size.h"
 
 #if defined(OS_WIN)
+#include "base/message_loop.h"
 #include "ui/base/clipboard/clipboard_util_win.h"
 #endif
 
@@ -29,14 +29,21 @@
 
 namespace ui {
 
+#if defined(OS_WIN)
 class ClipboardTest : public PlatformTest {
  protected:
-  Clipboard& clipboard() { return clipboard_; }
+  virtual void SetUp() {
+    message_loop_.reset(new MessageLoopForUI());
+  }
+  virtual void TearDown() {
+  }
 
  private:
-  MessageLoopForUI message_loop_;
-  Clipboard clipboard_;
+  scoped_ptr<MessageLoop> message_loop_;
 };
+#elif defined(OS_POSIX)
+typedef PlatformTest ClipboardTest;
+#endif  // defined(OS_WIN)
 
 namespace {
 
@@ -48,55 +55,61 @@ bool MarkupMatches(const string16& expected_markup,
 }  // namespace
 
 TEST_F(ClipboardTest, ClearTest) {
+  Clipboard clipboard;
+
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(ASCIIToUTF16("clear me"));
   }
 
-  clipboard().Clear(Clipboard::BUFFER_STANDARD);
+  clipboard.Clear(Clipboard::BUFFER_STANDARD);
 
-  EXPECT_FALSE(clipboard().IsFormatAvailable(
+  EXPECT_FALSE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
-  EXPECT_FALSE(clipboard().IsFormatAvailable(
+  EXPECT_FALSE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(), Clipboard::BUFFER_STANDARD));
 }
 
 TEST_F(ClipboardTest, TextTest) {
+  Clipboard clipboard;
+
   string16 text(ASCIIToUTF16("This is a string16!#$")), text_result;
   std::string ascii_text;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(text);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  clipboard.ReadText(Clipboard::BUFFER_STANDARD, &text_result);
 
   EXPECT_EQ(text, text_result);
-  clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
+  clipboard.ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
 }
 
 TEST_F(ClipboardTest, HTMLTest) {
+  Clipboard clipboard;
+
   string16 markup(ASCIIToUTF16("<string>Hi!</string>")), markup_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHTML(markup, url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
                      &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
@@ -107,79 +120,84 @@ TEST_F(ClipboardTest, HTMLTest) {
 }
 
 TEST_F(ClipboardTest, RTFTest) {
+  Clipboard clipboard;
+
   std::string rtf =
       "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
       "This is some {\\b bold} text.\\par\n"
       "}";
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteRTF(rtf);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetRtfFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetRtfFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   std::string result;
-  clipboard().ReadRTF(Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadRTF(Clipboard::BUFFER_STANDARD, &result);
   EXPECT_EQ(rtf, result);
 }
 
 #if defined(TOOLKIT_GTK)
 TEST_F(ClipboardTest, MultipleBufferTest) {
+  Clipboard clipboard;
+
   string16 text(ASCIIToUTF16("Standard")), text_result;
   string16 markup(ASCIIToUTF16("<string>Selection</string>")), markup_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(text);
   }
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_SELECTION);
     clipboard_writer.WriteHTML(markup, url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  EXPECT_FALSE(clipboard().IsFormatAvailable(
-      Clipboard::GetPlainTextFormatType(),
-      Clipboard::BUFFER_SELECTION));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  EXPECT_FALSE(clipboard.IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
+                                           Clipboard::BUFFER_SELECTION));
 
-  EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                             Clipboard::BUFFER_STANDARD));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_SELECTION));
+  EXPECT_FALSE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                           Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_SELECTION));
 
-  clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
+  clipboard.ReadText(Clipboard::BUFFER_STANDARD, &text_result);
   EXPECT_EQ(text, text_result);
 
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_SELECTION, &markup_result, &url_result,
-                       &ignored, &ignored);
+  clipboard.ReadHTML(Clipboard::BUFFER_SELECTION, &markup_result, &url_result,
+                     &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 }
 #endif
 
 TEST_F(ClipboardTest, TrickyHTMLTest) {
+  Clipboard clipboard;
+
   string16 markup(ASCIIToUTF16("<em>Bye!<!--EndFragment --></em>")),
       markup_result;
   std::string url, url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHTML(markup, url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
-                       &ignored, &ignored);
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
+                     &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
   // TODO(playmobil): It's not clear that non windows clipboards need to support
@@ -190,22 +208,24 @@ TEST_F(ClipboardTest, TrickyHTMLTest) {
 
 #if defined(OS_WIN)
 TEST_F(ClipboardTest, UniodeHTMLTest) {
+  Clipboard clipboard;
+
   string16 markup(UTF8ToUTF16("<div>A \xc3\xb8 \xe6\xb0\xb4</div>")),
       markup_result;
   std::string url, url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHTML(markup, url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   uint32 fragment_start;
   uint32 fragment_end;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
-                       &fragment_start, &fragment_end);
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
+                     &fragment_start, &fragment_end);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
   EXPECT_EQ(url, url_result);
   // Make sure that fragment indices were adjusted when converting.
@@ -217,20 +237,21 @@ TEST_F(ClipboardTest, UniodeHTMLTest) {
 #if defined(TOOLKIT_GTK)
 // Regression test for crbug.com/56298 (pasting empty HTML crashes Linux).
 TEST_F(ClipboardTest, EmptyHTMLTest) {
+  Clipboard clipboard;
   // ScopedClipboardWriter doesn't let us write empty data to the clipboard.
-  clipboard().clipboard_data_ = new Clipboard::TargetMap();
+  clipboard.clipboard_data_ = new Clipboard::TargetMap();
   // The 1 is so the compiler doesn't warn about allocating an empty array.
   char* empty = new char[1];
-  clipboard().InsertMapping("text/html", empty, 0U);
-  clipboard().SetGtkClipboard(Clipboard::BUFFER_STANDARD);
+  clipboard.InsertMapping("text/html", empty, 0U);
+  clipboard.SetGtkClipboard(Clipboard::BUFFER_STANDARD);
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   string16 markup_result;
   std::string url_result;
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
-                       &ignored, &ignored);
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
+                     &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, string16(), markup_result);
 }
 #endif
@@ -238,82 +259,88 @@ TEST_F(ClipboardTest, EmptyHTMLTest) {
 // TODO(estade): Port the following test (decide what target we use for urls)
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
 TEST_F(ClipboardTest, BookmarkTest) {
+  Clipboard clipboard;
+
   string16 title(ASCIIToUTF16("The Example Company")), title_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBookmark(title, url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetUrlWFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  clipboard().ReadBookmark(&title_result, &url_result);
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetUrlWFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  clipboard.ReadBookmark(&title_result, &url_result);
   EXPECT_EQ(title, title_result);
   EXPECT_EQ(url, url_result);
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(ClipboardTest, MultiFormatTest) {
+  Clipboard clipboard;
+
   string16 text(ASCIIToUTF16("Hi!")), text_result;
   string16 markup(ASCIIToUTF16("<strong>Hi!</string>")), markup_result;
   std::string url("http://www.example.com/"), url_result;
   std::string ascii_text;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHTML(markup, url);
     clipboard_writer.WriteText(text);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(), Clipboard::BUFFER_STANDARD));
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
-                       &ignored, &ignored);
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
+                     &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
   // TODO(playmobil): It's not clear that non windows clipboards need to support
   // this.
   EXPECT_EQ(url, url_result);
 #endif  // defined(OS_WIN)
-  clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
+  clipboard.ReadText(Clipboard::BUFFER_STANDARD, &text_result);
   EXPECT_EQ(text, text_result);
-  clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
+  clipboard.ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
 }
 
 TEST_F(ClipboardTest, URLTest) {
+  Clipboard clipboard;
+
   string16 url(ASCIIToUTF16("http://www.google.com/"));
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteURL(url);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   string16 text_result;
-  clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
+  clipboard.ReadText(Clipboard::BUFFER_STANDARD, &text_result);
 
   EXPECT_EQ(text_result, url);
 
   std::string ascii_text;
-  clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
+  clipboard.ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   ascii_text.clear();
-  clipboard().ReadAsciiText(Clipboard::BUFFER_SELECTION, &ascii_text);
+  clipboard.ReadAsciiText(Clipboard::BUFFER_SELECTION, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
 #endif
 }
@@ -339,7 +366,7 @@ TEST_F(ClipboardTest, SharedBitmapTest) {
   shared_buf.ShareToProcess(current_process, &handle_to_share);
   ASSERT_TRUE(shared_buf.Unmap());
 
-  // Setup data for clipboard().
+  // Setup data for clipboard.
   Clipboard::ObjectMapParam placeholder_param;
   Clipboard::ObjectMapParam size_param;
   const char* size_data = reinterpret_cast<const char*>(&fake_bitmap_size);
@@ -354,10 +381,11 @@ TEST_F(ClipboardTest, SharedBitmapTest) {
   objects[Clipboard::CBF_SMBITMAP] = params;
   Clipboard::ReplaceSharedMemHandle(&objects, handle_to_share, current_process);
 
-  clipboard().WriteObjects(Clipboard::BUFFER_STANDARD, objects);
+  Clipboard clipboard;
+  clipboard.WriteObjects(Clipboard::BUFFER_STANDARD, objects);
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetBitmapFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
 }
 
 // The following test somehow fails on GTK. The image when read back from the
@@ -365,6 +393,8 @@ TEST_F(ClipboardTest, SharedBitmapTest) {
 // channels stay intact. So I am turning this on only for aura.
 #if (defined(USE_AURA) && !defined(OS_WIN)) || defined(OS_ANDROID)
 TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
+  Clipboard clipboard;
+
   // Test first bitmap
   unsigned int fake_bitmap_1[] = {
     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
@@ -373,13 +403,13 @@ TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
   };
   gfx::Size fake_bitmap_1_size(3, 4);
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBitmapFromPixels(fake_bitmap_1, fake_bitmap_1_size);
   }
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  SkBitmap image_1 = clipboard().ReadImage(Clipboard::BUFFER_STANDARD);
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetBitmapFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  SkBitmap image_1 = clipboard.ReadImage(Clipboard::BUFFER_STANDARD);
   EXPECT_EQ(fake_bitmap_1_size, gfx::Size(image_1.width(), image_1.height()));
   unsigned int* pixels_1 = reinterpret_cast<unsigned int*>(image_1.getPixels());
   for (int i = 0; i < fake_bitmap_1_size.width(); ++i) {
@@ -401,13 +431,13 @@ TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
   };
   gfx::Size fake_bitmap_2_size(7, 2);
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBitmapFromPixels(fake_bitmap_2, fake_bitmap_2_size);
   }
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
-  SkBitmap image_2 = clipboard().ReadImage(Clipboard::BUFFER_STANDARD);
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetBitmapFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
+  SkBitmap image_2 = clipboard.ReadImage(Clipboard::BUFFER_STANDARD);
   EXPECT_EQ(fake_bitmap_2_size, gfx::Size(image_2.width(), image_2.height()));
   unsigned int* pixels_2 = reinterpret_cast<unsigned int*>(image_2.getPixels());
   for (int i = 0; i < fake_bitmap_2_size.width(); ++i) {
@@ -420,6 +450,7 @@ TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
 #endif
 
 TEST_F(ClipboardTest, DataTest) {
+  Clipboard clipboard;
   const ui::Clipboard::FormatType kFormat =
       ui::Clipboard::GetFormatType("chromium/x-test-format");
   std::string payload("test string");
@@ -427,15 +458,15 @@ TEST_F(ClipboardTest, DataTest) {
   write_pickle.WriteString(payload);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WritePickledData(write_pickle, kFormat);
   }
 
-  ASSERT_TRUE(clipboard().IsFormatAvailable(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat, Clipboard::BUFFER_STANDARD));
   std::string output;
-  clipboard().ReadData(kFormat, &output);
+  clipboard.ReadData(kFormat, &output);
   ASSERT_FALSE(output.empty());
 
   Pickle read_pickle(output.data(), output.size());
@@ -446,6 +477,7 @@ TEST_F(ClipboardTest, DataTest) {
 }
 
 TEST_F(ClipboardTest, MultipleDataTest) {
+  Clipboard clipboard;
   const ui::Clipboard::FormatType kFormat1 =
       ui::Clipboard::GetFormatType("chromium/x-test-format1");
   std::string payload1("test string1");
@@ -459,19 +491,19 @@ TEST_F(ClipboardTest, MultipleDataTest) {
   write_pickle2.WriteString(payload2);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
     // overwrite the previous pickle for fun
     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
   }
 
-  ASSERT_TRUE(clipboard().IsFormatAvailable(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat2, Clipboard::BUFFER_STANDARD));
 
   // Check string 2.
   std::string output2;
-  clipboard().ReadData(kFormat2, &output2);
+  clipboard.ReadData(kFormat2, &output2);
   ASSERT_FALSE(output2.empty());
 
   Pickle read_pickle2(output2.data(), output2.size());
@@ -481,19 +513,19 @@ TEST_F(ClipboardTest, MultipleDataTest) {
   EXPECT_EQ(payload2, unpickled_string2);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
     // overwrite the previous pickle for fun
     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
   }
 
-  ASSERT_TRUE(clipboard().IsFormatAvailable(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat1, Clipboard::BUFFER_STANDARD));
 
   // Check string 1.
   std::string output1;
-  clipboard().ReadData(kFormat1, &output1);
+  clipboard.ReadData(kFormat1, &output1);
   ASSERT_FALSE(output1.empty());
 
   Pickle read_pickle1(output1.data(), output1.size());
@@ -505,6 +537,8 @@ TEST_F(ClipboardTest, MultipleDataTest) {
 
 #if defined(OS_WIN)  // Windows only tests.
 TEST_F(ClipboardTest, HyperlinkTest) {
+  Clipboard clipboard;
+
   const std::string kTitle("The Example Company");
   const std::string kUrl("http://www.example.com/");
   const std::string kExpectedHtml("<a href=\"http://www.example.com/\">"
@@ -513,27 +547,29 @@ TEST_F(ClipboardTest, HyperlinkTest) {
   string16 html_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteHyperlink(ASCIIToUTF16(kTitle), kUrl);
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetHtmlFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
   uint32 ignored;
-  clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &html_result, &url_result,
-                       &ignored, &ignored);
+  clipboard.ReadHTML(Clipboard::BUFFER_STANDARD, &html_result, &url_result,
+                     &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, ASCIIToUTF16(kExpectedHtml), html_result);
 }
 
 TEST_F(ClipboardTest, WebSmartPasteTest) {
+  Clipboard clipboard;
+
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteWebSmartPaste();
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetWebKitSmartPasteFormatType(), Clipboard::BUFFER_STANDARD));
 }
 
@@ -544,14 +580,16 @@ TEST_F(ClipboardTest, BitmapTest) {
     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
   };
 
+  Clipboard clipboard;
+
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBitmapFromPixels(fake_bitmap, gfx::Size(3, 4));
   }
 
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
-                                            Clipboard::BUFFER_STANDARD));
+  EXPECT_TRUE(clipboard.IsFormatAvailable(Clipboard::GetBitmapFormatType(),
+                                          Clipboard::BUFFER_STANDARD));
 }
 
 void HtmlTestHelper(const std::string& cf_html,
@@ -599,8 +637,10 @@ TEST_F(ClipboardTest, HtmlTest) {
 
 // Test writing all formats we have simultaneously.
 TEST_F(ClipboardTest, WriteEverything) {
+  Clipboard clipboard;
+
   {
-    ScopedClipboardWriter writer(&clipboard(), Clipboard::BUFFER_STANDARD);
+    ScopedClipboardWriter writer(&clipboard, Clipboard::BUFFER_STANDARD);
     writer.WriteText(UTF8ToUTF16("foo"));
     writer.WriteURL(UTF8ToUTF16("foo"));
     writer.WriteHTML(UTF8ToUTF16("foo"), "bar");
@@ -624,9 +664,10 @@ TEST_F(ClipboardTest, InternalClipboardInvalidation) {
     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
   };
 
-  // Write a bitmap in our clipboard().
+  // Write a bitmap in our clipboard.
+  Clipboard clipboard;
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
+    ScopedClipboardWriter clipboard_writer(&clipboard,
                                            Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteBitmapFromPixels(kFakeBitmap, gfx::Size(3, 4));
   }
@@ -667,16 +708,16 @@ TEST_F(ClipboardTest, InternalClipboardInvalidation) {
                       env->NewStringUTF(new_value.c_str()));
 
   // The bitmap that should have been available should be gone.
-  EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
-                                             Clipboard::BUFFER_STANDARD));
+  EXPECT_FALSE(clipboard.IsFormatAvailable(Clipboard::GetBitmapFormatType(),
+                                           Clipboard::BUFFER_STANDARD));
 
   // Make sure some text is available
-  EXPECT_TRUE(clipboard().IsFormatAvailable(
+  EXPECT_TRUE(clipboard.IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
 
   // Make sure the text is what we inserted while simulating the other app
   std::string contents;
-  clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &contents);
+  clipboard.ReadAsciiText(Clipboard::BUFFER_STANDARD, &contents);
   EXPECT_EQ(contents, new_value);
 }
 #endif
diff --git a/ui/views/controls/message_box_view.cc b/ui/views/controls/message_box_view.cc
index 5d5e909..960b316 100644
--- a/ui/views/controls/message_box_view.cc
+++ b/ui/views/controls/message_box_view.cc
@@ -17,6 +17,7 @@
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
+#include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/client_view.h"
 
@@ -139,7 +140,10 @@ bool MessageBoxView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   if (prompt_field_ && prompt_field_->HasFocus())
     return false;
 
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  if (!ViewsDelegate::views_delegate)
+    return false;
+
+  ui::Clipboard* clipboard = ViewsDelegate::views_delegate->GetClipboard();
   if (!clipboard)
     return false;
 
diff --git a/ui/views/controls/textfield/native_textfield_views.cc b/ui/views/controls/textfield/native_textfield_views.cc
index 80474c9..f1cdf26 100644
--- a/ui/views/controls/textfield/native_textfield_views.cc
+++ b/ui/views/controls/textfield/native_textfield_views.cc
@@ -37,6 +37,7 @@
 #include "ui/views/controls/textfield/textfield_views_model.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/metrics.h"
+#include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "unicode/uchar.h"
 
@@ -585,8 +586,8 @@ bool NativeTextfieldViews::IsCommandIdEnabled(int command_id) const {
     case IDS_APP_COPY:
       return model_->HasSelection() && !textfield_->IsObscured();
     case IDS_APP_PASTE:
-      ui::Clipboard::GetForCurrentThread()->ReadText(
-          ui::Clipboard::BUFFER_STANDARD, &result);
+      ViewsDelegate::views_delegate->GetClipboard()
+          ->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
       return editable && !result.empty();
     case IDS_APP_DELETE:
       return editable && model_->HasSelection();
diff --git a/ui/views/controls/textfield/native_textfield_views_unittest.cc b/ui/views/controls/textfield/native_textfield_views_unittest.cc
index 392c010..c78bbf8 100644
--- a/ui/views/controls/textfield/native_textfield_views_unittest.cc
+++ b/ui/views/controls/textfield/native_textfield_views_unittest.cc
@@ -34,6 +34,7 @@
 #include "ui/views/ime/mock_input_method.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/views_test_base.h"
+#include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/widget.h"
 
@@ -234,14 +235,14 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
 
   string16 GetClipboardText() const {
     string16 text;
-    ui::Clipboard::GetForCurrentThread()->
+    views::ViewsDelegate::views_delegate->GetClipboard()->
         ReadText(ui::Clipboard::BUFFER_STANDARD, &text);
     return text;
   }
 
   void SetClipboardText(const std::string& text) {
     ui::ScopedClipboardWriter clipboard_writer(
-        ui::Clipboard::GetForCurrentThread(),
+        views::ViewsDelegate::views_delegate->GetClipboard(),
         ui::Clipboard::BUFFER_STANDARD);
     clipboard_writer.WriteText(ASCIIToUTF16(text));
   }
@@ -1102,7 +1103,7 @@ TEST_F(NativeTextfieldViewsTest, ReadOnlyTest) {
   EXPECT_STR_NE(" one two three ", str);
 
   SendKeyEvent(ui::VKEY_C, false, true);
-  ui::Clipboard::GetForCurrentThread()->
+  views::ViewsDelegate::views_delegate->GetClipboard()->
       ReadText(ui::Clipboard::BUFFER_STANDARD, &str);
   EXPECT_STR_EQ(" one two three ", str);
 
diff --git a/ui/views/controls/textfield/native_textfield_win.cc b/ui/views/controls/textfield/native_textfield_win.cc
index d5277d9..c356451 100644
--- a/ui/views/controls/textfield/native_textfield_win.cc
+++ b/ui/views/controls/textfield/native_textfield_win.cc
@@ -33,6 +33,7 @@
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/metrics.h"
+#include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
@@ -559,9 +560,9 @@ void NativeTextfieldWin::OnCopy() {
     return;
 
   const string16 text(GetSelectedText());
-  if (!text.empty()) {
+  if (!text.empty() && ViewsDelegate::views_delegate) {
     ui::ScopedClipboardWriter scw(
-        ui::Clipboard::GetForCurrentThread(),
+        ViewsDelegate::views_delegate->GetClipboard(),
         ui::Clipboard::BUFFER_STANDARD);
     scw.WriteText(text);
   }
@@ -974,10 +975,10 @@ void NativeTextfieldWin::OnNonLButtonDown(UINT keys, const CPoint& point) {
 }
 
 void NativeTextfieldWin::OnPaste() {
-  if (textfield_->read_only())
+  if (textfield_->read_only() || !ViewsDelegate::views_delegate)
     return;
 
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard* clipboard = ViewsDelegate::views_delegate->GetClipboard();
   if (!clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                     ui::Clipboard::BUFFER_STANDARD))
     return;
diff --git a/ui/views/controls/textfield/textfield_views_model.cc b/ui/views/controls/textfield/textfield_views_model.cc
index 89fe947..d51e417 100644
--- a/ui/views/controls/textfield/textfield_views_model.cc
+++ b/ui/views/controls/textfield/textfield_views_model.cc
@@ -20,6 +20,7 @@
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/controls/textfield/textfield.h"
+#include "ui/views/views_delegate.h"
 
 namespace views {
 
@@ -510,7 +511,7 @@ bool TextfieldViewsModel::Redo() {
 bool TextfieldViewsModel::Cut() {
   if (!HasCompositionText() && HasSelection() && !render_text_->is_obscured()) {
     ui::ScopedClipboardWriter(
-        ui::Clipboard::GetForCurrentThread(),
+        views::ViewsDelegate::views_delegate->GetClipboard(),
         ui::Clipboard::BUFFER_STANDARD).WriteText(GetSelectedText());
     // A trick to let undo/redo handle cursor correctly.
     // Undoing CUT moves the cursor to the end of the change rather
@@ -528,7 +529,7 @@ bool TextfieldViewsModel::Cut() {
 bool TextfieldViewsModel::Copy() {
   if (!HasCompositionText() && HasSelection() && !render_text_->is_obscured()) {
     ui::ScopedClipboardWriter(
-        ui::Clipboard::GetForCurrentThread(),
+        views::ViewsDelegate::views_delegate->GetClipboard(),
         ui::Clipboard::BUFFER_STANDARD).WriteText(GetSelectedText());
     return true;
   }
@@ -537,7 +538,7 @@ bool TextfieldViewsModel::Copy() {
 
 bool TextfieldViewsModel::Paste() {
   string16 result;
-  ui::Clipboard::GetForCurrentThread()
+  views::ViewsDelegate::views_delegate->GetClipboard()
       ->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   if (!result.empty()) {
     InsertTextInternal(result, false);
diff --git a/ui/views/controls/textfield/textfield_views_model_unittest.cc b/ui/views/controls/textfield/textfield_views_model_unittest.cc
index a94bf4d..376f7d4 100644
--- a/ui/views/controls/textfield/textfield_views_model_unittest.cc
+++ b/ui/views/controls/textfield/textfield_views_model_unittest.cc
@@ -18,6 +18,7 @@
 #include "ui/views/controls/textfield/textfield_views_model.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/views_test_base.h"
+#include "ui/views/views_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
@@ -494,7 +495,7 @@ TEST_F(TextfieldViewsModelTest, SetText) {
 #endif
 TEST_F(TextfieldViewsModelTest, MAYBE_Clipboard) {
   ui::Clipboard* clipboard
-      = ui::Clipboard::GetForCurrentThread();
+      = views::ViewsDelegate::views_delegate->GetClipboard();
   string16 initial_clipboard_text = ASCIIToUTF16("initial text");
   ui::ScopedClipboardWriter(
       clipboard,
diff --git a/ui/views/test/test_views_delegate.cc b/ui/views/test/test_views_delegate.cc
index e87f18d..2ae2aa4 100644
--- a/ui/views/test/test_views_delegate.cc
+++ b/ui/views/test/test_views_delegate.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "content/public/test/web_contents_tester.h"
+#include "ui/base/clipboard/clipboard.h"
 
 namespace views {
 
@@ -23,6 +24,14 @@ void TestViewsDelegate::SetUseTransparentWindows(bool transparent) {
   use_transparent_windows_ = transparent;
 }
 
+ui::Clipboard* TestViewsDelegate::GetClipboard() const {
+  if (!clipboard_.get()) {
+    // Note that we need a MessageLoop for the next call to work.
+    clipboard_.reset(new ui::Clipboard);
+  }
+  return clipboard_.get();
+}
+
 void TestViewsDelegate::SaveWindowPlacement(const Widget* window,
                                             const std::string& window_name,
                                             const gfx::Rect& bounds,
diff --git a/ui/views/test/test_views_delegate.h b/ui/views/test/test_views_delegate.h
index 6568196..54ae0be 100644
--- a/ui/views/test/test_views_delegate.h
+++ b/ui/views/test/test_views_delegate.h
@@ -28,6 +28,7 @@ class TestViewsDelegate : public ViewsDelegate {
   void SetUseTransparentWindows(bool transparent);
 
   // Overridden from ViewsDelegate:
+  virtual ui::Clipboard* GetClipboard() const OVERRIDE;
   virtual void SaveWindowPlacement(const Widget* window,
                                    const std::string& window_name,
                                    const gfx::Rect& bounds,
@@ -68,6 +69,7 @@ class TestViewsDelegate : public ViewsDelegate {
       content::SiteInstance* site_instance) OVERRIDE;
 
  private:
+  mutable scoped_ptr<ui::Clipboard> clipboard_;
   bool use_transparent_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewsDelegate);
diff --git a/ui/views/view_unittest.cc b/ui/views/view_unittest.cc
index 5b08793..45d83b5 100644
--- a/ui/views/view_unittest.cc
+++ b/ui/views/view_unittest.cc
@@ -1168,6 +1168,8 @@ TEST_F(ViewTest, Textfield) {
   const string16 kExtraText = ASCIIToUTF16("Pretty deep, Philip!");
   const string16 kEmptyString;
 
+  ui::Clipboard clipboard;
+
   Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
   params.bounds = gfx::Rect(0, 0, 100, 100);
@@ -1204,7 +1206,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   const string16 kReadOnlyText = ASCIIToUTF16("Read only");
   const string16 kPasswordText = ASCIIToUTF16("Password! ** Secret stuff **");
 
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard clipboard;
 
   Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
@@ -1233,7 +1235,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   ::SendMessage(normal->GetTestingHandle(), WM_CUT, 0, 0);
 
   string16 result;
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   EXPECT_EQ(kNormalText, result);
   normal->SetText(kNormalText);  // Let's revert to the original content.
 
@@ -1241,7 +1243,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   read_only->SelectAll(false);
   ::SendMessage(read_only->GetTestingHandle(), WM_CUT, 0, 0);
   result.clear();
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   // Cut should have failed, so the clipboard content should not have changed.
   EXPECT_EQ(kNormalText, result);
 
@@ -1249,7 +1251,7 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   password->SelectAll(false);
   ::SendMessage(password->GetTestingHandle(), WM_CUT, 0, 0);
   result.clear();
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   // Cut should have failed, so the clipboard content should not have changed.
   EXPECT_EQ(kNormalText, result);
 
@@ -1262,19 +1264,19 @@ TEST_F(ViewTest, TextfieldCutCopyPaste) {
   read_only->SelectAll(false);
   ::SendMessage(read_only->GetTestingHandle(), WM_COPY, 0, 0);
   result.clear();
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   EXPECT_EQ(kReadOnlyText, result);
 
   normal->SelectAll(false);
   ::SendMessage(normal->GetTestingHandle(), WM_COPY, 0, 0);
   result.clear();
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   EXPECT_EQ(kNormalText, result);
 
   password->SelectAll(false);
   ::SendMessage(password->GetTestingHandle(), WM_COPY, 0, 0);
   result.clear();
-  clipboard->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
+  clipboard.ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   // We don't let you copy from an obscured field, clipboard should not have
   // changed.
   EXPECT_EQ(kNormalText, result);
diff --git a/ui/views/views_delegate.h b/ui/views/views_delegate.h
index a3f8430..5fb3929 100644
--- a/ui/views/views_delegate.h
+++ b/ui/views/views_delegate.h
@@ -26,6 +26,10 @@ namespace gfx {
 class Rect;
 }
 
+namespace ui {
+class Clipboard;
+}
+
 namespace views {
 
 class NonClientFrameView;
@@ -50,6 +54,9 @@ class VIEWS_EXPORT ViewsDelegate {
 
   virtual ~ViewsDelegate() {}
 
+  // Gets the clipboard.
+  virtual ui::Clipboard* GetClipboard() const = 0;
+
   // Saves the position, size and "show" state for the window with the
   // specified name.
   virtual void SaveWindowPlacement(const Widget* widget,
diff --git a/webkit/tools/test_shell/simple_clipboard_impl.cc b/webkit/tools/test_shell/simple_clipboard_impl.cc
index d51e109..06d6c8b 100644
--- a/webkit/tools/test_shell/simple_clipboard_impl.cc
+++ b/webkit/tools/test_shell/simple_clipboard_impl.cc
@@ -23,6 +23,8 @@
 
 namespace {
 
+base::LazyInstance<ui::Clipboard> clipboard = LAZY_INSTANCE_INITIALIZER;
+
 }  // anonymous namespace
 
 SimpleClipboardClient::SimpleClipboardClient() {
@@ -33,7 +35,7 @@ SimpleClipboardClient::~SimpleClipboardClient() {
 
 
 ui::Clipboard* SimpleClipboardClient::GetClipboard() {
-  return ui::Clipboard::GetForCurrentThread();
+  return clipboard.Pointer();
 }
 
 uint64 SimpleClipboardClient::GetSequenceNumber(ui::Clipboard::Buffer buffer) {