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/bind.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 {
 
 namespace {
 
@@ skipping 50 matching lines @@
       opened_ = false;
     } else {
       NOTREACHED();
     }
   }
 
  private:
   bool opened_;
 };
 
-LRESULT CALLBACK ClipboardOwnerWndProc(HWND hwnd,
-                                       UINT message,
-                                       WPARAM wparam,
-                                       LPARAM lparam) {
+bool ClipboardOwnerWndProc(UINT message,
+                           WPARAM wparam,
+                           LPARAM lparam,
+                           LRESULT* result) {
   LRESULT lresult = 0;

[dcheng, 2013/06/27 17:56:23]

Nit: Remove this, since it's unused.

[alexeypa (please no reviews), 2013/06/27 17:58:55]

Done.

 
   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 false;
   }
-  return lresult;
+
+  *result = 0;
+  return true;
 }
 
 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';
@@ skipping 60 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 base::win::MessageWindow());
 }
 
 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_->hwnd() != NULL);
   ::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_->hwnd() != NULL);
   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 433 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_;
+  if (!clipboard_owner_)
+    return NULL;
+
+  if (clipboard_owner_->hwnd() == NULL)
+    clipboard_owner_->Create(base::Bind(&ClipboardOwnerWndProc));
+
+  return clipboard_owner_->hwnd();
 }
 
 }  // namespace ui