Home | History | Annotate | Download | only in base 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/base/user_input_monitor.h"
      6 
      7 #include <sys/select.h>
      8 #include <unistd.h>
      9 #define XK_MISCELLANY
     10 #include <X11/keysymdef.h>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/bind.h"
     14 #include "base/callback.h"
     15 #include "base/compiler_specific.h"
     16 #include "base/location.h"
     17 #include "base/logging.h"
     18 #include "base/message_loop/message_loop.h"
     19 #include "base/message_loop/message_pump_libevent.h"
     20 #include "base/single_thread_task_runner.h"
     21 #include "base/synchronization/lock.h"
     22 #include "media/base/keyboard_event_counter.h"
     23 #include "third_party/skia/include/core/SkPoint.h"
     24 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
     25 #include "ui/gfx/x/x11_types.h"
     26 
     27 // These includes need to be later than dictated by the style guide due to
     28 // Xlib header pollution, specifically the min, max, and Status macros.
     29 #include <X11/XKBlib.h>
     30 #include <X11/Xlibint.h>
     31 #include <X11/extensions/record.h>
     32 
     33 namespace media {
     34 namespace {
     35 
     36 // This is the actual implementation of event monitoring. It's separated from
     37 // UserInputMonitorLinux since it needs to be deleted on the IO thread.
     38 class UserInputMonitorLinuxCore
     39     : public base::MessagePumpLibevent::Watcher,
     40       public base::SupportsWeakPtr<UserInputMonitorLinuxCore>,
     41       public base::MessageLoop::DestructionObserver {
     42  public:
     43   enum EventType {
     44     MOUSE_EVENT,
     45     KEYBOARD_EVENT
     46   };
     47 
     48   explicit UserInputMonitorLinuxCore(
     49       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     50       const scoped_refptr<UserInputMonitor::MouseListenerList>&
     51           mouse_listeners);
     52   virtual ~UserInputMonitorLinuxCore();
     53 
     54   // DestructionObserver overrides.
     55   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
     56 
     57   size_t GetKeyPressCount() const;
     58   void StartMonitor(EventType type);
     59   void StopMonitor(EventType type);
     60 
     61  private:
     62   // base::MessagePumpLibevent::Watcher interface.
     63   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
     64   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
     65 
     66   // Processes key and mouse events.
     67   void ProcessXEvent(xEvent* event);
     68   static void ProcessReply(XPointer self, XRecordInterceptData* data);
     69 
     70   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
     71   scoped_refptr<ObserverListThreadSafe<UserInputMonitor::MouseEventListener> >
     72       mouse_listeners_;
     73 
     74   //
     75   // The following members should only be accessed on the IO thread.
     76   //
     77   base::MessagePumpLibevent::FileDescriptorWatcher controller_;
     78   Display* x_control_display_;
     79   Display* x_record_display_;
     80   XRecordRange* x_record_range_[2];
     81   XRecordContext x_record_context_;
     82   KeyboardEventCounter counter_;
     83 
     84   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinuxCore);
     85 };
     86 
     87 class UserInputMonitorLinux : public UserInputMonitor {
     88  public:
     89   explicit UserInputMonitorLinux(
     90       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
     91   virtual ~UserInputMonitorLinux();
     92 
     93   // Public UserInputMonitor overrides.
     94   virtual size_t GetKeyPressCount() const OVERRIDE;
     95 
     96  private:
     97   // Private UserInputMonitor overrides.
     98   virtual void StartKeyboardMonitoring() OVERRIDE;
     99   virtual void StopKeyboardMonitoring() OVERRIDE;
    100   virtual void StartMouseMonitoring() OVERRIDE;
    101   virtual void StopMouseMonitoring() OVERRIDE;
    102 
    103   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
    104   UserInputMonitorLinuxCore* core_;
    105 
    106   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
    107 };
    108 
    109 UserInputMonitorLinuxCore::UserInputMonitorLinuxCore(
    110     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
    111     const scoped_refptr<UserInputMonitor::MouseListenerList>& mouse_listeners)
    112     : io_task_runner_(io_task_runner),
    113       mouse_listeners_(mouse_listeners),
    114       x_control_display_(NULL),
    115       x_record_display_(NULL),
    116       x_record_context_(0) {
    117   x_record_range_[0] = NULL;
    118   x_record_range_[1] = NULL;
    119 }
    120 
    121 UserInputMonitorLinuxCore::~UserInputMonitorLinuxCore() {
    122   DCHECK(!x_control_display_);
    123   DCHECK(!x_record_display_);
    124   DCHECK(!x_record_range_[0]);
    125   DCHECK(!x_record_range_[1]);
    126   DCHECK(!x_record_context_);
    127 }
    128 
    129 void UserInputMonitorLinuxCore::WillDestroyCurrentMessageLoop() {
    130   DCHECK(io_task_runner_->BelongsToCurrentThread());
    131   StopMonitor(MOUSE_EVENT);
    132   StopMonitor(KEYBOARD_EVENT);
    133 }
    134 
    135 size_t UserInputMonitorLinuxCore::GetKeyPressCount() const {
    136   return counter_.GetKeyPressCount();
    137 }
    138 
    139 void UserInputMonitorLinuxCore::StartMonitor(EventType type) {
    140   DCHECK(io_task_runner_->BelongsToCurrentThread());
    141 
    142   if (type == KEYBOARD_EVENT)
    143     counter_.Reset();
    144 
    145   // TODO(jamiewalch): We should pass the display in. At that point, since
    146   // XRecord needs a private connection to the X Server for its data channel
    147   // and both channels are used from a separate thread, we'll need to duplicate
    148   // them with something like the following:
    149   //   XOpenDisplay(DisplayString(display));
    150   if (!x_control_display_)
    151     x_control_display_ = gfx::OpenNewXDisplay();
    152 
    153   if (!x_record_display_)
    154     x_record_display_ = gfx::OpenNewXDisplay();
    155 
    156   if (!x_control_display_ || !x_record_display_) {
    157     LOG(ERROR) << "Couldn't open X display";
    158     StopMonitor(type);
    159     return;
    160   }
    161 
    162   int xr_opcode, xr_event, xr_error;
    163   if (!XQueryExtension(
    164            x_control_display_, "RECORD", &xr_opcode, &xr_event, &xr_error)) {
    165     LOG(ERROR) << "X Record extension not available.";
    166     StopMonitor(type);
    167     return;
    168   }
    169 
    170   if (!x_record_range_[type])
    171     x_record_range_[type] = XRecordAllocRange();
    172 
    173   if (!x_record_range_[type]) {
    174     LOG(ERROR) << "XRecordAllocRange failed.";
    175     StopMonitor(type);
    176     return;
    177   }
    178 
    179   if (type == MOUSE_EVENT) {
    180     x_record_range_[type]->device_events.first = MotionNotify;
    181     x_record_range_[type]->device_events.last = MotionNotify;
    182   } else {
    183     DCHECK_EQ(KEYBOARD_EVENT, type);
    184     x_record_range_[type]->device_events.first = KeyPress;
    185     x_record_range_[type]->device_events.last = KeyRelease;
    186   }
    187 
    188   if (x_record_context_) {
    189     XRecordDisableContext(x_control_display_, x_record_context_);
    190     XFlush(x_control_display_);
    191     XRecordFreeContext(x_record_display_, x_record_context_);
    192     x_record_context_ = 0;
    193   }
    194   XRecordRange** record_range_to_use =
    195       (x_record_range_[0] && x_record_range_[1]) ? x_record_range_
    196                                                  : &x_record_range_[type];
    197   int number_of_ranges = (x_record_range_[0] && x_record_range_[1]) ? 2 : 1;
    198 
    199   XRecordClientSpec client_spec = XRecordAllClients;
    200   x_record_context_ = XRecordCreateContext(x_record_display_,
    201                                            0,
    202                                            &client_spec,
    203                                            1,
    204                                            record_range_to_use,
    205                                            number_of_ranges);
    206   if (!x_record_context_) {
    207     LOG(ERROR) << "XRecordCreateContext failed.";
    208     StopMonitor(type);
    209     return;
    210   }
    211 
    212   if (!XRecordEnableContextAsync(x_record_display_,
    213                                  x_record_context_,
    214                                  &UserInputMonitorLinuxCore::ProcessReply,
    215                                  reinterpret_cast<XPointer>(this))) {
    216     LOG(ERROR) << "XRecordEnableContextAsync failed.";
    217     StopMonitor(type);
    218     return;
    219   }
    220 
    221   if (!x_record_range_[0] || !x_record_range_[1]) {
    222     // Register OnFileCanReadWithoutBlocking() to be called every time there is
    223     // something to read from |x_record_display_|.
    224     base::MessageLoopForIO* message_loop = base::MessageLoopForIO::current();
    225     int result =
    226         message_loop->WatchFileDescriptor(ConnectionNumber(x_record_display_),
    227                                           true,
    228                                           base::MessageLoopForIO::WATCH_READ,
    229                                           &controller_,
    230                                           this);
    231     if (!result) {
    232       LOG(ERROR) << "Failed to create X record task.";
    233       StopMonitor(type);
    234       return;
    235     }
    236 
    237     // Start observing message loop destruction if we start monitoring the first
    238     // event.
    239     base::MessageLoop::current()->AddDestructionObserver(this);
    240   }
    241 
    242   // Fetch pending events if any.
    243   OnFileCanReadWithoutBlocking(ConnectionNumber(x_record_display_));
    244 }
    245 
    246 void UserInputMonitorLinuxCore::StopMonitor(EventType type) {
    247   DCHECK(io_task_runner_->BelongsToCurrentThread());
    248 
    249   if (x_record_range_[type]) {
    250     XFree(x_record_range_[type]);
    251     x_record_range_[type] = NULL;
    252   }
    253   if (x_record_range_[0] || x_record_range_[1])
    254     return;
    255 
    256   // Context must be disabled via the control channel because we can't send
    257   // any X protocol traffic over the data channel while it's recording.
    258   if (x_record_context_) {
    259     XRecordDisableContext(x_control_display_, x_record_context_);
    260     XFlush(x_control_display_);
    261     XRecordFreeContext(x_record_display_, x_record_context_);
    262     x_record_context_ = 0;
    263 
    264     controller_.StopWatchingFileDescriptor();
    265   }
    266   if (x_record_display_) {
    267     XCloseDisplay(x_record_display_);
    268     x_record_display_ = NULL;
    269   }
    270   if (x_control_display_) {
    271     XCloseDisplay(x_control_display_);
    272     x_control_display_ = NULL;
    273   }
    274   // Stop observing message loop destruction if no event is being monitored.
    275   base::MessageLoop::current()->RemoveDestructionObserver(this);
    276 }
    277 
    278 void UserInputMonitorLinuxCore::OnFileCanReadWithoutBlocking(int fd) {
    279   DCHECK(io_task_runner_->BelongsToCurrentThread());
    280   XEvent event;
    281   // Fetch pending events if any.
    282   while (XPending(x_record_display_)) {
    283     XNextEvent(x_record_display_, &event);
    284   }
    285 }
    286 
    287 void UserInputMonitorLinuxCore::OnFileCanWriteWithoutBlocking(int fd) {
    288   NOTREACHED();
    289 }
    290 
    291 void UserInputMonitorLinuxCore::ProcessXEvent(xEvent* event) {
    292   DCHECK(io_task_runner_->BelongsToCurrentThread());
    293   if (event->u.u.type == MotionNotify) {
    294     SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
    295                                      event->u.keyButtonPointer.rootY));
    296     mouse_listeners_->Notify(
    297         &UserInputMonitor::MouseEventListener::OnMouseMoved, position);
    298   } else {
    299     ui::EventType type;
    300     if (event->u.u.type == KeyPress) {
    301       type = ui::ET_KEY_PRESSED;
    302     } else if (event->u.u.type == KeyRelease) {
    303       type = ui::ET_KEY_RELEASED;
    304     } else {
    305       NOTREACHED();
    306       return;
    307     }
    308 
    309     KeySym key_sym =
    310         XkbKeycodeToKeysym(x_control_display_, event->u.u.detail, 0, 0);
    311     ui::KeyboardCode key_code = ui::KeyboardCodeFromXKeysym(key_sym);
    312     counter_.OnKeyboardEvent(type, key_code);
    313   }
    314 }
    315 
    316 // static
    317 void UserInputMonitorLinuxCore::ProcessReply(XPointer self,
    318                                              XRecordInterceptData* data) {
    319   if (data->category == XRecordFromServer) {
    320     xEvent* event = reinterpret_cast<xEvent*>(data->data);
    321     reinterpret_cast<UserInputMonitorLinuxCore*>(self)->ProcessXEvent(event);
    322   }
    323   XRecordFreeData(data);
    324 }
    325 
    326 //
    327 // Implementation of UserInputMonitorLinux.
    328 //
    329 
    330 UserInputMonitorLinux::UserInputMonitorLinux(
    331     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
    332     : io_task_runner_(io_task_runner),
    333       core_(new UserInputMonitorLinuxCore(io_task_runner, mouse_listeners())) {}
    334 
    335 UserInputMonitorLinux::~UserInputMonitorLinux() {
    336   if (!io_task_runner_->DeleteSoon(FROM_HERE, core_))
    337     delete core_;
    338 }
    339 
    340 size_t UserInputMonitorLinux::GetKeyPressCount() const {
    341   return core_->GetKeyPressCount();
    342 }
    343 
    344 void UserInputMonitorLinux::StartKeyboardMonitoring() {
    345   io_task_runner_->PostTask(
    346       FROM_HERE,
    347       base::Bind(&UserInputMonitorLinuxCore::StartMonitor,
    348                  core_->AsWeakPtr(),
    349                  UserInputMonitorLinuxCore::KEYBOARD_EVENT));
    350 }
    351 
    352 void UserInputMonitorLinux::StopKeyboardMonitoring() {
    353   io_task_runner_->PostTask(
    354       FROM_HERE,
    355       base::Bind(&UserInputMonitorLinuxCore::StopMonitor,
    356                  core_->AsWeakPtr(),
    357                  UserInputMonitorLinuxCore::KEYBOARD_EVENT));
    358 }
    359 
    360 void UserInputMonitorLinux::StartMouseMonitoring() {
    361   io_task_runner_->PostTask(FROM_HERE,
    362                             base::Bind(&UserInputMonitorLinuxCore::StartMonitor,
    363                                        core_->AsWeakPtr(),
    364                                        UserInputMonitorLinuxCore::MOUSE_EVENT));
    365 }
    366 
    367 void UserInputMonitorLinux::StopMouseMonitoring() {
    368   io_task_runner_->PostTask(FROM_HERE,
    369                             base::Bind(&UserInputMonitorLinuxCore::StopMonitor,
    370                                        core_->AsWeakPtr(),
    371                                        UserInputMonitorLinuxCore::MOUSE_EVENT));
    372 }
    373 
    374 }  // namespace
    375 
    376 scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
    377     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
    378     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
    379   return scoped_ptr<UserInputMonitor>(
    380       new UserInputMonitorLinux(io_task_runner));
    381 }
    382 
    383 }  // namespace media
    384