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

extensions/browser/api/usb/usb_api.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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 224 matching lines @@
     case device::USB_TRANSFER_OVERFLOW:
       return kErrorOverflow;
     case device::USB_TRANSFER_LENGTH_SHORT:
       return kErrorTransferLength;
     default:
       NOTREACHED();
       return "";
   }
 }
 
-#if defined(OS_CHROMEOS)
 void RequestUsbDevicesAccessHelper(
     ScopedDeviceVector devices,
     std::vector<scoped_refptr<UsbDevice> >::iterator i,
     int interface_id,
     const base::Callback<void(ScopedDeviceVector result)>& callback,
     bool success) {
   if (success) {
     ++i;
   } else {
     i = devices->erase(i);
@@ skipping 19 matching lines @@
     return;
   }
   std::vector<scoped_refptr<UsbDevice> >::iterator i = devices->begin();
   (*i)->RequestUsbAccess(interface_id,
                          base::Bind(RequestUsbDevicesAccessHelper,
                                     base::Passed(devices.Pass()),
                                     i,
                                     interface_id,
                                     callback));
 }
-#endif  // OS_CHROMEOS
 
 base::DictionaryValue* CreateTransferInfo(UsbTransferStatus status,
                                           scoped_refptr<net::IOBuffer> data,
                                           size_t length) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, status);
   result->Set(kDataKey,
               base::BinaryValue::CreateWithCopiedBuffer(data->data(), length));
   return result;
 }
@@ skipping 297 matching lines @@
   service->GetDevices(devices.get());
 
   for (DeviceVector::iterator it = devices->begin(); it != devices->end();) {
     if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
       it = devices->erase(it);
     } else {
       ++it;
     }
   }
 
-#if defined(OS_CHROMEOS)
   RequestUsbDevicesAccess(
       devices.Pass(),
       interface_id,
       base::Bind(&UsbFindDevicesFunction::OpenDevices, this));
-#else
-  OpenDevices(devices.Pass());
-#endif  // OS_CHROMEOS
 }
 
 void UsbFindDevicesFunction::OpenDevices(ScopedDeviceVector devices) {
   base::ListValue* result = new base::ListValue();
 
   for (size_t i = 0; i < devices->size(); ++i) {
     scoped_refptr<UsbDeviceHandle> device_handle = devices->at(i)->Open();
     if (device_handle.get())
       device_handles_.push_back(device_handle);
   }
@@ skipping 164 matching lines @@
     return;
   }
 
   if (!HasDevicePermission(device_)) {
     // This function must act as if there is no such device. Otherwise it can be
     // used to fingerprint unauthorized devices.
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-#if defined(OS_CHROMEOS)
   device_->RequestUsbAccess(
       -1, /* any interface, unused by the permission broker */
       base::Bind(&UsbOpenDeviceFunction::OnRequestAccessComplete, this));
-#else
-  OnRequestAccessComplete(true);
-#endif  // OS_CHROMEOS
 }
 
 void UsbOpenDeviceFunction::OnRequestAccessComplete(bool success) {
   if (!success) {
     SetError(kErrorPermissionDenied);
     AsyncWorkCompleted();
     return;
   }
 
   scoped_refptr<UsbDeviceHandle> handle = device_->Open();
@@ skipping 463 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions