Decouple LocalInputMonitor sub-classes from ClientSessionControl

This change decouples the mouse/keyboard input monitors from
ClientSessionControl and allows them to be used for other purposes.

Bug: 877176
Change-Id: Idcefa8a8dd1d36bb57f83b8a27d8aba90981466f
Reviewed-on: https://chromium-review.googlesource.com/1189027Reviewed-by: Jamie Walch <jamiewalch@chromium.org>
Commit-Queue: Joe Downing <joedow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#586061}

remoting/host/input_monitor/local_hotkey_input_monitor.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 
+#include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 
@@ -16,23 +17,20 @@ class SingleThreadTaskRunner;
 
 namespace remoting {
 
-class ClientSessionControl;
-
 // Monitors the local input to notify about keyboard hotkeys. If implemented for
 // the platform, catches the disconnection keyboard shortcut (Ctlr-Alt-Esc) and
-// invokes SessionController::Delegate::DisconnectSession() when this key
-// combination is pressed.
+// invokes |disconnect_callback| when this key combination is pressed.
 class LocalHotkeyInputMonitor {
  public:
   virtual ~LocalHotkeyInputMonitor() = default;
 
   // Creates a platform-specific instance of LocalHotkeyInputMonitor.
-  // |client_session_control| is called on the |caller_task_runner| thread.
+  // |disconnect_callback| is called on the |caller_task_runner| thread.
   static std::unique_ptr<LocalHotkeyInputMonitor> Create(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      base::OnceClosure disconnect_callback);
 
  protected:
   LocalHotkeyInputMonitor() = default;

remoting/host/input_monitor/local_hotkey_input_monitor_chromeos.cc

@@ -11,7 +11,6 @@
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
-#include "remoting/host/client_session_control.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
@@ -27,14 +26,14 @@ class LocalHotkeyInputMonitorChromeos : public LocalHotkeyInputMonitor {
   LocalHotkeyInputMonitorChromeos(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      base::OnceClosure disconnect_callback);
   ~LocalHotkeyInputMonitorChromeos() override;
 
  private:
   class Core : ui::PlatformEventObserver {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-         base::WeakPtr<ClientSessionControl> client_session_control);
+         base::OnceClosure disconnect_callback);
     ~Core() override;
 
     void Start();
@@ -48,9 +47,8 @@ class LocalHotkeyInputMonitorChromeos : public LocalHotkeyInputMonitor {
 
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
-    // Points to the object receiving mouse event notifications and session
-    // disconnect requests.  Must be called on the |caller_task_runner_|.
-    base::WeakPtr<ClientSessionControl> client_session_control_;
+    // Must be called on |caller_task_runner_|.
+    base::OnceClosure disconnect_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
@@ -65,9 +63,9 @@ class LocalHotkeyInputMonitorChromeos : public LocalHotkeyInputMonitor {
 LocalHotkeyInputMonitorChromeos::LocalHotkeyInputMonitorChromeos(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : input_task_runner_(input_task_runner),
-      core_(new Core(caller_task_runner, client_session_control)) {
+      core_(new Core(caller_task_runner, std::move(disconnect_callback))) {
   input_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&Core::Start, base::Unretained(core_.get())));
 }
@@ -78,10 +76,10 @@ LocalHotkeyInputMonitorChromeos::~LocalHotkeyInputMonitorChromeos() {
 
 LocalHotkeyInputMonitorChromeos::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : caller_task_runner_(caller_task_runner),
-      client_session_control_(client_session_control) {
-  DCHECK(client_session_control_.get());
+      disconnect_callback_(std::move(disconnect_callback)) {
+  DCHECK(disconnect_callback_);
 }
 
 void LocalHotkeyInputMonitorChromeos::Core::Start() {
@@ -112,13 +110,16 @@ void LocalHotkeyInputMonitorChromeos::Core::DidProcessEvent(
 
 void LocalHotkeyInputMonitorChromeos::Core::HandleKeyPressed(
     const ui::PlatformEvent& event) {
+  // Ignore input if we've already initiated a disconnect.
+  if (!disconnect_callback_) {
+    return;
+  }
+
   ui::KeyEvent key_event(event);
   DCHECK(key_event.is_char());
   if (key_event.IsControlDown() && key_event.IsAltDown() &&
       key_event.key_code() == ui::VKEY_ESCAPE) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::BindRepeating(&ClientSessionControl::DisconnectSession,
-                                       client_session_control_, protocol::OK));
+    caller_task_runner_->PostTask(FROM_HERE, std::move(disconnect_callback_));
   }
 }
 
@@ -128,9 +129,9 @@ std::unique_ptr<LocalHotkeyInputMonitor> LocalHotkeyInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalHotkeyInputMonitorChromeos>(
-      caller_task_runner, input_task_runner, client_session_control);
+      caller_task_runner, input_task_runner, std::move(disconnect_callback));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_hotkey_input_monitor_mac.mm

@@ -7,9 +7,10 @@
 #import <AppKit/AppKit.h>
 
 #include <cstdint>
-#include <set>
+#include <utility>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ -20,7 +21,6 @@
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "remoting/host/client_session_control.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMCarbonEvent.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
@@ -44,7 +44,7 @@ class LocalHotkeyInputMonitorMac : public LocalHotkeyInputMonitor {
   LocalHotkeyInputMonitorMac(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      base::OnceClosure disconnect_callback);
   ~LocalHotkeyInputMonitorMac() override;
 
  private:
@@ -126,7 +126,7 @@ class LocalHotkeyInputMonitorMac::Core
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-       base::WeakPtr<ClientSessionControl> client_session_control);
+       base::OnceClosure disconnect_callback);
 
   void Start();
   void Stop();
@@ -151,7 +151,7 @@ class LocalHotkeyInputMonitorMac::Core
 
   // Invoked in the |caller_task_runner_| thread to report session disconnect
   // requests.
-  base::WeakPtr<ClientSessionControl> client_session_control_;
+  base::OnceClosure disconnect_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
@@ -159,10 +159,10 @@ class LocalHotkeyInputMonitorMac::Core
 LocalHotkeyInputMonitorMac::LocalHotkeyInputMonitorMac(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : core_(new Core(caller_task_runner,
                      ui_task_runner,
-                     client_session_control)) {
+                     std::move(disconnect_callback))) {
   core_->Start();
 }
 
@@ -174,12 +174,12 @@ LocalHotkeyInputMonitorMac::~LocalHotkeyInputMonitorMac() {
 LocalHotkeyInputMonitorMac::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
       manager_(nil),
-      client_session_control_(client_session_control) {
-  DCHECK(client_session_control_);
+      disconnect_callback_(std::move(disconnect_callback)) {
+  DCHECK(disconnect_callback_);
 }
 
 void LocalHotkeyInputMonitorMac::Core::Start() {
@@ -215,9 +215,9 @@ void LocalHotkeyInputMonitorMac::Core::StopOnUiThread() {
 }
 
 void LocalHotkeyInputMonitorMac::Core::OnDisconnectShortcut() {
-  caller_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&ClientSessionControl::DisconnectSession,
-                                client_session_control_, protocol::OK));
+  if (disconnect_callback_) {
+    caller_task_runner_->PostTask(FROM_HERE, std::move(disconnect_callback_));
+  }
 }
 
 }  // namespace
@@ -226,9 +226,9 @@ std::unique_ptr<LocalHotkeyInputMonitor> LocalHotkeyInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalHotkeyInputMonitorMac>(
-      caller_task_runner, ui_task_runner, client_session_control);
+      caller_task_runner, ui_task_runner, std::move(disconnect_callback));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_hotkey_input_monitor_win.cc

@@ -4,8 +4,8 @@
 
 #include "remoting/host/input_monitor/local_hotkey_input_monitor.h"
 
+#include "base/callback.h"
 #include "base/single_thread_task_runner.h"
-#include "remoting/host/client_session_control.h"
 
 namespace remoting {
 
@@ -13,7 +13,7 @@ std::unique_ptr<LocalHotkeyInputMonitor> LocalHotkeyInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    base::OnceClosure disconnect_callback) {
   return nullptr;
 }
 

remoting/host/input_monitor/local_hotkey_input_monitor_x11.cc

@@ -18,7 +18,6 @@
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
-#include "remoting/host/client_session_control.h"
 #include "ui/gfx/x/x11.h"
 
 namespace remoting {
@@ -30,7 +29,7 @@ class LocalHotkeyInputMonitorX11 : public LocalHotkeyInputMonitor {
   LocalHotkeyInputMonitorX11(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      base::OnceClosure disconnect_callback);
   ~LocalHotkeyInputMonitorX11() override;
 
  private:
@@ -39,7 +38,7 @@ class LocalHotkeyInputMonitorX11 : public LocalHotkeyInputMonitor {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-         base::WeakPtr<ClientSessionControl> client_session_control);
+         base::OnceClosure disconnect_callback);
 
     void Start();
     void Stop();
@@ -66,7 +65,7 @@ class LocalHotkeyInputMonitorX11 : public LocalHotkeyInputMonitor {
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
     // Used to send session disconnect requests.
-    base::WeakPtr<ClientSessionControl> client_session_control_;
+    base::OnceClosure disconnect_callback_;
 
     // Controls watching X events.
     std::unique_ptr<base::FileDescriptorWatcher::Controller> controller_;
@@ -95,10 +94,10 @@ class LocalHotkeyInputMonitorX11 : public LocalHotkeyInputMonitor {
 LocalHotkeyInputMonitorX11::LocalHotkeyInputMonitorX11(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : core_(new Core(caller_task_runner,
                      input_task_runner,
-                     client_session_control)) {
+                     std::move(disconnect_callback))) {
   core_->Start();
 }
 
@@ -110,12 +109,12 @@ LocalHotkeyInputMonitorX11::~LocalHotkeyInputMonitorX11() {
 LocalHotkeyInputMonitorX11::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    base::OnceClosure disconnect_callback)
     : caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
-      client_session_control_(client_session_control) {
+      disconnect_callback_(std::move(disconnect_callback)) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(client_session_control_.get());
+  DCHECK(disconnect_callback_);
 }
 
 void LocalHotkeyInputMonitorX11::Core::Start() {
@@ -243,6 +242,11 @@ void LocalHotkeyInputMonitorX11::Core::OnPendingXEvents() {
 void LocalHotkeyInputMonitorX11::Core::ProcessXEvent(xEvent* event) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
+  // Ignore input if we've already initiated a disconnect.
+  if (!disconnect_callback_) {
+    return;
+  }
+
   int key_code = event->u.u.detail;
   bool down = event->u.u.type == KeyPress;
   KeySym key_sym = XkbKeycodeToKeysym(display_, key_code, 0, 0);
@@ -251,9 +255,7 @@ void LocalHotkeyInputMonitorX11::Core::ProcessXEvent(xEvent* event) {
   } else if (key_sym == XK_Alt_L || key_sym == XK_Alt_R) {
     alt_pressed_ = down;
   } else if (key_sym == XK_Escape && down && alt_pressed_ && ctrl_pressed_) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::BindOnce(&ClientSessionControl::DisconnectSession,
-                                  client_session_control_, protocol::OK));
+    caller_task_runner_->PostTask(FROM_HERE, std::move(disconnect_callback_));
   }
 }
 
@@ -274,9 +276,9 @@ std::unique_ptr<LocalHotkeyInputMonitor> LocalHotkeyInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalHotkeyInputMonitorX11>(
-      caller_task_runner, input_task_runner, client_session_control);
+      caller_task_runner, input_task_runner, std::move(disconnect_callback));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_input_monitor.cc

@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/host/client_session_control.h"
@@ -37,16 +38,22 @@ LocalInputMonitorImpl::LocalInputMonitorImpl(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control)
-    : hotkey_input_monitor_(
-          LocalHotkeyInputMonitor::Create(caller_task_runner,
-                                          input_task_runner,
-                                          ui_task_runner,
-                                          client_session_control)),
-      mouse_input_monitor_(
-          LocalMouseInputMonitor::Create(caller_task_runner,
-                                         input_task_runner,
-                                         ui_task_runner,
-                                         client_session_control)) {}
+    : hotkey_input_monitor_(LocalHotkeyInputMonitor::Create(
+          caller_task_runner,
+          input_task_runner,
+          ui_task_runner,
+          base::BindOnce(&ClientSessionControl::DisconnectSession,
+                         client_session_control,
+                         protocol::OK))),
+      mouse_input_monitor_(LocalMouseInputMonitor::Create(
+          caller_task_runner,
+          input_task_runner,
+          ui_task_runner,
+          base::BindRepeating(&ClientSessionControl::OnLocalMouseMoved,
+                              client_session_control),
+          base::BindOnce(&ClientSessionControl::DisconnectSession,
+                         client_session_control,
+                         protocol::OK))) {}
 
 LocalInputMonitorImpl::~LocalInputMonitorImpl() = default;
 

remoting/host/input_monitor/local_input_monitor.h

@@ -18,7 +18,8 @@ namespace remoting {
 
 class ClientSessionControl;
 
-// Monitors the local input to notify about mouse movements and keyboard events.
+// Monitors local input and sends notifications for mouse movements and
+// keyboard shortcuts when they are detected.
 class LocalInputMonitor {
  public:
   virtual ~LocalInputMonitor() = default;

remoting/host/input_monitor/local_mouse_input_monitor.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 
+#include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 
@@ -14,23 +15,31 @@ namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
-namespace remoting {
+namespace webrtc {
+class DesktopVector;
+}  // namespace webrtc
 
-class ClientSessionControl;
+namespace remoting {
 
-// Monitors the local input and sends a notification to the ClientSessionControl
-// instance passed in for every mouse move event received.
+// Monitors the local input and sends a notification via the callback passed in
+// for every mouse move event received.
 class LocalMouseInputMonitor {
  public:
+  using MouseMoveCallback =
+      base::RepeatingCallback<void(const webrtc::DesktopVector&)>;
+
   virtual ~LocalMouseInputMonitor() = default;
 
   // Creates a platform-specific instance of LocalMouseInputMonitor.
-  // |client_session_control| is called on the |caller_task_runner| thread.
+  // Callbacks are called on the |caller_task_runner| thread.
+  // |on_mouse_move| is called for each mouse movement detected.
+  // |disconnect_callback| is called if monitoring cannot be started.
   static std::unique_ptr<LocalMouseInputMonitor> Create(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      MouseMoveCallback mouse_move_callback,
+      base::OnceClosure disconnect_callback);
 
  protected:
   LocalMouseInputMonitor() = default;

remoting/host/input_monitor/local_mouse_input_monitor_chromeos.cc

@@ -12,7 +12,6 @@
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/host/chromeos/point_transformer.h"
-#include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
@@ -28,14 +27,14 @@ class LocalMouseInputMonitorChromeos : public LocalMouseInputMonitor {
   LocalMouseInputMonitorChromeos(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      MouseMoveCallback on_mouse_move);
   ~LocalMouseInputMonitorChromeos() override;
 
  private:
   class Core : ui::PlatformEventObserver {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-         base::WeakPtr<ClientSessionControl> client_session_control);
+         MouseMoveCallback on_mouse_move);
     ~Core() override;
 
     void Start();
@@ -49,9 +48,9 @@ class LocalMouseInputMonitorChromeos : public LocalMouseInputMonitor {
 
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
-    // Points to the object receiving mouse event notifications and session
-    // disconnect requests.  Must be called on the |caller_task_runner_|.
-    base::WeakPtr<ClientSessionControl> client_session_control_;
+    // Used to send mouse event notifications.
+    // Must be called on the |caller_task_runner_|.
+    MouseMoveCallback on_mouse_move_;
 
     // Used to rotate the local mouse positions appropriately based on the
     // current display rotation settings.
@@ -70,9 +69,9 @@ class LocalMouseInputMonitorChromeos : public LocalMouseInputMonitor {
 LocalMouseInputMonitorChromeos::LocalMouseInputMonitorChromeos(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : input_task_runner_(input_task_runner),
-      core_(new Core(caller_task_runner, client_session_control)) {
+      core_(new Core(caller_task_runner, std::move(on_mouse_move))) {
   input_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&Core::Start, base::Unretained(core_.get())));
 }
@@ -83,11 +82,9 @@ LocalMouseInputMonitorChromeos::~LocalMouseInputMonitorChromeos() {
 
 LocalMouseInputMonitorChromeos::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : caller_task_runner_(caller_task_runner),
-      client_session_control_(client_session_control) {
-  DCHECK(client_session_control_.get());
-}
+      on_mouse_move_(std::move(on_mouse_move)) {}
 
 void LocalMouseInputMonitorChromeos::Core::Start() {
   // TODO(erg): Need to handle the mus case where PlatformEventSource is null
@@ -122,10 +119,9 @@ void LocalMouseInputMonitorChromeos::Core::HandleMouseMove(
   mouse_position = point_transformer_->FromScreenCoordinates(mouse_position);
 
   caller_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &ClientSessionControl::OnLocalMouseMoved, client_session_control_,
-          webrtc::DesktopVector(mouse_position.x(), mouse_position.y())));
+      FROM_HERE, base::BindOnce(on_mouse_move_,
+                                webrtc::DesktopVector(mouse_position.x(),
+                                                      mouse_position.y())));
 }
 
 }  // namespace
@@ -134,9 +130,10 @@ std::unique_ptr<LocalMouseInputMonitor> LocalMouseInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalMouseInputMonitorChromeos>(
-      caller_task_runner, input_task_runner, client_session_control);
+      caller_task_runner, input_task_runner, std::move(on_mouse_move));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_mouse_input_monitor_mac.mm

@@ -6,8 +6,7 @@
 
 #import <AppKit/AppKit.h>
 
-#include <cstdint>
-#include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ -19,7 +18,6 @@
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
@@ -33,13 +31,12 @@ class LocalMouseInputMonitorMac : public LocalMouseInputMonitor {
     virtual ~EventHandler() {}
 
     virtual void OnLocalMouseMoved(const webrtc::DesktopVector& position) = 0;
-    virtual void OnDisconnectShortcut() = 0;
   };
 
   LocalMouseInputMonitorMac(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      MouseMoveCallback on_mouse_move);
   ~LocalMouseInputMonitorMac() override;
 
  private:
@@ -136,7 +133,7 @@ class LocalMouseInputMonitorMac::Core : public base::RefCountedThreadSafe<Core>,
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-       base::WeakPtr<ClientSessionControl> client_session_control);
+       MouseMoveCallback on_mouse_move);
 
   void Start();
   void Stop();
@@ -150,7 +147,6 @@ class LocalMouseInputMonitorMac::Core : public base::RefCountedThreadSafe<Core>,
 
   // EventHandler interface.
   void OnLocalMouseMoved(const webrtc::DesktopVector& position) override;
-  void OnDisconnectShortcut() override;
 
   // Task runner on which public methods of this class must be called.
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
@@ -160,9 +156,8 @@ class LocalMouseInputMonitorMac::Core : public base::RefCountedThreadSafe<Core>,
 
   LocalInputMonitorManager* manager_;
 
-  // Invoked in the |caller_task_runner_| thread to report local mouse events
-  // and session disconnect requests.
-  base::WeakPtr<ClientSessionControl> client_session_control_;
+  // Invoked in the |caller_task_runner_| thread to report local mouse events.
+  MouseMoveCallback on_mouse_move_;
 
   webrtc::DesktopVector mouse_position_;
 
@@ -172,10 +167,10 @@ class LocalMouseInputMonitorMac::Core : public base::RefCountedThreadSafe<Core>,
 LocalMouseInputMonitorMac::LocalMouseInputMonitorMac(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : core_(new Core(caller_task_runner,
                      ui_task_runner,
-                     client_session_control)) {
+                     std::move(on_mouse_move))) {
   core_->Start();
 }
 
@@ -187,13 +182,11 @@ LocalMouseInputMonitorMac::~LocalMouseInputMonitorMac() {
 LocalMouseInputMonitorMac::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
       manager_(nil),
-      client_session_control_(client_session_control) {
-  DCHECK(client_session_control_);
-}
+      on_mouse_move_(std::move(on_mouse_move)) {}
 
 void LocalMouseInputMonitorMac::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ -238,15 +231,8 @@ void LocalMouseInputMonitorMac::Core::OnLocalMouseMoved(
 
   mouse_position_ = position;
 
-  caller_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&ClientSessionControl::OnLocalMouseMoved,
-                                client_session_control_, position));
-}
-
-void LocalMouseInputMonitorMac::Core::OnDisconnectShortcut() {
-  caller_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&ClientSessionControl::DisconnectSession,
-                                client_session_control_, protocol::OK));
+  caller_task_runner_->PostTask(FROM_HERE,
+                                base::BindOnce(on_mouse_move_, position));
 }
 
 }  // namespace
@@ -255,9 +241,10 @@ std::unique_ptr<LocalMouseInputMonitor> LocalMouseInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalMouseInputMonitorMac>(
-      caller_task_runner, ui_task_runner, client_session_control);
+      caller_task_runner, ui_task_runner, std::move(on_mouse_move));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_mouse_input_monitor_win.cc

@@ -5,6 +5,7 @@
 #include "remoting/host/input_monitor/local_mouse_input_monitor.h"
 
 #include <cstdint>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ -15,7 +16,6 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/win/message_window.h"
-#include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
@@ -31,7 +31,8 @@ class LocalMouseInputMonitorWin : public LocalMouseInputMonitor {
   LocalMouseInputMonitorWin(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      MouseMoveCallback on_mouse_move,
+      base::OnceClosure disconnect_callback);
   ~LocalMouseInputMonitorWin() override;
 
  private:
@@ -40,7 +41,8 @@ class LocalMouseInputMonitorWin : public LocalMouseInputMonitor {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-         base::WeakPtr<ClientSessionControl> client_session_control);
+         MouseMoveCallback on_mouse_move,
+         base::OnceClosure disconnect_callback);
 
     void Start();
     void Stop();
@@ -71,7 +73,10 @@ class LocalMouseInputMonitorWin : public LocalMouseInputMonitor {
     std::unique_ptr<base::win::MessageWindow> window_;
 
     // Points to the object receiving mouse event notifications.
-    base::WeakPtr<ClientSessionControl> client_session_control_;
+    MouseMoveCallback on_mouse_move_;
+
+    // Used to disconnect the current session.
+    base::OnceClosure disconnect_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
@@ -86,10 +91,12 @@ class LocalMouseInputMonitorWin : public LocalMouseInputMonitor {
 LocalMouseInputMonitorWin::LocalMouseInputMonitorWin(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback)
     : core_(new Core(caller_task_runner,
                      ui_task_runner,
-                     client_session_control)) {
+                     std::move(on_mouse_move),
+                     std::move(disconnect_callback))) {
   core_->Start();
 }
 
@@ -101,12 +108,12 @@ LocalMouseInputMonitorWin::~LocalMouseInputMonitorWin() {
 LocalMouseInputMonitorWin::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
-      client_session_control_(client_session_control) {
-  DCHECK(client_session_control_);
-}
+      on_mouse_move_(std::move(on_mouse_move)),
+      disconnect_callback_(std::move(disconnect_callback)) {}
 
 void LocalMouseInputMonitorWin::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ -137,9 +144,7 @@ void LocalMouseInputMonitorWin::Core::StartOnUiThread() {
 
     // 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::BindOnce(&ClientSessionControl::DisconnectSession,
-                                  client_session_control_, protocol::OK));
+    caller_task_runner_->PostTask(FROM_HERE, std::move(disconnect_callback_));
   }
 }
 
