Move string descriptor getters from UsbDeviceHandle to UsbDevice.

device/usb/usb_device_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/usb/usb_device_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/usb/usb_context.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle_impl.h"
 #include "device/usb/usb_error.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #endif  // defined(OS_CHROMEOS)
 
+#if defined(OS_LINUX)
+#include "device/udev_linux/udev.h"
+#endif  // defined(OS_LINUX)
+
 namespace device {
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 void OnRequestUsbAccessReplied(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const base::Callback<void(bool success)>& callback,
     bool success) {
   task_runner->PostTask(FROM_HERE, base::Bind(callback, success));
@@ skipping 80 matching lines @@
     uint16 vendor_id,
     uint16 product_id,
     uint32 unique_id)
     : UsbDevice(vendor_id, product_id, unique_id),
       platform_device_(platform_device),
       current_configuration_cached_(false),
       context_(context),
       ui_task_runner_(ui_task_runner) {
   CHECK(platform_device) << "platform_device cannot be NULL";
   libusb_ref_device(platform_device);
+
+#if defined(OS_LINUX)
+  ScopedUdevPtr udev(udev_new());
+  ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev.get()));
+
+  udev_enumerate_add_match_subsystem(enumerate.get(), "usb");
+  if (udev_enumerate_scan_devices(enumerate.get()) != 0) {
+    return;
+  }
+  std::string bus_number =
+      base::IntToString(libusb_get_bus_number(platform_device));
+  std::string device_address =
+      base::IntToString(libusb_get_device_address(platform_device));
+  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
+  for (udev_list_entry* i = devices; i != NULL;
+       i = udev_list_entry_get_next(i)) {
+    ScopedUdevDevicePtr device(
+        udev_device_new_from_syspath(udev.get(), udev_list_entry_get_name(i)));
+    if (device) {
+      const char* value = udev_device_get_sysattr_value(device.get(), "busnum");
+      if (!value || bus_number != value) {
+        continue;
+      }
+      value = udev_device_get_sysattr_value(device.get(), "devnum");
+      if (!value || device_address != value) {
+        continue;
+      }
+
+      value = udev_device_get_sysattr_value(device.get(), "manufacturer");
+      manufacturer_ = value ? value : "";
+      value = udev_device_get_sysattr_value(device.get(), "product");
+      product_ = value ? value : "";
+      value = udev_device_get_sysattr_value(device.get(), "serial");
+      serial_number_ = value ? value : "";
+      break;
+    }
+  }
+#endif
 }
 
 UsbDeviceImpl::~UsbDeviceImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (HandlesVector::iterator it = handles_.begin(); it != handles_.end();
        ++it) {
     (*it)->InternalClose();
   }
   STLClearObject(&handles_);
   libusb_unref_device(platform_device_);
@@ skipping 132 matching lines @@
         platform_config->extra,
         platform_config->extra + platform_config->extra_length);
 
     libusb_free_config_descriptor(platform_config);
     current_configuration_cached_ = true;
   }
 
   return current_configuration_;
 }
 
+bool UsbDeviceImpl::GetManufacturer(base::string16* manufacturer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+#if defined(OS_LINUX)
+  if (manufacturer_.empty()) {

[scheib, 2014/09/25 17:36:04]

Consider caching into manufacturer_ on all platforms. On OS_LINUX fail if not
cached.

[Reilly Grant (use Gerrit), 2014/09/25 17:58:44]

GetStringDescriptor caches for the other platforms.

+    return false;
+  }
+  *manufacturer = base::UTF8ToUTF16(manufacturer_);
+  return true;
+#else
+  // This is a non-blocking call as libusb has the descriptor in memory.
+  libusb_device_descriptor desc;
+  const int rv = libusb_get_device_descriptor(platform_device_, &desc);
+  if (rv != LIBUSB_SUCCESS) {
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
+    return false;
+  }
+
+  if (desc.iManufacturer == 0) {
+    return false;
+  }
+
+  scoped_refptr<UsbDeviceHandle> device_handle = Open();
+  if (device_handle.get()) {
+    return device_handle->GetStringDescriptor(desc.iManufacturer, manufacturer);
+  }
+  return false;
+#endif
+}
+
+bool UsbDeviceImpl::GetProduct(base::string16* product) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+#if defined(OS_LINUX)
+  if (product_.empty()) {
+    return false;
+  }
+  *product = base::UTF8ToUTF16(product_);
+  return true;
+#else
+  // This is a non-blocking call as libusb has the descriptor in memory.
+  libusb_device_descriptor desc;
+  const int rv = libusb_get_device_descriptor(platform_device_, &desc);
+  if (rv != LIBUSB_SUCCESS) {
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
+    return false;
+  }
+
+  if (desc.iProduct == 0) {
+    return false;
+  }
+
+  scoped_refptr<UsbDeviceHandle> device_handle = Open();
+  if (device_handle.get()) {
+    return device_handle->GetStringDescriptor(desc.iProduct, product);
+  }
+  return false;
+#endif
+}
+
+bool UsbDeviceImpl::GetSerialNumber(base::string16* serial_number) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+#if defined(OS_LINUX)
+  if (serial_number_.empty()) {
+    return false;
+  }
+  *serial_number = base::UTF8ToUTF16(serial_number_);
+  return true;
+#else
+  // This is a non-blocking call as libusb has the descriptor in memory.
+  libusb_device_descriptor desc;
+  const int rv = libusb_get_device_descriptor(platform_device_, &desc);
+  if (rv != LIBUSB_SUCCESS) {
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
+    return false;
+  }
+
+  if (desc.iSerialNumber == 0) {
+    return false;
+  }
+
+  scoped_refptr<UsbDeviceHandle> device_handle = Open();
+  if (device_handle.get()) {
+    return device_handle->GetStringDescriptor(desc.iSerialNumber,
+                                              serial_number);
+  }
+  return false;
+#endif
+}
+
 void UsbDeviceImpl::OnDisconnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
   HandlesVector handles;
   swap(handles, handles_);
   for (HandlesVector::iterator it = handles.begin(); it != handles.end(); ++it)
     (*it)->InternalClose();
 }
 
 }  // namespace device