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 interface of UserInputMonitor.
+  virtual void AddMouseListener(MouseEventListener* listener) OVERRIDE;
+  virtual void RemoveMouseListener(MouseEventListener* listener) OVERRIDE;
   virtual size_t GetKeyPressCount() const OVERRIDE;
 
  private:
+  // Private interface of UserInputMonitor.
+  virtual void StartKeyboardMonitoring() OVERRIDE;
+  virtual void StopKeyboardMonitoring() OVERRIDE;
+
+  class Core;
+  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 {
+ 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_;
   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_);
   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);
+  {
+    base::AutoLock auto_lock(lock_);
+    mouse_listeners_count_++;
+    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() {
+  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();
 
   // 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));
@@ skipping 49 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