@@ -194,10 +199,8 @@ LRESULT LocalMouseInputMonitorWin::Core::OnInput(HRAWINPUT input_handle) {
     }
 
     caller_task_runner_->PostTask(
-        FROM_HERE,
-        base::BindOnce(&ClientSessionControl::OnLocalMouseMoved,
-                       client_session_control_,
-                       webrtc::DesktopVector(position.x, position.y)));
+        FROM_HERE, base::BindOnce(on_mouse_move_, webrtc::DesktopVector(
+                                                      position.x, position.y)));
   }
 
   return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
@@ -239,9 +242,11 @@ std::unique_ptr<LocalMouseInputMonitor> LocalMouseInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalMouseInputMonitorWin>(
-      caller_task_runner, ui_task_runner, client_session_control);
+      caller_task_runner, ui_task_runner, std::move(on_mouse_move),
+      std::move(disconnect_callback));
 }
 
 }  // namespace remoting

remoting/host/input_monitor/local_mouse_input_monitor_x11.cc

@@ -18,7 +18,6 @@
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
-#include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "ui/gfx/x/x11.h"
 
@@ -31,7 +30,7 @@ class LocalMouseInputMonitorX11 : public LocalMouseInputMonitor {
   LocalMouseInputMonitorX11(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-      base::WeakPtr<ClientSessionControl> client_session_control);
+      MouseMoveCallback on_mouse_move);
   ~LocalMouseInputMonitorX11() override;
 
  private:
