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() {

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

Move Start() to constructor?

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

No, PostTask cannot be called from a constructor because it increments the
reference counter of the object. If the task completes before the constructor
returns, the reference counter will be dropped back to zero and the object will
be destroyed.

I could collapse Start() and StartOnUiThread() but then it will be harder to
check that Start() was initially called on |caller_task_runner|.

   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