Make sure that Clipboard operations that require dispatching...

base/clipboard_win.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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include <shlobj.h>
 #include <shellapi.h>
 
 #include "base/clipboard.h"
 
 #include "base/clipboard_util.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "base/string_util.h"
 
 namespace {
 
 // A scoper to manage acquiring and automatically releasing the clipboard.
 class ScopedClipboard {
  public:
   ScopedClipboard() : opened_(false) { }
 
   ~ScopedClipboard() {
@@ skipping 50 matching lines @@
  private:
   bool opened_;
 };
 
 LRESULT CALLBACK ClipboardOwnerWndProc(HWND hwnd,
                                        UINT message,
                                        WPARAM wparam,
                                        LPARAM lparam) {
   LRESULT lresult = 0;
 
-  switch(message) {
+  switch (message) {
   case WM_RENDERFORMAT:
     // This message comes when SetClipboardData was sent a null data handle
     // and now it's come time to put the data on the clipboard.
     // We always set data, so there isn't a need to actually do anything here.
     break;
   case WM_RENDERALLFORMATS:
     // This message comes when SetClipboardData was sent a null data handle
     // and now this application is about to quit, so it must put data on
     // the clipboard before it exits.
     // We always set data, so there isn't a need to actually do anything here.
@@ skipping 19 matching lines @@
     charT* raw_data = static_cast<charT*>(::GlobalLock(data));
     memcpy(raw_data, str.data(), str.size() * sizeof(charT));
     raw_data[str.size()] = '\0';
     ::GlobalUnlock(data);
   }
   return data;
 };
 
 } // namespace
 
-Clipboard::Clipboard() {
-  // make a dummy HWND to be the clipboard's owner
-  WNDCLASSEX wcex = {0};
-  wcex.cbSize = sizeof(WNDCLASSEX);
-  wcex.lpfnWndProc = ClipboardOwnerWndProc;
-  wcex.hInstance = GetModuleHandle(NULL);
-  wcex.lpszClassName = L"ClipboardOwnerWindowClass";
-  ::RegisterClassEx(&wcex);
+Clipboard::Clipboard() : create_window_(false) {
+  if (MessageLoop::current()->type() == MessageLoop::TYPE_UI) {
+    // Make a dummy HWND to be the clipboard's owner.
+    WNDCLASSEX wcex = {0};
+    wcex.cbSize = sizeof(WNDCLASSEX);
+    wcex.lpfnWndProc = ClipboardOwnerWndProc;
+    wcex.hInstance = GetModuleHandle(NULL);
+    wcex.lpszClassName = L"ClipboardOwnerWindowClass";
+    ::RegisterClassEx(&wcex);
+    create_window_ = true;
+  }
 
   clipboard_owner_ = NULL;
 }
 
 Clipboard::~Clipboard() {
   if (clipboard_owner_)
     ::DestroyWindow(clipboard_owner_);
   clipboard_owner_ = NULL;
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   WriteObjects(objects, NULL);
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects,
                              base::ProcessHandle process) {
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   ::EmptyClipboard();
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     if (iter->first == CBF_SMBITMAP)
       WriteBitmapFromSharedMemory(&(iter->second[0].front()),
                                   &(iter->second[1].front()),
                                   process);
-    else 
+    else
       DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
   std::wstring text;
   UTF8ToWide(text_data, text_len, &text);
   HGLOBAL glob = CreateGlobalData(text);
 
   WriteToClipboard(CF_UNICODETEXT, glob);
@@ skipping 44 matching lines @@
   link.append(url);
   link.append("\">");
   link.append(title);
   link.append("</a>");
 
   // Store hyperlink as html.
   WriteHTML(link.c_str(), link.size(), NULL, 0);
 }
 
 void Clipboard::WriteWebSmartPaste() {
+  DCHECK(clipboard_owner_);
   ::SetClipboardData(GetWebKitSmartPasteFormatType(), NULL);
 }
 
 void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
   const gfx::Size* size = reinterpret_cast<const gfx::Size*>(size_data);
   HDC dc = ::GetDC(NULL);
 
   // This doesn't actually cost us a memcpy when the bitmap comes from the
   // renderer as we load it into the bitmap using setPixels which just sets a
   // pointer.  Someone has to memcpy it into GDI, it might as well be us here.
@@ skipping 22 matching lines @@
     WriteBitmapFromHandle(source_hbitmap, *size);
   }
 
   ::DeleteObject(source_hbitmap);
   ::ReleaseDC(NULL, dc);
 }
 
 void Clipboard::WriteBitmapFromSharedMemory(const char* bitmap_data,
                                             const char* size_data,
                                             base::ProcessHandle process) {
-  const base::SharedMemoryHandle* remote_bitmap_handle =
-      reinterpret_cast<const base::SharedMemoryHandle*>(bitmap_data);
   const gfx::Size* size = reinterpret_cast<const gfx::Size*>(size_data);
 
-  base::SharedMemory bitmap(*remote_bitmap_handle, false, process);
+  // bitmap_data has an encoded shared memory object. See
+  // DuplicateRemoteHandles().
+  char* ptr = const_cast<char*>(bitmap_data);
+  scoped_ptr<const base::SharedMemory> bitmap(*
+      reinterpret_cast<const base::SharedMemory**>(ptr));
 
-  // TODO(darin): share data in gfx/bitmap_header.cc somehow
+  // TODO(darin): share data in gfx/bitmap_header.cc somehow.
   BITMAPINFO bm_info = {0};
   bm_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   bm_info.bmiHeader.biWidth = size->width();
   bm_info.bmiHeader.biHeight = -size->height();  // Sets the vertical orientation
   bm_info.bmiHeader.biPlanes = 1;
   bm_info.bmiHeader.biBitCount = 32;
   bm_info.bmiHeader.biCompression = BI_RGB;
 
   HDC dc = ::GetDC(NULL);
 
   // We can create an HBITMAP directly using the shared memory handle, saving
   // a memcpy.
   HBITMAP source_hbitmap =
       ::CreateDIBSection(dc, &bm_info, DIB_RGB_COLORS, NULL,
-                         bitmap.handle(), 0);
+                         bitmap->handle(), 0);
 
   if (source_hbitmap) {
     // Now we can write the HBITMAP to the clipboard
     WriteBitmapFromHandle(source_hbitmap, *size);
   }
 
   ::DeleteObject(source_hbitmap);
   ::ReleaseDC(NULL, dc);
 }
 
