Linux: Dynamically load libudev.

content/browser/gamepad/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/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/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/udev_linux.h"
 #include "device/udev_linux/scoped_udev.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)
     close(fd);
 }
 
 bool IsGamepad(udev_device* dev, int* index, std::string* path) {
-  if (!udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK"))
+  if (!device::udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK"))
     return false;
 
-  const char* node_path = udev_device_get_devnode(dev);
+  const char* node_path = device::udev_device_get_devnode(dev);
   if (!node_path)
     return false;
 
   static const char kJoystickRoot[] = "/dev/input/js";
   bool is_gamepad = StartsWithASCII(node_path, kJoystickRoot, true);
   if (!is_gamepad)
     return false;
 
   int tmp_idx = -1;
   const int base_len = sizeof(kJoystickRoot) - 1;
@@ skipping 67 matching lines @@
     int& device_fd = device_fds_[index];
     WebGamepad& pad = data_.items[index];
     GamepadStandardMappingFunction& mapper = mappers_[index];
 
     CloseFileDescriptorIfValid(device_fd);
 
     // The device pointed to by dev contains information about the logical
     // joystick device. In order to get the information about the physical
     // hardware, get the parent device that is also in the "input" subsystem.
     // This function should just walk up the tree one level.
-    dev = udev_device_get_parent_with_subsystem_devtype(
+    dev = device::udev_device_get_parent_with_subsystem_devtype(
         dev, kInputSubsystem, NULL);
     if (!dev) {
       // Unable to get device information, don't use this device.
       device_fd = -1;
       pad.connected = false;
       return;
     }
 
     device_fd = HANDLE_EINTR(open(node_path.c_str(), O_RDONLY | O_NONBLOCK));
     if (device_fd < 0) {
       // Unable to open device, don't use.
       pad.connected = false;
       return;
     }
 
-    const char* vendor_id = udev_device_get_sysattr_value(dev, "id/vendor");
-    const char* product_id = udev_device_get_sysattr_value(dev, "id/product");
+    const char* vendor_id =
+        device::udev_device_get_sysattr_value(dev, "id/vendor");
+    const char* product_id =
+        device::udev_device_get_sysattr_value(dev, "id/product");
     mapper = GetGamepadStandardMappingFunction(vendor_id, product_id);
 
     // Driver returns utf-8 strings here, so combine in utf-8 first and
     // convert to WebUChar later once we've picked an id string.
-    const char* name = udev_device_get_sysattr_value(dev, "name");
+    const char* name = device::udev_device_get_sysattr_value(dev, "name");
     std::string name_string = base::StringPrintf("%s", name);
 
     // In many cases the information the input subsystem contains isn't
     // as good as the information that the device bus has, walk up further
     // to the subsystem/device type "usb"/"usb_device" and if this device
     // has the same vendor/product id, prefer the description from that.
-    struct udev_device* usb_dev = udev_device_get_parent_with_subsystem_devtype(
-        dev, kUsbSubsystem, kUsbDeviceType);
+    struct udev_device* usb_dev =
+        device::udev_device_get_parent_with_subsystem_devtype(
+            dev, kUsbSubsystem, kUsbDeviceType);
     if (usb_dev) {
       const char* usb_vendor_id =
-          udev_device_get_sysattr_value(usb_dev, "idVendor");
+          device::udev_device_get_sysattr_value(usb_dev, "idVendor");
       const char* usb_product_id =
-          udev_device_get_sysattr_value(usb_dev, "idProduct");
+          device::udev_device_get_sysattr_value(usb_dev, "idProduct");
 
       if (strcmp(vendor_id, usb_vendor_id) == 0 &&
           strcmp(product_id, usb_product_id) == 0) {
         const char* manufacturer =
-            udev_device_get_sysattr_value(usb_dev, "manufacturer");
-        const char* product = udev_device_get_sysattr_value(usb_dev, "product");
+            device::udev_device_get_sysattr_value(usb_dev, "manufacturer");
+        const char* product =
+            device::udev_device_get_sysattr_value(usb_dev, "product");
 
         // Replace the previous name string with one containing the better
         // information, again driver returns utf-8 strings here so combine
         // in utf-8 for conversion to WebUChar below.
         name_string = base::StringPrintf("%s %s", manufacturer, product);
       }
     }
 
     // Append the vendor and product information then convert the utf-8
     // id string to WebUChar.
@@ skipping 17 matching lines @@
     } else {
       pad.mapping[0] = 0;
     }
 
     pad.connected = true;
   }
 }
 
 void GamepadPlatformDataFetcherLinux::EnumerateDevices() {
   device::ScopedUdevEnumeratePtr enumerate(
-      udev_enumerate_new(udev_->udev_handle()));
+      device::udev_enumerate_new(udev_->udev_handle()));
   if (!enumerate)
     return;
-  int ret =
-      udev_enumerate_add_match_subsystem(enumerate.get(), kInputSubsystem);
+  int ret = device::udev_enumerate_add_match_subsystem(enumerate.get(),
+                                                       kInputSubsystem);
   if (ret != 0)
     return;
-  ret = udev_enumerate_scan_devices(enumerate.get());
+  ret = device::udev_enumerate_scan_devices(enumerate.get());
   if (ret != 0)
     return;
 
-  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
+  udev_list_entry* devices =
+      device::udev_enumerate_get_list_entry(enumerate.get());
   for (udev_list_entry* dev_list_entry = devices; dev_list_entry != NULL;
-       dev_list_entry = udev_list_entry_get_next(dev_list_entry)) {
+       dev_list_entry = device::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);
+    const char* path = device::udev_list_entry_get_name(dev_list_entry);
     device::ScopedUdevDevicePtr dev(
-        udev_device_new_from_syspath(udev_->udev_handle(), path));
+        device::udev_device_new_from_syspath(udev_->udev_handle(), path));
     if (!dev)
       continue;
     RefreshDevice(dev.get());
   }
 }
 
 void GamepadPlatformDataFetcherLinux::ReadDeviceData(size_t index) {
   // Linker does not like CHECK_LT(index, WebGamepads::itemsLengthCap). =/
   if (index >= WebGamepads::itemsLengthCap) {
     CHECK(false);
@@ skipping 19 matching lines @@
       pad.buttons[item].pressed = event.value;
       pad.buttons[item].value = event.value ? 1.0 : 0.0;
       if (item >= pad.buttonsLength)
         pad.buttonsLength = item + 1;
     }
     pad.timestamp = event.time;
   }
 }
 
 }  // namespace content