Allow top-level frames to request any USB device.

chrome/browser/usb/usb_chooser_controller.cc

 // Copyright 2015 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 "chrome/browser/usb/usb_chooser_controller.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/usb/usb_blocklist.h"
 #include "chrome/browser/usb/usb_chooser_context.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "chrome/browser/usb/web_usb_histograms.h"
 #include "chrome/browser/usb/web_usb_permission_provider.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "device/base/device_client.h"
 #include "device/usb/mojo/type_converters.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_ids.h"
 #include "device/usb/webusb_descriptors.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
+using content::RenderFrameHost;
+using content::WebContents;
+
 namespace {
 
 Browser* GetBrowser() {
   chrome::ScopedTabbedBrowserDisplayer browser_displayer(
       ProfileManager::GetActiveUserProfile());
   DCHECK(browser_displayer.browser());
   return browser_displayer.browser();
 }
 
 base::string16 GetDeviceName(scoped_refptr<device::UsbDevice> device) {
@@ skipping 16 matching lines @@
           base::ASCIIToUTF16(base::StringPrintf("%04x", product_id)));
     }
   }
 
   return device_name;
 }
 
 }  // namespace
 
 UsbChooserController::UsbChooserController(
-    content::RenderFrameHost* owner,
+    RenderFrameHost* render_frame_host,
     mojo::Array<device::usb::DeviceFilterPtr> device_filters,
-    content::RenderFrameHost* render_frame_host,
     const device::usb::ChooserService::GetPermissionCallback& callback)
-    : ChooserController(owner,
+    : ChooserController(render_frame_host,
                         IDS_USB_DEVICE_CHOOSER_PROMPT_ORIGIN,
                         IDS_USB_DEVICE_CHOOSER_PROMPT_EXTENSION_NAME),
       render_frame_host_(render_frame_host),
       callback_(callback),
       usb_service_observer_(this),
       weak_factory_(this) {
   device::UsbService* usb_service =
       device::DeviceClient::Get()->GetUsbService();
   if (!usb_service)
     return;
@@ skipping 45 matching lines @@
 void UsbChooserController::RefreshOptions() {}
 
 base::string16 UsbChooserController::GetStatus() const {
   return base::string16();
 }
 
 void UsbChooserController::Select(const std::vector<size_t>& indices) {
   DCHECK_EQ(1u, indices.size());
   size_t index = indices[0];
   DCHECK_LT(index, devices_.size());
-  content::WebContents* web_contents =
-      content::WebContents::FromRenderFrameHost(render_frame_host_);
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host_);
   GURL embedding_origin =
       web_contents->GetMainFrame()->GetLastCommittedURL().GetOrigin();
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   UsbChooserContext* chooser_context =
       UsbChooserContextFactory::GetForProfile(profile);
   chooser_context->GrantDevicePermission(
       render_frame_host_->GetLastCommittedURL().GetOrigin(), embedding_origin,
       devices_[index].first->guid());
 
@@ skipping 60 matching lines @@
       devices_.push_back(std::make_pair(device, device_name));
       ++device_name_map_[device_name];
     }
   }
   if (view())
     view()->OnOptionsInitialized();
 }
 
 bool UsbChooserController::DisplayDevice(
     scoped_refptr<device::UsbDevice> device) const {
-  return device::UsbDeviceFilter::MatchesAny(device, filters_) &&
-         !UsbBlocklist::Get().IsExcluded(device) &&
-         (base::CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableWebUsbSecurity) ||
-          device::FindInWebUsbAllowedOrigins(
-              device->webusb_allowed_origins(),
-              render_frame_host_->GetLastCommittedURL().GetOrigin()));
+  if (!device::UsbDeviceFilter::MatchesAny(device, filters_))
+    return false;
+
+  if (UsbBlocklist::Get().IsExcluded(device))
+    return false;
+
+  // Embedded frames must have their origin in the list provided by the device.
+  RenderFrameHost* main_frame =
+      WebContents::FromRenderFrameHost(render_frame_host_)->GetMainFrame();
+  if (render_frame_host_ != main_frame) {
+    return device::FindInWebUsbAllowedOrigins(
+        device->webusb_allowed_origins(),
+        render_frame_host_->GetLastCommittedURL().GetOrigin());
+  }
+
+  return true;
 }