DesktopEnvironment is now responsible for creation of the local input monitor.

LocalInputMonitor instances use the ClientSessionControl interface to pass notification about local mouse movements and to disconnect the client session when the disconnect shortcut (Ctrl+Alt+Esc) is pressed.

This CL also completely removes the MouseMoveObserver interface (along with its implementation in ChromotingHost) since it is not used any more.

BUG=104544

Review URL: https://chromiumcodereview.appspot.com/12594009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@190444 0039d316-1c4b-4281-b951-d872f2087c98

20 files changed, 185 insertions, 358 deletions

diff --git a/remoting/host/basic_desktop_environment.cc b/remoting/host/basic_desktop_environment.cc
index e6d57b7..21d6600 100644
--- a/remoting/host/basic_desktop_environment.cc
+++ b/remoting/host/basic_desktop_environment.cc
@@ -10,6 +10,7 @@
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/input_injector.h"
+#include "remoting/host/local_input_monitor.h"
 #include "remoting/host/screen_controls.h"
 
 namespace remoting {
@@ -54,6 +55,12 @@ BasicDesktopEnvironment::BasicDesktopEnvironment(
       input_task_runner_(input_task_runner),
       ui_task_runner_(ui_task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  // Create the local input monitor.
+  local_input_monitor_ = LocalInputMonitor::Create(caller_task_runner_,
+                                                   input_task_runner_,
+                                                   ui_task_runner_,
+                                                   client_session_control);
 }
 
 BasicDesktopEnvironmentFactory::BasicDesktopEnvironmentFactory(
diff --git a/remoting/host/basic_desktop_environment.h b/remoting/host/basic_desktop_environment.h
index 21e7be9..dcd5f8f 100644
--- a/remoting/host/basic_desktop_environment.h
+++ b/remoting/host/basic_desktop_environment.h
@@ -12,6 +12,8 @@
 
 namespace remoting {
 
+class LocalInputMonitor;
+
 // Used to create audio/video capturers and event executor that work with
 // the local console.
 class BasicDesktopEnvironment : public DesktopEnvironment {
@@ -55,6 +57,9 @@ class BasicDesktopEnvironment : public DesktopEnvironment {
   // Used to run UI code.
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
+  // Notifies the client session about the local mouse movements.
+  scoped_ptr<LocalInputMonitor> local_input_monitor_;
+
   DISALLOW_COPY_AND_ASSIGN(BasicDesktopEnvironment);
 };
 
diff --git a/remoting/host/chromoting_host.cc b/remoting/host/chromoting_host.cc
index 0a465c4..447be4d 100644
--- a/remoting/host/chromoting_host.cc
+++ b/remoting/host/chromoting_host.cc
@@ -329,20 +329,6 @@ void ChromotingHost::set_protocol_config(
   protocol_config_ = config.Pass();
 }
 
-void ChromotingHost::OnLocalMouseMoved(const SkIPoint& new_pos) {
-  if (!network_task_runner_->BelongsToCurrentThread()) {
-    network_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&ChromotingHost::OnLocalMouseMoved,
-                              this, new_pos));
-    return;
-  }
-
-  ClientList::iterator client;
-  for (client = clients_.begin(); client != clients_.end(); ++client) {
-    (*client)->OnLocalMouseMoved(new_pos);
-  }
-}
-
 void ChromotingHost::PauseSession(bool pause) {
   if (!network_task_runner_->BelongsToCurrentThread()) {
     network_task_runner_->PostTask(
diff --git a/remoting/host/chromoting_host.h b/remoting/host/chromoting_host.h
index 6a574a8..7115ede 100644
--- a/remoting/host/chromoting_host.h
+++ b/remoting/host/chromoting_host.h
@@ -17,7 +17,6 @@
 #include "remoting/host/client_session.h"
 #include "remoting/host/host_status_monitor.h"
 #include "remoting/host/host_status_observer.h"
-#include "remoting/host/mouse_move_observer.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/session_manager.h"
 #include "remoting/protocol/connection_to_client.h"
@@ -63,8 +62,7 @@ class DesktopEnvironmentFactory;
 class ChromotingHost : public base::RefCountedThreadSafe<ChromotingHost>,
                        public ClientSession::EventHandler,
                        public protocol::SessionManager::Listener,
-                       public HostStatusMonitor,
-                       public MouseMoveObserver {
+                       public HostStatusMonitor {
  public:
   // The caller must ensure that |signal_strategy| and
   // |desktop_environment_factory| remain valid at least until the
@@ -133,9 +131,6 @@ class ChromotingHost : public base::RefCountedThreadSafe<ChromotingHost>,
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) OVERRIDE;
 
-  // MouseMoveObserver interface.
-  virtual void OnLocalMouseMoved(const SkIPoint& new_pos) OVERRIDE;
-
   // Sets desired configuration for the protocol. Must be called before Start().
   void set_protocol_config(scoped_ptr<protocol::CandidateSessionConfig> config);
 
diff --git a/remoting/host/chromoting_host_unittest.cc b/remoting/host/chromoting_host_unittest.cc
index 1159367..d7df709 100644
--- a/remoting/host/chromoting_host_unittest.cc
+++ b/remoting/host/chromoting_host_unittest.cc
@@ -70,8 +70,7 @@ class MockIt2MeHostUserInterface : public It2MeHostUserInterface {
 
   void InitFrom(
       scoped_ptr<DisconnectWindow> disconnect_window,
-      scoped_ptr<ContinueWindow> continue_window,
-      scoped_ptr<LocalInputMonitor> local_input_monitor);
+      scoped_ptr<ContinueWindow> continue_window);
 
   // A test-only version of Start that does not register a HostStatusObserver.
   // TODO(rmsousa): Make the unit tests work with the regular Start().
@@ -87,13 +86,11 @@ MockIt2MeHostUserInterface::MockIt2MeHostUserInterface(
 
 void MockIt2MeHostUserInterface::InitFrom(
     scoped_ptr<DisconnectWindow> disconnect_window,
-    scoped_ptr<ContinueWindow> continue_window,
-    scoped_ptr<LocalInputMonitor> local_input_monitor) {
+    scoped_ptr<ContinueWindow> continue_window) {
   DCHECK(ui_task_runner()->BelongsToCurrentThread());
 
   disconnect_window_ = disconnect_window.Pass();
   continue_window_ = continue_window.Pass();
-  local_input_monitor_ = local_input_monitor.Pass();
 }
 
 void MockIt2MeHostUserInterface::Start(
@@ -141,13 +138,11 @@ class ChromotingHostTest : public testing::Test {
 
     disconnect_window_ = new MockDisconnectWindow();
     continue_window_ = new MockContinueWindow();
-    local_input_monitor_ = new MockLocalInputMonitor();
     it2me_host_user_interface_.reset(
         new MockIt2MeHostUserInterface(ui_task_runner_, ui_task_runner_));
     it2me_host_user_interface_->InitFrom(
         scoped_ptr<DisconnectWindow>(disconnect_window_),
-        scoped_ptr<ContinueWindow>(continue_window_),
-        scoped_ptr<LocalInputMonitor>(local_input_monitor_));
+        scoped_ptr<ContinueWindow>(continue_window_));
 
     it2me_host_user_interface_->Start(
         host_, base::Bind(&ChromotingHost::Shutdown, host_, base::Closure()));
@@ -499,7 +494,6 @@ class ChromotingHostTest : public testing::Test {
   // Owned by |host_|.
   MockDisconnectWindow* disconnect_window_;
   MockContinueWindow* continue_window_;
-  MockLocalInputMonitor* local_input_monitor_;
 
   MockConnectionToClient*& get_connection(int connection_index) {
     return (connection_index == 0) ? connection1_ : connection2_;
diff --git a/remoting/host/client_session_control.h b/remoting/host/client_session_control.h
index 7d46586..5daf04c 100644
--- a/remoting/host/client_session_control.h
+++ b/remoting/host/client_session_control.h
@@ -6,7 +6,6 @@
 #define REMOTING_HOST_CLIENT_SESSION_CONTROL_H_
 
 #include "base/basictypes.h"
-#include "remoting/host/mouse_move_observer.h"
 #include "third_party/skia/include/core/SkPoint.h"
 
 namespace remoting {
@@ -14,10 +13,7 @@ namespace remoting {
 // Allows the desktop environment to disconnect the client session and
 // to control the remote input handling (i.e. disable, enable, and pause
 // temporarily if the local mouse movements are detected).
-//
-// TODO(alexeypa): remove the MouseMoveObserver interface entirely.
-// See http://crbug.com/104544.
-class ClientSessionControl : public MouseMoveObserver {
+class ClientSessionControl {
  public:
   virtual ~ClientSessionControl() {}
 
diff --git a/remoting/host/desktop_session_agent.cc b/remoting/host/desktop_session_agent.cc
index be78c87..8c90842 100644
--- a/remoting/host/desktop_session_agent.cc
+++ b/remoting/host/desktop_session_agent.cc
@@ -17,7 +17,6 @@
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/input_injector.h"
-#include "remoting/host/local_input_monitor.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
@@ -71,7 +70,6 @@ DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!audio_capturer_);
   DCHECK(!desktop_environment_);
   DCHECK(!disconnect_window_);
-  DCHECK(!local_input_monitor_);
   DCHECK(!network_channel_);
   DCHECK(!screen_controls_);
   DCHECK(!video_capturer_);
@@ -198,7 +196,6 @@ void DesktopSessionAgent::OnStartSessionAgent(
   DCHECK(!desktop_environment_);
   DCHECK(!disconnect_window_);
   DCHECK(!input_injector_);
-  DCHECK(!local_input_monitor_);
   DCHECK(!screen_controls_);
   DCHECK(!video_capturer_);
 
@@ -232,19 +229,11 @@ void DesktopSessionAgent::OnStartSessionAgent(
   input_injector_->Start(clipboard_stub.Pass());
 
   // Create the disconnect window.
-  base::Closure disconnect_session =
-      base::Bind(&DesktopSessionAgent::DisconnectSession, this);
   disconnect_window_ = DisconnectWindow::Create(&ui_strings_);
   disconnect_window_->Show(
-      disconnect_session,
+      base::Bind(&DesktopSessionAgent::DisconnectSession, this),
       authenticated_jid.substr(0, authenticated_jid.find('/')));
 
-  // Start monitoring local input.
-  local_input_monitor_ = LocalInputMonitor::Create(caller_task_runner_,
-                                                   input_task_runner_,
-                                                   caller_task_runner_);
-  local_input_monitor_->Start(this, disconnect_session);
-
   // Start the audio capturer.
   if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
     audio_capturer_ = desktop_environment_->CreateAudioCapturer();
@@ -347,19 +336,15 @@ void DesktopSessionAgent::Stop() {
     control_factory_.InvalidateWeakPtrs();
     client_jid_.clear();
 
-    // Stop monitoring to local input.
-    local_input_monitor_->Stop();
-    local_input_monitor_.reset();
-
     remote_input_filter_.reset();
 
     // Ensure that any pressed keys or buttons are released.
     input_tracker_->ReleaseAll();
     input_tracker_.reset();
 
+    desktop_environment_.reset();
     input_injector_.reset();
     screen_controls_.reset();
-    desktop_environment_.reset();
 
     // Stop the audio capturer.
     audio_capture_task_runner()->PostTask(
diff --git a/remoting/host/desktop_session_agent.h b/remoting/host/desktop_session_agent.h
index ae9961e..9f8c905 100644
--- a/remoting/host/desktop_session_agent.h
+++ b/remoting/host/desktop_session_agent.h
@@ -37,7 +37,6 @@ class DesktopEnvironment;
 class DesktopEnvironmentFactory;
 class DisconnectWindow;
 class InputInjector;
-class LocalInputMonitor;
 class RemoteInputFilter;
 class ScreenControls;
 class ScreenResolution;
@@ -228,10 +227,6 @@ class DesktopSessionAgent
   // Executes keyboard, mouse and clipboard events.
   scoped_ptr<InputInjector> input_injector_;
 
-  // Monitor local inputs to allow remote inputs to be blocked while the local
-  // user is trying to do something.
-  scoped_ptr<LocalInputMonitor> local_input_monitor_;
-
   // Tracker used to release pressed keys and buttons when disconnecting.
   scoped_ptr<protocol::InputEventTracker> input_tracker_;
 
diff --git a/remoting/host/host_mock_objects.cc b/remoting/host/host_mock_objects.cc
index adbcd67..01cbdb7 100644
--- a/remoting/host/host_mock_objects.cc
+++ b/remoting/host/host_mock_objects.cc
@@ -74,9 +74,9 @@ scoped_ptr<ContinueWindow> ContinueWindow::Create(const UiStrings* ui_strings) {
   return scoped_ptr<ContinueWindow>(new MockContinueWindow());
 }
 
-MockLocalInputMonitor::MockLocalInputMonitor() {}
+MockClientSessionControl::MockClientSessionControl() {}
 
-MockLocalInputMonitor::~MockLocalInputMonitor() {}
+MockClientSessionControl::~MockClientSessionControl() {}
 
 MockClientSessionEventHandler::MockClientSessionEventHandler() {}
 
diff --git a/remoting/host/host_mock_objects.h b/remoting/host/host_mock_objects.h
index 04aaaa7..690dc05 100644
--- a/remoting/host/host_mock_objects.h
+++ b/remoting/host/host_mock_objects.h
@@ -14,7 +14,6 @@
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/input_injector.h"
-#include "remoting/host/local_input_monitor.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/control.pb.h"
@@ -53,16 +52,6 @@ class MockDisconnectWindow : public DisconnectWindow {
   MOCK_METHOD0(Hide, void());
 };
 
-class MockLocalInputMonitor : public LocalInputMonitor {
- public:
-  MockLocalInputMonitor();
-  virtual ~MockLocalInputMonitor();
-
-  MOCK_METHOD2(Start, void(MouseMoveObserver* mouse_move_observer,
-                           const base::Closure& disconnect_callback));
-  MOCK_METHOD0(Stop, void());
-};
-
 class MockContinueWindow : public ContinueWindow {
  public:
   MockContinueWindow();
@@ -73,6 +62,20 @@ class MockContinueWindow : public ContinueWindow {
   MOCK_METHOD0(Hide, void());
 };
 
+class MockClientSessionControl : public ClientSessionControl {
+ public:
+  MockClientSessionControl();
+  virtual ~MockClientSessionControl();
+
+  MOCK_CONST_METHOD0(client_jid, const std::string&());
+  MOCK_METHOD0(DisconnectSession, void());
+  MOCK_METHOD1(OnLocalMouseMoved, void(const SkIPoint&));
+  MOCK_METHOD1(SetDisableInputs, void(bool));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockClientSessionControl);
+};
+
 class MockClientSessionEventHandler : public ClientSession::EventHandler {
  public:
   MockClientSessionEventHandler();
diff --git a/remoting/host/host_user_interface.cc b/remoting/host/host_user_interface.cc
index c411eb2..333e474 100644
--- a/remoting/host/host_user_interface.cc
+++ b/remoting/host/host_user_interface.cc
@@ -18,7 +18,6 @@ HostUserInterface::HostUserInterface(
     : host_(NULL),
       network_task_runner_(network_task_runner),
       ui_task_runner_(ui_task_runner),
-      is_monitoring_local_inputs_(false),
       ui_strings_(ui_strings),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       weak_ptr_(weak_factory_.GetWeakPtr()) {
@@ -28,7 +27,6 @@ HostUserInterface::HostUserInterface(
 HostUserInterface::~HostUserInterface() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
-  MonitorLocalInputs(false);
   disconnect_window_->Hide();
 }
 
@@ -36,9 +34,6 @@ void HostUserInterface::Init() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   disconnect_window_ = DisconnectWindow::Create(&ui_strings());
-  local_input_monitor_ = LocalInputMonitor::Create(ui_task_runner_,
-                                                   network_task_runner_,
-                                                   ui_task_runner_);
 }
 
 void HostUserInterface::Start(ChromotingHost* host,
@@ -87,7 +82,6 @@ void HostUserInterface::OnShutdown() {
 void HostUserInterface::OnDisconnectCallback() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
-  MonitorLocalInputs(false);
   disconnect_window_->Hide();
   DisconnectSession();
 }
@@ -117,28 +111,12 @@ void HostUserInterface::ProcessOnClientAuthenticated(
     DisconnectSession();
     return;
   }
-
-  MonitorLocalInputs(true);
 }
 
 void HostUserInterface::ProcessOnClientDisconnected() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
-  MonitorLocalInputs(false);
   disconnect_window_->Hide();
 }
 
-void HostUserInterface::MonitorLocalInputs(bool enable) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  if (enable != is_monitoring_local_inputs_) {
-    if (enable) {
-      local_input_monitor_->Start(host_, disconnect_callback_);
-    } else {
-      local_input_monitor_->Stop();
-    }
-    is_monitoring_local_inputs_ = enable;
-  }
-}
-
 }  // namespace remoting
diff --git a/remoting/host/host_user_interface.h b/remoting/host/host_user_interface.h
index d22cb61..88adc45 100644
--- a/remoting/host/host_user_interface.h
+++ b/remoting/host/host_user_interface.h
@@ -24,7 +24,6 @@ namespace remoting {
 
 class ChromotingHost;
 class DisconnectWindow;
-class LocalInputMonitor;
 
 class HostUserInterface : public HostStatusObserver {
  public:
@@ -77,17 +76,11 @@ class HostUserInterface : public HostStatusObserver {
   // Provide a user interface allowing the host user to close the connection.
   scoped_ptr<DisconnectWindow> disconnect_window_;
 
-  // Monitor local inputs to allow remote inputs to be blocked while the local
-  // user is trying to do something.
-  scoped_ptr<LocalInputMonitor> local_input_monitor_;
-
  private:
   // Invoked from the UI thread when the user clicks on the Disconnect button
   // to disconnect the session.
   void OnDisconnectCallback();
 
-  void MonitorLocalInputs(bool enable);
-
   // The JID of the currently-authenticated user (or an empty string if no user
   // is connected).
   std::string authenticated_jid_;
@@ -99,8 +92,6 @@ class HostUserInterface : public HostStatusObserver {
   // Thread on which to run the user interface.
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
-  bool is_monitoring_local_inputs_;
-
   // TODO(alexeypa): move |ui_strings_| to DesktopEnvironmentFactory.
   UiStrings ui_strings_;
 
diff --git a/remoting/host/ipc_desktop_environment_unittest.cc b/remoting/host/ipc_desktop_environment_unittest.cc
index 72c53d1..c41af3c 100644
--- a/remoting/host/ipc_desktop_environment_unittest.cc
+++ b/remoting/host/ipc_desktop_environment_unittest.cc
@@ -77,20 +77,6 @@ class MockDaemonListener : public IPC::Listener {
   DISALLOW_COPY_AND_ASSIGN(MockDaemonListener);
 };
 
-class MockClientSessionControl : public ClientSessionControl {
- public:
-  MockClientSessionControl() {}
-  virtual ~MockClientSessionControl() {}
-
-  MOCK_CONST_METHOD0(client_jid, const std::string&());
-  MOCK_METHOD0(DisconnectSession, void());
-  MOCK_METHOD1(OnLocalMouseMoved, void(const SkIPoint&));
-  MOCK_METHOD1(SetDisableInputs, void(bool));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockClientSessionControl);
-};
-
 bool FakeDaemonSender::Send(IPC::Message* message) {
   OnMessageReceived(*message);
   delete message;
diff --git a/remoting/host/local_input_monitor.h b/remoting/host/local_input_monitor.h
index 29893d6..57ec051 100644
--- a/remoting/host/local_input_monitor.h
+++ b/remoting/host/local_input_monitor.h
@@ -5,9 +5,9 @@
 #ifndef REMOTING_HOST_LOCAL_INPUT_MONITOR_H_
 #define REMOTING_HOST_LOCAL_INPUT_MONITOR_H_
 
-#include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -15,26 +15,28 @@ class SingleThreadTaskRunner;
 
 namespace remoting {
 
-class MouseMoveObserver;
+class ClientSessionControl;
 
+// Monitors the local input to notify about mouse movements. On Mac and Linux
+// catches the disconnection keyboard shortcut (Ctlr-Alt-Esc) and invokes
+// SessionController::Delegate::DisconnectSession() when this key combination is
+// pressed.
+//
+// TODO(sergeyu): Refactor shortcut code to a separate class.
 class LocalInputMonitor {
  public:
   virtual ~LocalInputMonitor() {}
 
-  // Starts local input monitoring. This class is also responsible for
-  // of catching the disconnection keyboard shortcut on Mac and Linux
-  // (Ctlr-Alt-Esc). The |disconnect_callback| is called when this key
-  // combination is pressed.
-  //
-  // TODO(sergeyu): Refactor shortcut code to a separate class.
-  virtual void Start(MouseMoveObserver* mouse_move_observer,
-                     const base::Closure& disconnect_callback) = 0;
-  virtual void Stop() = 0;
-
+  // Creates a platform-specific instance of LocalInputMonitor.
+  // |client_session_control| is called on the |caller_task_runner| thread.
   static scoped_ptr<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);
+
+ protected:
+  LocalInputMonitor() {}
 };
 
 }  // namespace remoting
diff --git a/remoting/host/local_input_monitor_linux.cc b/remoting/host/local_input_monitor_linux.cc
index 241b1b4..3123832 100644
--- a/remoting/host/local_input_monitor_linux.cc
+++ b/remoting/host/local_input_monitor_linux.cc
@@ -19,7 +19,8 @@
 #include "base/message_pump_libevent.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
-#include "remoting/host/mouse_move_observer.h"
+#include "base/threading/non_thread_safe.h"
+#include "remoting/host/client_session_control.h"
 #include "third_party/skia/include/core/SkPoint.h"
 
 // These includes need to be later than dictated by the style guide due to
@@ -32,17 +33,15 @@ namespace remoting {
 
 namespace {
 
-class LocalInputMonitorLinux : public LocalInputMonitor {
+class LocalInputMonitorLinux : public base::NonThreadSafe,
+                               public LocalInputMonitor {
  public:
   LocalInputMonitorLinux(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> input_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+      base::WeakPtr<ClientSessionControl> client_session_control);
   virtual ~LocalInputMonitorLinux();
 
-  virtual void Start(MouseMoveObserver* mouse_move_observer,
-                     const base::Closure& disconnect_callback) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-
  private:
   // The actual implementation resides in LocalInputMonitorLinux::Core class.
   class Core
@@ -50,10 +49,10 @@ class LocalInputMonitorLinux : public LocalInputMonitor {
         public base::MessagePumpLibevent::Watcher {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-         scoped_refptr<base::SingleThreadTaskRunner> input_task_runner);
+         scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+         base::WeakPtr<ClientSessionControl> client_session_control);
 
-    void Start(MouseMoveObserver* mouse_move_observer,
-               const base::Closure& disconnect_callback);
+    void Start();
     void Stop();
 
    private:
@@ -67,13 +66,6 @@ class LocalInputMonitorLinux : public LocalInputMonitor {
     virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
     virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
-    // Posts OnLocalMouseMoved() notification to |mouse_move_observer_| on
-    // the |caller_task_runner_| thread.
-    void OnLocalMouseMoved(const SkIPoint& position);
-
-    // Posts |disconnect_callback_| on the |caller_task_runner_| thread.
-    void OnDisconnectShortcut();
-
     // Processes key and mouse events.
     void ProcessXEvent(xEvent* event);
 
@@ -85,12 +77,9 @@ class LocalInputMonitorLinux : public LocalInputMonitor {
     // Task runner on which X Window events are received.
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
-    // Invoked in the |caller_task_runner_| thread to report local mouse events.
-    MouseMoveObserver* mouse_move_observer_;
-
-    // Posted to the |caller_task_runner_| thread every time the disconnect key
-    // combination is pressed.
-    base::Closure disconnect_callback_;
+    // Points to the object receiving mouse event notifications and session
+    // disconnect requests.
+    base::WeakPtr<ClientSessionControl> client_session_control_;
 
     // Used to receive base::MessagePumpLibevent::Watcher events.
     base::MessagePumpLibevent::FileDescriptorWatcher controller_;
@@ -116,51 +105,40 @@ class LocalInputMonitorLinux : public LocalInputMonitor {
 
 LocalInputMonitorLinux::LocalInputMonitorLinux(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner)
-    : core_(new Core(caller_task_runner, input_task_runner)) {
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    base::WeakPtr<ClientSessionControl> client_session_control)
+    : core_(new Core(caller_task_runner,
+                     input_task_runner,
+                     client_session_control)) {
+  core_->Start();
 }
 
 LocalInputMonitorLinux::~LocalInputMonitorLinux() {
-}
-
-void LocalInputMonitorLinux::Start(
-    MouseMoveObserver* mouse_move_observer,
-    const base::Closure& disconnect_callback) {
-  core_->Start(mouse_move_observer, disconnect_callback);
-}
-
-void LocalInputMonitorLinux::Stop() {
   core_->Stop();
 }
 
 LocalInputMonitorLinux::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    base::WeakPtr<ClientSessionControl> client_session_control)
     : caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
-      mouse_move_observer_(NULL),
+      client_session_control_(client_session_control),
       alt_pressed_(false),
       ctrl_pressed_(false),
       display_(NULL),
       x_record_display_(NULL),
       x_record_context_(0) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(client_session_control_);
 
   x_record_range_[0] = NULL;
   x_record_range_[1] = NULL;
 }
 
-void LocalInputMonitorLinux::Core::Start(
-    MouseMoveObserver* mouse_move_observer,
-    const base::Closure& disconnect_callback) {
+void LocalInputMonitorLinux::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(disconnect_callback_.is_null());
-  DCHECK(!disconnect_callback.is_null());
-  DCHECK(!mouse_move_observer_);
-  DCHECK(mouse_move_observer);
 
-  disconnect_callback_ = disconnect_callback;
-  mouse_move_observer_ = mouse_move_observer;
   input_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Core::StartOnInputThread, this));
 }
@@ -168,15 +146,11 @@ void LocalInputMonitorLinux::Core::Start(
 void LocalInputMonitorLinux::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  disconnect_callback_.Reset();
-  mouse_move_observer_ = NULL;
   input_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Core::StopOnInputThread, this));
 }
 
 LocalInputMonitorLinux::Core::~Core() {
-  DCHECK(disconnect_callback_.is_null());
-  DCHECK(!mouse_move_observer_);
   DCHECK(!display_);
   DCHECK(!x_record_display_);
   DCHECK(!x_record_range_[0]);
@@ -303,35 +277,16 @@ void LocalInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
-void LocalInputMonitorLinux::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);
-}
-
-void LocalInputMonitorLinux::Core::OnDisconnectShortcut() {
-  if (!caller_task_runner_->BelongsToCurrentThread()) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&Core::OnDisconnectShortcut, this));
-    return;
-  }
-
-  if (!disconnect_callback_.is_null())
-    disconnect_callback_.Run();
-}
-
 void LocalInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   if (event->u.u.type == MotionNotify) {
     SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
                                      event->u.keyButtonPointer.rootY));
-    OnLocalMouseMoved(position);
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
+                              client_session_control_,
+                              position));
   } else {
     int key_code = event->u.u.detail;
     bool down = event->u.u.type == KeyPress;
@@ -341,7 +296,9 @@ void LocalInputMonitorLinux::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_) {
-      OnDisconnectShortcut();
+      caller_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
+                                client_session_control_));
     }
   }
 }
@@ -361,9 +318,12 @@ void LocalInputMonitorLinux::Core::ProcessReply(XPointer self,
 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 LocalInputMonitorLinux(caller_task_runner, input_task_runner));
+      new LocalInputMonitorLinux(caller_task_runner,
+                                 input_task_runner,
+                                 client_session_control));
 }
 
 }  // namespace remoting
diff --git a/remoting/host/local_input_monitor_mac.mm b/remoting/host/local_input_monitor_mac.mm
index 1231e45..f38489a 100644
--- a/remoting/host/local_input_monitor_mac.mm
+++ b/remoting/host/local_input_monitor_mac.mm
@@ -15,7 +15,8 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "remoting/host/mouse_move_observer.h"
+#include "base/threading/non_thread_safe.h"
+#include "remoting/host/client_session_control.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #import "third_party/GTM/AppKit/GTMCarbonEvent.h"
 
@@ -26,7 +27,8 @@ static const NSUInteger kEscKeyCode = 53;
 namespace remoting {
 namespace {
 
-class LocalInputMonitorMac : public LocalInputMonitor {
+class LocalInputMonitorMac : public base::NonThreadSafe,
+                             public LocalInputMonitor {
  public:
   // Invoked by LocalInputMonitorManager.
   class EventHandler {
@@ -39,13 +41,10 @@ class LocalInputMonitorMac : public LocalInputMonitor {
 
   LocalInputMonitorMac(
       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);
   virtual ~LocalInputMonitorMac();
 
-  virtual void Start(MouseMoveObserver* mouse_move_observer,
-                     const base::Closure& disconnect_callback) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-
  private:
   // The actual implementation resides in LocalInputMonitorMac::Core class.
   class Core;
@@ -161,10 +160,10 @@ class LocalInputMonitorMac::Core
       public EventHandler {
  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,
-             const base::Closure& disconnect_callback);
+  void Start();
   void Stop();
 
  private:
@@ -186,54 +185,41 @@ class LocalInputMonitorMac::Core
 
   LocalInputMonitorManager* manager_;
 
-  // Invoked in the |caller_task_runner_| thread to report local mouse events.
-  MouseMoveObserver* mouse_move_observer_;
-
-  // Posted to the |caller_task_runner_| thread every time the disconnect key
-  // combination is pressed.
-  base::Closure disconnect_callback_;
+  // Invoked in the |caller_task_runner_| thread to report local mouse events
+  // and session disconnect requests.
+  base::WeakPtr<ClientSessionControl> client_session_control_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 LocalInputMonitorMac::LocalInputMonitorMac(
     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();
 }
 
 LocalInputMonitorMac::~LocalInputMonitorMac() {
-}
-
-void LocalInputMonitorMac::Start(MouseMoveObserver* mouse_move_observer,
-                                 const base::Closure& disconnect_callback) {
-  core_->Start(mouse_move_observer, disconnect_callback);
-}
-
-void LocalInputMonitorMac::Stop() {
   core_->Stop();
 }
 
 LocalInputMonitorMac::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),
       manager_(nil),
-      mouse_move_observer_(NULL) {
+      client_session_control_(client_session_control) {
+  DCHECK(client_session_control_);
 }
 
-void LocalInputMonitorMac::Core::Start(
-    MouseMoveObserver* mouse_move_observer,
-    const base::Closure& disconnect_callback) {
+void LocalInputMonitorMac::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(disconnect_callback_.is_null());
-  DCHECK(!disconnect_callback.is_null());
-  DCHECK(!mouse_move_observer_);
-  DCHECK(mouse_move_observer);
 
-  disconnect_callback_ = disconnect_callback;
-  mouse_move_observer_ = mouse_move_observer;
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&Core::StartOnUiThread, this));
 }
@@ -241,15 +227,11 @@ void LocalInputMonitorMac::Core::Start(
 void LocalInputMonitorMac::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  mouse_move_observer_ = NULL;
-  disconnect_callback_.Reset();
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 }
 
 LocalInputMonitorMac::Core::~Core() {
   DCHECK(manager_ == nil);
-  DCHECK(disconnect_callback_.is_null());
-  DCHECK(!mouse_move_observer_);
 }
 
 void LocalInputMonitorMac::Core::StartOnUiThread() {
@@ -267,25 +249,16 @@ void LocalInputMonitorMac::Core::StopOnUiThread() {
 }
 
 void LocalInputMonitorMac::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);
+  caller_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
+                            client_session_control_,
+                            position));
 }
 
 void LocalInputMonitorMac::Core::OnDisconnectShortcut() {
-  if (!caller_task_runner_->BelongsToCurrentThread()) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&Core::OnDisconnectShortcut, this));
-    return;
-  }
-
-  if (!disconnect_callback_.is_null())
-    disconnect_callback_.Run();
+  caller_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
+                            client_session_control_));
 }
 
 }  // namespace
@@ -293,9 +266,12 @@ void LocalInputMonitorMac::Core::OnDisconnectShortcut() {
 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 LocalInputMonitorMac(caller_task_runner, ui_task_runner));
+      new LocalInputMonitorMac(caller_task_runner,
+                               ui_task_runner,
+                               client_session_control));
 }
 
 }  // namespace remoting
