Add path open errors from the permission broker to the device log.

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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 178 matching lines @@
 
 void UsbDeviceImpl::Open(const OpenCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
   client->OpenPath(
       device_path_,
-      base::Bind(&UsbDeviceImpl::OnOpenRequestComplete, this, callback));
+      base::Bind(&UsbDeviceImpl::OnOpenRequestComplete, this, callback),
+      base::Bind(&UsbDeviceImpl::OnOpenRequestError, this, callback));
 #else
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UsbDeviceImpl::OpenOnBlockingThread, this, callback));
 #endif  // defined(OS_CHROMEOS)
 }
 
 void UsbDeviceImpl::Close(scoped_refptr<UsbDeviceHandle> handle) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 74 matching lines @@
 
 #if defined(OS_CHROMEOS)
 
 void UsbDeviceImpl::OnOpenRequestComplete(const OpenCallback& callback,
                                           dbus::FileDescriptor fd) {
   blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceImpl::OpenOnBlockingThreadWithFd, this,
                             base::Passed(&fd), callback));
 }
 
+void UsbDeviceImpl::OnOpenRequestError(const OpenCallback& callback,
+                                       const std::string& error_name,
+                                       const std::string& error_message) {
+  USB_LOG(EVENT) << "Permission broker failed to open the device: "
+                 << error_name << ": " << error_message;
+  callback.Run(nullptr);
+}
+
 void UsbDeviceImpl::OpenOnBlockingThreadWithFd(dbus::FileDescriptor fd,
                                                const OpenCallback& callback) {
   fd.CheckValidity();
-  if (!fd.is_valid()) {
-    USB_LOG(EVENT) << "Did not get valid device handle from permission broker.";
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
-    return;
-  }
+  DCHECK(fd.is_valid());
 
   PlatformUsbDeviceHandle handle;
   const int rv = libusb_open_fd(platform_device_, fd.TakeValue(), &handle);
   if (LIBUSB_SUCCESS == rv) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbDeviceImpl::Opened, this, handle, callback));
   } else {
     USB_LOG(EVENT) << "Failed to open device: "
                    << ConvertPlatformUsbErrorToString(rv);
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
@@ skipping 18 matching lines @@
 void UsbDeviceImpl::Opened(PlatformUsbDeviceHandle platform_handle,
                            const OpenCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<UsbDeviceHandleImpl> device_handle = new UsbDeviceHandleImpl(
       context_, this, platform_handle, blocking_task_runner_);
   handles_.push_back(device_handle);
   callback.Run(device_handle);
 }
 
 }  // namespace device