Check USB device path access when prompting users to select a device.

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 "components/device_event_log/device_event_log.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(USE_UDEV)
 #include "device/udev_linux/scoped_udev.h"
 #endif  // defined(USE_UDEV)
 
 namespace device {
 
 namespace {
 
 #if defined(OS_CHROMEOS)
-void OnRequestUsbAccessReplied(
+
+void PostResultOnTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const base::Callback<void(bool success)>& callback,
     bool success) {
   task_runner->PostTask(FROM_HERE, base::Bind(callback, success));
 }
+
 #endif  // defined(OS_CHROMEOS)
 
 UsbEndpointDirection GetDirection(
     const libusb_endpoint_descriptor* descriptor) {
   switch (descriptor->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) {
     case LIBUSB_ENDPOINT_IN:
       return USB_DIRECTION_INBOUND;
     case LIBUSB_ENDPOINT_OUT:
       return USB_DIRECTION_OUTBOUND;
     default:
@@ skipping 118 matching lines @@
 #endif
 }
 
 UsbDeviceImpl::~UsbDeviceImpl() {
   // The destructor must be safe to call from any thread.
   libusb_unref_device(platform_device_);
 }
 
 #if defined(OS_CHROMEOS)
 
-void UsbDeviceImpl::RequestUsbAccess(
-    int interface_id,
-    const base::Callback<void(bool success)>& callback) {
+void UsbDeviceImpl::CheckUsbAccess(const ResultCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // ChromeOS builds on non-ChromeOS machines (dev) should not attempt to
-  // use permission broker.
-  if (base::SysInfo::IsRunningOnChromeOS()) {
-    chromeos::PermissionBrokerClient* client =
-        chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
-    DCHECK(client) << "Could not get permission broker client.";
-    if (!client) {
-      callback.Run(false);
-      return;
-    }
+  chromeos::PermissionBrokerClient* client =
+      chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
+  DCHECK(client) << "Could not get permission broker client.";
 
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&chromeos::PermissionBrokerClient::RequestPathAccess,
-                   base::Unretained(client),
-                   devnode_,
-                   interface_id,
-                   base::Bind(&OnRequestUsbAccessReplied,
-                              base::ThreadTaskRunnerHandle::Get(),
-                              callback)));
-  } else {
-    // Not really running on Chrome OS, declare success.
-    callback.Run(true);
-  }
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&chromeos::PermissionBrokerClient::CheckPathAccess,
+                 base::Unretained(client), devnode_,
+                 base::Bind(&PostResultOnTaskRunner,
+                            base::ThreadTaskRunnerHandle::Get(), callback)));
+}
+
+void UsbDeviceImpl::RequestUsbAccess(int interface_id,
+                                     const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  chromeos::PermissionBrokerClient* client =
+      chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
+  DCHECK(client) << "Could not get permission broker client.";
+
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&chromeos::PermissionBrokerClient::RequestPathAccess,
+                 base::Unretained(client), devnode_, interface_id,
+                 base::Bind(&PostResultOnTaskRunner,
+                            base::ThreadTaskRunnerHandle::Get(), callback)));
 }
 
 #endif
 
 scoped_refptr<UsbDeviceHandle> UsbDeviceImpl::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDeviceHandle handle;
   const int rv = libusb_open(platform_device_, &handle);
   if (LIBUSB_SUCCESS == rv) {
     scoped_refptr<UsbDeviceHandleImpl> device_handle =
@@ skipping 168 matching lines @@
   } else {
     USB_LOG(EVENT)
         << "Failed to read device descriptor to cache string descriptors: "
         << ConvertPlatformUsbErrorToString(rv);
   }
   strings_cached_ = true;
 }
 #endif  // !defined(USE_UDEV)
 
 }  // namespace device