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

extensions/browser/api/device_permissions_prompt.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/device_permissions_prompt.h"
 
+#include "base/barrier_closure.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_ids.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using content::BrowserThread;
 using device::UsbDevice;
 using device::UsbDeviceFilter;
 using device::UsbService;
 
 namespace extensions {
 
 DevicePermissionsPrompt::Prompt::DeviceInfo::DeviceInfo(
     scoped_refptr<UsbDevice> device)
     : device(device) {
   base::string16 manufacturer_string;
@@ skipping 44 matching lines @@
       browser_context_(nullptr),
       multiple_(false),
       observer_(nullptr),
       usb_service_observer_(this) {
 }
 
 void DevicePermissionsPrompt::Prompt::SetObserver(Observer* observer) {
   observer_ = observer;
 
   if (observer_) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::FILE, FROM_HERE,
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
         base::Bind(&DevicePermissionsPrompt::Prompt::DoDeviceQuery, this));
   }
 }
 
 base::string16 DevicePermissionsPrompt::Prompt::GetHeading() const {
   return l10n_util::GetStringUTF16(
       multiple_ ? IDS_DEVICE_PERMISSIONS_PROMPT_TITLE_MULTIPLE
                 : IDS_DEVICE_PERMISSIONS_PROMPT_TITLE_SINGLE);
 }
 
@@ skipping 33 matching lines @@
 
 void DevicePermissionsPrompt::Prompt::DoDeviceQuery() {
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     return;
   }
 
   std::vector<scoped_refptr<UsbDevice>> devices;
   service->GetDevices(&devices);
 
-  std::vector<DeviceInfo> device_info;
-  for (const auto& device : devices) {
-    if (!(filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_))) {
-      continue;
-    }
-
-    device_info.push_back(DeviceInfo(device));
-  }
-
   if (!usb_service_observer_.IsObserving(service)) {
     usb_service_observer_.Add(service);
   }
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(
-          &DevicePermissionsPrompt::Prompt::SetDevices, this, device_info));
+  std::vector<DeviceInfo>* device_info = new std::vector<DeviceInfo>();
+  base::Closure barrier = base::BarrierClosure(
+      devices.size(),
+      base::Bind(&DevicePermissionsPrompt::Prompt::DeviceQueryComplete, this,
+                 base::Owned(device_info)));
+
+  for (const auto& device : devices) {
+    if (filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_)) {
+      device->CheckUsbAccess(
+          base::Bind(&DevicePermissionsPrompt::Prompt::AppendCheckedUsbDevice,
+                     this, device_info, device, barrier));
+    } else {
+      barrier.Run();
+    }
+  }
+}
+
+void DevicePermissionsPrompt::Prompt::AppendCheckedUsbDevice(
+    std::vector<DeviceInfo>* device_info,
+    scoped_refptr<UsbDevice> device,
+    const base::Closure& callback,
+    bool allowed) {
+  if (allowed) {
+    device_info->push_back(DeviceInfo(device));
+  }
+  callback.Run();
+}
+
+void DevicePermissionsPrompt::Prompt::AddCheckedUsbDevice(
+    scoped_refptr<UsbDevice> device,
+    bool allowed) {
+  if (allowed) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DevicePermissionsPrompt::Prompt::AddDevice, this,
+                   DeviceInfo(device)));
+  }
+}
+
+void DevicePermissionsPrompt::Prompt::DeviceQueryComplete(
+    std::vector<DeviceInfo>* device_info) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&DevicePermissionsPrompt::Prompt::SetDevices, this,
+                 *device_info));
 }
 
 void DevicePermissionsPrompt::Prompt::SetDevices(
     const std::vector<DeviceInfo>& devices) {
   devices_ = devices;
   if (observer_) {
     observer_->OnDevicesChanged();
   }
 }
 
@@ skipping 19 matching lines @@
     observer_->OnDevicesChanged();
   }
 }
 
 void DevicePermissionsPrompt::Prompt::OnDeviceAdded(
     scoped_refptr<UsbDevice> device) {
   if (!(filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_))) {
     return;
   }
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&DevicePermissionsPrompt::Prompt::AddDevice, this,
-                 DeviceInfo(device)));
+  device->CheckUsbAccess(base::Bind(
+      &DevicePermissionsPrompt::Prompt::AddCheckedUsbDevice, this, device));
 }
 
 void DevicePermissionsPrompt::Prompt::OnDeviceRemoved(
     scoped_refptr<UsbDevice> device) {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       base::Bind(&DevicePermissionsPrompt::Prompt::RemoveDevice, this, device));
 }
 
 DevicePermissionsPrompt::DevicePermissionsPrompt(
     content::WebContents* web_contents)
     : web_contents_(web_contents), delegate_(nullptr) {
 }
 
 DevicePermissionsPrompt::~DevicePermissionsPrompt() {
 }
 
 void DevicePermissionsPrompt::AskForUsbDevices(
     Delegate* delegate,
     const Extension* extension,
     content::BrowserContext* context,
     bool multiple,
     const std::vector<UsbDeviceFilter>& filters) {
   prompt_ = new Prompt();
   prompt_->set_extension(extension);
   prompt_->set_browser_context(context);
   prompt_->set_multiple(multiple);
   prompt_->set_filters(filters);
   delegate_ = delegate;
 
   ShowDialog();
 }
 
 }  // namespace extensions