Linux: Refactor udev device monitoring code into its own class so it can be reused more easily.

content/browser/gamepad/platform_data_fetcher_linux.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 "content/browser/gamepad/platform_data_fetcher_linux.h"
 
 #include <fcntl.h>
 #include <libudev.h>
 #include <linux/joystick.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/debug/trace_event.h"
 #include "base/eintr_wrapper.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "content/browser/udev_linux.h"
 
 namespace {
 
 const char kInputSubsystem[] = "input";
 const char kUsbSubsystem[] = "usb";
 const char kUsbDeviceType[] = "usb_device";
 const float kMaxLinuxAxisValue = 32767.0;
 
 void CloseFileDescriptorIfValid(int fd) {
   if (fd >= 0)
@@ skipping 32 matching lines @@
 namespace content {
 
 using WebKit::WebGamepad;
 using WebKit::WebGamepads;
 
 GamepadPlatformDataFetcherLinux::GamepadPlatformDataFetcherLinux() {
   for (size_t i = 0; i < arraysize(device_fds_); ++i)
     device_fds_[i] = -1;
   memset(mappers_, 0, sizeof(mappers_));
 
-  udev_ = udev_new();
-  CHECK(udev_);
-
-  monitor_ = udev_monitor_new_from_netlink(udev_, "udev");
-  CHECK(monitor_);
-  int ret = udev_monitor_filter_add_match_subsystem_devtype(monitor_,
-                                                            kInputSubsystem,
-                                                            NULL);
-  CHECK_EQ(0, ret);
-  ret = udev_monitor_enable_receiving(monitor_);
-  CHECK_EQ(0, ret);
-  monitor_fd_ = udev_monitor_get_fd(monitor_);
-  CHECK_GE(monitor_fd_, 0);
-  bool success = MessageLoopForIO::current()->WatchFileDescriptor(monitor_fd_,
-      true, MessageLoopForIO::WATCH_READ, &monitor_watcher_, this);
-  CHECK(success);
+  std::vector<UdevLinux::UdevMonitorFilter> filters;
+  filters.push_back(
+      content::UdevLinux::UdevMonitorFilter(kInputSubsystem, NULL));
+  udev_.reset(
+      new UdevLinux(filters,
+                    base::Bind(&GamepadPlatformDataFetcherLinux::RefreshDevice,
+                               base::Unretained(this))));
 
   EnumerateDevices();
 }
 
 GamepadPlatformDataFetcherLinux::~GamepadPlatformDataFetcherLinux() {
-  monitor_watcher_.StopWatchingFileDescriptor();
-  udev_monitor_unref(monitor_);
-  udev_unref(udev_);
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i)
     CloseFileDescriptorIfValid(device_fds_[i]);
 }
 
 void GamepadPlatformDataFetcherLinux::GetGamepadData(WebGamepads* pads, bool) {
   TRACE_EVENT0("GAMEPAD", "GetGamepadData");
 
   data_.length = WebGamepads::itemsLengthCap;
 
   // Update our internal state.
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
     if (device_fds_[i] >= 0) {
       ReadDeviceData(i);
     }
   }
 
   // Copy to the current state to the output buffer, using the mapping
   // function, if there is one available.
   pads->length = data_.length;
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
     if (mappers_[i])
       mappers_[i](data_.items[i], &pads->items[i]);
     else
       pads->items[i] = data_.items[i];
   }
 }
 
-void GamepadPlatformDataFetcherLinux::OnFileCanReadWithoutBlocking(int fd) {
-  // Events occur when devices attached to the system are added, removed, or
-  // change state. udev_monitor_receive_device() will return a device object
-  // representing the device which changed and what type of change occured.
-  DCHECK_EQ(monitor_fd_, fd);
-  udev_device* dev = udev_monitor_receive_device(monitor_);
-  if (!dev)
-    return;
-  RefreshDevice(dev);
-  udev_device_unref(dev);
-}
-
-void GamepadPlatformDataFetcherLinux::OnFileCanWriteWithoutBlocking(int fd) {
-}
-
 // Used during enumeration, and monitor notifications.
 void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
   int index;
   std::string node_path;
   if (IsGamepad(dev, &index, &node_path)) {
     int& device_fd = device_fds_[index];
     WebGamepad& pad = data_.items[index];
     GamepadStandardMappingFunction& mapper = mappers_[index];
 
     CloseFileDescriptorIfValid(device_fd);
@@ skipping 66 matching lines @@
     TruncateUTF8ToByteSize(id, WebGamepad::idLengthCap - 1, &id);
     string16 tmp16 = UTF8ToUTF16(id);
     memset(pad.id, 0, sizeof(pad.id));
     tmp16.copy(pad.id, arraysize(pad.id) - 1);
 
     pad.connected = true;
   }
 }
 
 void GamepadPlatformDataFetcherLinux::EnumerateDevices() {
-  udev_enumerate* enumerate = udev_enumerate_new(udev_);
+  udev_enumerate* enumerate = udev_enumerate_new(udev_->udev_handle());
   if (!enumerate)
     return;
   int ret = udev_enumerate_add_match_subsystem(enumerate, kInputSubsystem);
   if (ret != 0)
     return;
   ret = udev_enumerate_scan_devices(enumerate);
   if (ret != 0)
     return;
 
   udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate);
   for (udev_list_entry* dev_list_entry = devices;
        dev_list_entry != NULL;
        dev_list_entry = udev_list_entry_get_next(dev_list_entry)) {
     // Get the filename of the /sys entry for the device and create a
     // udev_device object (dev) representing it
     const char* path = udev_list_entry_get_name(dev_list_entry);
-    udev_device* dev = udev_device_new_from_syspath(udev_, path);
+    udev_device* dev = udev_device_new_from_syspath(udev_->udev_handle(), path);
     if (!dev)
       continue;
     RefreshDevice(dev);
     udev_device_unref(dev);
   }
   // Free the enumerator object
   udev_enumerate_unref(enumerate);
 }
 
 void GamepadPlatformDataFetcherLinux::ReadDeviceData(size_t index) {
@@ skipping 21 matching lines @@
         continue;
       pad.buttons[item] = event.value ? 1.0 : 0.0;
       if (item >= pad.buttonsLength)
         pad.buttonsLength = item + 1;
     }
     pad.timestamp = event.time;
   }
 }
 
 }  // namespace content