ui::Clipboard now uses base::win::MessageWindow to create a message-only window on Windows.

ui/base/clipboard/clipboard_win.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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <shlobj.h>
 #include <shellapi.h>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop.h"
 #include "base/safe_numerics.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/win/message_window.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/wrapped_window_proc.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/clipboard_util_win.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
@@ skipping 53 matching lines @@
       opened_ = false;
     } else {
       NOTREACHED();
     }
   }
 
  private:
   bool opened_;
 };
 
-LRESULT CALLBACK ClipboardOwnerWndProc(HWND hwnd,
-                                       UINT message,
-                                       WPARAM wparam,
-                                       LPARAM lparam) {
-  LRESULT lresult = 0;
-
-  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.
-    break;
-  case WM_DRAWCLIPBOARD:
-    break;
-  case WM_DESTROY:
-    break;
-  case WM_CHANGECBCHAIN:
-    break;
-  default:
-    lresult = DefWindowProc(hwnd, message, wparam, lparam);
-    break;
-  }
-  return lresult;
-}
-
 template <typename charT>
 HGLOBAL CreateGlobalData(const std::basic_string<charT>& str) {
   HGLOBAL data =
     ::GlobalAlloc(GMEM_MOVEABLE, ((str.size() + 1) * sizeof(charT)));
   if (data) {
     charT* raw_data = static_cast<charT*>(::GlobalLock(data));
     memcpy(raw_data, str.data(), str.size() * sizeof(charT));
     raw_data[str.size()] = '\0';
     ::GlobalUnlock(data);
   }
@@ skipping 16 matching lines @@
 void MakeBitmapOpaque(const SkBitmap& bitmap) {
   for (int x = 0; x < bitmap.width(); ++x) {
     for (int y = 0; y < bitmap.height(); ++y) {
       *bitmap.getAddr32(x, y) = SkColorSetA(*bitmap.getAddr32(x, y), 0xFF);
     }
   }
 }
 
 }  // namespace
 
+// Used to create a message-only window handling clipboard-related window
+// messages. It is intended to be passed to OpenClipboard() API.
+class Clipboard::ClipboardWindow
+    : public base::win::MessageWindow::Delegate {
+ public:
+  ClipboardWindow();
+  virtual ~ClipboardWindow();
+
+  // Creates the window if it is not created yat and returns its handle. Returns
+  // NULL if an error occurs.
+  HWND GetHandle();
+
+  // Returns |true| if the window is created.
+  bool IsValid() const;
+
+ private:
+  // base::win::MessageWindow::Delegate interface.
+  virtual bool HandleMessage(HWND hwnd,
+                             UINT message,
+                             WPARAM wparam,
+                             LPARAM lparam,
+                             LRESULT* result) OVERRIDE;
+
+  base::win::MessageWindow window_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClipboardWindow);
+};
+
+
+Clipboard::ClipboardWindow::ClipboardWindow() {
+}
+
+Clipboard::ClipboardWindow::~ClipboardWindow() {
+}
+
+HWND Clipboard::ClipboardWindow::GetHandle() {
+  if (!IsValid())
+    window_.Create(this);
+
+  return window_.hwnd();
+}
+
+bool Clipboard::ClipboardWindow::IsValid() const {
+  return window_.hwnd() != NULL;
+}
+
+bool Clipboard::ClipboardWindow::HandleMessage(HWND hwnd,
+                                               UINT message,
+                                               WPARAM wparam,
+                                               LPARAM lparam,
+                                               LRESULT* result) {
+  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.
+    break;
+  case WM_DRAWCLIPBOARD:
+    break;
+  case WM_DESTROY:
+    break;
+  case WM_CHANGECBCHAIN:
+    break;
+  default:
+    return false;
+  }
+
+  *result = 0;
+  return true;
+}
+
 Clipboard::FormatType::FormatType() : data_() {}
 
 Clipboard::FormatType::FormatType(UINT native_format) : data_() {
   // There's no good way to actually initialize this in the constructor in
   // C++03.
   data_.cfFormat = native_format;
   data_.dwAspect = DVASPECT_CONTENT;
   data_.lindex = -1;
   data_.tymed = TYMED_HGLOBAL;
 }
@@ skipping 22 matching lines @@
     NOTREACHED();
     return FormatType();
   }
   return FormatType(clipboard_format);
 }
 
 bool Clipboard::FormatType::operator<(const FormatType& other) const {
   return ToUINT() < other.ToUINT();
 }
 
-Clipboard::Clipboard() : create_window_(false) {
-  if (base::MessageLoop::current()->type() == base::MessageLoop::TYPE_UI) {
-    // Make a dummy HWND to be the clipboard's owner.
-    WNDCLASSEX window_class;
-    base::win::InitializeWindowClass(
-        L"ClipboardOwnerWindowClass",
-        &base::win::WrappedWindowProc<ClipboardOwnerWndProc>,
-        0, 0, 0, NULL, NULL, NULL, NULL, NULL,
-        &window_class);
-    ::RegisterClassEx(&window_class);
-    create_window_ = true;
-  }
-
-  clipboard_owner_ = NULL;
+Clipboard::Clipboard() {
+  if (base::MessageLoop::current()->type() == base::MessageLoop::TYPE_UI)
+    clipboard_owner_.reset(new ClipboardWindow());
 }
 
 Clipboard::~Clipboard() {
-  if (clipboard_owner_)
-    ::DestroyWindow(clipboard_owner_);
-  clipboard_owner_ = NULL;
 }
 
 void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   ::EmptyClipboard();
@@ skipping 40 matching lines @@
   bookmark.append(1, L'\n');
   bookmark.append(url_data, url_len);
 
   string16 wide_bookmark = UTF8ToWide(bookmark);
   HGLOBAL glob = CreateGlobalData(wide_bookmark);
 
   WriteToClipboard(GetUrlWFormatType().ToUINT(), glob);
 }
 
 void Clipboard::WriteWebSmartPaste() {
-  DCHECK(clipboard_owner_);
+  DCHECK(clipboard_owner_->IsValid());
   ::SetClipboardData(GetWebKitSmartPasteFormatType().ToUINT(), 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 74 matching lines @@
   if (!hdata)
     return;
 
   char* data = static_cast<char*>(::GlobalLock(hdata));
   memcpy(data, data_data, data_len);
   ::GlobalUnlock(data);
   WriteToClipboard(format.ToUINT(), hdata);
 }
 
 void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
-  DCHECK(clipboard_owner_);
+  DCHECK(clipboard_owner_->IsValid());
   if (handle && !::SetClipboardData(format, handle)) {
     DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError());
     FreeData(format, handle);
   }
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
   return ::GetClipboardSequenceNumber();
 }
@@ skipping 426 matching lines @@
 
 // static
 void Clipboard::FreeData(unsigned int format, HANDLE data) {
   if (format == CF_BITMAP)
     ::DeleteObject(static_cast<HBITMAP>(data));
   else
     ::GlobalFree(data);
 }
 
 HWND Clipboard::GetClipboardWindow() const {
-  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_;
+  return clipboard_owner_ ? clipboard_owner_->GetHandle() : NULL;
 }
 
 }  // namespace ui