Adds the UserInputMonitor implementation for Windows.

media/base/user_input_monitor_linux.cc

 // Copyright 2013 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 "media/base/user_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/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_libevent.h"
+#include "base/observer_list_threadsafe.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
 #include "media/base/keyboard_event_counter.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.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 media {
 namespace {
 
-class UserInputMonitorLinux : public UserInputMonitor ,
-                              public base::MessagePumpLibevent::Watcher {
+class UserInputMonitorLinux : public UserInputMonitor {
  public:
   explicit UserInputMonitorLinux(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   virtual ~UserInputMonitorLinux();
 
+  // Public UserInputMonitor overrides.
+  virtual void AddMouseListener(MouseEventListener* listener) OVERRIDE;
+  virtual void RemoveMouseListener(MouseEventListener* listener) OVERRIDE;
   virtual size_t GetKeyPressCount() const OVERRIDE;
 
  private:
+  class Core;
+  // Private UserInputMonitor overrides.
+  virtual void StartKeyboardMonitoring() OVERRIDE;
+  virtual void StopKeyboardMonitoring() OVERRIDE;
+
+  Core* core_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
+};
+
+// This is the actual implementation of event monitoring. It's separated from
+// UserInputMonitorLinux since it needs to be deleted on the IO thread.
+class UserInputMonitorLinux::Core : public base::MessagePumpLibevent::Watcher {

[Wez, 2013/09/10 21:09:00]

nit: If you rename this UserInputMonitorLinuxCore and define it before
UserInputMonitorLinux, above, then you can avoid needing to forward-define it in
UIML's private section.

[jiayl, 2013/09/10 23:14:19]

Done.

+ public:
+  explicit Core(
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
+  virtual ~Core();
+
+  void AddMouseListener(MouseEventListener* listener);
+  void RemoveMouseListener(MouseEventListener* listener);
+  size_t GetKeyPressCount() const;
+  void StartKeyboardMonitoring();
+  void StopKeyboardMonitoring();
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() {
+    return io_task_runner_;
+  }
+
+ private:
   enum EventType {
     MOUSE_EVENT,
     KEYBOARD_EVENT
   };
 
-  virtual void StartMouseMonitoring() OVERRIDE;
-  virtual void StopMouseMonitoring() OVERRIDE;
-  virtual void StartKeyboardMonitoring() OVERRIDE;
-  virtual void StopKeyboardMonitoring() OVERRIDE;
-
-  //
-  // The following methods must be called on the IO thread.
-  //
   void StartMonitor(EventType type);
   void StopMonitor(EventType type);
 
   // base::MessagePumpLibevent::Watcher interface.
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
   // Processes key and mouse events.
   void ProcessXEvent(xEvent* event);
   static void ProcessReply(XPointer self, XRecordInterceptData* data);
 
-  // Task runner on which X Window events are received.
+  base::Lock lock_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_refptr<ObserverListThreadSafe<MouseEventListener> > mouse_listeners_;
+  size_t mouse_listeners_count_;
 
   //
   // The following members should only be accessed on the IO thread.
   //
   base::MessagePumpLibevent::FileDescriptorWatcher controller_;
   Display* display_;

[Wez, 2013/09/10 21:09:00]

nit: Suggest |display_control_| and |display_record_| for these, to make it
clearer why you need two.

[jiayl, 2013/09/10 23:14:19]

Done.

   Display* x_record_display_;
   XRecordRange* x_record_range_[2];
   XRecordContext x_record_context_;
   KeyboardEventCounter counter_;
+  base::WeakPtrFactory<Core> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
+  DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-UserInputMonitorLinux::UserInputMonitorLinux(
+UserInputMonitorLinux::Core::Core(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : io_task_runner_(io_task_runner),
+      mouse_listeners_(new ObserverListThreadSafe<MouseEventListener>()),
+      mouse_listeners_count_(0),
       display_(NULL),
       x_record_display_(NULL),
-      x_record_context_(0) {
+      x_record_context_(0),
+      weak_factory_(this) {
   x_record_range_[0] = NULL;
   x_record_range_[1] = NULL;
 }
 
-UserInputMonitorLinux::~UserInputMonitorLinux() {
+UserInputMonitorLinux::Core::~Core() {
+  DCHECK_EQ(0u, mouse_listeners_count_);

[Wez, 2013/09/10 21:09:00]

nit: You could also mouse_listeners_.AssertEmpty() here if you want.

[jiayl, 2013/09/10 23:14:19]

Done.

   DCHECK(!display_);
   DCHECK(!x_record_display_);
   DCHECK(!x_record_range_[0]);
   DCHECK(!x_record_range_[1]);
   DCHECK(!x_record_context_);
 }
 
-size_t UserInputMonitorLinux::GetKeyPressCount() const {
+void UserInputMonitorLinux::Core::AddMouseListener(
+    MouseEventListener* listener) {
+  mouse_listeners_->AddObserver(listener);
+  {

[Wez, 2013/09/10 21:09:00]

If you move |lock_|, |mouse_listeners_count_|, |weak_factory_| into the main
class, and keep a copy of |io_task_runner_| there as well then you can move the
lock/increment/post logic back to the outer class.

[jiayl, 2013/09/10 23:14:19]

lock is removed now; "post" cannot be done from the outer class because the
listener list must be updated on the calling thread.

[Wez, 2013/09/11 08:03:42]

Sorry, I don't understand that logic.  Calling PostTask() in
UserInputMonitor::AddMouseListener() immediately after core_->AddMouseListener()
is equivalent to calling it here, surely?

[jiayl, 2013/09/11 16:57:10]

Core::AddMouseListener updates the listener list in the calling thread, not in
the posted task. If we don't update the listener list in the calling thread, we
may call into destroyed listener since the caller may destroy the listener
immediately after calling RemoveListener.

[Wez, 2013/09/13 10:01:27]

True, you would need to add the observer from the outer class as well , before
posting StartMonitor() to the Core.

[Wez, 2013/09/13 10:01:27]

Yes, see above re updating the listener list from the outer class.

+    base::AutoLock auto_lock(lock_);
+    mouse_listeners_count_++;

[Wez, 2013/09/10 21:09:00]

Why not keep this count on the IO thread, and increment/decrement when
processing Start/StopMonitor()? Then you wouldn't need the lock.

[jiayl, 2013/09/10 23:14:19]

Done.

+    if (mouse_listeners_count_ == 1) {
+      io_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &Core::StartMonitor, weak_factory_.GetWeakPtr(), MOUSE_EVENT));
+      DVLOG(2) << "Started mouse monitoring.";
+    }
+  }
+}
+
+void UserInputMonitorLinux::Core::RemoveMouseListener(
+    MouseEventListener* listener) {
+  mouse_listeners_->RemoveObserver(listener);
+  {
+    base::AutoLock auto_lock(lock_);
+    mouse_listeners_count_--;
+    if (mouse_listeners_count_ == 0) {
+      io_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(
+              &Core::StopMonitor, weak_factory_.GetWeakPtr(), MOUSE_EVENT));
+      DVLOG(2) << "Stopped mouse monitoring.";
+    }
+  }
+}
+
+size_t UserInputMonitorLinux::Core::GetKeyPressCount() const {
   return counter_.GetKeyPressCount();
 }
 
-void UserInputMonitorLinux::StartMouseMonitoring() {
-  if (!io_task_runner_->BelongsToCurrentThread()) {
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StartMonitor,
-                   base::Unretained(this),
-                   MOUSE_EVENT));
-    return;
-  }
-  StartMonitor(MOUSE_EVENT);
+void UserInputMonitorLinux::Core::StartKeyboardMonitoring() {

[Wez, 2013/09/10 21:09:00]

If you move |weak_factory_| into the outer class, and keep a copy of
|io_task_runner_| there then you don't need these boilerplate methods - you can
Bind() to Start/StopMonitor directly from StartKeyboardMonitoring instead.

[jiayl, 2013/09/10 23:14:19]

Done.

+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &Core::StartMonitor, weak_factory_.GetWeakPtr(), KEYBOARD_EVENT));
 }
 
-void UserInputMonitorLinux::StopMouseMonitoring() {
-  if (!io_task_runner_->BelongsToCurrentThread()) {
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StopMonitor,
-                   base::Unretained(this),
-                   MOUSE_EVENT));
-    return;
-  }
-  StopMonitor(MOUSE_EVENT);
+void UserInputMonitorLinux::Core::StopKeyboardMonitoring() {
+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &Core::StopMonitor, weak_factory_.GetWeakPtr(), KEYBOARD_EVENT));
 }
 
-void UserInputMonitorLinux::StartKeyboardMonitoring() {
-  if (!io_task_runner_->BelongsToCurrentThread()) {
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StartMonitor,
-                   base::Unretained(this),
-                   KEYBOARD_EVENT));
-    return;
-  }
-  StartMonitor(KEYBOARD_EVENT);
-}
-
-void UserInputMonitorLinux::StopKeyboardMonitoring() {
-  if (!io_task_runner_->BelongsToCurrentThread()) {
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StopMonitor,
-                   base::Unretained(this),
-                   KEYBOARD_EVENT));
-    return;
-  }
-  StopMonitor(KEYBOARD_EVENT);
-}
-
-void UserInputMonitorLinux::StartMonitor(EventType type) {
+void UserInputMonitorLinux::Core::StartMonitor(EventType type) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (type == KEYBOARD_EVENT)
     counter_.Reset();

[Wez, 2013/09/10 21:09:00]

You're resetting the counter every time StartKeyboardMonitoring() is called -
doesn't that mean that if you get multiple calls then earlier callers might be
confused by the event count being reset when later callers start monitoring?

[jiayl, 2013/09/10 23:14:19]

The base class makes sure that StartKeyboardMonitoring is only called for the
first external caller, so the count is consistent for each caller. 

[Wez, 2013/09/11 08:03:42]

Why not do the same for the mouse? i.e:

AddMouseListener(listener) // adds the Observer
Lock
mouse_listener_count_++
if (mouse_listener_count == 1)
  StartMonitor(MOUSE_TYPE);
Unlock

So long as the counter increment/decrement & Start/Stop occur with the locked
held this won't be racey.

[jiayl, 2013/09/11 16:57:10]

What's the benefit? I see two shortcomings instead: 1. the listener count and
the listener list will be scattered in two classes thus harder to maintain; 2.
it reintroduces the lock that was removed in this patch.

 
   // TODO(jamiewalch): We should pass the display in. At that point, since
   // XRecord needs a private connection to the X Server for its data channel
   // and both channels are used from a separate thread, we'll need to duplicate
   // them with something like the following:
   //   XOpenDisplay(DisplayString(display));
   if (!display_)
     display_ = XOpenDisplay(NULL);
 
   if (!x_record_display_)
@@ skipping 45 matching lines @@
                                            1,
                                            record_range_to_use,
                                            number_of_ranges);
   if (!x_record_context_) {
     LOG(ERROR) << "XRecordCreateContext failed.";
     return;
   }
 
   if (!XRecordEnableContextAsync(x_record_display_,
                                  x_record_context_,
-                                 &UserInputMonitorLinux::ProcessReply,
+                                 &Core::ProcessReply,
                                  reinterpret_cast<XPointer>(this))) {
     LOG(ERROR) << "XRecordEnableContextAsync failed.";
     return;
   }
 
   if (!x_record_range_[0] || !x_record_range_[1]) {
     // Register OnFileCanReadWithoutBlocking() to be called every time there is
     // something to read from |x_record_display_|.
     base::MessageLoopForIO* message_loop = base::MessageLoopForIO::current();
     int result =
         message_loop->WatchFileDescriptor(ConnectionNumber(x_record_display_),
                                           true,
                                           base::MessageLoopForIO::WATCH_READ,
                                           &controller_,
                                           this);
     if (!result) {
       LOG(ERROR) << "Failed to create X record task.";
       return;
     }
   }
 
   // Fetch pending events if any.
   OnFileCanReadWithoutBlocking(ConnectionNumber(x_record_display_));
 }
 
