Cache important USB string descriptors all at once.

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"
@@ skipping 140 matching lines @@
       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 : "";
+      if (value) {
+        manufacturer_ = base::UTF8ToUTF16(value);
+      }
       value = udev_device_get_sysattr_value(device.get(), "product");
-      product_ = value ? value : "";
+      if (value) {
+        product_ = base::UTF8ToUTF16(value);
+      }
       value = udev_device_get_sysattr_value(device.get(), "serial");
-      serial_number_ = value ? value : "";
+      if (value) {
+        serial_number_ = base::UTF8ToUTF16(value);
+      }
       break;
     }
   }
+#else
+  strings_cached_ = false;
 #endif
 }
 
 UsbDeviceImpl::~UsbDeviceImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (HandlesVector::iterator it = handles_.begin(); it != handles_.end();
        ++it) {
     (*it)->InternalClose();
   }
   STLClearObject(&handles_);
@@ skipping 33 matching lines @@
 
 #endif
 
 scoped_refptr<UsbDeviceHandle> UsbDeviceImpl::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDeviceHandle handle;
   const int rv = libusb_open(platform_device_, &handle);
   if (LIBUSB_SUCCESS == rv) {
     GetConfiguration();
     if (!current_configuration_cached_) {
+      libusb_close(handle);
       return NULL;
     }
     scoped_refptr<UsbDeviceHandleImpl> device_handle =
         new UsbDeviceHandleImpl(context_, this, handle, current_configuration_);
     handles_.push_back(device_handle);
     return device_handle;
   } else {
     VLOG(1) << "Failed to open device: " << ConvertPlatformUsbErrorToString(rv);
     return NULL;
   }
@@ skipping 83 matching lines @@
     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(USE_UDEV)
-  if (manufacturer_.empty()) {
-    return false;
+#if !defined(USE_UDEV)
+  if (!strings_cached_) {
+    CacheStrings();
   }
-  *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;
-  }
+#endif
 
-  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
+  *manufacturer = manufacturer_;
+  return !manufacturer_.empty();
 }
 
 bool UsbDeviceImpl::GetProduct(base::string16* product) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if defined(USE_UDEV)
-  if (product_.empty()) {
-    return false;
+#if !defined(USE_UDEV)
+  if (!strings_cached_) {
+    CacheStrings();
   }
-  *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;
-  }
+#endif
 
-  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
+  *product = product_;
+  return !product_.empty();
 }
 
 bool UsbDeviceImpl::GetSerialNumber(base::string16* serial_number) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#if defined(USE_UDEV)
-  if (serial_number_.empty()) {
-    return false;
+#if !defined(USE_UDEV)
+  if (!strings_cached_) {
+    CacheStrings();
   }
-  *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;
-  }
+#endif
 
-  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
+  *serial_number = serial_number_;
+  return !serial_number_.empty();
 }
 
 void UsbDeviceImpl::OnDisconnect() {
   DCHECK(thread_checker_.CalledOnValidThread());
   HandlesVector handles;
   swap(handles, handles_);
   for (HandlesVector::iterator it = handles.begin(); it != handles.end(); ++it)
     (*it)->InternalClose();
 }
 
+#if !defined(USE_UDEV)
+void UsbDeviceImpl::CacheStrings() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // 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) {
+    scoped_refptr<UsbDeviceHandle> device_handle = Open();
+    if (device_handle.get()) {
+      if (desc.iManufacturer != 0) {
+        device_handle->GetStringDescriptor(desc.iManufacturer, &manufacturer_);
+      }
+      if (desc.iProduct != 0) {
+        device_handle->GetStringDescriptor(desc.iProduct, &product_);
+      }
+      if (desc.iSerialNumber != 0) {
+        device_handle->GetStringDescriptor(desc.iSerialNumber, &serial_number_);
+      }
+      device_handle->Close();
+    } else {
+      VLOG(1) << "Failed to open device to cache string descriptors.";
+    }
+  } else {
+    VLOG(1) << "Failed to read device descriptor to cache string descriptors: "
+            << ConvertPlatformUsbErrorToString(rv);
+  }
+  strings_cached_ = true;
+}
+#endif  // !defined(USE_UDEV)
+
 }  // namespace device