Log errors from libusb.

components/usb_service/usb_service_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 "components/usb_service/usb_service.h"
 
 #include <map>
 #include <set>
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "components/usb_service/usb_context.h"
 #include "components/usb_service/usb_device_impl.h"
+#include "components/usb_service/usb_error.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 namespace usb_service {
 
 namespace {
 
 base::LazyInstance<scoped_ptr<UsbService> >::Leaky g_usb_service_instance =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 70 matching lines @@
     it->second->OnDisconnect();
   }
 }
 
 void UsbServiceImpl::RefreshDevices() {
   DCHECK(CalledOnValidThread());
 
   libusb_device** platform_devices = NULL;
   const ssize_t device_count =
       libusb_get_device_list(context_->context(), &platform_devices);
+  if (device_count < 0) {
+    LOG(ERROR) << "Failed to get device list: " <<
+        ConvertErrorToString(device_count);
+  }
 
   std::set<UsbDevice*> connected_devices;
   std::vector<PlatformUsbDevice> disconnected_devices;
 
   // Populates new devices.
   for (ssize_t i = 0; i < device_count; ++i) {
     if (!ContainsKey(devices_, platform_devices[i])) {
       libusb_device_descriptor descriptor;
+      const int rv =
+          libusb_get_device_descriptor(platform_devices[i], &descriptor);
       // This test is needed. A valid vendor/produce pair is required.
-      if (0 != libusb_get_device_descriptor(platform_devices[i], &descriptor))
+      if (rv != LIBUSB_SUCCESS) {
+        LOG(WARNING) << "Failed to get device descriptor: "
+            << ConvertErrorToString(rv);
         continue;
+      }
       UsbDeviceImpl* new_device = new UsbDeviceImpl(context_,
                                                     platform_devices[i],
                                                     descriptor.idVendor,
                                                     descriptor.idProduct,
                                                     ++next_unique_id_);
       devices_[platform_devices[i]] = new_device;
       connected_devices.insert(new_device);
     } else {
       connected_devices.insert(devices_[platform_devices[i]].get());
     }
@@ skipping 15 matching lines @@
 
   libusb_free_device_list(platform_devices, true);
 }
 
 // static
 UsbService* UsbService::GetInstance() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   UsbService* instance = g_usb_service_instance.Get().get();
   if (!instance) {
     PlatformUsbContext context = NULL;
-    if (libusb_init(&context) != LIBUSB_SUCCESS)
+
+    const int rv = libusb_init(&context);
+    if (rv != LIBUSB_SUCCESS) {
+      LOG(ERROR) << "Failed to initialize libusb: " << ConvertErrorToString(rv);
       return NULL;
+    }
     if (!context)
       return NULL;
 
     instance = new UsbServiceImpl(context);
     g_usb_service_instance.Get().reset(instance);
   }
   return instance;
 }
 
 // static
 void UsbService::SetInstanceForTest(UsbService* instance) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   g_usb_service_instance.Get().reset(instance);
 }
 
 }  // namespace usb_service