-void UserInputMonitorLinux::StopMonitor(EventType type) {
+void UserInputMonitorLinux::Core::StopMonitor(EventType type) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (x_record_range_[type]) {
     XFree(x_record_range_[type]);
     x_record_range_[type] = NULL;
   }
   if (x_record_range_[0] || x_record_range_[1])
     return;
 
   // Context must be disabled via the control channel because we can't send
   // any X protocol traffic over the data channel while it's recording.
   if (x_record_context_) {
     XRecordDisableContext(display_, x_record_context_);
     XFlush(display_);
     XRecordFreeContext(x_record_display_, x_record_context_);
     x_record_context_ = 0;
 
     controller_.StopWatchingFileDescriptor();
     if (x_record_display_) {
       XCloseDisplay(x_record_display_);
       x_record_display_ = NULL;
     }
     if (display_) {
       XCloseDisplay(display_);
       display_ = NULL;
     }
   }
 }
 
-void UserInputMonitorLinux::OnFileCanReadWithoutBlocking(int fd) {
+void UserInputMonitorLinux::Core::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   XEvent event;
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XNextEvent(x_record_display_, &event);
   }
 }
 
-void UserInputMonitorLinux::OnFileCanWriteWithoutBlocking(int fd) {
+void UserInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
-void UserInputMonitorLinux::ProcessXEvent(xEvent* event) {
+void UserInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (event->u.u.type == MotionNotify) {
     SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
                                      event->u.keyButtonPointer.rootY));
-    OnMouseEvent(position);
+    mouse_listeners_->Notify(&MouseEventListener::OnMouseMoved, position);
   } else {
     ui::EventType type;
     if (event->u.u.type == KeyPress) {
       type = ui::ET_KEY_PRESSED;
     } else if (event->u.u.type == KeyRelease) {
       type = ui::ET_KEY_RELEASED;
     } else {
       NOTREACHED();
       return;
     }
 
     KeySym key_sym = XkbKeycodeToKeysym(display_, event->u.u.detail, 0, 0);
     ui::KeyboardCode key_code = ui::KeyboardCodeFromXKeysym(key_sym);
     counter_.OnKeyboardEvent(type, key_code);
   }
 }
 
 // static
