Moved remoting::win::MessageWindow to base::win::MessageWindow so that it could be re-used outside …

remoting/host/local_input_monitor_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/local_input_monitor.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/non_thread_safe.h"
+#include "base/win/message_window.h"
 #include "remoting/host/client_session_control.h"
-#include "remoting/host/win/message_window.h"
 #include "third_party/skia/include/core/SkPoint.h"
 
 namespace remoting {
 
 namespace {
 
 const wchar_t kWindowClassFormat[] = L"Chromoting_LocalInputMonitorWin_%p";
 
 // From the HID Usage Tables specification.
 const USHORT kGenericDesktopPage = 1;
 const USHORT kMouseUsage = 2;
 
 class LocalInputMonitorWin : public base::NonThreadSafe,
                              public LocalInputMonitor {
  public:
   LocalInputMonitorWin(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control);
   ~LocalInputMonitorWin();
 
  private:
   // The actual implementation resides in LocalInputMonitorWin::Core class.
   class Core : public base::RefCountedThreadSafe<Core>,
-               public win::MessageWindow::Delegate {
+               public base::win::MessageWindow::Delegate {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
          base::WeakPtr<ClientSessionControl> client_session_control);
 
     void Start();
     void Stop();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void StartOnUiThread();
     void StopOnUiThread();
 
     // Handles WM_INPUT messages.
     LRESULT OnInput(HRAWINPUT input_handle);
 
-    // win::MessageWindow::Delegate interface.
+    // base::win::MessageWindow::Delegate interface.
     virtual bool HandleMessage(HWND hwnd,
                                UINT message,
                                WPARAM wparam,
                                LPARAM lparam,
                                LRESULT* result) OVERRIDE;
 
     // Task runner on which public methods of this class must be called.
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
     // Task runner on which |window_| is created.
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
     // Used to receive raw input.
-    scoped_ptr<win::MessageWindow> window_;
+    scoped_ptr<base::win::MessageWindow> window_;
 
     // Points to the object receiving mouse event notifications.
     base::WeakPtr<ClientSessionControl> client_session_control_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorWin);
@@ skipping 36 matching lines @@
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 }
 
 LocalInputMonitorWin::Core::~Core() {
   DCHECK(!window_);
 }
 
 void LocalInputMonitorWin::Core::StartOnUiThread() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
-  window_.reset(new win::MessageWindow());
-  if (!window_->Create(this)) {
+  window_.reset(new base::win::MessageWindow());
+  if (!window_->Create(this, NULL)) {
     LOG_GETLASTERROR(ERROR) << "Failed to create the raw input window";
     window_.reset();
 
     // If the local input cannot be monitored, the remote user can take over
     // the session. Disconnect the session now to prevent this.
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
                               client_session_control_));
   }
 }
@@ skipping 98 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
   return scoped_ptr<LocalInputMonitor>(
       new LocalInputMonitorWin(caller_task_runner,
                                ui_task_runner,
                                client_session_control));
 }
 
 }  // namespace remoting