diff --git a/remoting/host/local_input_monitor_unittest.cc b/remoting/host/local_input_monitor_unittest.cc
index a3c1836..c1da580 100644
--- a/remoting/host/local_input_monitor_unittest.cc
+++ b/remoting/host/local_input_monitor_unittest.cc
@@ -7,8 +7,10 @@
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "remoting/base/auto_thread_task_runner.h"
+#include "remoting/host/client_session_control.h"
+#include "remoting/host/host_mock_objects.h"
 #include "remoting/host/local_input_monitor.h"
-#include "remoting/host/mouse_move_observer.h"
+#include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPoint.h"
@@ -17,6 +19,7 @@ namespace remoting {
 
 using testing::_;
 using testing::AnyNumber;
+using testing::ReturnRef;
 
 namespace {
 
@@ -26,49 +29,57 @@ const MessageLoop::Type kDesiredMessageLoopType = MessageLoop::TYPE_UI;
 const MessageLoop::Type kDesiredMessageLoopType = MessageLoop::TYPE_IO;
 #endif  // !defined(OS_WIN)
 
-class FakeMouseMoveObserver : public MouseMoveObserver {
- public:
-  FakeMouseMoveObserver() {}
-  virtual ~FakeMouseMoveObserver() {}
-
-  // Ignore mouse events to avoid breaking the test of someone moves the mouse.
-  virtual void OnLocalMouseMoved(const SkIPoint&) OVERRIDE {}
-  void OnDisconnectCallback() {}
-};
-
 }  // namespace
 
 class LocalInputMonitorTest : public testing::Test {
  public:
-  LocalInputMonitorTest() : message_loop_(kDesiredMessageLoopType) {
-  }
+  LocalInputMonitorTest();
 
-  virtual void SetUp() OVERRIDE {
-    // Arrange to run |message_loop_| until no components depend on it.
-    task_runner_ = new AutoThreadTaskRunner(
-        message_loop_.message_loop_proxy(), run_loop_.QuitClosure());
-  }
+  virtual void SetUp() OVERRIDE;
 
   MessageLoop message_loop_;
   base::RunLoop run_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
 
-  FakeMouseMoveObserver mouse_move_observer_;
+  std::string client_jid_;
+  MockClientSessionControl client_session_control_;
+  base::WeakPtrFactory<ClientSessionControl> client_session_control_factory_;
 };
 
+LocalInputMonitorTest::LocalInputMonitorTest()
+    : message_loop_(kDesiredMessageLoopType),
+      client_jid_("user@domain/rest-of-jid"),
+      client_session_control_factory_(&client_session_control_) {
+}
+
+void LocalInputMonitorTest::SetUp() {
+  // Arrange to run |message_loop_| until no components depend on it.
+  task_runner_ = new AutoThreadTaskRunner(
+      message_loop_.message_loop_proxy(), run_loop_.QuitClosure());
+}
+
+
 // This test is really to exercise only the creation and destruction code in
 // LocalInputMonitor.
 TEST_F(LocalInputMonitorTest, Basic) {
+  // Ignore all callbacks.
+  EXPECT_CALL(client_session_control_, client_jid())
+      .Times(AnyNumber())
+      .WillRepeatedly(ReturnRef(client_jid_));
+  EXPECT_CALL(client_session_control_, DisconnectSession())
+      .Times(AnyNumber());
+  EXPECT_CALL(client_session_control_, OnLocalMouseMoved(_))
+      .Times(AnyNumber());
+  EXPECT_CALL(client_session_control_, SetDisableInputs(_))
+      .Times(0);
+
   {
     scoped_ptr<LocalInputMonitor> local_input_monitor =
-        LocalInputMonitor::Create(task_runner_, task_runner_, task_runner_);
+        LocalInputMonitor::Create(task_runner_,
+                                  task_runner_,
+                                  task_runner_,
+                                  client_session_control_factory_.GetWeakPtr());
     task_runner_ = NULL;
-
-    local_input_monitor->Start(
-        &mouse_move_observer_,
-        base::Bind(&FakeMouseMoveObserver::OnDisconnectCallback,
-                   base::Unretained(&mouse_move_observer_)));
-    local_input_monitor->Stop();
   }
 
   run_loop_.Run();
diff --git a/remoting/host/local_input_monitor_win.cc b/remoting/host/local_input_monitor_win.cc
index 85a2030..28deebc 100644
--- a/remoting/host/local_input_monitor_win.cc
+++ b/remoting/host/local_input_monitor_win.cc
@@ -12,7 +12,7 @@
 #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 {
@@ -30,21 +30,19 @@ class LocalInputMonitorWin : public base::NonThreadSafe,
  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:
@@ -54,10 +52,6 @@ class LocalInputMonitorWin : public base::NonThreadSafe,
     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);
 
@@ -83,8 +77,8 @@ class LocalInputMonitorWin : public base::NonThreadSafe,
     // 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);
   };