-void UserInputMonitorLinux::ProcessReply(XPointer self,
-                                         XRecordInterceptData* data) {
+void UserInputMonitorLinux::Core::ProcessReply(XPointer self,
+                                               XRecordInterceptData* data) {
   if (data->category == XRecordFromServer) {
     xEvent* event = reinterpret_cast<xEvent*>(data->data);
-    reinterpret_cast<UserInputMonitorLinux*>(self)->ProcessXEvent(event);
+    reinterpret_cast<Core*>(self)->ProcessXEvent(event);
   }
   XRecordFreeData(data);
 }
 
+//
+// Implementation of UserInputMonitorLinux.
+//
+
+UserInputMonitorLinux::UserInputMonitorLinux(
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : core_(new Core(io_task_runner)) {}
+
+UserInputMonitorLinux::~UserInputMonitorLinux() {
+  if (!core_->io_task_runner()->DeleteSoon(FROM_HERE, core_))
+    delete core_;
+}
+
+void UserInputMonitorLinux::AddMouseListener(MouseEventListener* listener) {
+  core_->AddMouseListener(listener);
+}
+
+void UserInputMonitorLinux::RemoveMouseListener(MouseEventListener* listener) {
+  core_->RemoveMouseListener(listener);
+}
+
+size_t UserInputMonitorLinux::GetKeyPressCount() const {
+  return core_->GetKeyPressCount();
+}
+
+void UserInputMonitorLinux::StartKeyboardMonitoring() {
+  core_->StartKeyboardMonitoring();
+}
+
+void UserInputMonitorLinux::StopKeyboardMonitoring() {
+  core_->StopKeyboardMonitoring();
+}
+
 }  // namespace
 
 scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
   return scoped_ptr<UserInputMonitor>(
       new UserInputMonitorLinux(io_task_runner));
 }
 
 }  // namespace media