@@ skipping 57 matching lines @@
   drop_files->fWide = TRUE;
 
   memcpy(data + sizeof DROPFILES, filenames.c_str(),
          filenames.length() * sizeof(wchar_t));
 
   ::GlobalUnlock(hdata);
   WriteToClipboard(CF_HDROP, hdata);
 }
 
 void Clipboard::WriteToClipboard(FormatType format, HANDLE handle) {
-  if (handle && !::SetClipboardData(format, handle))
+  DCHECK(clipboard_owner_);
+  if (handle && !::SetClipboardData(format, handle)) {
+    DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError());
     FreeData(format, handle);
+  }
 }
 
 bool Clipboard::IsFormatAvailable(unsigned int format) const {
   return ::IsClipboardFormatAvailable(format) != FALSE;
 }
 
 void Clipboard::ReadText(std::wstring* result) const {
   if (!result) {
     NOTREACHED();
     return;
@@ skipping 205 matching lines @@
 Clipboard::FormatType Clipboard::GetFileDescriptorFormatType() {
   return ClipboardUtil::GetFileDescriptorFormat()->cfFormat;
 }
 
 // static
 Clipboard::FormatType Clipboard::GetFileContentFormatZeroType() {
   return ClipboardUtil::GetFileContentFormatZero()->cfFormat;
 }
 
 // static
+void Clipboard::DuplicateRemoteHandles(base::ProcessHandle process,
+                                       ObjectMap* objects) {
+  for (ObjectMap::iterator iter = objects->begin(); iter != objects->end();
+       ++iter) {
+    if (iter->first == CBF_SMBITMAP) {
+      // There is a shared memory handle encoded on the first ObjectMapParam.
+      // Use it to open a local handle to the memory.
+      char* bitmap_data = &(iter->second[0].front());
+      base::SharedMemoryHandle* remote_bitmap_handle =
+          reinterpret_cast<base::SharedMemoryHandle*>(bitmap_data);
+
+      base::SharedMemory* bitmap = new base::SharedMemory(*remote_bitmap_handle,
+                                                          false, process);
+
+      // We store the object where the remote handle was located so it can
+      // be retrieved by the UI thread (see WriteBitmapFromSharedMemory()).
+      iter->second[0].clear();
+      for (size_t i = 0; i < sizeof(bitmap); i++)
+        iter->second[0].push_back(reinterpret_cast<char*>(&bitmap)[i]);
+    }
+  }
+}
+
+// static
 Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
   return ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat;
 }
 
 // static
 void Clipboard::FreeData(FormatType format, HANDLE data) {
   if (format == CF_BITMAP)
     ::DeleteObject(static_cast<HBITMAP>(data));
   else
     ::GlobalFree(data);
 }
 
 HWND Clipboard::GetClipboardWindow() const {
-  if (!clipboard_owner_) {
+  if (!clipboard_owner_ && create_window_) {
     clipboard_owner_ = ::CreateWindow(L"ClipboardOwnerWindowClass",
                                       L"ClipboardOwnerWindow",
                                       0, 0, 0, 0, 0,
                                       HWND_MESSAGE,
                                       0, 0, 0);
   }
   return clipboard_owner_;
 }