Moved code implementing message-only windows to a dedicated class (Windows only).

remoting/host/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.
 
 #include "remoting/host/clipboard.h"
 
 #include <windows.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/string16.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_hglobal.h"
 #include "base/win/windows_version.h"
 #include "base/win/wrapped_window_proc.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
+#include "remoting/host/win/message_window.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 
 namespace {
 
-const WCHAR kWindowClassName[] = L"clipboardWindowClass";
-const WCHAR kWindowName[] = L"clipboardWindow";
-
 // A scoper class that opens and closes the clipboard.
 // This class was adapted from the ScopedClipboard class in
 // ui/base/clipboard/clipboard_win.cc.
 class ScopedClipboard {
  public:
   ScopedClipboard() : opened_(false) {
   }
 
   ~ScopedClipboard() {
     if (opened_) {
@@ skipping 56 matching lines @@
   bool opened_;
 };
 
 typedef BOOL (WINAPI AddClipboardFormatListenerFn)(HWND);
 typedef BOOL (WINAPI RemoveClipboardFormatListenerFn)(HWND);
 
 }  // namespace
 
 namespace remoting {
 
-class ClipboardWin : public Clipboard {
+class ClipboardWin : public Clipboard,
+                     public win::MessageWindow::Delegate {
  public:
   ClipboardWin();
 
   virtual void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
   virtual void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) OVERRIDE;
   virtual void Stop() OVERRIDE;
 
  private:
   void OnClipboardUpdate();
-  bool HaveClipboardListenerApi();
 
-  static bool RegisterWindowClass();
-  static LRESULT CALLBACK WndProc(HWND hwmd, UINT msg, WPARAM wParam,
-                                  LPARAM lParam);
+  // win::MessageWindow::Delegate interface.
+  virtual bool HandleMessage(HWND hwnd,
+                             UINT message,
+                             WPARAM wparam,
+                             LPARAM lparam,
+                             LRESULT* result) OVERRIDE;
 
   scoped_ptr<protocol::ClipboardStub> client_clipboard_;
-  HWND hwnd_;
   AddClipboardFormatListenerFn* add_clipboard_format_listener_;
   RemoveClipboardFormatListenerFn* remove_clipboard_format_listener_;
-  bool load_functions_tried_;
+
+  // Used to subscribe to WM_CLIPBOARDUPDATE messages.
+  scoped_ptr<win::MessageWindow> window_;
 
   DISALLOW_COPY_AND_ASSIGN(ClipboardWin);
 };
 
 ClipboardWin::ClipboardWin()
-    : hwnd_(NULL),
-      add_clipboard_format_listener_(NULL),
-      remove_clipboard_format_listener_(NULL),
-      load_functions_tried_(false) {
+    : add_clipboard_format_listener_(NULL),
+      remove_clipboard_format_listener_(NULL) {
 }
 
 void ClipboardWin::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+  DCHECK(!add_clipboard_format_listener_);
+  DCHECK(!remove_clipboard_format_listener_);
+  DCHECK(!window_);
+
   client_clipboard_.swap(client_clipboard);
 
-  if (!load_functions_tried_) {
-    load_functions_tried_ = true;
-    HMODULE user32_module = ::GetModuleHandle(L"user32.dll");
-    if (!user32_module) {
-      LOG(WARNING) << "Couldn't find user32.dll.";
-    } else {
-      add_clipboard_format_listener_ =
-          reinterpret_cast<AddClipboardFormatListenerFn*>(
-              ::GetProcAddress(user32_module, "AddClipboardFormatListener"));
-      remove_clipboard_format_listener_ =
-          reinterpret_cast<RemoveClipboardFormatListenerFn*>(
-              ::GetProcAddress(user32_module, "RemoveClipboardFormatListener"));
-      if (!HaveClipboardListenerApi()) {
-        LOG(WARNING) << "Couldn't load AddClipboardFormatListener or "
-                     << "RemoveClipboardFormatListener.";
-      }
-    }
+  // user32.dll is statically linked.
+  HMODULE user32 = GetModuleHandle(L"user32.dll");
+  CHECK(user32);
+
+  add_clipboard_format_listener_ =
+      reinterpret_cast<AddClipboardFormatListenerFn*>(
+          GetProcAddress(user32, "AddClipboardFormatListener"));
+  if (add_clipboard_format_listener_) {
+    remove_clipboard_format_listener_ =
+        reinterpret_cast<RemoveClipboardFormatListenerFn*>(
+            GetProcAddress(user32, "RemoveClipboardFormatListener"));
+    // If AddClipboardFormatListener() present, RemoveClipboardFormatListener()
+    // should be available too.
+    CHECK(remove_clipboard_format_listener_);
+  } else {
+    LOG(WARNING) << "AddClipboardFormatListener() is not available.";
   }
 
-  if (!RegisterWindowClass()) {
-    LOG(ERROR) << "Couldn't register clipboard window class.";
-    return;
-  }
-  hwnd_ = ::CreateWindow(kWindowClassName,
-                         kWindowName,
-                         0, 0, 0, 0, 0,
-                         HWND_MESSAGE,
-                         NULL,
-                         base::GetModuleFromAddress(&WndProc),
-                         this);
-  if (!hwnd_) {
+  window_.reset(new win::MessageWindow());
+  if (!window_->Create(this)) {
     LOG(ERROR) << "Couldn't create clipboard window.";
+    window_.reset();
     return;
   }
 
-  if (HaveClipboardListenerApi()) {
-    if (!(*add_clipboard_format_listener_)(hwnd_)) {
+  if (add_clipboard_format_listener_) {
+    if (!(*add_clipboard_format_listener_)(window_->hwnd())) {
       LOG(WARNING) << "AddClipboardFormatListener() failed: " << GetLastError();
     }
   }
 }
 
 void ClipboardWin::Stop() {
   client_clipboard_.reset();
 
-  if (hwnd_) {
-    if (HaveClipboardListenerApi()) {
-      (*remove_clipboard_format_listener_)(hwnd_);
-    }
-    ::DestroyWindow(hwnd_);
-    hwnd_ = NULL;
-  }
+  if (window_ && remove_clipboard_format_listener_)
+    (*remove_clipboard_format_listener_)(window_->hwnd());
+
+  window_.reset();
 }
 
 void ClipboardWin::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
-  if (!hwnd_)
+  if (!window_)
     return;
 
   // Currently we only handle UTF-8 text.
   if (event.mime_type().compare(kMimeTypeTextUtf8) != 0)
     return;
   if (!StringIsUtf8(event.data().c_str(), event.data().length())) {
     LOG(ERROR) << "ClipboardEvent: data is not UTF-8 encoded.";
     return;
   }
 
   string16 text = UTF8ToUTF16(ReplaceLfByCrLf(event.data()));
 
   ScopedClipboard clipboard;
-  if (!clipboard.Init(hwnd_)) {
+  if (!clipboard.Init(window_->hwnd())) {
     LOG(WARNING) << "Couldn't open the clipboard.";
     return;
   }
 
   clipboard.Empty();
 
   HGLOBAL text_global =
       ::GlobalAlloc(GMEM_MOVEABLE, (text.size() + 1) * sizeof(WCHAR));
   if (!text_global) {
     LOG(WARNING) << "Couldn't allocate global memory.";
     return;
   }
 
   LPWSTR text_global_locked =
       reinterpret_cast<LPWSTR>(::GlobalLock(text_global));
   memcpy(text_global_locked, text.data(), text.size() * sizeof(WCHAR));
   text_global_locked[text.size()] = (WCHAR)0;
   ::GlobalUnlock(text_global);
 
   clipboard.SetData(CF_UNICODETEXT, text_global);
 }
 
 void ClipboardWin::OnClipboardUpdate() {
-  DCHECK(hwnd_);
+  DCHECK(window_);
 
   if (::IsClipboardFormatAvailable(CF_UNICODETEXT)) {
     string16 text;
     // Add a scope, so that we keep the clipboard open for as short a time as
     // possible.
     {
       ScopedClipboard clipboard;
-      if (!clipboard.Init(hwnd_)) {
+      if (!clipboard.Init(window_->hwnd())) {
         LOG(WARNING) << "Couldn't open the clipboard." << GetLastError();
         return;
       }
 
       HGLOBAL text_global = clipboard.GetData(CF_UNICODETEXT);
       if (!text_global) {
         LOG(WARNING) << "Couldn't get data from the clipboard: "
                      << GetLastError();
         return;
       }
 
       base::win::ScopedHGlobal<WCHAR> text_lock(text_global);
       if (!text_lock.get()) {
         LOG(WARNING) << "Couldn't lock clipboard data: " << GetLastError();
         return;
       }
       text.assign(text_lock.get());
     }
 
     protocol::ClipboardEvent event;
     event.set_mime_type(kMimeTypeTextUtf8);
     event.set_data(ReplaceCrLfByLf(UTF16ToUTF8(text)));
 
     if (client_clipboard_.get()) {
       client_clipboard_->InjectClipboardEvent(event);
     }
   }
 }
 
-bool ClipboardWin::HaveClipboardListenerApi() {
-  return add_clipboard_format_listener_ && remove_clipboard_format_listener_;
-}
-
-bool ClipboardWin::RegisterWindowClass() {
-  // This method is only called on the UI thread, so it doesn't matter
-  // that the following test is not thread-safe.
-  static bool registered = false;
-  if (registered) {
+bool ClipboardWin::HandleMessage(
+    HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT* result) {
+  if (message == WM_CLIPBOARDUPDATE) {
+    OnClipboardUpdate();
+    *result = 0;
     return true;
   }
 
-  WNDCLASSEX window_class;
-  base::win::InitializeWindowClass(
-      kWindowClassName,
-      base::win::WrappedWindowProc<WndProc>,
-      0, 0, 0, NULL, NULL, NULL, NULL, NULL,
-      &window_class);
-  if (!::RegisterClassEx(&window_class)) {
-    return false;
-  }
-
-  registered = true;
-  return true;
-}
-
-LRESULT CALLBACK ClipboardWin::WndProc(HWND hwnd, UINT msg, WPARAM wparam,
-                                       LPARAM lparam) {
-  if (msg == WM_CREATE) {
-    CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lparam);
-    ::SetWindowLongPtr(hwnd,
-                       GWLP_USERDATA,
-                       reinterpret_cast<LONG_PTR>(cs->lpCreateParams));
-    return 0;
-  }
-  ClipboardWin* clipboard =
-      reinterpret_cast<ClipboardWin*>(::GetWindowLongPtr(hwnd, GWLP_USERDATA));
-  switch (msg) {
-    case WM_CLIPBOARDUPDATE:
-      clipboard->OnClipboardUpdate();
-      return 0;
-  }
-  return ::DefWindowProc(hwnd, msg, wparam, lparam);
+  return false;
 }
 
 scoped_ptr<Clipboard> Clipboard::Create() {
   return scoped_ptr<Clipboard>(new ClipboardWin());
 }
 
 }  // namespace remoting