Adding key press detection in the browser process.

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/posix/eintr_wrapper.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/non_thread_safe.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 base::NonThreadSafe,
+                              public UserInputMonitor {
+ public:
+  UserInputMonitorLinux(
+      const scoped_refptr<base::SingleThreadTaskRunner>& input_task_runner);
+  virtual ~UserInputMonitorLinux();
+
+ private:
+  enum EventType {
+    MOUSE_EVENT = 0,
+    KEYBOARD_EVENT = 1
+  };
+
+  // The actual implementation resides in UserInputMonitorLinux::Core class.
+  // Must be called on the input_task_runner thread.
+  class Core : public base::RefCountedThreadSafe<Core>,
+               public base::MessagePumpLibevent::Watcher {
+   public:
+    typedef const base::Callback<void(const SkIPoint&)> MouseCallback;
+    typedef base::Callback<void(ui::EventType event, ui::KeyboardCode key_code)>
+        KeyboardCallback;
+    Core(const MouseCallback& mouse_callback,
+         const KeyboardCallback& keyboard_callback);
+
+    void StartMonitor(EventType type);
+    void StopMonitor(EventType type);
+
+   private:
+    friend class base::RefCountedThreadSafe<Core>;
+    virtual ~Core();
+
+    // 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);
+
+    // Used to receive base::MessagePumpLibevent::Watcher events.
+    base::MessagePumpLibevent::FileDescriptorWatcher controller_;
+
+    Display* display_;
+    Display* x_record_display_;
+    XRecordRange* x_record_range_[2];
+    XRecordContext x_record_context_;
+    base::Callback<void(const SkIPoint&)> mouse_callback_;
+    base::Callback<void(ui::EventType event, ui::KeyboardCode key_code)>
+        keyboard_callback_;
+
+    DISALLOW_COPY_AND_ASSIGN(Core);
+  };
+
+  virtual void StartMonitorMouse() OVERRIDE;
+  virtual void StopMonitorMouse() OVERRIDE;
+  virtual void StartMonitorKeyboard() OVERRIDE;
+  virtual void StopMonitorKeyboard() OVERRIDE;
+
+  void OnMouseEvent(const SkIPoint& position);
+  void OnKeyboardEvent(ui::EventType event, ui::KeyboardCode key_code);
+
+  void SetOrVerifyCallingThread();
+
+  // Task runner on which monitoring is started and callbacks are called.
+  scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
+  // Task runner on which X Window events are received.
+  scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
+  scoped_refptr<Core> core_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
+};
+
+UserInputMonitorLinux::UserInputMonitorLinux(
+    const scoped_refptr<base::SingleThreadTaskRunner>& input_task_runner)
+    : input_task_runner_(input_task_runner),
+      core_(new Core(base::Bind(&UserInputMonitorLinux::OnMouseEvent,
+                                base::Unretained(this)),
+                     base::Bind(&UserInputMonitorLinux::OnKeyboardEvent,
+                                base::Unretained(this)))) {}
+
+UserInputMonitorLinux::~UserInputMonitorLinux() {}
+
+void UserInputMonitorLinux::StartMonitorMouse() {
+  SetOrVerifyCallingThread();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), MOUSE_EVENT));
+}
+
+void UserInputMonitorLinux::StopMonitorMouse() {
+  SetOrVerifyCallingThread();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), MOUSE_EVENT));
+}
+
+void UserInputMonitorLinux::StartMonitorKeyboard() {
+  SetOrVerifyCallingThread();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), KEYBOARD_EVENT));
+}
+
+void UserInputMonitorLinux::StopMonitorKeyboard() {
+  SetOrVerifyCallingThread();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), KEYBOARD_EVENT));
+}
+
+void UserInputMonitorLinux::OnMouseEvent(const SkIPoint& position) {
+  if (!callback_task_runner_->BelongsToCurrentThread()) {
+    callback_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&UserInputMonitorLinux::OnMouseEvent,
+                   base::Unretained(this),
+                   position));
+    return;
+  }
+  UserInputMonitor::OnMouseEvent(position);
+}
+
+void UserInputMonitorLinux::OnKeyboardEvent(ui::EventType event,
+                                            ui::KeyboardCode key_code) {
+  if (!callback_task_runner_->BelongsToCurrentThread()) {
+    callback_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&UserInputMonitorLinux::OnKeyboardEvent,
+                   base::Unretained(this),
+                   event,
+                   key_code));
+    return;
+  }
+  UserInputMonitor::OnKeyboardEvent(event, key_code);
+}
+
+void UserInputMonitorLinux::SetOrVerifyCallingThread() {

[DaleCurtis, 2013/08/10 00:13:12]

Instead of trying to do this, which feels a bit sketchy, how about just letting
clients handle their own thread hopping?  I.e. you deliver the notification via
ObserverList and clients can post a task to whatever thread they want if
necessary.

[jiayl, 2013/08/10 00:37:56]

If it's not done here, it needs to be done in the base class, since the
ObserverList should be accessed on one thread. I think moving it to the base
class is better.

[Sergey Ulanov, 2013/08/10 00:48:19]

It would mean that the clients of this interface have to be thread-aware, which
isn't good.
I think ObserverListThreadSafe might be useful here - it will jump threads as
needed (and so it can be used to make UserInputMonitor usable on different
threads).

[DaleCurtis, 2013/08/10 00:57:51]

Since UserInputMonitor is owned by BrowserMainLoop, multiple threads may now
register for user input... so registering yourself to a single callback task
runner seems a recipe for disaster. 

Actually, I think the only way around this is a lock or a requirement that
listeners are only added and removed on the UI or IO thread (depending on
whether linux or mac/win is used).

Since you don't actually need the ability for reentrant removal of observers,
you could switch them to std::lists protected by a single lock.

[jiayl, 2013/08/12 19:05:59]

Is there any problem with using ObserverList with a lock? It's nice to reuse the
duplicated observer checking and such of ObserverList.

+  if (!callback_task_runner_) {
+    callback_task_runner_ = base::MessageLoopProxy::current();
+    return;
+  }
+  CHECK(callback_task_runner_->BelongsToCurrentThread());

[Sergey Ulanov, 2013/08/10 00:48:19]

it's more common to use DCHECKs for thread checks.

+}
+
+UserInputMonitorLinux::Core::Core(const MouseCallback& mouse_callback,
+                                  const KeyboardCallback& keyboard_callback)
+    : display_(NULL),
+      x_record_display_(NULL),
+      x_record_context_(0),
+      mouse_callback_(mouse_callback),
+      keyboard_callback_(keyboard_callback) {
+  x_record_range_[0] = NULL;
+  x_record_range_[1] = NULL;
+}
+
+UserInputMonitorLinux::Core::~Core() {
+  DCHECK(!display_);
+  DCHECK(!x_record_display_);
+  DCHECK(!x_record_range_[0]);
+  DCHECK(!x_record_range_[1]);
+  DCHECK(!x_record_context_);
+}
+
+void UserInputMonitorLinux::Core::StartMonitor(EventType type) {
+  DCHECK(base::MessageLoopForIO::current());
+  // 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_)
+    x_record_display_ = XOpenDisplay(NULL);
+
+  if (!display_ || !x_record_display_) {
+    LOG(ERROR) << "Couldn't open X display";
+    return;
+  }
+
+  int xr_opcode, xr_event, xr_error;
+  if (!XQueryExtension(display_, "RECORD", &xr_opcode, &xr_event, &xr_error)) {
+    LOG(ERROR) << "X Record extension not available.";
+    return;
+  }
+
+  if (!x_record_range_[type])
+    x_record_range_[type] = XRecordAllocRange();
+
+  if (!x_record_range_[type]) {
+    LOG(ERROR) << "XRecordAllocRange failed.";
+    return;
+  }
+  if (type == MOUSE_EVENT) {
+    x_record_range_[type]->device_events.first = MotionNotify;
+    x_record_range_[type]->device_events.last = MotionNotify;
+  } else {
+    DCHECK_EQ(KEYBOARD_EVENT, type);
+    x_record_range_[type]->device_events.first = KeyPress;
+    x_record_range_[type]->device_events.last = KeyRelease;
+  }
+
+  if (x_record_context_) {
+    XRecordDisableContext(display_, x_record_context_);
+    XFlush(display_);
+    XRecordFreeContext(x_record_display_, x_record_context_);
+    x_record_context_ = 0;
+  }
+  XRecordRange** record_range_to_use =
+      (x_record_range_[0] && x_record_range_[1]) ? x_record_range_
+                                                 : &x_record_range_[type];
+  int number_of_ranges = (x_record_range_[0] && x_record_range_[1]) ? 2 : 1;
+
+  XRecordClientSpec client_spec = XRecordAllClients;
+  x_record_context_ = XRecordCreateContext(x_record_display_,
+                                           0,
+                                           &client_spec,
+                                           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_,
+                                 &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();

[DaleCurtis, 2013/08/10 00:13:12]

?? just use io_loop_ ?

[jiayl, 2013/08/10 00:37:56]

Core doesn't have a member as io_loop_. It's always running on the IO loop.

[Sergey Ulanov, 2013/08/10 00:48:19]

Also, only ForIO version of MessageLoop has WatchFileDescriptor(), so io_loop_
(which is a task runner wrapping the message loop) would not be useful here.

+    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.
+  while (XPending(x_record_display_)) {
+    XEvent ev;
+    XNextEvent(x_record_display_, &ev);
+  }
+}
+
+void UserInputMonitorLinux::Core::StopMonitor(EventType type) {
+  DCHECK(base::MessageLoopForIO::current());
+
+  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::Core::OnFileCanReadWithoutBlocking(int fd) {
+  DCHECK(base::MessageLoopForIO::current());
+
+  // Fetch pending events if any.
+  while (XPending(x_record_display_)) {
+    XEvent ev;
+    XNextEvent(x_record_display_, &ev);
+  }
+}
+
+void UserInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
+  NOTREACHED();
+}
+
+void UserInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
+  if (event->u.u.type == MotionNotify) {
+    SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
+                                     event->u.keyButtonPointer.rootY));
+    mouse_callback_.Run(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();
+    }
+
+    KeySym key_sym = XkbKeycodeToKeysym(display_, event->u.u.detail, 0, 0);
+    ui::KeyboardCode key_code = ui::KeyboardCodeFromXKeysym(key_sym);
+    keyboard_callback_.Run(type, key_code);
+  }
+}
+
+// static
+void UserInputMonitorLinux::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<UserInputMonitor> UserInputMonitor::Create(
+    const scoped_refptr<base::SingleThreadTaskRunner>& input_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
+  return scoped_ptr<UserInputMonitor>(
+      new UserInputMonitorLinux(input_task_runner));
+}
+
+}  // namespace media