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>
@@ skipping 19 matching lines @@
 #include <X11/extensions/record.h>
 
 namespace media {
 namespace {
 
 class UserInputMonitorLinux : public UserInputMonitor ,
                               public base::MessagePumpLibevent::Watcher {
  public:
   explicit UserInputMonitorLinux(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
-  virtual ~UserInputMonitorLinux();
-
   virtual size_t GetKeyPressCount() const OVERRIDE;
 
  private:
   enum EventType {
     MOUSE_EVENT,
     KEYBOARD_EVENT
   };
 
+  virtual ~UserInputMonitorLinux();
+
   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);
@@ skipping 41 matching lines @@
 }
 
 size_t UserInputMonitorLinux::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));
+        base::Bind(&UserInputMonitorLinux::StartMouseMonitoring, this));
     return;
   }
   StartMonitor(MOUSE_EVENT);
 }
 
 void UserInputMonitorLinux::StopMouseMonitoring() {
   if (!io_task_runner_->BelongsToCurrentThread()) {
     io_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StopMonitor,
-                   base::Unretained(this),
-                   MOUSE_EVENT));
+        base::Bind(&UserInputMonitorLinux::StopMouseMonitoring, this));
     return;
   }
   StopMonitor(MOUSE_EVENT);
 }
 
 void UserInputMonitorLinux::StartKeyboardMonitoring() {
   if (!io_task_runner_->BelongsToCurrentThread()) {
     io_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StartMonitor,
-                   base::Unretained(this),
-                   KEYBOARD_EVENT));
+        base::Bind(&UserInputMonitorLinux::StartKeyboardMonitoring, this));
     return;
   }
   StartMonitor(KEYBOARD_EVENT);
 }
 
 void UserInputMonitorLinux::StopKeyboardMonitoring() {
   if (!io_task_runner_->BelongsToCurrentThread()) {

[Sergey Ulanov, 2013/09/04 18:40:09]

There is potential race between StartKeyboardMonitoring() and
StopKeyboardMonitoring(). If StopKeyboardMonitoring() is called on a thread
other than the IO thread and then StartKeyboardMonitoring() is called the IO
immediately after that then monitoring will be started and then stopped on the
IO thread, while it should be stopped first and then started. I think you can
avoid it by always posting a task to call StopMonitor().

[jiayl, 2013/09/05 00:29:38]

If the same caller calls Start and Stop on different threads, there is no way to
know what's the intended ordering and I think it's expected to get undefined
behavior.

[Sergey Ulanov, 2013/09/07 20:19:41]

It might not be the same caller.  One object may be calling
RemoveMouseListener() which would call StopMonitoring(), while completely
different object is calling AddMouseListener() which calls StartMonitoring().
What matters is that the listener gets notification after registering with
AddMouseListener(), but due to this race it could happen that monitoring will be
stopped when it shouldn't be.

[jiayl, 2013/09/10 16:31:00]

Done.

     io_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&UserInputMonitorLinux::StopMonitor,
-                   base::Unretained(this),
-                   KEYBOARD_EVENT));
+        base::Bind(&UserInputMonitorLinux::StopKeyboardMonitoring, this));
     return;
   }
   StopMonitor(KEYBOARD_EVENT);
 }
 
 void UserInputMonitorLinux::StartMonitor(EventType type) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (type == KEYBOARD_EVENT)
     counter_.Reset();
@@ skipping 159 matching lines @@
                                          XRecordInterceptData* data) {
   if (data->category == XRecordFromServer) {
     xEvent* event = reinterpret_cast<xEvent*>(data->data);
     reinterpret_cast<UserInputMonitorLinux*>(self)->ProcessXEvent(event);
   }
   XRecordFreeData(data);
 }
 
 }  // namespace
 
-scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
+scoped_refptr<UserInputMonitor> UserInputMonitor::Create(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
-  return scoped_ptr<UserInputMonitor>(
+  return scoped_refptr<UserInputMonitor>(
       new UserInputMonitorLinux(io_task_runner));
 }
 
 }  // namespace media