@@ -40,7 +39,7 @@ class LocalMouseInputMonitorX11 : public LocalMouseInputMonitor {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-         base::WeakPtr<ClientSessionControl> client_session_control);
+         MouseMoveCallback on_mouse_move);
 
     void Start();
     void Stop();
@@ -66,9 +65,8 @@ class LocalMouseInputMonitorX11 : public LocalMouseInputMonitor {
     // Task runner on which X Window events are received.
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
-    // Points to the object receiving mouse event notifications and session
-    // disconnect requests.
-    base::WeakPtr<ClientSessionControl> client_session_control_;
+    // Used to send mouse event notifications.
+    MouseMoveCallback on_mouse_move_;
 
     // Controls watching X events.
     std::unique_ptr<base::FileDescriptorWatcher::Controller> controller_;
@@ -91,10 +89,10 @@ class LocalMouseInputMonitorX11 : public LocalMouseInputMonitor {
 LocalMouseInputMonitorX11::LocalMouseInputMonitorX11(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : core_(new Core(caller_task_runner,
                      input_task_runner,
-                     client_session_control)) {
+                     std::move(on_mouse_move))) {
   core_->Start();
 }
 
@@ -106,12 +104,11 @@ LocalMouseInputMonitorX11::~LocalMouseInputMonitorX11() {
 LocalMouseInputMonitorX11::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control)
+    MouseMoveCallback on_mouse_move)
     : caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
-      client_session_control_(client_session_control) {
+      on_mouse_move_(std::move(on_mouse_move)) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(client_session_control_.get());
 }
 
 void LocalMouseInputMonitorX11::Core::Start() {
@@ -244,9 +241,8 @@ void LocalMouseInputMonitorX11::Core::ProcessXEvent(xEvent* event) {
 
   webrtc::DesktopVector position(event->u.keyButtonPointer.rootX,
                                  event->u.keyButtonPointer.rootY);
-  caller_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&ClientSessionControl::OnLocalMouseMoved,
-                                client_session_control_, position));
+  caller_task_runner_->PostTask(FROM_HERE,
+                                base::BindOnce(on_mouse_move_, position));
 }
 
 // static
@@ -265,9 +261,10 @@ std::unique_ptr<LocalMouseInputMonitor> LocalMouseInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    base::WeakPtr<ClientSessionControl> client_session_control) {
+    MouseMoveCallback on_mouse_move,
+    base::OnceClosure disconnect_callback) {
   return std::make_unique<LocalMouseInputMonitorX11>(
-      caller_task_runner, input_task_runner, client_session_control);
+      caller_task_runner, input_task_runner, std::move(on_mouse_move));
 }
 
 }  // namespace remoting