Use FileDescriptorWatcher in UserInputMonitorLinuxCore.

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 <stddef.h>
 #include <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/files/file_descriptor_watcher_posix.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_pump_libevent.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/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/gfx/x/x11_types.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 {
 
 // This is the actual implementation of event monitoring. It's separated from
 // UserInputMonitorLinux since it needs to be deleted on the IO thread.
 class UserInputMonitorLinuxCore
-    : public base::MessagePumpLibevent::Watcher,
-      public base::SupportsWeakPtr<UserInputMonitorLinuxCore>,
+    : public base::SupportsWeakPtr<UserInputMonitorLinuxCore>,
       public base::MessageLoop::DestructionObserver {
  public:
   enum EventType {
     MOUSE_EVENT,
     KEYBOARD_EVENT
   };
 
   explicit UserInputMonitorLinuxCore(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
       const scoped_refptr<UserInputMonitor::MouseListenerList>&
           mouse_listeners);
   ~UserInputMonitorLinuxCore() override;
 
   // DestructionObserver overrides.
   void WillDestroyCurrentMessageLoop() override;
 
   size_t GetKeyPressCount() const;
   void StartMonitor(EventType type);
   void StopMonitor(EventType type);
 
  private:
-  // base::MessagePumpLibevent::Watcher interface.
-  void OnFileCanReadWithoutBlocking(int fd) override;
-  void OnFileCanWriteWithoutBlocking(int fd) override;
+  void OnXEvent();
 
   // Processes key and mouse events.
   void ProcessXEvent(xEvent* event);
   static void ProcessReply(XPointer self, XRecordInterceptData* data);
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::ObserverListThreadSafe<
       UserInputMonitor::MouseEventListener>> mouse_listeners_;
 
   //
   // The following members should only be accessed on the IO thread.
   //
-  base::MessagePumpLibevent::FileDescriptorWatcher controller_;
+  std::unique_ptr<base::FileDescriptorWatcher::Controller> watch_controller_;
   Display* x_control_display_;
   Display* x_record_display_;
   XRecordRange* x_record_range_[2];
   XRecordContext x_record_context_;
   KeyboardEventCounter counter_;
 
   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinuxCore);
 };
 
 class UserInputMonitorLinux : public UserInputMonitor {
@@ skipping 124 matching lines @@
   if (!XRecordEnableContextAsync(x_record_display_,
                                  x_record_context_,
                                  &UserInputMonitorLinuxCore::ProcessReply,
                                  reinterpret_cast<XPointer>(this))) {
     LOG(ERROR) << "XRecordEnableContextAsync failed.";
     StopMonitor(type);
     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.";
-      StopMonitor(type);
-      return;
-    }
+    // Register OnXEvent() to be called every time there is something to read
+    // from |x_record_display_|.
+    watch_controller_ = base::FileDescriptorWatcher::WatchReadable(
+        ConnectionNumber(x_record_display_),
+        base::Bind(&UserInputMonitorLinuxCore::OnXEvent,
+                   base::Unretained(this)));
 
     // Start observing message loop destruction if we start monitoring the first
     // event.
     base::MessageLoop::current()->AddDestructionObserver(this);
   }
 
   // Fetch pending events if any.
-  OnFileCanReadWithoutBlocking(ConnectionNumber(x_record_display_));
+  OnXEvent();
 }
 
 void UserInputMonitorLinuxCore::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(x_control_display_, x_record_context_);
     XFlush(x_control_display_);
     XRecordFreeContext(x_record_display_, x_record_context_);
     x_record_context_ = 0;
 
-    controller_.StopWatchingFileDescriptor();
+    watch_controller_.reset();
   }
   if (x_record_display_) {
     XCloseDisplay(x_record_display_);
     x_record_display_ = NULL;
   }
   if (x_control_display_) {
     XCloseDisplay(x_control_display_);
     x_control_display_ = NULL;
   }
   // Stop observing message loop destruction if no event is being monitored.
   base::MessageLoop::current()->RemoveDestructionObserver(this);
 }
 
-void UserInputMonitorLinuxCore::OnFileCanReadWithoutBlocking(int fd) {
+void UserInputMonitorLinuxCore::OnXEvent() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   XEvent event;
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XNextEvent(x_record_display_, &event);
   }
 }
 
-void UserInputMonitorLinuxCore::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-
 void UserInputMonitorLinuxCore::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));
     mouse_listeners_->Notify(
         FROM_HERE, &UserInputMonitor::MouseEventListener::OnMouseMoved,
         position);
   } else {
     ui::EventType type;
@@ skipping 73 matching lines @@
 
 }  // namespace
 
 std::unique_ptr<UserInputMonitor> UserInputMonitor::Create(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
   return base::WrapUnique(new UserInputMonitorLinux(io_task_runner));
 }
 
 }  // namespace media