Log errors from libusb.

components/usb_service/usb_device_handle_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_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "components/usb_service/usb_context.h"
 #include "components/usb_service/usb_device_impl.h"
+#include "components/usb_service/usb_error.h"
 #include "components/usb_service/usb_interface.h"
 #include "components/usb_service/usb_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 using content::BrowserThread;
 
 namespace usb_service {
 
 typedef libusb_device* PlatformUsbDevice;
@@ skipping 125 matching lines @@
     : handle_(handle),
       interface_number_(interface_number),
       alternate_setting_(0) {
 }
 
 UsbDeviceHandleImpl::InterfaceClaimer::~InterfaceClaimer() {
   libusb_release_interface(handle_->handle(), interface_number_);
 }
 
 bool UsbDeviceHandleImpl::InterfaceClaimer::Claim() const {
-  return libusb_claim_interface(handle_->handle(), interface_number_) == 0;
+  const int rv = libusb_claim_interface(handle_->handle(), interface_number_);
+  if (rv != LIBUSB_SUCCESS) {
+    LOG(ERROR) << "Failed to claim interface: " << ConvertErrorToString(rv);
+  }
+  return rv == LIBUSB_SUCCESS;
 }
 
 struct UsbDeviceHandleImpl::Transfer {
   Transfer();
   ~Transfer();
 
   UsbTransferType transfer_type;
   scoped_refptr<net::IOBuffer> buffer;
   scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> claimed_interface;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy;
@@ skipping 165 matching lines @@
 bool UsbDeviceHandleImpl::SetInterfaceAlternateSetting(
     const int interface_number,
     const int alternate_setting) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
   if (!ContainsKey(claimed_interfaces_, interface_number))
     return false;
   const int rv = libusb_set_interface_alt_setting(
       handle_, interface_number, alternate_setting);
-  if (rv == 0) {
+  if (rv == LIBUSB_SUCCESS) {
     claimed_interfaces_[interface_number]->set_alternate_setting(
         alternate_setting);
     RefreshEndpointMap();
-    return true;
+  } else {
+    LOG(ERROR) << "Failed to set interface (" << interface_number
+        << ", " << alternate_setting << "): " << ConvertErrorToString(rv);
   }
-  return false;
+  return rv == LIBUSB_SUCCESS;
 }
 
 bool UsbDeviceHandleImpl::ResetDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
 
-  return libusb_reset_device(handle_) == 0;
+  const int rv = libusb_reset_device(handle_);
+  if (rv != LIBUSB_SUCCESS) {
+    LOG(ERROR) << "Failed to reset device: " << ConvertErrorToString(rv);
+  }
+  return rv == LIBUSB_SUCCESS;
 }
 
 bool UsbDeviceHandleImpl::GetSerial(base::string16* serial) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDevice device = libusb_get_device(handle_);
   libusb_device_descriptor desc;
 
-  if (libusb_get_device_descriptor(device, &desc) != LIBUSB_SUCCESS)
+  const int rv = libusb_get_device_descriptor(device, &desc);
+  if (rv != LIBUSB_SUCCESS) {
+    LOG(ERROR) << "Failed to read device descriptor: "
+        << ConvertErrorToString(rv);
     return false;
+  }
 
   if (desc.iSerialNumber == 0)
     return false;
 
   // Getting supported language ID.
   uint16 langid[128] = {0};
 
   int size =
       libusb_get_string_descriptor(handle_,
                                    0,
                                    0,
                                    reinterpret_cast<unsigned char*>(&langid[0]),
                                    sizeof(langid));
-  if (size < 0)
+  if (size < 0) {
+    LOG(ERROR) << "Failed to get language IDs: "
+        << ConvertErrorToString(size);
     return false;
+  }
 
   int language_count = (size - 2) / 2;
 
   for (int i = 1; i <= language_count; ++i) {
     // Get the string using language ID.
     base::char16 text[256] = {0};
     size =
         libusb_get_string_descriptor(handle_,
                                      desc.iSerialNumber,
                                      langid[i],
                                      reinterpret_cast<unsigned char*>(&text[0]),
                                      sizeof(text));
+    if (size < 0) {
+      LOG(ERROR) << "Failed to get serial number (langid " << langid[i] << "): "
+          << ConvertErrorToString(size);
+      continue;
+    }
     if (size <= 2)
       continue;
     if ((text[0] >> 8) != LIBUSB_DT_STRING)
       continue;
     if ((text[0] & 255) > size)
       continue;
 
     size = size / 2 - 1;
     *serial = base::string16(text + 1, size);
     return true;
@@ skipping 211 matching lines @@
   transfer.transfer_type = transfer_type;
   transfer.buffer = buffer;
   transfer.length = length;
   transfer.callback = callback;
   transfer.message_loop_proxy = message_loop_proxy;
 
   // It's OK for this method to return NULL. libusb_submit_transfer will fail if
   // it requires an interface we didn't claim.
   transfer.claimed_interface = GetClaimedInterfaceForEndpoint(handle->endpoint);
 
-  if (libusb_submit_transfer(handle) == LIBUSB_SUCCESS) {
+  const int rv = libusb_submit_transfer(handle);
+  if (rv == LIBUSB_SUCCESS) {
     transfers_[handle] = transfer;
   } else {
+    LOG(ERROR) << "Failed to submit transfer: " << ConvertErrorToString(rv);
     message_loop_proxy->PostTask(
         FROM_HERE,
         base::Bind(
             callback, USB_TRANSFER_ERROR, make_scoped_refptr(buffer), 0));
   }
 }
 
 void UsbDeviceHandleImpl::InternalClose() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return;
 
   // Cancel all the transfers.
   for (TransferMap::iterator it = transfers_.begin(); it != transfers_.end();
        ++it) {
     // The callback will be called some time later.
     libusb_cancel_transfer(it->first);
   }
 
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace usb_service