Linux: Dynamically load libudev.

components/storage_monitor/storage_monitor_linux.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // StorageMonitorLinux implementation.
 
 #include "components/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
@@ skipping 81 matching lines @@
   bool result_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedGetDeviceInfoResultRecorder);
 };
 
 // Returns the storage partition size of the device specified by |device_path|.
 // If the requested information is unavailable, returns 0.
 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
   // unavailable.
   UMA_HISTOGRAM_BOOLEAN(
       "RemovableDeviceNotificationsLinux.device_partition_size_available",
       !partition_size.empty());
 
   uint64 total_size_in_bytes = 0;
   if (!base::StringToUint64(partition_size, &total_size_in_bytes))
     return 0;
   return (total_size_in_bytes <= kuint64max / 512) ?
       total_size_in_bytes * 512 : 0;
 }
 
 // Gets the device information using udev library.
 scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
                                       const base::FilePath& mount_point) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!device_path.empty());
 
   scoped_ptr<StorageInfo> storage_info;
 
   ScopedGetDeviceInfoResultRecorder results_recorder;
 
-  device::ScopedUdevPtr udev_obj(udev_new());
+  device::ScopedUdevPtr udev_obj(device::udev_new());
   if (!udev_obj.get())
     return storage_info.Pass();
 
   struct stat device_stat;
   if (stat(device_path.value().c_str(), &device_stat) < 0)
     return storage_info.Pass();
 
   char device_type;
   if (S_ISCHR(device_stat.st_mode))
     device_type = 'c';
   else if (S_ISBLK(device_stat.st_mode))
     device_type = 'b';
   else
     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();
 
   base::string16 volume_label =
       base::UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(), kLabel));
   base::string16 vendor_name =
       base::UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(), kVendor));
   base::string16 model_name =
       base::UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(), kModel));
 
   std::string unique_id = MakeDeviceUniqueId(device.get());
 
   // Keep track of device info details to see how often we get invalid values.
   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);
 
   StorageInfo::Type type = StorageInfo::FIXED_MASS_STORAGE;
   if (is_removable) {
     if (MediaStorageUtil::HasDcim(mount_point))
       type = StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
     else
       type = StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
   }
@@ skipping 316 matching lines @@
   mount_priority_map_[mount_device][mount_point] = removable;
   receiver()->ProcessAttach(*storage_info);
 }
 
 StorageMonitor* StorageMonitor::CreateInternal() {
   const base::FilePath kDefaultMtabPath("/etc/mtab");
   return new StorageMonitorLinux(kDefaultMtabPath);
 }
 
 }  // namespace storage_monitor