Converted LocalInputMonitor into a SessionController instance.

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/stringprintf.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/win/wrapped_window_proc.h"
-#include "remoting/host/mouse_move_observer.h"
+#include "remoting/host/client_session_control.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);
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      base::WeakPtr<ClientSessionControl> client_session_control);
   ~LocalInputMonitorWin();
 
-  virtual void Start(MouseMoveObserver* mouse_move_observer,
-                     const base::Closure& disconnect_callback) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-
  private:
   // The actual implementation resides in LocalInputMonitorWin::Core class.
   class Core : public base::RefCountedThreadSafe<Core> {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-         scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
+         scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+         base::WeakPtr<ClientSessionControl> client_session_control);
 
-    void Start(MouseMoveObserver* mouse_move_observer);
+    void Start();
     void Stop();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void StartOnUiThread();
     void StopOnUiThread();
 
-    // Posts OnLocalMouseMoved() notification to |mouse_move_observer_| on
-    // the |caller_task_runner_| thread.
-    void OnLocalMouseMoved(const SkIPoint& position);
-
     // Handles WM_CREATE messages.
     LRESULT OnCreate(HWND hwnd);
 
     // Handles WM_INPUT messages.
     LRESULT OnInput(HRAWINPUT input_handle);
 
     // Window procedure invoked by the OS to process window messages.
     static LRESULT CALLBACK WindowProc(HWND hwnd, UINT message,
                                        WPARAM wparam, LPARAM lparam);
 
     // 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_;
 
     // Atom representing the input window class.
     ATOM atom_;
 
     // Instance of the module containing the window procedure.
     HINSTANCE instance_;
 
     // Handle of the input window.
     HWND window_;
 
-    // Observer to dispatch mouse event notifications to.
-    MouseMoveObserver* mouse_move_observer_;
+    // 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);
 };
 
 LocalInputMonitorWin::LocalInputMonitorWin(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
-    : core_(new Core(caller_task_runner, ui_task_runner)) {
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    base::WeakPtr<ClientSessionControl> client_session_control)
+    : core_(new Core(caller_task_runner,
+                     ui_task_runner,
+                     client_session_control)) {
+  core_->Start();

[Sergey Ulanov, 2013/03/23 19:54:22]

get rid of Core::Start() too?

[alexeypa (please no reviews), 2013/03/25 15:54:07]

No, because of the same reason.

 }
 
 LocalInputMonitorWin::~LocalInputMonitorWin() {
-}
-
-void LocalInputMonitorWin::Start(MouseMoveObserver* mouse_move_observer,
-                                 const base::Closure& disconnect_callback) {
-  core_->Start(mouse_move_observer);
-}
-
-void LocalInputMonitorWin::Stop() {
   core_->Stop();
 }
 
 LocalInputMonitorWin::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    base::WeakPtr<ClientSessionControl> client_session_control)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
       atom_(0),
       instance_(NULL),
       window_(NULL),
-      mouse_move_observer_(NULL) {
+      client_session_control_(client_session_control) {
+  DCHECK(client_session_control_);
 }
 
-void LocalInputMonitorWin::Core::Start(MouseMoveObserver* mouse_move_observer) {
+void LocalInputMonitorWin::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(!mouse_move_observer_);
-  DCHECK(mouse_move_observer);
 
-  mouse_move_observer_ = mouse_move_observer;
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&Core::StartOnUiThread, this));
 }
 
 void LocalInputMonitorWin::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  mouse_move_observer_ = NULL;
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 }
 
 LocalInputMonitorWin::Core::~Core() {
   DCHECK(!atom_);
   DCHECK(!instance_);
   DCHECK(!window_);
-  DCHECK(!mouse_move_observer_);
 }
 
 void LocalInputMonitorWin::Core::StartOnUiThread() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   // Create a window for receiving raw input.
   string16 window_class_name = base::StringPrintf(kWindowClassFormat, this);
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
       window_class_name.c_str(),
@@ skipping 24 matching lines @@
     window_ = NULL;
   }
 
   if (atom_ != 0) {
     UnregisterClass(MAKEINTATOM(atom_), instance_);
     atom_ = 0;
     instance_ = NULL;
   }
 }
 
-void LocalInputMonitorWin::Core::OnLocalMouseMoved(const SkIPoint& position) {
-  if (!caller_task_runner_->BelongsToCurrentThread()) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&Core::OnLocalMouseMoved, this, position));
-    return;
-  }
-
-  if (mouse_move_observer_)
-    mouse_move_observer_->OnLocalMouseMoved(position);
-}
-
 LRESULT LocalInputMonitorWin::Core::OnCreate(HWND hwnd) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   // Register to receive raw mouse input.
   RAWINPUTDEVICE device = {0};
   device.dwFlags = RIDEV_INPUTSINK;
   device.usUsagePage = kGenericDesktopPage;
   device.usUsage = kMouseUsage;
   device.hwndTarget = hwnd;
   if (!RegisterRawInputDevices(&device, 1, sizeof(device))) {
@@ skipping 35 matching lines @@
   // Notify the observer about mouse events generated locally. Remote (injected)
   // mouse events do not specify a device handle (based on observed behavior).
   if (input->header.dwType == RIM_TYPEMOUSE &&
       input->header.hDevice != NULL) {
     POINT position;
     if (!GetCursorPos(&position)) {
       position.x = 0;
       position.y = 0;
     }
 
-    OnLocalMouseMoved(SkIPoint::Make(position.x, position.y));
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
+                              client_session_control_,
+                              SkIPoint::Make(position.x, position.y)));
   }
 
   return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
 }
 
 // static
 LRESULT CALLBACK LocalInputMonitorWin::Core::WindowProc(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
   // Store |this| to the window's user data.
   if (message == WM_CREATE) {
@@ skipping 15 matching lines @@
     default:
       return DefWindowProc(hwnd, message, wparam, lparam);
   }
 }
 
 }  // namespace
 
 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_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));
+      new LocalInputMonitorWin(caller_task_runner,
+                               ui_task_runner,
+                               client_session_control));
 }
 
 }  // namespace remoting