Linux: Dynamically load libudev.

Funnel all libudev access through a wrapper for the udev library loader.

BUG=415212

Review URL: https://codereview.chromium.org/674703002

Cr-Commit-Position: refs/heads/master@{#305348}

53 files changed, 1388 insertions, 261 deletions

diff --git a/build/config/linux/BUILD.gn b/build/config/linux/BUILD.gn
index 758f42a..dec1017 100644
--- a/build/config/linux/BUILD.gn
+++ b/build/config/linux/BUILD.gn
@@ -8,6 +8,12 @@ import("//build/config/sysroot.gni")
 import("//build/config/ui.gni")
 import("//tools/generate_library_loader/generate_library_loader.gni")
 
+gypi_values = exec_script(
+    "//build/gypi_to_gn.py",
+    [ rebase_path("../../linux/system.gyp") ],
+    "scope",
+    [ "../../linux/system.gyp" ])
+
 config("sdk") {
   if (sysroot != "") {
     cflags = [ "--sysroot=" + sysroot ]
@@ -47,10 +53,6 @@ pkg_config("pangoft2") {
   packages = [ "pangoft2" ]
 }
 
-pkg_config("udev") {
-  packages = [ "libudev" ]
-}
-
 # Note: if your target also depends on //dbus, you don't need to add this
 # config (it will get added automatically if you depend on //dbus).
 pkg_config("dbus") {
@@ -140,19 +142,7 @@ if (use_brlapi) {
     header = "<brlapi.h>"
     config = ":brlapi_config"
 
-    functions = [
-      "brlapi_getHandleSize",
-      "brlapi_error_location",
-      "brlapi_strerror",
-      "brlapi__acceptKeys",
-      "brlapi__openConnection",
-      "brlapi__closeConnection",
-      "brlapi__getDisplaySize",
-      "brlapi__enterTtyModeWithPath",
-      "brlapi__leaveTtyMode",
-      "brlapi__writeDots",
-      "brlapi__readKey",
-    ]
+    functions = gypi_values.libbrlapi_functions
   }
 }
 
@@ -166,7 +156,7 @@ pkg_config("gio_config") {
   # (saucy) and earlier. Update the code to use
   # g_settings_schema_source_list_schemas instead.
   defines = [ "USE_GIO", "GLIB_DISABLE_DEPRECATION_WARNINGS" ]
- 
+
   # TODO(brettw) Theoretically I think ignore_libs should be set so that we
   # don't link directly to GIO and use the loader generated below. But the gio
   # target in GYP doesn't make any sense to me and appears to link directly to
@@ -183,15 +173,7 @@ generate_library_loader("gio") {
   header = "<gio/gio.h>"
   config = ":gio_config"
 
-  functions = [
-    "g_settings_new",
-    "g_settings_get_child",
-    "g_settings_get_string",
-    "g_settings_get_boolean",
-    "g_settings_get_int",
-    "g_settings_get_strv",
-    "g_settings_list_schemas",
-  ]
+  functions = gypi_values.libgio_functions
 }
 
 # This generates a target named "libpci".
@@ -201,14 +183,34 @@ generate_library_loader("libpci") {
   output_cc = "libpci_loader.cc"
   header = "<pci/pci.h>"
 
-  functions = [
-    "pci_alloc",
-    "pci_init",
-    "pci_cleanup",
-    "pci_scan_bus",
-    "pci_fill_info",
-    "pci_lookup_name",
-  ]
+  functions = gypi_values.libpci_functions
 }
 
 # Looking for libspeechd? Use //third_party/speech-dispatcher
+
+# This generates a target named "udev0_loader".
+generate_library_loader("udev0_loader") {
+  name = "LibUdev0Loader"
+  output_h = "libudev0.h"
+  output_cc = "libudev0_loader.cc"
+  header = "\"third_party/libudev/libudev0.h\""
+
+  functions = gypi_values.libudev_functions
+}
+
+# This generates a target named "udev1_loader".
+generate_library_loader("udev1_loader") {
+  name = "LibUdev1Loader"
+  output_h = "libudev1.h"
+  output_cc = "libudev1_loader.cc"
+  header = "\"third_party/libudev/libudev1.h\""
+
+  functions = gypi_values.libudev_functions
+}
+
+group("udev") {
+  deps = [
+    ":udev0_loader",
+    ":udev1_loader",
+  ]
+}
diff --git a/build/linux/system.gyp b/build/linux/system.gyp
index 3e88093..cd0288b 100644
--- a/build/linux/system.gyp
+++ b/build/linux/system.gyp
@@ -20,6 +20,69 @@
     'linux_link_libpci%': 0,
     'linux_link_libspeechd%': 0,
     'linux_link_libbrlapi%': 0,
+
+    # Used below for the various libraries. In this scope for sharing with GN.
+    'libbrlapi_functions': [
+      'brlapi_getHandleSize',
+      'brlapi_error_location',
+      'brlapi_strerror',
+      'brlapi__acceptKeys',
+      'brlapi__openConnection',
+      'brlapi__closeConnection',
+      'brlapi__getDisplaySize',
+      'brlapi__enterTtyModeWithPath',
+      'brlapi__leaveTtyMode',
+      'brlapi__writeDots',
+      'brlapi__readKey',
+    ],
+    'libgio_functions': [
+      'g_settings_new',
+      'g_settings_get_child',
+      'g_settings_get_string',
+      'g_settings_get_boolean',
+      'g_settings_get_int',
+      'g_settings_get_strv',
+      'g_settings_list_schemas',
+    ],
+    'libpci_functions': [
+      'pci_alloc',
+      'pci_init',
+      'pci_cleanup',
+      'pci_scan_bus',
+      'pci_fill_info',
+      'pci_lookup_name',
+    ],
+    'libudev_functions': [
+      'udev_device_get_action',
+      'udev_device_get_devnode',
+      'udev_device_get_parent',
+      'udev_device_get_parent_with_subsystem_devtype',
+      'udev_device_get_property_value',
+      'udev_device_get_subsystem',
+      'udev_device_get_sysattr_value',
+      'udev_device_get_sysname',
+      'udev_device_get_syspath',
+      'udev_device_new_from_devnum',
+      'udev_device_new_from_syspath',
+      'udev_device_unref',
+      'udev_enumerate_add_match_subsystem',
+      'udev_enumerate_get_list_entry',
+      'udev_enumerate_new',
+      'udev_enumerate_scan_devices',
+      'udev_enumerate_unref',
+      'udev_list_entry_get_next',
+      'udev_list_entry_get_name',
+      'udev_monitor_enable_receiving',
+      'udev_monitor_filter_add_match_subsystem_devtype',
+      'udev_monitor_get_fd',
+      'udev_monitor_new_from_netlink',
+      'udev_monitor_receive_device',
+      'udev_monitor_unref',
+      'udev_new',
+      'udev_set_log_fn',
+      'udev_set_log_priority',
+      'udev_unref',
+    ],
   },
   'conditions': [
     [ 'chromeos==0 and use_ozone==0', {
@@ -445,22 +508,67 @@
       'targets': [
         {
           'target_name': 'udev',
-          'type': 'none',
+          'type': 'static_library',
           'conditions': [
             ['_toolset=="target"', {
-              'direct_dependent_settings': {
-                'cflags': [
-                  '<!@(<(pkg-config) --cflags libudev)'
-                ],
-              },
-              'link_settings': {
-                'ldflags': [
-                  '<!@(<(pkg-config) --libs-only-L --libs-only-other libudev)',
-                ],
-                'libraries': [
-                  '<!@(<(pkg-config) --libs-only-l libudev)',
-                ],
-              },
+              'include_dirs': [
+                '../..',
+              ],
+              'hard_dependency': 1,
+              'actions': [
+                {
+                  'variables': {
+                    'output_h': '<(SHARED_INTERMEDIATE_DIR)/library_loaders/libudev0.h',
+                    'output_cc': '<(INTERMEDIATE_DIR)/libudev0_loader.cc',
+                    'generator': '../../tools/generate_library_loader/generate_library_loader.py',
+                  },
+                  'action_name': 'generate_libudev0_loader',
+                  'inputs': [
+                    '<(generator)',
+                  ],
+                  'outputs': [
+                    '<(output_h)',
+                    '<(output_cc)',
+                  ],
+                  'action': ['python',
+                             '<(generator)',
+                             '--name', 'LibUdev0Loader',
+                             '--output-h', '<(output_h)',
+                             '--output-cc', '<(output_cc)',
+                             '--header', '"third_party/libudev/libudev0.h"',
+                             '--link-directly=0',
+                             '<@(libudev_functions)',
+                  ],
+                  'message': 'Generating libudev0 library loader',
+                  'process_outputs_as_sources': 1,
+                },
+                {
+                  'variables': {
+                    'output_h': '<(SHARED_INTERMEDIATE_DIR)/library_loaders/libudev1.h',
+                    'output_cc': '<(INTERMEDIATE_DIR)/libudev1_loader.cc',
+                    'generator': '../../tools/generate_library_loader/generate_library_loader.py',
+                  },
+                  'action_name': 'generate_libudev1_loader',
+                  'inputs': [
+                    '<(generator)',
+                  ],
+                  'outputs': [
+                    '<(output_h)',
+                    '<(output_cc)',
+                  ],
+                  'action': ['python',
+                             '<(generator)',
+                             '--name', 'LibUdev1Loader',
+                             '--output-h', '<(output_h)',
+                             '--output-cc', '<(output_cc)',
+                             '--header', '"third_party/libudev/libudev1.h"',
+                             '--link-directly=0',
+                             '<@(libudev_functions)',
+                  ],
+                  'message': 'Generating libudev1 library loader',
+                  'process_outputs_as_sources': 1,
+                },
+              ],
             }],
           ],
         },
@@ -520,12 +628,7 @@
                          # and get it fixed so that we don't need --use-extern-c.
                          '--use-extern-c',
                          '--link-directly=<(linux_link_libpci)',
-                         'pci_alloc',
-                         'pci_init',
-                         'pci_cleanup',
-                         'pci_scan_bus',
-                         'pci_fill_info',
-                         'pci_lookup_name',
+                         '<@(libpci_functions)',
               ],
               'message': 'Generating libpci library loader',
               'process_outputs_as_sources': 1,
@@ -706,13 +809,7 @@
                          '--output-cc', '<(output_cc)',
                          '--header', '<gio/gio.h>',
                          '--link-directly=<(linux_link_gsettings)',
-                         'g_settings_new',
-                         'g_settings_get_child',
-                         'g_settings_get_string',
-                         'g_settings_get_boolean',
-                         'g_settings_get_int',
-                         'g_settings_get_strv',
-                         'g_settings_list_schemas',
+                         '<@(libgio_functions)',
               ],
               'message': 'Generating libgio library loader',
               'process_outputs_as_sources': 1,
@@ -882,17 +979,7 @@
                      '--output-cc', '<(output_cc)',
                      '--header', '<brlapi.h>',
                      '--link-directly=<(linux_link_libbrlapi)',
-                     'brlapi_getHandleSize',
-                     'brlapi_error_location',
-                     'brlapi_strerror',
-                     'brlapi__acceptKeys',
-                     'brlapi__openConnection',
-                     'brlapi__closeConnection',
-                     'brlapi__getDisplaySize',
-                     'brlapi__enterTtyModeWithPath',
-                     'brlapi__leaveTtyMode',
-                     'brlapi__writeDots',
-                     'brlapi__readKey',
+                     '<@(libbrlapi_functions)',
           ],
           'message': 'Generating libbrlapi library loader',
           'process_outputs_as_sources': 1,
diff --git a/chrome/browser/BUILD.gn b/chrome/browser/BUILD.gn
index 2f028d8..dafc5af 100644
--- a/chrome/browser/BUILD.gn
+++ b/chrome/browser/BUILD.gn
@@ -387,8 +387,10 @@ static_library("browser") {
   }
 
   if (is_linux) {
-    configs += [ "//build/config/linux:udev" ]
-    deps += [ "//device/media_transfer_protocol" ]
+    deps += [
+      "//device/media_transfer_protocol",
+      "//device/udev_linux"
+    ]
   }
   if (is_linux && !is_chromeos) {
     deps += [ "//third_party/speech-dispatcher" ]
diff --git a/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_linux.cc b/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_linux.cc
index cd218b8..4bd7680 100644
--- a/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_linux.cc
+++ b/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_linux.cc
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <libudev.h>
-
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/image_writer_private/removable_storage_provider.h"
@@ -44,34 +42,36 @@ static int get_device_blk_size(const std::string& path) {
 
 bool RemovableStorageProvider::PopulateDeviceList(
     scoped_refptr<StorageDeviceList> device_list) {
-  device::ScopedUdevPtr udev(udev_new());
+  device::ScopedUdevPtr udev(device::udev_new());
   if (!udev) {
     DLOG(ERROR) << "Can't create udev";
     return false;
   }
 
   /* Create a list of the devices in the 'block' subsystem. */
-  device::ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev.get()));
+  device::ScopedUdevEnumeratePtr enumerate(
+      device::udev_enumerate_new(udev.get()));
 
-  udev_enumerate_add_match_subsystem(enumerate.get(), "block");
-  udev_enumerate_scan_devices(enumerate.get());
-  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
+  device::udev_enumerate_add_match_subsystem(enumerate.get(), "block");
+  device::udev_enumerate_scan_devices(enumerate.get());
+  udev_list_entry* devices =
+      device::udev_enumerate_get_list_entry(enumerate.get());
 
   udev_list_entry* dev_list_entry;
   udev_list_entry_foreach(dev_list_entry, devices) {
-    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 cur_device(
-        udev_device_new_from_syspath(udev.get(), path));
+        device::udev_device_new_from_syspath(udev.get(), path));
 
     const char* partition =
-        udev_device_get_sysattr_value(cur_device.get(), "partition");
+        device::udev_device_get_sysattr_value(cur_device.get(), "partition");
     if (partition && get_int_attr(partition)) {
       // This is a partition of a device, not the device itself
       continue;
     }
 
     const char* removable =
-        udev_device_get_sysattr_value(cur_device.get(), "removable");
+        device::udev_device_get_sysattr_value(cur_device.get(), "removable");
     if (!removable || !get_int_attr(removable)) {
       // This is not a removable storage device.
       continue;
@@ -80,8 +80,9 @@ bool RemovableStorageProvider::PopulateDeviceList(
     /* Get the parent SCSI device that contains the model
        and manufacturer.  You can look at the hierarchy with
        udevadm info -a -n /dev/<device> */
-    udev_device* parent_device = udev_device_get_parent_with_subsystem_devtype(
-        cur_device.get(), "scsi", NULL);
+    udev_device* parent_device =
+        device::udev_device_get_parent_with_subsystem_devtype(
+            cur_device.get(), "scsi", NULL);
     if (!parent_device) {
       // this is not a usb device
       continue;
@@ -90,13 +91,15 @@ bool RemovableStorageProvider::PopulateDeviceList(
     linked_ptr<api::image_writer_private::RemovableStorageDevice> device_item(
         new api::image_writer_private::RemovableStorageDevice());
     device_item->vendor =
-        udev_device_get_sysattr_value(parent_device, "vendor");
-    device_item->model = udev_device_get_sysattr_value(parent_device, "model");
+        device::udev_device_get_sysattr_value(parent_device, "vendor");
+    device_item->model =
+        device::udev_device_get_sysattr_value(parent_device, "model");
     // TODO (smaskell): Don't expose raw device path
-    device_item->storage_unit_id = udev_device_get_devnode(cur_device.get());
-    device_item->capacity =
-        get_int_attr(udev_device_get_sysattr_value(cur_device.get(), "size")) *
-        get_device_blk_size(device_item->storage_unit_id);
+    device_item->storage_unit_id =
+        device::udev_device_get_devnode(cur_device.get());
+    device_item->capacity = get_int_attr(device::udev_device_get_sysattr_value(
+                                cur_device.get(), "size")) *
+                            get_device_blk_size(device_item->storage_unit_id);
     device_item->removable = removable;
 
     device_list->data.push_back(device_item);
diff --git a/chrome/browser/ui/BUILD.gn b/chrome/browser/ui/BUILD.gn
index 6c4ebce..ed18746 100644
--- a/chrome/browser/ui/BUILD.gn
+++ b/chrome/browser/ui/BUILD.gn
@@ -367,7 +367,7 @@ static_library("ui") {
   if (is_linux) {  # Both desktop Linux and ChromeOS.
     sources += rebase_path(gypi_values.chrome_browser_ui_linux_sources,
                            ".", "//chrome")
-    configs += [ "//build/config/linux:udev" ]
+    deps += [ "//device/udev_linux" ]
     if (use_aura) {
       configs += [ "//build/config/linux:fontconfig" ]
       deps += [ "//dbus" ]
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 4e97a64..26fc961 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -3189,7 +3189,7 @@
         }],
         ['use_udev == 1', {
           'dependencies': [
-            '../build/linux/system.gyp:udev',
+            '../device/udev_linux/udev.gyp:udev_linux',
           ],
         }],
         ['OS=="linux"', {
diff --git a/chrome/chrome_browser_ui.gypi b/chrome/chrome_browser_ui.gypi
index 5fe1e92..2da046a 100644
--- a/chrome/chrome_browser_ui.gypi
+++ b/chrome/chrome_browser_ui.gypi
@@ -3003,7 +3003,7 @@
             }],
             ['use_udev==1', {
               'dependencies': [
-                '../build/linux/system.gyp:udev',
+                '../device/udev_linux/udev.gyp:udev_linux',
               ],
             }],
           ],
diff --git a/chrome/installer/linux/common/symlinks.include b/chrome/installer/linux/common/symlinks.include
index 7bad92e..700215c 100644
--- a/chrome/installer/linux/common/symlinks.include
+++ b/chrome/installer/linux/common/symlinks.include
@@ -24,28 +24,6 @@ remove_nss_symlinks() {
   done
 }
 
-# Fedora 18 now has libudev.so.1. http://crbug.com/145160
-# Same for Ubuntu 13.04. http://crbug.com/226002
-LIBUDEV_0=libudev.so.0
-LIBUDEV_1=libudev.so.1
-
-add_udev_symlinks() {
-  get_lib_dir
-  if [ -f "/$LIBDIR/$LIBUDEV_0" -o -f "/usr/$LIBDIR/$LIBUDEV_0" -o -f "/lib/$LIBUDEV_0" ]; then
-    return 0
-  fi
-
-  if [ -f "/$LIBDIR/$LIBUDEV_1" ]; then
-    ln -snf "/$LIBDIR/$LIBUDEV_1" "@@INSTALLDIR@@/$LIBUDEV_0"
-  elif [ -f "/usr/$LIBDIR/$LIBUDEV_1" ];
-  then
-    ln -snf "/usr/$LIBDIR/$LIBUDEV_1" "@@INSTALLDIR@@/$LIBUDEV_0"
-  else
-    echo "$LIBUDEV_1" not found in "$LIBDIR" or "/usr/$LIBDIR".
-    exit 1
-  fi
-}
-
 remove_udev_symlinks() {
-  rm -rf "@@INSTALLDIR@@/$LIBUDEV_0"
+  rm -rf "@@INSTALLDIR@@/libudev.so.0"
 }
diff --git a/chrome/installer/linux/debian/build.sh b/chrome/installer/linux/debian/build.sh
index 747f743..2e5e061 100755
--- a/chrome/installer/linux/debian/build.sh
+++ b/chrome/installer/linux/debian/build.sh
@@ -299,11 +299,6 @@ DPKG_SHLIB_DEPS=$(sed \
     's/\(libnspr4-0d ([^)]*)\), /\1 | libnspr4 (>= 4.9.5-0ubuntu0), /g' \
     <<< $DPKG_SHLIB_DEPS)
 
-# Fix-up libudev dependency because Ubuntu 13.04 has libudev1 instead of
-# libudev0.
-DPKG_SHLIB_DEPS=$(sed 's/\(libudev0 ([^)]*)\), /\1 | libudev1 (>= 198), /g' \
-                  <<< $DPKG_SHLIB_DEPS)
-
 COMMON_DEPS="${DPKG_SHLIB_DEPS}, ${ADDITION_DEPS}"
 COMMON_PREDEPS="dpkg (>= 1.14.0)"
 
diff --git a/chrome/installer/linux/debian/expected_deps_ia32 b/chrome/installer/linux/debian/expected_deps_ia32
index ec92bc9..e184f20 100644
--- a/chrome/installer/linux/debian/expected_deps_ia32
+++ b/chrome/installer/linux/debian/expected_deps_ia32
@@ -17,7 +17,6 @@ libnspr4 (>= 1.8.0.10)
 libnss3 (>= 3.14.3)
 libpango1.0-0 (>= 1.22.0)
 libstdc++6 (>= 4.6)
-libudev0 (>= 147)
 libx11-6 (>= 2:1.4.99.1)
 libxcomposite1 (>= 1:0.3-1)
 libxcursor1 (>> 1.1.2)
diff --git a/chrome/installer/linux/debian/expected_deps_x64 b/chrome/installer/linux/debian/expected_deps_x64
index b0d25f0..6ede7d1 100644
--- a/chrome/installer/linux/debian/expected_deps_x64
+++ b/chrome/installer/linux/debian/expected_deps_x64
@@ -16,7 +16,6 @@ libnspr4 (>= 1.8.0.10)
 libnss3 (>= 3.14.3)
 libpango1.0-0 (>= 1.22.0)
 libstdc++6 (>= 4.6)
-libudev0 (>= 147)
 libx11-6 (>= 2:1.4.99.1)
 libxcomposite1 (>= 1:0.3-1)
 libxcursor1 (>> 1.1.2)
diff --git a/chrome/installer/linux/debian/postinst b/chrome/installer/linux/debian/postinst
index da5e6b1..7acf8b2 100755
--- a/chrome/installer/linux/debian/postinst
+++ b/chrome/installer/linux/debian/postinst
@@ -57,7 +57,6 @@ update-alternatives --install /usr/bin/google-chrome google-chrome \
 @@include@@../common/symlinks.include
 
 remove_udev_symlinks
-add_udev_symlinks
 
 ## MAIN ##
 if [ ! -e "$DEFAULTS_FILE" ]; then
diff --git a/chrome/installer/linux/rpm/build.sh b/chrome/installer/linux/rpm/build.sh
index ff54b95..70e9541 100755
--- a/chrome/installer/linux/rpm/build.sh
+++ b/chrome/installer/linux/rpm/build.sh
@@ -99,9 +99,7 @@ do_package() {
 
   # Use find-requires script to make sure the dependencies are complete
   # (especially libc and libstdc++ versions).
-  # - Filter out udev to avoid libudev.so.0 vs. libudev.so.1 mismatches.
-  DETECTED_DEPENDS="$(echo "${BUILDDIR}/chrome" | /usr/lib/rpm/find-requires |
-      grep -v udev)"
+  DETECTED_DEPENDS="$(echo "${BUILDDIR}/chrome" | /usr/lib/rpm/find-requires)"
 
   # Compare the expected dependency list to the generated list.
   BAD_DIFF=0
diff --git a/chrome/installer/linux/rpm/chrome.spec.template b/chrome/installer/linux/rpm/chrome.spec.template
index e93f02f..8f1525d 100644
--- a/chrome/installer/linux/rpm/chrome.spec.template
+++ b/chrome/installer/linux/rpm/chrome.spec.template
@@ -119,7 +119,6 @@ remove_nss_symlinks
 add_nss_symlinks
 
 remove_udev_symlinks
-add_udev_symlinks
 
 DEFAULTS_FILE="/etc/default/@@PACKAGE@@"
 if [ ! -e "$DEFAULTS_FILE" ]; then
diff --git a/chrome/installer/linux/sysroot_scripts/packagelist.trusty.arm b/chrome/installer/linux/sysroot_scripts/packagelist.trusty.arm
index cf8a825..cd4b671 100644
--- a/chrome/installer/linux/sysroot_scripts/packagelist.trusty.arm
+++ b/chrome/installer/linux/sysroot_scripts/packagelist.trusty.arm
@@ -143,8 +143,6 @@ main/p/pulseaudio/libpulse-mainloop-glib0_4.0-0ubuntu11_armhf.deb
 main/s/speech-dispatcher/libspeechd2_0.8-5ubuntu1_armhf.deb
 main/s/speech-dispatcher/libspeechd-dev_0.8-5ubuntu1_armhf.deb
 main/s/speech-dispatcher/speech-dispatcher_0.8-5ubuntu1_armhf.deb
-main/s/systemd/libudev1_204-5ubuntu20_armhf.deb
-main/s/systemd/libudev-dev_204-5ubuntu20_armhf.deb
 main/x/x11proto-composite/x11proto-composite-dev_0.4.2-2_all.deb
 main/x/x11proto-core/x11proto-core-dev_7.0.24-1_all.deb
 main/x/x11proto-damage/x11proto-damage-dev_1.2.1-2_all.deb
diff --git a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.amd64 b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.amd64
index 53fe0f9..92cdde3 100644
--- a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.amd64
+++ b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.amd64
@@ -141,8 +141,6 @@ main/p/pulseaudio/libpulse-mainloop-glib0_2.0-6.1_amd64.deb
 main/s/speech-dispatcher/libspeechd2_0.7.1-6.2_amd64.deb
 main/s/speech-dispatcher/libspeechd-dev_0.7.1-6.2_amd64.deb
 main/s/speech-dispatcher/speech-dispatcher_0.7.1-6.2_amd64.deb
-main/u/udev/libudev0_175-7.2_amd64.deb
-main/u/udev/libudev-dev_175-7.2_amd64.deb
 main/x/x11proto-composite/x11proto-composite-dev_0.4.2-2_all.deb
 main/x/x11proto-core/x11proto-core-dev_7.0.23-1_all.deb
 main/x/x11proto-damage/x11proto-damage-dev_1.2.1-2_all.deb
diff --git a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.arm b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.arm
index c9c7b2f..bd9a55c 100644
--- a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.arm
+++ b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.arm
@@ -140,8 +140,6 @@ main/p/pulseaudio/libpulse-mainloop-glib0_2.0-6.1_armhf.deb
 main/s/speech-dispatcher/libspeechd2_0.7.1-6.2_armhf.deb
 main/s/speech-dispatcher/libspeechd-dev_0.7.1-6.2_armhf.deb
 main/s/speech-dispatcher/speech-dispatcher_0.7.1-6.2_armhf.deb
-main/u/udev/libudev0_175-7.2_armhf.deb
-main/u/udev/libudev-dev_175-7.2_armhf.deb
 main/x/x11proto-composite/x11proto-composite-dev_0.4.2-2_all.deb
 main/x/x11proto-core/x11proto-core-dev_7.0.23-1_all.deb
 main/x/x11proto-damage/x11proto-damage-dev_1.2.1-2_all.deb
diff --git a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.i386 b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.i386
index fd7f53e..b851cf1 100644
--- a/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.i386
+++ b/chrome/installer/linux/sysroot_scripts/packagelist.wheezy.i386
@@ -141,8 +141,6 @@ main/p/pulseaudio/libpulse-mainloop-glib0_2.0-6.1_i386.deb
 main/s/speech-dispatcher/libspeechd2_0.7.1-6.2_i386.deb
 main/s/speech-dispatcher/libspeechd-dev_0.7.1-6.2_i386.deb
 main/s/speech-dispatcher/speech-dispatcher_0.7.1-6.2_i386.deb
-main/u/udev/libudev0_175-7.2_i386.deb
-main/u/udev/libudev-dev_175-7.2_i386.deb
 main/x/x11proto-composite/x11proto-composite-dev_0.4.2-2_all.deb
 main/x/x11proto-core/x11proto-core-dev_7.0.23-1_all.deb
 main/x/x11proto-damage/x11proto-damage-dev_1.2.1-2_all.deb
diff --git a/chrome/installer/linux/sysroot_scripts/sysroot-creator-trusty.sh b/chrome/installer/linux/sysroot_scripts/sysroot-creator-trusty.sh
index cdd79d3..bb04664 100755
--- a/chrome/installer/linux/sysroot_scripts/sysroot-creator-trusty.sh
+++ b/chrome/installer/linux/sysroot_scripts/sysroot-creator-trusty.sh
@@ -122,8 +122,6 @@ DEBIAN_PACKAGES="\
   libstdc++6 \
   libstdc++-4.8-dev \
   libtasn1-6 \
-  libudev1 \
-  libudev-dev \
   libx11-6 \
   libx11-dev \
   libx11-xcb1 \
diff --git a/chrome/installer/linux/sysroot_scripts/sysroot-creator-wheezy.sh b/chrome/installer/linux/sysroot_scripts/sysroot-creator-wheezy.sh
index eb2a33c..80d277c 100755
--- a/chrome/installer/linux/sysroot_scripts/sysroot-creator-wheezy.sh
+++ b/chrome/installer/linux/sysroot_scripts/sysroot-creator-wheezy.sh
@@ -116,8 +116,6 @@ DEBIAN_PACKAGES="\
   libstdc++6 \
   libstdc++6-4.6-dev \
   libtasn1-3 \
-  libudev0 \
-  libudev-dev \
   libx11-6 \
   libx11-dev \
   libx11-xcb1 \
diff --git a/components/storage_monitor/storage_monitor_linux.cc b/components/storage_monitor/storage_monitor_linux.cc
index 6b57f5c..9d0b75a 100644
--- a/components/storage_monitor/storage_monitor_linux.cc
+++ b/components/storage_monitor/storage_monitor_linux.cc
@@ -99,7 +99,7 @@ class ScopedGetDeviceInfoResultRecorder {
 uint64 GetDeviceStorageSize(const base::FilePath& device_path,
                             struct udev_device* device) {
   // sysfs provides the device size in units of 512-byte blocks.
-  const std::string partition_size = udev_device_get_sysattr_value(
+  const std::string partition_size = device::udev_device_get_sysattr_value(
       device, kSizeSysAttr);
 
   // Keep track of device size, to see how often this information is
@@ -125,7 +125,7 @@ scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
 
   ScopedGetDeviceInfoResultRecorder results_recorder;
 
-  device::ScopedUdevPtr udev_obj(udev_new());
+  device::ScopedUdevPtr udev_obj(device::udev_new());
   if (!udev_obj.get())
     return storage_info.Pass();
 
@@ -142,8 +142,8 @@ scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
     return storage_info.Pass();  // Not a supported type.
 
   device::ScopedUdevDevicePtr device(
-      udev_device_new_from_devnum(udev_obj.get(), device_type,
-                                  device_stat.st_rdev));
+      device::udev_device_new_from_devnum(udev_obj.get(), device_type,
+                                          device_stat.st_rdev));
   if (!device.get())
     return storage_info.Pass();
 
@@ -160,15 +160,17 @@ scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
   MediaStorageUtil::RecordDeviceInfoHistogram(true, unique_id, volume_label);
 
   const char* value =
-      udev_device_get_sysattr_value(device.get(), kRemovableSysAttr);
+      device::udev_device_get_sysattr_value(device.get(), kRemovableSysAttr);
   if (!value) {
     // |parent_device| is owned by |device| and does not need to be cleaned
     // up.
     struct udev_device* parent_device =
-        udev_device_get_parent_with_subsystem_devtype(device.get(),
-                                                      kBlockSubsystemKey,
-                                                      kDiskDeviceTypeKey);
-    value = udev_device_get_sysattr_value(parent_device, kRemovableSysAttr);
+        device::udev_device_get_parent_with_subsystem_devtype(
+            device.get(),
+            kBlockSubsystemKey,
+            kDiskDeviceTypeKey);
+    value = device::udev_device_get_sysattr_value(parent_device,
+                                                  kRemovableSysAttr);
   }
   const bool is_removable = (value && atoi(value) == 1);
 
diff --git a/components/storage_monitor/udev_util_linux.cc b/components/storage_monitor/udev_util_linux.cc
index 154f11c..00019c1 100644
--- a/components/storage_monitor/udev_util_linux.cc
+++ b/components/storage_monitor/udev_util_linux.cc
@@ -11,17 +11,17 @@ namespace storage_monitor {
 
 std::string GetUdevDevicePropertyValue(udev_device* udev_device,
                                        const char* key) {
-  const char* value = udev_device_get_property_value(udev_device, key);
+  const char* value = device::udev_device_get_property_value(udev_device, key);
   return value ? value : std::string();
 }
 
 bool GetUdevDevicePropertyValueByPath(const base::FilePath& device_path,
                                       const char* key,
                                       std::string* result) {
-  device::ScopedUdevPtr udev(udev_new());
+  device::ScopedUdevPtr udev(device::udev_new());
   if (!udev.get())
     return false;
-  device::ScopedUdevDevicePtr device(udev_device_new_from_syspath(
+  device::ScopedUdevDevicePtr device(device::udev_device_new_from_syspath(
       udev.get(), device_path.value().c_str()));
   if (!device.get())
     return false;
diff --git a/content/browser/BUILD.gn b/content/browser/BUILD.gn
index a63da8d..95c2680 100644
--- a/content/browser/BUILD.gn
+++ b/content/browser/BUILD.gn
@@ -220,7 +220,7 @@ source_set("browser") {
   }
 
   if (use_udev) {
-    configs += [ "//build/config/linux:udev" ]
+    deps += [ "//device/udev_linux" ]
   } else {
     # Remove udev-specific sources.
     sources -= [
diff --git a/content/browser/device_monitor_udev.cc b/content/browser/device_monitor_udev.cc
index ddfe053..6e2b4ec 100644
--- a/content/browser/device_monitor_udev.cc
+++ b/content/browser/device_monitor_udev.cc
@@ -6,13 +6,12 @@
 
 #include "content/browser/device_monitor_udev.h"
 
-#include <libudev.h>
-
 #include <string>
 
 #include "base/system_monitor/system_monitor.h"
 #include "content/browser/udev_linux.h"
 #include "content/public/browser/browser_thread.h"
+#include "device/udev_linux/udev.h"
 
 namespace {
 
@@ -72,7 +71,7 @@ void DeviceMonitorLinux::OnDevicesChanged(udev_device* device) {
 
   base::SystemMonitor::DeviceType device_type =
       base::SystemMonitor::DEVTYPE_UNKNOWN;
-  std::string subsystem(udev_device_get_subsystem(device));
+  std::string subsystem(device::udev_device_get_subsystem(device));
   for (size_t i = 0; i < arraysize(kSubsystemMap); ++i) {
     if (subsystem == kSubsystemMap[i].subsystem) {
       device_type = kSubsystemMap[i].device_type;
diff --git a/content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc b/content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc
index e99a5e1..d922636 100644
--- a/content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc
+++ b/content/browser/gamepad/gamepad_platform_data_fetcher_linux.cc
@@ -5,7 +5,6 @@
 #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>
@@ -35,10 +34,10 @@ void CloseFileDescriptorIfValid(int 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;
 
@@ -126,7 +125,7 @@ void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
     // 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.
@@ -142,32 +141,36 @@ void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
       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
@@ -205,25 +208,26 @@ void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
 
 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());
diff --git a/content/browser/udev_linux.cc b/content/browser/udev_linux.cc
index 80c929b..dfcb52b 100644
--- a/content/browser/udev_linux.cc
+++ b/content/browser/udev_linux.cc
@@ -4,30 +4,28 @@
 
 #include "content/browser/udev_linux.h"
 
-#include <libudev.h>
-
 #include "base/message_loop/message_loop.h"
 
 namespace content {
 
 UdevLinux::UdevLinux(const std::vector<UdevMonitorFilter>& filters,
                      const UdevNotificationCallback& callback)
-    : udev_(udev_new()),
-      monitor_(udev_monitor_new_from_netlink(udev_.get(), "udev")),
+    : udev_(device::udev_new()),
+      monitor_(device::udev_monitor_new_from_netlink(udev_.get(), "udev")),
       monitor_fd_(-1),
       callback_(callback) {
   CHECK(udev_);
   CHECK(monitor_);
 
   for (size_t i = 0; i < filters.size(); ++i) {
-    int ret = udev_monitor_filter_add_match_subsystem_devtype(
+    int ret = device::udev_monitor_filter_add_match_subsystem_devtype(
         monitor_.get(), filters[i].subsystem, filters[i].devtype);
     CHECK_EQ(0, ret);
   }
 
-  int ret = udev_monitor_enable_receiving(monitor_.get());
+  int ret = device::udev_monitor_enable_receiving(monitor_.get());
   CHECK_EQ(0, ret);
-  monitor_fd_ = udev_monitor_get_fd(monitor_.get());
+  monitor_fd_ = device::udev_monitor_get_fd(monitor_.get());
   CHECK_GE(monitor_fd_, 0);
 
   bool success = base::MessageLoopForIO::current()->WatchFileDescriptor(
@@ -53,7 +51,7 @@ void UdevLinux::OnFileCanReadWithoutBlocking(int fd) {
   // representing the device which changed and what type of change occured.
   DCHECK_EQ(monitor_fd_, fd);
   device::ScopedUdevDevicePtr dev(
-      udev_monitor_receive_device(monitor_.get()));
+      device::udev_monitor_receive_device(monitor_.get()));
   if (!dev)
     return;
 
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index befe927..9d25e98 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -1789,7 +1789,7 @@
     }],
     ['use_udev == 1', {
       'dependencies': [
-        '../build/linux/system.gyp:udev',
+        '../device/udev_linux/udev.gyp:udev_linux',
       ],
     }, {
       'sources!': [
diff --git a/device/hid/BUILD.gn b/device/hid/BUILD.gn
index bc450db..7741f90 100644
--- a/device/hid/BUILD.gn
+++ b/device/hid/BUILD.gn
@@ -44,10 +44,6 @@ source_set("hid") {
   ]
 
   if (is_linux) {
-    configs += [
-      "//build/config/linux:udev"
-    ]
-
     deps += [
       "//device/udev_linux",
     ]
diff --git a/device/hid/device_monitor_linux.cc b/device/hid/device_monitor_linux.cc
index 8d112c1..5dffc85 100644
--- a/device/hid/device_monitor_linux.cc
+++ b/device/hid/device_monitor_linux.cc
@@ -4,11 +4,10 @@
 
 #include "device/hid/device_monitor_linux.h"
 
-#include <libudev.h>
-
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
+#include "device/udev_linux/udev.h"
 
 namespace device {
 
diff --git a/device/hid/hid_connection_linux.cc b/device/hid/hid_connection_linux.cc
index 907f79b..bec4de7 100644
--- a/device/hid/hid_connection_linux.cc
+++ b/device/hid/hid_connection_linux.cc
@@ -6,7 +6,6 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <libudev.h>
 #include <linux/hidraw.h>
 #include <sys/ioctl.h>
 
diff --git a/device/hid/input_service_linux.cc b/device/hid/input_service_linux.cc
index 78b11f6..f6fd0dc 100644
--- a/device/hid/input_service_linux.cc
+++ b/device/hid/input_service_linux.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <libudev.h>
+#include "device/hid/input_service_linux.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ -10,7 +10,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
-#include "device/hid/input_service_linux.h"
+#include "device/udev_linux/udev.h"
 
 namespace device {
 
diff --git a/device/serial/BUILD.gn b/device/serial/BUILD.gn
index 7ac28a5..eed42cb 100644
--- a/device/serial/BUILD.gn
+++ b/device/serial/BUILD.gn
@@ -41,13 +41,14 @@ static_library("serial") {
     "serial_service_impl.h",
   ]
 
-  if (is_linux) {
-    configs += [ "//build/config/linux:udev" ]
-  }
-
   public_deps = [
     ":serial_mojo",
   ]
+  deps = []
+
+  if (is_linux) {
+    deps += [ "//device/udev_linux" ]
+  }
 }
 
 # GYP version: device/serial/serial.gyp:device_serial_test_util
diff --git a/device/serial/serial.gyp b/device/serial/serial.gyp
index 50aaa70..e3eca58 100644
--- a/device/serial/serial.gyp
+++ b/device/serial/serial.gyp
@@ -31,7 +31,7 @@
       'conditions': [
         ['use_udev == 1', {
           'dependencies': [
-            '../../build/linux/system.gyp:udev',
+            '../udev_linux/udev.gyp:udev_linux',
           ],
         }, {
           'sources!': [
diff --git a/device/udev_linux/BUILD.gn b/device/udev_linux/BUILD.gn
index a32319b..6a3c831 100644
--- a/device/udev_linux/BUILD.gn
+++ b/device/udev_linux/BUILD.gn
@@ -8,13 +8,18 @@ if (use_udev) {
   source_set("udev_linux") {
     sources = [
       "scoped_udev.h",
+      "udev.cc",
+      "udev.h",
+      "udev0_loader.cc",
+      "udev0_loader.h",
+      "udev1_loader.cc",
+      "udev1_loader.h",
+      "udev_loader.cc",
+      "udev_loader.h",
     ]
 
     deps = [
       "//base",
-    ]
-
-    configs += [
       "//build/config/linux:udev",
     ]
   }
diff --git a/device/udev_linux/scoped_udev.h b/device/udev_linux/scoped_udev.h
index 54df387..06e3926 100644
--- a/device/udev_linux/scoped_udev.h
+++ b/device/udev_linux/scoped_udev.h
@@ -5,9 +5,8 @@
 #ifndef DEVICE_UDEV_LINUX_SCOPED_UDEV_H_
 #define DEVICE_UDEV_LINUX_SCOPED_UDEV_H_
 
-#include <libudev.h>
-
 #include "base/memory/scoped_ptr.h"
+#include "device/udev_linux/udev.h"
 
 #if !defined(USE_UDEV)
 #error "USE_UDEV not defined"
diff --git a/device/udev_linux/udev.cc b/device/udev_linux/udev.cc
new file mode 100644
index 0000000..56f7b7e
--- /dev/null
+++ b/device/udev_linux/udev.cc
@@ -0,0 +1,141 @@
+// 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/udev_linux/udev.h"
+
+#include "device/udev_linux/udev_loader.h"
+
+namespace device {
+
+const char* udev_device_get_action(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_action(udev_device);
+}
+
+const char* udev_device_get_devnode(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_devnode(udev_device);
+}
+
+udev_device* udev_device_get_parent(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_parent(udev_device);
+}
+
+udev_device* udev_device_get_parent_with_subsystem_devtype(
+    udev_device* udev_device,
+    const char* subsystem,
+    const char* devtype) {
+  return UdevLoader::Get()->udev_device_get_parent_with_subsystem_devtype(
+      udev_device, subsystem, devtype);
+}
+
+const char* udev_device_get_property_value(udev_device* udev_device,
+                                           const char* key) {
+  return UdevLoader::Get()->udev_device_get_property_value(udev_device, key);
+}
+
+const char* udev_device_get_subsystem(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_subsystem(udev_device);
+}
+
+const char* udev_device_get_sysattr_value(udev_device* udev_device,
+                                          const char* sysattr) {
+  return UdevLoader::Get()->udev_device_get_sysattr_value(udev_device, sysattr);
+}
+
+const char* udev_device_get_sysname(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_sysname(udev_device);
+}
+
+const char* udev_device_get_syspath(udev_device* udev_device) {
+  return UdevLoader::Get()->udev_device_get_syspath(udev_device);
+}
+
+udev_device* udev_device_new_from_devnum(udev* udev, char type, dev_t devnum) {
+  return UdevLoader::Get()->udev_device_new_from_devnum(udev, type, devnum);
+}
+
+udev_device* udev_device_new_from_syspath(udev* udev, const char* syspath) {
+  return UdevLoader::Get()->udev_device_new_from_syspath(udev, syspath);
+}
+
+void udev_device_unref(udev_device* udev_device) {
+  UdevLoader::Get()->udev_device_unref(udev_device);
+}
+
+int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
+                                       const char* subsystem) {
+  return UdevLoader::Get()->udev_enumerate_add_match_subsystem(udev_enumerate,
+                                                               subsystem);
+}
+
+udev_list_entry* udev_enumerate_get_list_entry(udev_enumerate* udev_enumerate) {
+  return UdevLoader::Get()->udev_enumerate_get_list_entry(udev_enumerate);
+}
+
+udev_enumerate* udev_enumerate_new(udev* udev) {
+  return UdevLoader::Get()->udev_enumerate_new(udev);
+}
+
+int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) {
+  return UdevLoader::Get()->udev_enumerate_scan_devices(udev_enumerate);
+}
+
+void udev_enumerate_unref(udev_enumerate* udev_enumerate) {
+  UdevLoader::Get()->udev_enumerate_unref(udev_enumerate);
+}
+
+udev_list_entry* udev_list_entry_get_next(udev_list_entry* list_entry) {
+  return UdevLoader::Get()->udev_list_entry_get_next(list_entry);
+}
+
+const char* udev_list_entry_get_name(udev_list_entry* list_entry) {
+  return UdevLoader::Get()->udev_list_entry_get_name(list_entry);
+}
+
+int udev_monitor_enable_receiving(udev_monitor* udev_monitor) {
+  return UdevLoader::Get()->udev_monitor_enable_receiving(udev_monitor);
+}
+
+int udev_monitor_filter_add_match_subsystem_devtype(udev_monitor* udev_monitor,
+                                                    const char* subsystem,
+                                                    const char* devtype) {
+  return UdevLoader::Get()->udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor, subsystem, devtype);
+}
+
+int udev_monitor_get_fd(udev_monitor* udev_monitor) {
+  return UdevLoader::Get()->udev_monitor_get_fd(udev_monitor);
+}
+
+udev_monitor* udev_monitor_new_from_netlink(udev* udev, const char* name) {
+  return UdevLoader::Get()->udev_monitor_new_from_netlink(udev, name);
+}
+
+udev_device* udev_monitor_receive_device(udev_monitor* udev_monitor) {
+  return UdevLoader::Get()->udev_monitor_receive_device(udev_monitor);
+}
+
+void udev_monitor_unref(udev_monitor* udev_monitor) {
+  UdevLoader::Get()->udev_monitor_unref(udev_monitor);
+}
+
+udev* udev_new() {
+  return UdevLoader::Get()->udev_new();
+}
+
+void udev_set_log_fn(
+    struct udev* udev,
+    void (*log_fn)(struct udev* udev, int priority, const char* file, int line,
+                   const char* fn, const char* format, va_list args)) {
+  return UdevLoader::Get()->udev_set_log_fn(udev, log_fn);
+}
+
+void udev_set_log_priority(struct udev* udev, int priority) {
+  return UdevLoader::Get()->udev_set_log_priority(udev, priority);
+}
+
+void udev_unref(udev* udev) {
+  UdevLoader::Get()->udev_unref(udev);
+}
+
+}  // namespace device
diff --git a/device/udev_linux/udev.gyp b/device/udev_linux/udev.gyp
index cc43430..4769d83 100644
--- a/device/udev_linux/udev.gyp
+++ b/device/udev_linux/udev.gyp
@@ -21,6 +21,14 @@
           ],
           'sources': [
             'scoped_udev.h',
+            'udev.cc',
+            'udev.h',
+            'udev0_loader.cc',
+            'udev0_loader.h',
+            'udev1_loader.cc',
+            'udev1_loader.h',
+            'udev_loader.cc',
+            'udev_loader.h',
           ],
         },
       ],
diff --git a/device/udev_linux/udev.h b/device/udev_linux/udev.h
new file mode 100644
index 0000000..d58960d
--- /dev/null
+++ b/device/udev_linux/udev.h
@@ -0,0 +1,73 @@
+// 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.
+
+#ifndef DEVICE_UDEV_LINUX_UDEV_H_
+#define DEVICE_UDEV_LINUX_UDEV_H_
+
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if !defined(USE_UDEV)
+#error "USE_UDEV not defined"
+#endif
+
+// Adapted from libudev.h.
+#define udev_list_entry_foreach(list_entry, first_entry) \
+  for (list_entry = first_entry; list_entry != NULL;     \
+       list_entry = ::device::udev_list_entry_get_next(list_entry))
+
+// Forward declarations of opaque structs.
+struct udev;
+struct udev_device;
+struct udev_enumerate;
+struct udev_list_entry;
+struct udev_monitor;
+
+namespace device {
+
+const char* udev_device_get_action(udev_device* udev_device);
+const char* udev_device_get_devnode(udev_device* udev_device);
+udev_device* udev_device_get_parent(udev_device* udev_device);
+udev_device* udev_device_get_parent_with_subsystem_devtype(
+    udev_device* udev_device,
+    const char* subsystem,
+    const char* devtype);
+const char* udev_device_get_property_value(udev_device* udev_device,
+                                           const char* key);
+const char* udev_device_get_subsystem(udev_device* udev_device);
+const char* udev_device_get_sysattr_value(udev_device* udev_device,
+                                          const char* sysattr);
+const char* udev_device_get_sysname(udev_device* udev_device);
+const char* udev_device_get_syspath(udev_device* udev_device);
+udev_device* udev_device_new_from_devnum(udev* udev, char type, dev_t devnum);
+udev_device* udev_device_new_from_syspath(udev* udev, const char* syspath);
+void udev_device_unref(udev_device* udev_device);
+int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
+                                       const char* subsystem);
+udev_list_entry* udev_enumerate_get_list_entry(udev_enumerate* udev_enumerate);
+udev_enumerate* udev_enumerate_new(udev* udev);
+int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate);
+void udev_enumerate_unref(udev_enumerate* udev_enumerate);
+udev_list_entry* udev_list_entry_get_next(udev_list_entry* list_entry);
+const char* udev_list_entry_get_name(udev_list_entry* list_entry);
+int udev_monitor_enable_receiving(udev_monitor* udev_monitor);
+int udev_monitor_filter_add_match_subsystem_devtype(udev_monitor* udev_monitor,
+                                                    const char* subsystem,
+                                                    const char* devtype);
+int udev_monitor_get_fd(udev_monitor* udev_monitor);
+udev_monitor* udev_monitor_new_from_netlink(udev* udev, const char* name);
+udev_device* udev_monitor_receive_device(udev_monitor* udev_monitor);
+void udev_monitor_unref(udev_monitor* udev_monitor);
+udev* udev_new();
+void udev_set_log_fn(
+    struct udev* udev,
+    void (*log_fn)(struct udev* udev, int priority, const char* file, int line,
+                   const char* fn, const char* format, va_list args));
+void udev_set_log_priority(struct udev* udev, int priority);
+void udev_unref(udev* udev);
+
+}  // namespace device
+
+#endif  // DEVICE_UDEV_LINUX_UDEV_H_
diff --git a/device/udev_linux/udev0_loader.cc b/device/udev_linux/udev0_loader.cc
new file mode 100644
index 0000000..d70b2f2
--- /dev/null
+++ b/device/udev_linux/udev0_loader.cc
@@ -0,0 +1,165 @@
+// 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/udev_linux/udev0_loader.h"
+
+#include "library_loaders/libudev0.h"
+
+namespace device {
+
+Udev0Loader::Udev0Loader() {
+}
+
+Udev0Loader::~Udev0Loader() {
+}
+
+bool Udev0Loader::Init() {
+  if (lib_loader_)
+    return lib_loader_->loaded();
+  lib_loader_.reset(new LibUdev0Loader);
+  return lib_loader_->Load("libudev.so.0");
+}
+
+const char* Udev0Loader::udev_device_get_action(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_action(udev_device);
+}
+
+const char* Udev0Loader::udev_device_get_devnode(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_devnode(udev_device);
+}
+
+udev_device* Udev0Loader::udev_device_get_parent(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_parent(udev_device);
+}
+
+udev_device* Udev0Loader::udev_device_get_parent_with_subsystem_devtype(
+    udev_device* udev_device,
+    const char* subsystem,
+    const char* devtype) {
+  return lib_loader_->udev_device_get_parent_with_subsystem_devtype(
+      udev_device, subsystem, devtype);
+}
+
+const char* Udev0Loader::udev_device_get_property_value(
+    udev_device* udev_device,
+    const char* key) {
+  return lib_loader_->udev_device_get_property_value(udev_device, key);
+}
+
+const char* Udev0Loader::udev_device_get_subsystem(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_subsystem(udev_device);
+}
+
+const char* Udev0Loader::udev_device_get_sysattr_value(udev_device* udev_device,
+                                                       const char* sysattr) {
+  return lib_loader_->udev_device_get_sysattr_value(udev_device, sysattr);
+}
+
+const char* Udev0Loader::udev_device_get_sysname(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_sysname(udev_device);
+}
+
+const char* Udev0Loader::udev_device_get_syspath(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_syspath(udev_device);
+}
+
+udev_device* Udev0Loader::udev_device_new_from_devnum(udev* udev,
+                                                      char type,
+                                                      dev_t devnum) {
+  return lib_loader_->udev_device_new_from_devnum(udev, type, devnum);
+}
+
+udev_device* Udev0Loader::udev_device_new_from_syspath(udev* udev,
+                                                       const char* syspath) {
+  return lib_loader_->udev_device_new_from_syspath(udev, syspath);
+}
+
+void Udev0Loader::udev_device_unref(udev_device* udev_device) {
+  lib_loader_->udev_device_unref(udev_device);
+}
+
+int Udev0Loader::udev_enumerate_add_match_subsystem(
+    udev_enumerate* udev_enumerate,
+    const char* subsystem) {
+  return lib_loader_->udev_enumerate_add_match_subsystem(udev_enumerate,
+                                                         subsystem);
+}
+
+udev_list_entry* Udev0Loader::udev_enumerate_get_list_entry(
+    udev_enumerate* udev_enumerate) {
+  return lib_loader_->udev_enumerate_get_list_entry(udev_enumerate);
+}
+
+udev_enumerate* Udev0Loader::udev_enumerate_new(udev* udev) {
+  return lib_loader_->udev_enumerate_new(udev);
+}
+
+int Udev0Loader::udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) {
+  return lib_loader_->udev_enumerate_scan_devices(udev_enumerate);
+}
+
+void Udev0Loader::udev_enumerate_unref(udev_enumerate* udev_enumerate) {
+  lib_loader_->udev_enumerate_unref(udev_enumerate);
+}
+
+udev_list_entry* Udev0Loader::udev_list_entry_get_next(
+    udev_list_entry* list_entry) {
+  return lib_loader_->udev_list_entry_get_next(list_entry);
+}
+
+const char* Udev0Loader::udev_list_entry_get_name(udev_list_entry* list_entry) {
+  return lib_loader_->udev_list_entry_get_name(list_entry);
+}
+
+int Udev0Loader::udev_monitor_enable_receiving(udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_enable_receiving(udev_monitor);
+}
+
+int Udev0Loader::udev_monitor_filter_add_match_subsystem_devtype(
+    udev_monitor* udev_monitor,
+    const char* subsystem,
+    const char* devtype) {
+  return lib_loader_->udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor, subsystem, devtype);
+}
+
+int Udev0Loader::udev_monitor_get_fd(udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_get_fd(udev_monitor);
+}
+
+udev_monitor* Udev0Loader::udev_monitor_new_from_netlink(udev* udev,
+                                                         const char* name) {
+  return lib_loader_->udev_monitor_new_from_netlink(udev, name);
+}
+
+udev_device* Udev0Loader::udev_monitor_receive_device(
+    udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_receive_device(udev_monitor);
+}
+
+void Udev0Loader::udev_monitor_unref(udev_monitor* udev_monitor) {
+  lib_loader_->udev_monitor_unref(udev_monitor);
+}
+
+udev* Udev0Loader::udev_new() {
+  return lib_loader_->udev_new();
+}
+
+void Udev0Loader::udev_set_log_fn(
+      struct udev* udev,
+      void (*log_fn)(struct udev* udev, int priority,
+                     const char* file, int line,
+                     const char* fn, const char* format, va_list args)) {
+  return lib_loader_->udev_set_log_fn(udev, log_fn);
+}
+
+void Udev0Loader::udev_set_log_priority(struct udev* udev, int priority) {
+  return lib_loader_->udev_set_log_priority(udev, priority);
+}
+
+void Udev0Loader::udev_unref(udev* udev) {
+  lib_loader_->udev_unref(udev);
+}
+
+}  // namespace device
diff --git a/device/udev_linux/udev0_loader.h b/device/udev_linux/udev0_loader.h
new file mode 100644
index 0000000..2e48c7c
--- /dev/null
+++ b/device/udev_linux/udev0_loader.h
@@ -0,0 +1,79 @@
+// 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.
+
+#ifndef DEVICE_UDEV_LINUX_UDEV0_LOADER_H_
+#define DEVICE_UDEV_LINUX_UDEV0_LOADER_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "device/udev_linux/udev_loader.h"
+
+class LibUdev0Loader;
+
+namespace device {
+
+class Udev0Loader : public UdevLoader {
+ public:
+  Udev0Loader();
+  ~Udev0Loader() override;
+
+ private:
+  bool Init() override;
+  const char* udev_device_get_action(udev_device* udev_device) override;
+  const char* udev_device_get_devnode(udev_device* udev_device) override;
+  udev_device* udev_device_get_parent(udev_device* udev_device) override;
+  udev_device* udev_device_get_parent_with_subsystem_devtype(
+      udev_device* udev_device,
+      const char* subsystem,
+      const char* devtype) override;
+  const char* udev_device_get_property_value(udev_device* udev_device,
+                                             const char* key) override;
+  const char* udev_device_get_subsystem(udev_device* udev_device) override;
+  const char* udev_device_get_sysattr_value(udev_device* udev_device,
+                                            const char* sysattr) override;
+  const char* udev_device_get_sysname(udev_device* udev_device) override;
+  const char* udev_device_get_syspath(udev_device* udev_device) override;
+  udev_device* udev_device_new_from_devnum(udev* udev,
+                                           char type,
+                                           dev_t devnum) override;
+  udev_device* udev_device_new_from_syspath(udev* udev,
+                                            const char* syspath) override;
+  void udev_device_unref(udev_device* udev_device) override;
+  int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
+                                         const char* subsystem) override;
+  udev_list_entry* udev_enumerate_get_list_entry(
+      udev_enumerate* udev_enumerate) override;
+  udev_enumerate* udev_enumerate_new(udev* udev) override;
+  int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) override;
+  void udev_enumerate_unref(udev_enumerate* udev_enumerate) override;
+  udev_list_entry* udev_list_entry_get_next(
+      udev_list_entry* list_entry) override;
+  const char* udev_list_entry_get_name(udev_list_entry* list_entry) override;
+  int udev_monitor_enable_receiving(udev_monitor* udev_monitor) override;
+  int udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor* udev_monitor,
+      const char* subsystem,
+      const char* devtype) override;
+  int udev_monitor_get_fd(udev_monitor* udev_monitor) override;
+  udev_monitor* udev_monitor_new_from_netlink(udev* udev,
+                                              const char* name) override;
+  udev_device* udev_monitor_receive_device(udev_monitor* udev_monitor) override;
+  void udev_monitor_unref(udev_monitor* udev_monitor) override;
+  udev* udev_new() override;
+  void udev_set_log_fn(
+      struct udev* udev,
+      void (*log_fn)(struct udev* udev, int priority,
+                     const char* file, int line,
+                     const char* fn, const char* format,
+                     va_list args)) override;
+  void udev_set_log_priority(struct udev* udev, int priority) override;
+  void udev_unref(udev* udev) override;
+
+  scoped_ptr<LibUdev0Loader> lib_loader_;
+
+  DISALLOW_COPY_AND_ASSIGN(Udev0Loader);
+};
+
+}  // namespace device
+
+#endif  // DEVICE_UDEV_LINUX_UDEV0_LOADER_H_
diff --git a/device/udev_linux/udev1_loader.cc b/device/udev_linux/udev1_loader.cc
new file mode 100644
index 0000000..ab741b9
--- /dev/null
+++ b/device/udev_linux/udev1_loader.cc
@@ -0,0 +1,165 @@
+// 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/udev_linux/udev1_loader.h"
+
+#include "library_loaders/libudev1.h"
+
+namespace device {
+
+Udev1Loader::Udev1Loader() {
+}
+
+Udev1Loader::~Udev1Loader() {
+}
+
+bool Udev1Loader::Init() {
+  if (lib_loader_)
+    return lib_loader_->loaded();
+  lib_loader_.reset(new LibUdev1Loader);
+  return lib_loader_->Load("libudev.so.1");
+}
+
+const char* Udev1Loader::udev_device_get_action(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_action(udev_device);
+}
+
+const char* Udev1Loader::udev_device_get_devnode(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_devnode(udev_device);
+}
+
+udev_device* Udev1Loader::udev_device_get_parent(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_parent(udev_device);
+}
+
+udev_device* Udev1Loader::udev_device_get_parent_with_subsystem_devtype(
+    udev_device* udev_device,
+    const char* subsystem,
+    const char* devtype) {
+  return lib_loader_->udev_device_get_parent_with_subsystem_devtype(
+      udev_device, subsystem, devtype);
+}
+
+const char* Udev1Loader::udev_device_get_property_value(
+    udev_device* udev_device,
+    const char* key) {
+  return lib_loader_->udev_device_get_property_value(udev_device, key);
+}
+
+const char* Udev1Loader::udev_device_get_subsystem(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_subsystem(udev_device);
+}
+
+const char* Udev1Loader::udev_device_get_sysattr_value(udev_device* udev_device,
+                                                       const char* sysattr) {
+  return lib_loader_->udev_device_get_sysattr_value(udev_device, sysattr);
+}
+
+const char* Udev1Loader::udev_device_get_sysname(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_sysname(udev_device);
+}
+
+const char* Udev1Loader::udev_device_get_syspath(udev_device* udev_device) {
+  return lib_loader_->udev_device_get_syspath(udev_device);
+}
+
+udev_device* Udev1Loader::udev_device_new_from_devnum(udev* udev,
+                                                      char type,
+                                                      dev_t devnum) {
+  return lib_loader_->udev_device_new_from_devnum(udev, type, devnum);
+}
+
+udev_device* Udev1Loader::udev_device_new_from_syspath(udev* udev,
+                                                       const char* syspath) {
+  return lib_loader_->udev_device_new_from_syspath(udev, syspath);
+}
+
+void Udev1Loader::udev_device_unref(udev_device* udev_device) {
+  lib_loader_->udev_device_unref(udev_device);
+}
+
+int Udev1Loader::udev_enumerate_add_match_subsystem(
+    udev_enumerate* udev_enumerate,
+    const char* subsystem) {
+  return lib_loader_->udev_enumerate_add_match_subsystem(udev_enumerate,
+                                                         subsystem);
+}
+
+udev_list_entry* Udev1Loader::udev_enumerate_get_list_entry(
+    udev_enumerate* udev_enumerate) {
+  return lib_loader_->udev_enumerate_get_list_entry(udev_enumerate);
+}
+
+udev_enumerate* Udev1Loader::udev_enumerate_new(udev* udev) {
+  return lib_loader_->udev_enumerate_new(udev);
+}
+
+int Udev1Loader::udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) {
+  return lib_loader_->udev_enumerate_scan_devices(udev_enumerate);
+}
+
+void Udev1Loader::udev_enumerate_unref(udev_enumerate* udev_enumerate) {
+  lib_loader_->udev_enumerate_unref(udev_enumerate);
+}
+
+udev_list_entry* Udev1Loader::udev_list_entry_get_next(
+    udev_list_entry* list_entry) {
+  return lib_loader_->udev_list_entry_get_next(list_entry);
+}
+
+const char* Udev1Loader::udev_list_entry_get_name(udev_list_entry* list_entry) {
+  return lib_loader_->udev_list_entry_get_name(list_entry);
+}
+
+int Udev1Loader::udev_monitor_enable_receiving(udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_enable_receiving(udev_monitor);
+}
+
+int Udev1Loader::udev_monitor_filter_add_match_subsystem_devtype(
+    udev_monitor* udev_monitor,
+    const char* subsystem,
+    const char* devtype) {
+  return lib_loader_->udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor, subsystem, devtype);
+}
+
+int Udev1Loader::udev_monitor_get_fd(udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_get_fd(udev_monitor);
+}
+
+udev_monitor* Udev1Loader::udev_monitor_new_from_netlink(udev* udev,
+                                                         const char* name) {
+  return lib_loader_->udev_monitor_new_from_netlink(udev, name);
+}
+
+udev_device* Udev1Loader::udev_monitor_receive_device(
+    udev_monitor* udev_monitor) {
+  return lib_loader_->udev_monitor_receive_device(udev_monitor);
+}
+
+void Udev1Loader::udev_monitor_unref(udev_monitor* udev_monitor) {
+  lib_loader_->udev_monitor_unref(udev_monitor);
+}
+
+udev* Udev1Loader::udev_new() {
+  return lib_loader_->udev_new();
+}
+
+void Udev1Loader::udev_set_log_fn(
+      struct udev* udev,
+      void (*log_fn)(struct udev* udev, int priority,
+                     const char* file, int line,
+                     const char* fn, const char* format, va_list args)) {
+  return lib_loader_->udev_set_log_fn(udev, log_fn);
+}
+
+void Udev1Loader::udev_set_log_priority(struct udev* udev, int priority) {
+  return lib_loader_->udev_set_log_priority(udev, priority);
+}
+
+void Udev1Loader::udev_unref(udev* udev) {
+  lib_loader_->udev_unref(udev);
+}
+
+}  // namespace device
diff --git a/device/udev_linux/udev1_loader.h b/device/udev_linux/udev1_loader.h
new file mode 100644
index 0000000..0c46c22
--- /dev/null
+++ b/device/udev_linux/udev1_loader.h
@@ -0,0 +1,79 @@
+// 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.
+
+#ifndef DEVICE_UDEV_LINUX_UDEV1_LOADER_H_
+#define DEVICE_UDEV_LINUX_UDEV1_LOADER_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "device/udev_linux/udev_loader.h"
+
+class LibUdev1Loader;
+
+namespace device {
+
+class Udev1Loader : public UdevLoader {
+ public:
+  Udev1Loader();
+  ~Udev1Loader() override;
+
+ private:
+  bool Init() override;
+  const char* udev_device_get_action(udev_device* udev_device) override;
+  const char* udev_device_get_devnode(udev_device* udev_device) override;
+  udev_device* udev_device_get_parent(udev_device* udev_device) override;
+  udev_device* udev_device_get_parent_with_subsystem_devtype(
+      udev_device* udev_device,
+      const char* subsystem,
+      const char* devtype) override;
+  const char* udev_device_get_property_value(udev_device* udev_device,
+                                             const char* key) override;
+  const char* udev_device_get_subsystem(udev_device* udev_device) override;
+  const char* udev_device_get_sysattr_value(udev_device* udev_device,
+                                            const char* sysattr) override;
+  const char* udev_device_get_sysname(udev_device* udev_device) override;
+  const char* udev_device_get_syspath(udev_device* udev_device) override;
+  udev_device* udev_device_new_from_devnum(udev* udev,
+                                           char type,
+                                           dev_t devnum) override;
+  udev_device* udev_device_new_from_syspath(udev* udev,
+                                            const char* syspath) override;
+  void udev_device_unref(udev_device* udev_device) override;
+  int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
+                                         const char* subsystem) override;
+  udev_list_entry* udev_enumerate_get_list_entry(
+      udev_enumerate* udev_enumerate) override;
+  udev_enumerate* udev_enumerate_new(udev* udev) override;
+  int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) override;
+  void udev_enumerate_unref(udev_enumerate* udev_enumerate) override;
+  udev_list_entry* udev_list_entry_get_next(
+      udev_list_entry* list_entry) override;
+  const char* udev_list_entry_get_name(udev_list_entry* list_entry) override;
+  int udev_monitor_enable_receiving(udev_monitor* udev_monitor) override;
+  int udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor* udev_monitor,
+      const char* subsystem,
+      const char* devtype) override;
+  int udev_monitor_get_fd(udev_monitor* udev_monitor) override;
+  udev_monitor* udev_monitor_new_from_netlink(udev* udev,
+                                              const char* name) override;
+  udev_device* udev_monitor_receive_device(udev_monitor* udev_monitor) override;
+  void udev_monitor_unref(udev_monitor* udev_monitor) override;
+  udev* udev_new() override;
+  void udev_set_log_fn(
+      struct udev* udev,
+      void (*log_fn)(struct udev* udev, int priority,
+                     const char* file, int line,
+                     const char* fn, const char* format,
+                     va_list args)) override;
+  void udev_set_log_priority(struct udev* udev, int priority) override;
+  void udev_unref(udev* udev) override;
+
+  scoped_ptr<LibUdev1Loader> lib_loader_;
+
+  DISALLOW_COPY_AND_ASSIGN(Udev1Loader);
+};
+
+}  // namespace device
+
+#endif  // DEVICE_UDEV_LINUX_UDEV1_LOADER_H_
diff --git a/device/udev_linux/udev_loader.cc b/device/udev_linux/udev_loader.cc
new file mode 100644
index 0000000..88b64e1
--- /dev/null
+++ b/device/udev_linux/udev_loader.cc
@@ -0,0 +1,43 @@
+// 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/udev_linux/udev_loader.h"
+
+#include "base/logging.h"
+#include "device/udev_linux/udev0_loader.h"
+#include "device/udev_linux/udev1_loader.h"
+
+namespace device {
+
+namespace {
+
+UdevLoader* g_udev_loader = NULL;
+
+}  // namespace
+
+// static
+UdevLoader* UdevLoader::Get() {
+  if (g_udev_loader)
+    return g_udev_loader;
+
+  scoped_ptr<UdevLoader> udev_loader;
+  udev_loader.reset(new Udev1Loader);
+  if (udev_loader->Init()) {
+    g_udev_loader = udev_loader.release();
+    return g_udev_loader;
+  }
+
+  udev_loader.reset(new Udev0Loader);
+  if (udev_loader->Init()) {
+    g_udev_loader = udev_loader.release();
+    return g_udev_loader;
+  }
+  CHECK(false);
+  return NULL;
+}
+
+UdevLoader::~UdevLoader() {
+}
+
+}  // namespace device
diff --git a/device/udev_linux/udev_loader.h b/device/udev_linux/udev_loader.h
new file mode 100644
index 0000000..9160a89
--- /dev/null
+++ b/device/udev_linux/udev_loader.h
@@ -0,0 +1,91 @@
+// 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.
+
+#ifndef DEVICE_UDEV_LINUX_UDEV_LOADER_H_
+#define DEVICE_UDEV_LINUX_UDEV_LOADER_H_
+
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if !defined(USE_UDEV)
+#error "USE_UDEV not defined"
+#endif
+
+struct udev;
+struct udev_device;
+struct udev_enumerate;
+struct udev_list_entry;
+struct udev_monitor;
+
+namespace device {
+
+// Interface to libudev. Accessed through the static Get() function, which
+// will try to load libudev1 first and then libudev0 on first use. If neither
+// libraries load successfully, the program will fail with a crash.
+//
+// All the methods have the same signatures as libudev's functions. e.g.
+// udev_monitor_get_fd(mon) simply becomes device::udev_monitor_get_fd(mon).
+class UdevLoader {
+ public:
+  static UdevLoader* Get();
+
+  virtual ~UdevLoader();
+
+  virtual bool Init() = 0;
+
+  virtual const char* udev_device_get_action(udev_device* udev_device) = 0;
+  virtual const char* udev_device_get_devnode(udev_device* udev_device) = 0;
+  virtual udev_device* udev_device_get_parent(udev_device* udev_device) = 0;
+  virtual udev_device* udev_device_get_parent_with_subsystem_devtype(
+      udev_device* udev_device,
+      const char* subsystem,
+      const char* devtype) = 0;
+  virtual const char* udev_device_get_property_value(udev_device* udev_device,
+                                                     const char* key) = 0;
+  virtual const char* udev_device_get_subsystem(udev_device* udev_device) = 0;
+  virtual const char* udev_device_get_sysattr_value(udev_device* udev_device,
+                                                    const char* sysattr) = 0;
+  virtual const char* udev_device_get_sysname(udev_device* udev_device) = 0;
+  virtual const char* udev_device_get_syspath(udev_device* udev_device) = 0;
+  virtual udev_device* udev_device_new_from_devnum(udev* udev,
+                                                   char type,
+                                                   dev_t devnum) = 0;
+  virtual udev_device* udev_device_new_from_syspath(udev* udev,
+                                                    const char* syspath) = 0;
+  virtual void udev_device_unref(udev_device* udev_device) = 0;
+  virtual int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
+                                                 const char* subsystem) = 0;
+  virtual udev_list_entry* udev_enumerate_get_list_entry(
+      udev_enumerate* udev_enumerate) = 0;
+  virtual udev_enumerate* udev_enumerate_new(udev* udev) = 0;
+  virtual int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) = 0;
+  virtual void udev_enumerate_unref(udev_enumerate* udev_enumerate) = 0;
+  virtual udev_list_entry* udev_list_entry_get_next(
+      udev_list_entry* list_entry) = 0;
+  virtual const char* udev_list_entry_get_name(udev_list_entry* list_entry) = 0;
+  virtual int udev_monitor_enable_receiving(udev_monitor* udev_monitor) = 0;
+  virtual int udev_monitor_filter_add_match_subsystem_devtype(
+      udev_monitor* udev_monitor,
+      const char* subsystem,
+      const char* devtype) = 0;
+  virtual int udev_monitor_get_fd(udev_monitor* udev_monitor) = 0;
+  virtual udev_monitor* udev_monitor_new_from_netlink(udev* udev,
+                                                      const char* name) = 0;
+  virtual udev_device* udev_monitor_receive_device(
+      udev_monitor* udev_monitor) = 0;
+  virtual void udev_monitor_unref(udev_monitor* udev_monitor) = 0;
+  virtual udev* udev_new() = 0;
+  virtual void udev_set_log_fn(
+      struct udev* udev,
+      void (*log_fn)(struct udev* udev, int priority,
+                     const char* file, int line,
+                     const char* fn, const char* format, va_list args)) = 0;
+  virtual void udev_set_log_priority(struct udev* udev, int priority) = 0;
+  virtual void udev_unref(udev* udev) = 0;
+};
+
+}  // namespace device
+
+#endif  // DEVICE_UDEV_LINUX_UDEV_LOADER_H_
diff --git a/device/usb/BUILD.gn b/device/usb/BUILD.gn
index e12e745..d310a95 100644
--- a/device/usb/BUILD.gn
+++ b/device/usb/BUILD.gn
@@ -39,7 +39,7 @@ source_set("usb") {
   ]
 
   if (is_linux) {
-    configs += [ "//build/config/linux:udev" ]
+    deps += [ "//device/udev_linux" ]
   }
 }
 
diff --git a/device/usb/usb.gyp b/device/usb/usb.gyp
index f0b5275..a73bbe2 100644
--- a/device/usb/usb.gyp
+++ b/device/usb/usb.gyp
@@ -62,7 +62,7 @@
       'conditions': [
         ['use_udev == 1', {
           'dependencies': [
-            '../../build/linux/system.gyp:udev',
+            '../udev_linux/udev.gyp:udev_linux',
           ],
         }],
         ['chromeos==1', {
diff --git a/third_party/libusb/BUILD.gn b/third_party/libusb/BUILD.gn
index 0d04ef5..30ae077 100644
--- a/third_party/libusb/BUILD.gn
+++ b/third_party/libusb/BUILD.gn
@@ -24,7 +24,7 @@ static_library("libusb") {
     "src/libusb/libusbi.h",
     "src/libusb/os/darwin_usb.c",
     "src/libusb/os/darwin_usb.h",
-    "src/libusb/os/linux_udev.c",
+    "src/libusb/os/linux_udev.cc",
     "src/libusb/os/linux_usbfs.c",
     "src/libusb/os/linux_usbfs.h",
     "src/libusb/os/poll_posix.c",
@@ -46,6 +46,7 @@ static_library("libusb") {
     "src/msvc/inttypes.h",
     "src/msvc/stdint.h",
   ]
+  deps = []
   include_dirs = [
     "src/libusb/os",
   ]
@@ -83,10 +84,10 @@ static_library("libusb") {
       "USE_UDEV=1",
       "_GNU_SOURCE=1",
     ]
-    configs += [ "//build/config/linux:udev" ]
+    deps += [ "//build/config/linux:udev" ]
   } else {
     sources -= [
-      "src/libusb/os/linux_udev.c",
+      "src/libusb/os/linux_udev.cc",
       "src/libusb/os/linux_usbfs.c",
       "src/libusb/os/linux_usbfs.h",
     ]
diff --git a/third_party/libusb/README.chromium b/third_party/libusb/README.chromium
index fd52246..c00bdd2 100644
--- a/third_party/libusb/README.chromium
+++ b/third_party/libusb/README.chromium
@@ -17,3 +17,4 @@ Local Modifications:
 - windows-build.patch has been applied.
 - darwin-sigfpe.patch has been applied.
 - upstream-tick147.patch has been applied.
+- linux-udev.patch has been applied.
diff --git a/third_party/libusb/libusb.gyp b/third_party/libusb/libusb.gyp
index ee6c22e..21ce243 100644
--- a/third_party/libusb/libusb.gyp
+++ b/third_party/libusb/libusb.gyp
@@ -63,12 +63,18 @@
         }],
         ['use_udev==1', {
           'sources': [
-            'src/libusb/os/linux_udev.c',
+            'src/libusb/os/linux_udev.cc',
           ],
           'defines': [
             'HAVE_LIBUDEV=1',
             'USE_UDEV=1',
           ],
+          'dependencies': [
+            '../../device/udev_linux/udev.gyp:udev_linux',
+          ],
+          'include_dirs': [
+            '../..',
+          ],
         }],
         ['OS=="linux" and use_udev==0', {
           'sources': [
diff --git a/third_party/libusb/linux-udev.patch b/third_party/libusb/linux-udev.patch
new file mode 100644
index 0000000..93249c0
--- /dev/null
+++ b/third_party/libusb/linux-udev.patch
@@ -0,0 +1,209 @@
+Index: third_party/libusb/src/libusb/os/linux_udev.cc
+diff --git a/third_party/libusb/src/libusb/os/linux_udev.c b/third_party/libusb/src/libusb/os/linux_udev.cc
+similarity index 83%
+rename from third_party/libusb/src/libusb/os/linux_udev.c
+rename to third_party/libusb/src/libusb/os/linux_udev.cc
+index 99ac943410557de1a5cdd54082932db972040c2c..1b51ce44f4973c39b906d472b2a0cab51f987d3c 100644
+--- a/third_party/libusb/src/libusb/os/linux_udev.c
++++ b/third_party/libusb/src/libusb/os/linux_udev.cc
+@@ -37,11 +37,14 @@
+ #include <sys/utsname.h>
+ #include <sys/socket.h>
+ #include <unistd.h>
+-#include <libudev.h>
+ 
++extern "C" {
+ #include "libusb.h"
+ #include "libusbi.h"
+ #include "linux_usbfs.h"
++}
++
++#include "device/udev_linux/udev.h"
+ 
+ /* udev context */
+ static struct udev *udev_ctx = NULL;
+@@ -58,30 +61,30 @@ int linux_udev_start_event_monitor(void)
+ 	int r;
+ 
+ 	assert(udev_ctx == NULL);
+-	udev_ctx = udev_new();
++	udev_ctx = device::udev_new();
+ 	if (!udev_ctx) {
+ 		usbi_err(NULL, "could not create udev context");
+ 		return LIBUSB_ERROR_OTHER;
+ 	}
+ 
+-	udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
++	udev_monitor = device::udev_monitor_new_from_netlink(udev_ctx, "udev");
+ 	if (!udev_monitor) {
+ 		usbi_err(NULL, "could not initialize udev monitor");
+ 		goto err_free_ctx;
+ 	}
+ 
+-	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);
++	r = device::udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);
+ 	if (r) {
+ 		usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
+ 		goto err_free_monitor;
+ 	}
+ 
+-	if (udev_monitor_enable_receiving(udev_monitor)) {
++	if (device::udev_monitor_enable_receiving(udev_monitor)) {
+ 		usbi_err(NULL, "failed to enable the udev monitor");
+ 		goto err_free_monitor;
+ 	}
+ 
+-	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
++	udev_monitor_fd = device::udev_monitor_get_fd(udev_monitor);
+ 
+ 	/* Some older versions of udev are not non-blocking by default,
+ 	 * so make sure this is set */
+@@ -114,11 +117,11 @@ err_close_pipe:
+ 	close(udev_control_pipe[0]);
+ 	close(udev_control_pipe[1]);
+ err_free_monitor:
+-	udev_monitor_unref(udev_monitor);
++	device::udev_monitor_unref(udev_monitor);
+ 	udev_monitor = NULL;
+ 	udev_monitor_fd = -1;
+ err_free_ctx:
+-	udev_unref(udev_ctx);
++	device::udev_unref(udev_ctx);
+ 	udev_ctx = NULL;
+ 	return LIBUSB_ERROR_OTHER;
+ }
+@@ -141,12 +144,12 @@ int linux_udev_stop_event_monitor(void)
+ 	pthread_join(linux_event_thread, NULL);
+ 
+ 	/* Release the udev monitor */
+-	udev_monitor_unref(udev_monitor);
++	device::udev_monitor_unref(udev_monitor);
+ 	udev_monitor = NULL;
+ 	udev_monitor_fd = -1;
+ 
+ 	/* Clean up the udev context */
+-	udev_unref(udev_ctx);
++	device::udev_unref(udev_ctx);
+ 	udev_ctx = NULL;
+ 
+ 	/* close and reset control pipe */
+@@ -183,7 +186,7 @@ static void *linux_udev_event_thread_main(void *arg)
+ 		}
+ 		if (fds[1].revents & POLLIN) {
+ 			usbi_mutex_static_lock(&linux_hotplug_lock);
+-			udev_dev = udev_monitor_receive_device(udev_monitor);
++			udev_dev = device::udev_monitor_receive_device(udev_monitor);
+ 			if (udev_dev)
+ 				udev_hotplug_event(udev_dev);
+ 			usbi_mutex_static_unlock(&linux_hotplug_lock);
+@@ -200,12 +203,12 @@ static int udev_device_info(struct libusb_context *ctx, int detached,
+ 			    uint8_t *devaddr, const char **sys_name) {
+ 	const char *dev_node;
+ 
+-	dev_node = udev_device_get_devnode(udev_dev);
++	dev_node = device::udev_device_get_devnode(udev_dev);
+ 	if (!dev_node) {
+ 		return LIBUSB_ERROR_OTHER;
+ 	}
+ 
+-	*sys_name = udev_device_get_sysname(udev_dev);
++	*sys_name = device::udev_device_get_sysname(udev_dev);
+ 	if (!*sys_name) {
+ 		return LIBUSB_ERROR_OTHER;
+ 	}
+@@ -223,7 +226,7 @@ static void udev_hotplug_event(struct udev_device* udev_dev)
+ 	int r;
+ 
+ 	do {
+-		udev_action = udev_device_get_action(udev_dev);
++		udev_action = device::udev_device_get_action(udev_dev);
+ 		if (!udev_action) {
+ 			break;
+ 		}
+@@ -246,7 +249,7 @@ static void udev_hotplug_event(struct udev_device* udev_dev)
+ 		}
+ 	} while (0);
+ 
+-	udev_device_unref(udev_dev);
++	device::udev_device_unref(udev_dev);
+ }
+ 
+ int linux_udev_scan_devices(struct libusb_context *ctx)
+@@ -259,33 +262,33 @@ int linux_udev_scan_devices(struct libusb_context *ctx)
+ 
+ 	assert(udev_ctx != NULL);
+ 
+-	enumerator = udev_enumerate_new(udev_ctx);
++	enumerator = device::udev_enumerate_new(udev_ctx);
+ 	if (NULL == enumerator) {
+ 		usbi_err(ctx, "error creating udev enumerator");
+ 		return LIBUSB_ERROR_OTHER;
+ 	}
+ 
+-	udev_enumerate_add_match_subsystem(enumerator, "usb");
+-	udev_enumerate_scan_devices(enumerator);
+-	devices = udev_enumerate_get_list_entry(enumerator);
++	device::udev_enumerate_add_match_subsystem(enumerator, "usb");
++	device::udev_enumerate_scan_devices(enumerator);
++	devices = device::udev_enumerate_get_list_entry(enumerator);
+ 
+ 	udev_list_entry_foreach(entry, devices) {
+-		const char *path = udev_list_entry_get_name(entry);
++		const char *path = device::udev_list_entry_get_name(entry);
+ 		uint8_t busnum = 0, devaddr = 0;
+ 
+-		udev_dev = udev_device_new_from_syspath(udev_ctx, path);
++		udev_dev = device::udev_device_new_from_syspath(udev_ctx, path);
+ 
+ 		r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
+ 		if (r) {
+-			udev_device_unref(udev_dev);
++			device::udev_device_unref(udev_dev);
+ 			continue;
+ 		}
+ 
+ 		linux_enumerate_device(ctx, busnum, devaddr, sys_name);
+-		udev_device_unref(udev_dev);
++		device::udev_device_unref(udev_dev);
+ 	}
+ 
+-	udev_enumerate_unref(enumerator);
++	device::udev_enumerate_unref(enumerator);
+ 
+ 	return LIBUSB_SUCCESS;
+ }
+@@ -296,7 +299,7 @@ void linux_udev_hotplug_poll(void)
+ 
+ 	usbi_mutex_static_lock(&linux_hotplug_lock);
+ 	do {
+-		udev_dev = udev_monitor_receive_device(udev_monitor);
++		udev_dev = device::udev_monitor_receive_device(udev_monitor);
+ 		if (udev_dev) {
+ 			usbi_dbg("Handling hotplug event from hotplug_poll");
+ 			udev_hotplug_event(udev_dev);
+Index: third_party/libusb/src/libusb/os/linux_usbfs.h
+diff --git a/third_party/libusb/src/libusb/os/linux_usbfs.h b/third_party/libusb/src/libusb/os/linux_usbfs.h
+index 1f5b191f4a745937efe52695d7dbaa949a15df08..eedeaaf3654f22ecaac9fd1332d32b2855450bce 100644
+--- a/third_party/libusb/src/libusb/os/linux_usbfs.h
++++ b/third_party/libusb/src/libusb/os/linux_usbfs.h
+@@ -159,10 +159,20 @@ struct usbfs_disconnect_claim {
+ extern usbi_mutex_static_t linux_hotplug_lock;
+ 
+ #if defined(HAVE_LIBUDEV)
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
+ int linux_udev_start_event_monitor(void);
+ int linux_udev_stop_event_monitor(void);
+ int linux_udev_scan_devices(struct libusb_context *ctx);
+ void linux_udev_hotplug_poll(void);
++
++#ifdef __cplusplus
++}
++#endif
++
+ #else
+ int linux_netlink_start_event_monitor(void);
+ int linux_netlink_stop_event_monitor(void);
diff --git a/third_party/libusb/src/libusb/os/linux_udev.c b/third_party/libusb/src/libusb/os/linux_udev.cc
index 99ac943..1b51ce4 100644
--- a/third_party/libusb/src/libusb/os/linux_udev.c
+++ b/third_party/libusb/src/libusb/os/linux_udev.cc
@@ -37,11 +37,14 @@
 #include <sys/utsname.h>
 #include <sys/socket.h>
 #include <unistd.h>
-#include <libudev.h>
 
+extern "C" {
 #include "libusb.h"
 #include "libusbi.h"
 #include "linux_usbfs.h"
+}
+
+#include "device/udev_linux/udev.h"
 
 /* udev context */
 static struct udev *udev_ctx = NULL;
@@ -58,30 +61,30 @@ int linux_udev_start_event_monitor(void)
 	int r;
 
 	assert(udev_ctx == NULL);
-	udev_ctx = udev_new();
+	udev_ctx = device::udev_new();
 	if (!udev_ctx) {
 		usbi_err(NULL, "could not create udev context");
 		return LIBUSB_ERROR_OTHER;
 	}
 
-	udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");
+	udev_monitor = device::udev_monitor_new_from_netlink(udev_ctx, "udev");
 	if (!udev_monitor) {
 		usbi_err(NULL, "could not initialize udev monitor");
 		goto err_free_ctx;
 	}
 
-	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);
+	r = device::udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);
 	if (r) {
 		usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
 		goto err_free_monitor;
 	}
 
-	if (udev_monitor_enable_receiving(udev_monitor)) {
+	if (device::udev_monitor_enable_receiving(udev_monitor)) {
 		usbi_err(NULL, "failed to enable the udev monitor");
 		goto err_free_monitor;
 	}
 
-	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
+	udev_monitor_fd = device::udev_monitor_get_fd(udev_monitor);
 
 	/* Some older versions of udev are not non-blocking by default,
 	 * so make sure this is set */
@@ -114,11 +117,11 @@ err_close_pipe:
 	close(udev_control_pipe[0]);
 	close(udev_control_pipe[1]);
 err_free_monitor:
-	udev_monitor_unref(udev_monitor);
+	device::udev_monitor_unref(udev_monitor);
 	udev_monitor = NULL;
 	udev_monitor_fd = -1;
 err_free_ctx:
-	udev_unref(udev_ctx);
+	device::udev_unref(udev_ctx);
 	udev_ctx = NULL;
 	return LIBUSB_ERROR_OTHER;
 }
@@ -141,12 +144,12 @@ int linux_udev_stop_event_monitor(void)
 	pthread_join(linux_event_thread, NULL);
 
 	/* Release the udev monitor */
-	udev_monitor_unref(udev_monitor);
+	device::udev_monitor_unref(udev_monitor);
 	udev_monitor = NULL;
 	udev_monitor_fd = -1;
 
 	/* Clean up the udev context */
-	udev_unref(udev_ctx);
+	device::udev_unref(udev_ctx);
 	udev_ctx = NULL;
 
 	/* close and reset control pipe */
@@ -183,7 +186,7 @@ static void *linux_udev_event_thread_main(void *arg)
 		}
 		if (fds[1].revents & POLLIN) {
 			usbi_mutex_static_lock(&linux_hotplug_lock);
-			udev_dev = udev_monitor_receive_device(udev_monitor);
+			udev_dev = device::udev_monitor_receive_device(udev_monitor);
 			if (udev_dev)
 				udev_hotplug_event(udev_dev);
 			usbi_mutex_static_unlock(&linux_hotplug_lock);
@@ -200,12 +203,12 @@ static int udev_device_info(struct libusb_context *ctx, int detached,
 			    uint8_t *devaddr, const char **sys_name) {
 	const char *dev_node;
 
-	dev_node = udev_device_get_devnode(udev_dev);
+	dev_node = device::udev_device_get_devnode(udev_dev);
 	if (!dev_node) {
 		return LIBUSB_ERROR_OTHER;
 	}
 
-	*sys_name = udev_device_get_sysname(udev_dev);
+	*sys_name = device::udev_device_get_sysname(udev_dev);
 	if (!*sys_name) {
 		return LIBUSB_ERROR_OTHER;
 	}
@@ -223,7 +226,7 @@ static void udev_hotplug_event(struct udev_device* udev_dev)
 	int r;
 
 	do {
-		udev_action = udev_device_get_action(udev_dev);
+		udev_action = device::udev_device_get_action(udev_dev);
 		if (!udev_action) {
 			break;
 		}
@@ -246,7 +249,7 @@ static void udev_hotplug_event(struct udev_device* udev_dev)
 		}
 	} while (0);
 
-	udev_device_unref(udev_dev);
+	device::udev_device_unref(udev_dev);
 }
 
 int linux_udev_scan_devices(struct libusb_context *ctx)
@@ -259,33 +262,33 @@ int linux_udev_scan_devices(struct libusb_context *ctx)
 
 	assert(udev_ctx != NULL);
 
-	enumerator = udev_enumerate_new(udev_ctx);
+	enumerator = device::udev_enumerate_new(udev_ctx);
 	if (NULL == enumerator) {
 		usbi_err(ctx, "error creating udev enumerator");
 		return LIBUSB_ERROR_OTHER;
 	}
 
-	udev_enumerate_add_match_subsystem(enumerator, "usb");
-	udev_enumerate_scan_devices(enumerator);
-	devices = udev_enumerate_get_list_entry(enumerator);
+	device::udev_enumerate_add_match_subsystem(enumerator, "usb");
+	device::udev_enumerate_scan_devices(enumerator);
+	devices = device::udev_enumerate_get_list_entry(enumerator);
 
 	udev_list_entry_foreach(entry, devices) {
-		const char *path = udev_list_entry_get_name(entry);
+		const char *path = device::udev_list_entry_get_name(entry);
 		uint8_t busnum = 0, devaddr = 0;
 
-		udev_dev = udev_device_new_from_syspath(udev_ctx, path);
+		udev_dev = device::udev_device_new_from_syspath(udev_ctx, path);
 
 		r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
 		if (r) {
-			udev_device_unref(udev_dev);
+			device::udev_device_unref(udev_dev);
 			continue;
 		}
 
 		linux_enumerate_device(ctx, busnum, devaddr, sys_name);
-		udev_device_unref(udev_dev);
+		device::udev_device_unref(udev_dev);
 	}
 
-	udev_enumerate_unref(enumerator);
+	device::udev_enumerate_unref(enumerator);
 
 	return LIBUSB_SUCCESS;
 }
@@ -296,7 +299,7 @@ void linux_udev_hotplug_poll(void)
 
 	usbi_mutex_static_lock(&linux_hotplug_lock);
 	do {
-		udev_dev = udev_monitor_receive_device(udev_monitor);
+		udev_dev = device::udev_monitor_receive_device(udev_monitor);
 		if (udev_dev) {
 			usbi_dbg("Handling hotplug event from hotplug_poll");
 			udev_hotplug_event(udev_dev);
diff --git a/third_party/libusb/src/libusb/os/linux_usbfs.h b/third_party/libusb/src/libusb/os/linux_usbfs.h
index 1f5b191..eedeaaf 100644
--- a/third_party/libusb/src/libusb/os/linux_usbfs.h
+++ b/third_party/libusb/src/libusb/os/linux_usbfs.h
@@ -159,10 +159,20 @@ struct usbfs_disconnect_claim {
 extern usbi_mutex_static_t linux_hotplug_lock;
 
 #if defined(HAVE_LIBUDEV)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 int linux_udev_start_event_monitor(void);
 int linux_udev_stop_event_monitor(void);
 int linux_udev_scan_devices(struct libusb_context *ctx);
 void linux_udev_hotplug_poll(void);
+
+#ifdef __cplusplus
+}
+#endif
+
 #else
 int linux_netlink_start_event_monitor(void);
 int linux_netlink_stop_event_monitor(void);
diff --git a/ui/events/ozone/device/udev/device_manager_udev.cc b/ui/events/ozone/device/udev/device_manager_udev.cc
index 7f86bee..e01e13b 100644
--- a/ui/events/ozone/device/udev/device_manager_udev.cc
+++ b/ui/events/ozone/device/udev/device_manager_udev.cc
@@ -4,8 +4,6 @@
 
 #include "ui/events/ozone/device/udev/device_manager_udev.h"
 
-#include <libudev.h>
-
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "ui/events/ozone/device/device_event.h"
@@ -15,7 +13,7 @@ namespace ui {
 
 namespace {
 
-const char* kSubsystems[] = {
+const char* const kSubsystems[] = {
   "input",
   "drm",
 };
@@ -51,23 +49,24 @@ void UdevLog(struct udev* udev,
 
 // Create libudev context.
 device::ScopedUdevPtr UdevCreate() {
-  struct udev* udev = udev_new();
+  struct udev* udev = device::udev_new();
   if (udev) {
-    udev_set_log_fn(udev, UdevLog);
-    udev_set_log_priority(udev, SYS_LOG_DEBUG);
+    device::udev_set_log_fn(udev, UdevLog);
+    device::udev_set_log_priority(udev, SYS_LOG_DEBUG);
   }
   return device::ScopedUdevPtr(udev);
 }
 
 // Start monitoring input device changes.
 device::ScopedUdevMonitorPtr UdevCreateMonitor(struct udev* udev) {
-  struct udev_monitor* monitor = udev_monitor_new_from_netlink(udev, "udev");
+  struct udev_monitor* monitor =
+      device::udev_monitor_new_from_netlink(udev, "udev");
   if (monitor) {
     for (size_t i = 0; i < arraysize(kSubsystems); ++i)
-      udev_monitor_filter_add_match_subsystem_devtype(
+      device::udev_monitor_filter_add_match_subsystem_devtype(
           monitor, kSubsystems[i], NULL);
 
-    if (udev_monitor_enable_receiving(monitor))
+    if (device::udev_monitor_enable_receiving(monitor))
       LOG(ERROR) << "Failed to start receiving events from udev";
   } else {
     LOG(ERROR) << "Failed to create udev monitor";
@@ -89,7 +88,7 @@ void DeviceManagerUdev::CreateMonitor() {
     return;
   monitor_ = UdevCreateMonitor(udev_.get());
   if (monitor_) {
-    int fd = udev_monitor_get_fd(monitor_.get());
+    int fd = device::udev_monitor_get_fd(monitor_.get());
     CHECK_GT(fd, 0);
     base::MessageLoopForUI::current()->WatchFileDescriptor(
         fd, true, base::MessagePumpLibevent::WATCH_READ, &controller_, this);
@@ -99,21 +98,22 @@ void DeviceManagerUdev::CreateMonitor() {
 void DeviceManagerUdev::ScanDevices(DeviceEventObserver* observer) {
   CreateMonitor();
 
-  device::ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_.get()));
+  device::ScopedUdevEnumeratePtr enumerate(
+      device::udev_enumerate_new(udev_.get()));
   if (!enumerate)
     return;
 
   for (size_t i = 0; i < arraysize(kSubsystems); ++i)
-    udev_enumerate_add_match_subsystem(enumerate.get(), kSubsystems[i]);
-  udev_enumerate_scan_devices(enumerate.get());
+    device::udev_enumerate_add_match_subsystem(enumerate.get(), kSubsystems[i]);
+  device::udev_enumerate_scan_devices(enumerate.get());
 
   struct udev_list_entry* devices =
-      udev_enumerate_get_list_entry(enumerate.get());
+      device::udev_enumerate_get_list_entry(enumerate.get());
   struct udev_list_entry* entry;
 
   udev_list_entry_foreach(entry, devices) {
-    device::ScopedUdevDevicePtr device(udev_device_new_from_syspath(
-        udev_.get(), udev_list_entry_get_name(entry)));
+    device::ScopedUdevDevicePtr device(device::udev_device_new_from_syspath(
+        udev_.get(), device::udev_list_entry_get_name(entry)));
     if (!device)
       continue;
 
@@ -137,7 +137,7 @@ void DeviceManagerUdev::OnFileCanReadWithoutBlocking(int fd) {
   TRACE_EVENT1("ozone", "UdevDeviceChange", "socket", fd);
 
   device::ScopedUdevDevicePtr device(
-      udev_monitor_receive_device(monitor_.get()));
+      device::udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
@@ -152,10 +152,12 @@ void DeviceManagerUdev::OnFileCanWriteWithoutBlocking(int fd) {
 }
 
 scoped_ptr<DeviceEvent> DeviceManagerUdev::ProcessMessage(udev_device* device) {
-  const char* path = udev_device_get_devnode(device);
-  const char* action = udev_device_get_action(device);
-  const char* hotplug = udev_device_get_property_value(device, "HOTPLUG");
-  const char* subsystem = udev_device_get_property_value(device, "SUBSYSTEM");
+  const char* path = device::udev_device_get_devnode(device);
+  const char* action = device::udev_device_get_action(device);
+  const char* hotplug =
+      device::udev_device_get_property_value(device, "HOTPLUG");
+  const char* subsystem =
+      device::udev_device_get_property_value(device, "SUBSYSTEM");
 
   if (!path || !subsystem)
     return scoped_ptr<DeviceEvent>();