Converted LocalInputMonitor into a SessionController instance.

remoting/host/local_input_monitor_linux.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 <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #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
 // Xlib header pollution, specifically the min, max, and Status macros.
 #include <X11/XKBlib.h>
 #include <X11/Xlibint.h>
 #include <X11/extensions/record.h>
 
 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
       : public base::RefCountedThreadSafe<Core>,
         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:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void StartOnInputThread();
     void StopOnInputThread();
 
     // base::MessagePumpLibevent::Watcher interface.
     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);
 
     static void ProcessReply(XPointer self, XRecordInterceptData* data);
 
     // Task runner on which public methods of this class must be called.
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
     // 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_;
 
     // True when Alt is pressed.
     bool alt_pressed_;
 
     // True when Ctrl is pressed.
     bool ctrl_pressed_;
 
     Display* display_;
     Display* x_record_display_;
     XRecordRange* x_record_range_[2];
     XRecordContext x_record_context_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorLinux);
 };
 
 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));
 }
 
 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]);
   DCHECK(!x_record_range_[1]);
   DCHECK(!x_record_context_);
 }
 
 void LocalInputMonitorLinux::Core::StartOnInputThread() {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
   DCHECK(!display_);
@@ skipping 106 matching lines @@
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
   }
 }
 
 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;
     KeySym key_sym = XkbKeycodeToKeysym(display_, key_code, 0, 0);
     if (key_sym == XK_Control_L || key_sym == XK_Control_R) {
       ctrl_pressed_ = down;
     } 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_));
     }
   }
 }
 
 // static
 void LocalInputMonitorLinux::Core::ProcessReply(XPointer self,
                                                 XRecordInterceptData* data) {
   if (data->category == XRecordFromServer) {
     xEvent* event = reinterpret_cast<xEvent*>(data->data);
     reinterpret_cast<Core*>(self)->ProcessXEvent(event);
   }
   XRecordFreeData(data);
 }
 
 }  // 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 LocalInputMonitorLinux(caller_task_runner, input_task_runner));
+      new LocalInputMonitorLinux(caller_task_runner,
+                                 input_task_runner,
+                                 client_session_control));
 }
 
 }  // namespace remoting