@@ -96,39 +90,34 @@ class LocalInputMonitorWin : public base::NonThreadSafe,
 
 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();
 }
 
 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));
 }
@@ -136,7 +125,6 @@ void LocalInputMonitorWin::Core::Start(MouseMoveObserver* mouse_move_observer) {
 void LocalInputMonitorWin::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  mouse_move_observer_ = NULL;
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 }
 
@@ -144,7 +132,6 @@ LocalInputMonitorWin::Core::~Core() {
   DCHECK(!atom_);
   DCHECK(!instance_);
   DCHECK(!window_);
-  DCHECK(!mouse_move_observer_);
 }
 
 void LocalInputMonitorWin::Core::StartOnUiThread() {
@@ -189,17 +176,6 @@ void LocalInputMonitorWin::Core::StopOnUiThread() {
   }
 }
 
-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());
 
@@ -255,7 +231,10 @@ LRESULT LocalInputMonitorWin::Core::OnInput(HRAWINPUT input_handle) {
       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));
@@ -291,9 +270,12 @@ LRESULT CALLBACK LocalInputMonitorWin::Core::WindowProc(
 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
diff --git a/remoting/host/mouse_move_observer.h b/remoting/host/mouse_move_observer.h
deleted file mode 100644
index e19306e..0000000
--- a/remoting/host/mouse_move_observer.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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.
-
-#ifndef REMOTING_HOST_MOUSE_MOVE_OBSERVER_H_
-#define REMOTING_HOST_MOUSE_MOVE_OBSERVER_H_
-
-struct SkIPoint;
-
-namespace remoting {
-
-// Interface used by LocalInputMonitor to notify about local mouse
-// movement.
-class MouseMoveObserver {
- public:
-  virtual void OnLocalMouseMoved(const SkIPoint& new_pos) = 0;
-
- protected:
-  virtual ~MouseMoveObserver() {}
-};
-
-}  // namespace remoting
-
-#endif  // REMOTING_HOST_MOUSE_MOVE_OBSERVER_H_
diff --git a/remoting/remoting.gyp b/remoting/remoting.gyp
index a049650..5f3b408 100644
--- a/remoting/remoting.gyp
+++ b/remoting/remoting.gyp
@@ -407,7 +407,6 @@
             'host/me2me_desktop_environment.h',
             'host/mouse_clamping_filter.cc',
             'host/mouse_clamping_filter.h',
-            'host/mouse_move_observer.h',
             'host/network_settings.h',
             'host/pam_authorization_factory_posix.cc',
             'host/pam_authorization_factory_posix.h',