Make sure that Clipboard operations that require dispatching...

chrome/browser/resource_message_filter.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/resource_message_filter.h"
 
 #include "base/clipboard.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/histogram.h"
 #include "base/thread.h"
@@ skipping 44 matching lines @@
       host->OnMessageReceived(context_menu_message_);
   }
 
  private:
   int render_process_host_id_;
   const ViewHostMsg_ContextMenu context_menu_message_;
 
   DISALLOW_COPY_AND_ASSIGN(ContextMenuMessageDispatcher);
 };
 
+// Completes a clipboard write initiated by the renderer. The write must be
+// performed on the UI thread because the clipboard service from the IO thread
+// cannot create windows so it cannot be the "owner" of the clipboard's
+// contents.
+class WriteClipboardTask : public Task {
+ public:
+  explicit WriteClipboardTask(Clipboard::ObjectMap* objects)
+      : objects_(objects) {}
+  ~WriteClipboardTask() {}
+
+  void Run() {
+    g_browser_process->clipboard_service()->WriteObjects(*objects_.get());
+  }
+
+ private:
+  scoped_ptr<Clipboard::ObjectMap> objects_;
+};
+
+
 }  // namespace
 
 ResourceMessageFilter::ResourceMessageFilter(
     ResourceDispatcherHost* resource_dispatcher_host,
     PluginService* plugin_service,
     printing::PrintJobManager* print_job_manager,
     int render_process_host_id,
     Profile* profile,
     RenderWidgetHelper* render_widget_helper,
     SpellChecker* spellchecker)
@@ skipping 363 matching lines @@
                                           const GURL& referrer) {
   resource_dispatcher_host_->BeginDownload(url,
                                            referrer,
                                            render_process_host_id_,
                                            message.routing_id(),
                                            request_context_);
 }
 
 void ResourceMessageFilter::OnClipboardWriteObjects(
     const Clipboard::ObjectMap& objects) {
+  // We cannot write directly from the IO thread, and cannot service the IPC
+  // on the UI thread. We'll copy the relevant data and get a handle to any
+  // shared memory so it doesn't go away when we resume the renderer, and post
+  // a task to perform the write on the UI thread.
+  Clipboard::ObjectMap* long_living_objects = new Clipboard::ObjectMap(objects); 
+
   // We pass the render_handle_ to assist the clipboard with using shared
   // memory objects. render_handle_ is a handle to the process that would
   // own any shared memory that might be in the object list.
-  GetClipboardService()->WriteObjects(objects, render_handle_);
+  Clipboard::DuplicateRemoteHandles(render_handle_, long_living_objects);
+
+  render_widget_helper_->ui_loop()->PostTask(FROM_HERE,
+      new WriteClipboardTask(long_living_objects));
 }
 
 void ResourceMessageFilter::OnClipboardIsFormatAvailable(unsigned int format,
                                                          bool* result) {
   DCHECK(result);
   *result = GetClipboardService()->IsFormatAvailable(format);
 }
 
 void ResourceMessageFilter::OnClipboardReadText(std::wstring* result) {
   GetClipboardService()->ReadText(result);
@@ skipping 224 matching lines @@
   if (type == NOTIFY_SPELLCHECKER_REINITIALIZED) {
     spellchecker_ = Details<SpellcheckerReinitializedDetails>
         (details).ptr()->spellchecker;
   }
 }
 
 void ResourceMessageFilter::OnDnsPrefetch(
     const std::vector<std::string>& hostnames) {
   chrome_browser_net::DnsPrefetchList(hostnames);
 }