Use FileDescriptorWatcher in LocalInputMonitorX11.

remoting/host/local_input_monitor_x11.cc

 // Copyright (c) 2012 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 "remoting/host/local_input_monitor.h"
 
 #include <sys/select.h>
 #include <unistd.h>
 
 #include "base/memory/ptr_util.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/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_libevent.h"

[joedow, 2016/10/11 16:56:12]

message_pump_libevent.h can be removed now

[fdoray, 2016/10/11 17:07:31]

Done.

 #include "base/single_thread_task_runner.h"
 #include "base/threading/non_thread_safe.h"
 #include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.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 remoting {
 
 namespace {
 
 class LocalInputMonitorX11 : public base::NonThreadSafe,
                                public LocalInputMonitor {
  public:
   LocalInputMonitorX11(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control);
   ~LocalInputMonitorX11() override;
 
  private:
   // The actual implementation resides in LocalInputMonitorX11::Core class.
-  class Core
-      : public base::RefCountedThreadSafe<Core>,
-        public base::MessagePumpLibevent::Watcher {
+  class Core : public base::RefCountedThreadSafe<Core> {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
          base::WeakPtr<ClientSessionControl> client_session_control);
 
     void Start();
     void Stop();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
-    ~Core() override;
+    ~Core();
 
     void StartOnInputThread();
     void StopOnInputThread();
 
-    // base::MessagePumpLibevent::Watcher interface.
-    void OnFileCanReadWithoutBlocking(int fd) override;
-    void OnFileCanWriteWithoutBlocking(int fd) override;
+    // Called when there are pending X events.
+    void OnPendingXEvents();
 
     // Processes key and mouse events.
     void ProcessXEvent(xEvent* event);
 
     static void ProcessReply(XPointer self, XRecordInterceptData* data);
 
     // Task runner on which public methods of this class must be called.
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
     // Task runner on which X Window events are received.
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
     // Points to the object receiving mouse event notifications and session
     // disconnect requests.
     base::WeakPtr<ClientSessionControl> client_session_control_;
 
-    // Used to receive base::MessagePumpLibevent::Watcher events.
-    base::MessagePumpLibevent::FileDescriptorWatcher controller_;
+    // Controls watching X events.
+    std::unique_ptr<base::FileDescriptorWatcher::Controller> controller_;
 
     // True when Alt is pressed.
     bool alt_pressed_;
 
     // True when Ctrl is pressed.
     bool ctrl_pressed_;
 
     Display* display_;
     Display* x_record_display_;
     XRecordRange* x_record_range_[2];
@@ skipping 108 matching lines @@
     return;
   }
 
   if (!XRecordEnableContextAsync(x_record_display_, x_record_context_,
                                  &Core::ProcessReply,
                                  reinterpret_cast<XPointer>(this))) {
     LOG(ERROR) << "XRecordEnableContextAsync failed.";
     return;
   }
 
-  // Register OnFileCanReadWithoutBlocking() to be called every time there is
+  // Register OnPendingXEvents() 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;
-  }
+  controller_ = base::FileDescriptorWatcher::WatchReadable(
+      ConnectionNumber(x_record_display_),
+      base::Bind(&Core::OnPendingXEvents, base::Unretained(this)));
 
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
   }
 }
 
 void LocalInputMonitorX11::Core::StopOnInputThread() {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   // 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_);
   }
 
-  controller_.StopWatchingFileDescriptor();
+  controller_.reset();
 
   if (x_record_range_[0]) {
     XFree(x_record_range_[0]);
     x_record_range_[0] = nullptr;
   }
   if (x_record_range_[1]) {
     XFree(x_record_range_[1]);
     x_record_range_[1] = nullptr;
   }
   if (x_record_context_) {
     XRecordFreeContext(x_record_display_, x_record_context_);
     x_record_context_ = 0;
   }
   if (x_record_display_) {
     XCloseDisplay(x_record_display_);
     x_record_display_ = nullptr;
   }
   if (display_) {
     XCloseDisplay(display_);
     display_ = nullptr;
   }
 }
 
-void LocalInputMonitorX11::Core::OnFileCanReadWithoutBlocking(int fd) {
+void LocalInputMonitorX11::Core::OnPendingXEvents() {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
   }
 }
 
-void LocalInputMonitorX11::Core::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-
 void LocalInputMonitorX11::Core::ProcessXEvent(xEvent* event) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   if (event->u.u.type == MotionNotify) {
     webrtc::DesktopVector position(event->u.keyButtonPointer.rootX,
                                    event->u.keyButtonPointer.rootY);
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
                               client_session_control_,
                               position));
@@ skipping 28 matching lines @@
 std::unique_ptr<LocalInputMonitor> LocalInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
   return base::WrapUnique(new LocalInputMonitorX11(
       caller_task_runner, input_task_runner, client_session_control));
 }
 
 }  // namespace remoting