Use FileDescriptorWatcher in DeviceMonitorLinux

device/core/device_monitor_linux.cc

 // Copyright 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/core/device_monitor_linux.h"
 
 #include <memory>
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/udev_linux/udev.h"
 
 namespace device {
 
 namespace {
 
 const char kUdevName[] = "udev";
@@ skipping 26 matching lines @@
     LOG(ERROR) << "Failed to start udev monitoring.";
     return;
   }
 
   monitor_fd_ = udev_monitor_get_fd(monitor_.get());
   if (monitor_fd_ <= 0) {
     LOG(ERROR) << "Failed to start udev monitoring.";
     return;
   }
 
-  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          monitor_fd_, true /* persistent */,
-          base::MessageLoopForIO::WATCH_READ, &monitor_watcher_, this)) {
-    return;
-  }
+  monitor_watch_controller_ = base::FileDescriptorWatcher::WatchReadable(
+      monitor_fd_,
+      base::Bind(&DeviceMonitorLinux::OnMonitorCanReadWithoutBlocking,
+                 base::Unretained(this)));
 }
 
 // static
 DeviceMonitorLinux* DeviceMonitorLinux::GetInstance() {
   if (!g_device_monitor_linux_ptr.Get().get())
     g_device_monitor_linux_ptr.Get().reset(new DeviceMonitorLinux());
   return g_device_monitor_linux_ptr.Get().get();
 }
 
 void DeviceMonitorLinux::AddObserver(Observer* observer) {
@@ skipping 38 matching lines @@
       callback.Run(device.get());
   }
 }
 
 void DeviceMonitorLinux::WillDestroyCurrentMessageLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(Observer, observers_, WillDestroyMonitorMessageLoop());
   g_device_monitor_linux_ptr.Get().reset(nullptr);
 }
 
-void DeviceMonitorLinux::OnFileCanReadWithoutBlocking(int fd) {
+DeviceMonitorLinux::~DeviceMonitorLinux() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(monitor_fd_, fd);
+  base::MessageLoop::current()->RemoveDestructionObserver(this);
+  close(monitor_fd_);
+}
+
+void DeviceMonitorLinux::OnMonitorCanReadWithoutBlocking() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   ScopedUdevDevicePtr device(udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
   std::string action(udev_device_get_action(device.get()));
   if (action == kUdevActionAdd)
     FOR_EACH_OBSERVER(Observer, observers_, OnDeviceAdded(device.get()));
   else if (action == kUdevActionRemove)
     FOR_EACH_OBSERVER(Observer, observers_, OnDeviceRemoved(device.get()));
 }
 
-void DeviceMonitorLinux::OnFileCanWriteWithoutBlocking(int fd) {}
-
-DeviceMonitorLinux::~DeviceMonitorLinux() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
-  monitor_watcher_.StopWatchingFileDescriptor();
-  close(monitor_fd_);
-}
-
 }  // namespace device