Use FileDescriptorWatcher in HidConnectionLinux::FileThreadHelper.

device/hid/hid_connection_linux.cc

 // Copyright (c) 2014 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 "device/hid/hid_connection_linux.h"
 
 #include <errno.h>
 #include <linux/hidraw.h>
 #include <sys/ioctl.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/files/file_descriptor_watcher_posix.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_pump_libevent.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/hid/hid_service.h"
 
 // These are already defined in newer versions of linux/hidraw.h.
 #ifndef HIDIOCSFEATURE
 #define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x06, len)
 #endif
 #ifndef HIDIOCGFEATURE
 #define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
 #endif
 
 namespace device {
 
 class HidConnectionLinux::FileThreadHelper
-    : public base::MessagePumpLibevent::Watcher,
-      public base::MessageLoop::DestructionObserver {
+    : public base::MessageLoop::DestructionObserver {
  public:
   FileThreadHelper(base::PlatformFile platform_file,
                    scoped_refptr<HidDeviceInfo> device_info,
                    base::WeakPtr<HidConnectionLinux> connection,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : platform_file_(platform_file),
         connection_(connection),
         task_runner_(task_runner) {
     // Report buffers must always have room for the report ID.
     report_buffer_size_ = device_info->max_input_report_size() + 1;
     has_report_id_ = device_info->has_report_id();
   }
 
   ~FileThreadHelper() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::MessageLoop::current()->RemoveDestructionObserver(this);
   }
 
   // Starts the FileDescriptorWatcher that reads input events from the device.
   // Must be called on a thread that has a base::MessageLoopForIO.
   static void Start(std::unique_ptr<FileThreadHelper> self) {
     base::ThreadRestrictions::AssertIOAllowed();
     self->thread_checker_.DetachFromThread();
 
-    if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-            self->platform_file_, true, base::MessageLoopForIO::WATCH_READ,
-            &self->file_watcher_, self.get())) {
-      HID_LOG(ERROR) << "Failed to start watching device file.";
-    }
+    self->file_watcher_ = base::FileDescriptorWatcher::WatchReadable(
+        self->platform_file_,
+        base::Bind(&FileThreadHelper::OnFileCanReadWithoutBlocking,
+                   base::Unretained(self.get())));
 
     // |self| is now owned by the current message loop.
     base::MessageLoop::current()->AddDestructionObserver(self.release());
   }
 
  private:
-  // base::MessagePumpLibevent::Watcher implementation.
-  void OnFileCanReadWithoutBlocking(int fd) override {
+  void OnFileCanReadWithoutBlocking() {
     DCHECK(thread_checker_.CalledOnValidThread());
-    DCHECK_EQ(fd, platform_file_);
 
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(report_buffer_size_));
     char* data = buffer->data();
     size_t length = report_buffer_size_;
     if (!has_report_id_) {
       // Linux will not prefix the buffer with a report ID if report IDs are not
       // used by the device. Prefix the buffer with 0.
       *data++ = 0;
       length--;
     }
 
     ssize_t bytes_read = HANDLE_EINTR(read(platform_file_, data, length));
     if (bytes_read < 0) {
       if (errno != EAGAIN) {
         HID_PLOG(EVENT) << "Read failed";
         // This assumes that the error is unrecoverable and disables reading
         // from the device until it has been re-opened.
         // TODO(reillyg): Investigate starting and stopping the file descriptor
         // watcher in response to pending read requests so that per-request
         // errors can be returned to the client.
-        file_watcher_.StopWatchingFileDescriptor();
+        file_watcher_.reset();
       }
       return;
     }
     if (!has_report_id_) {
       // Behave as if the byte prefixed above as the the report ID was read.
       bytes_read++;
     }
 
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&HidConnectionLinux::ProcessInputReport,
                                       connection_, buffer, bytes_read));
   }
 
-  void OnFileCanWriteWithoutBlocking(int fd) override {
-    NOTREACHED();  // Only listening for reads.
-  }
-
   // base::MessageLoop::DestructionObserver:
   void WillDestroyCurrentMessageLoop() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     delete this;
   }
 
   base::ThreadChecker thread_checker_;
   base::PlatformFile platform_file_;
   size_t report_buffer_size_;
   bool has_report_id_;
   base::WeakPtr<HidConnectionLinux> connection_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  base::MessagePumpLibevent::FileDescriptorWatcher file_watcher_;
+  std::unique_ptr<base::FileDescriptorWatcher::Controller> file_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(FileThreadHelper);
 };
 
 HidConnectionLinux::HidConnectionLinux(
     scoped_refptr<HidDeviceInfo> device_info,
     base::File device_file,
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : HidConnection(device_info),
       file_task_runner_(file_task_runner),
@@ skipping 180 matching lines @@
     PendingHidReport report = pending_reports_.front();
 
     pending_reports_.pop();
     if (CompleteRead(report.buffer, report.size, read.callback)) {
       pending_reads_.pop();
     }
   }
 }
 
 }  // namespace device