Integrate WebUSB with Feature Policy

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"
@@ skipping 11 matching lines @@
 #include "chrome/browser/usb/web_usb_permission_provider.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;
 using device::UsbDevice;
 using device::UsbDeviceFilter;
 
 namespace {
 
@@ skipping 47 matching lines @@
     usb_service_observer_.Add(usb_service);
     usb_service->GetDevices(base::Bind(&UsbChooserController::GotUsbDeviceList,
                                        weak_factory_.GetWeakPtr()));
   }
 
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   RenderFrameHost* main_frame = web_contents->GetMainFrame();
   requesting_origin_ = render_frame_host->GetLastCommittedURL().GetOrigin();
   embedding_origin_ = main_frame->GetLastCommittedURL().GetOrigin();
-  is_embedded_frame_ = render_frame_host != main_frame;
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   chooser_context_ =
       UsbChooserContextFactory::GetForProfile(profile)->AsWeakPtr();
 }
 
 UsbChooserController::~UsbChooserController() {
   if (!callback_.is_null())
     callback_.Run(nullptr);
 }
@@ skipping 22 matching lines @@
                    devices_[index].first->serial_number());
 }
 
 bool UsbChooserController::IsPaired(size_t index) const {
   scoped_refptr<UsbDevice> device = devices_[index].first;
 
   if (!chooser_context_)
     return false;
 
   return WebUSBPermissionProvider::HasDevicePermission(
-      chooser_context_.get(), requesting_origin_, embedding_origin_,
-      is_embedded_frame_, device);
+      chooser_context_.get(), requesting_origin_, embedding_origin_, device);
 }
 
 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());
@@ skipping 70 matching lines @@
 }
 
 bool UsbChooserController::DisplayDevice(
     scoped_refptr<UsbDevice> device) const {
   if (!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.
-  if (is_embedded_frame_) {
-    return device::FindInWebUsbAllowedOrigins(device->webusb_allowed_origins(),
-                                              requesting_origin_, base::nullopt,
-                                              base::nullopt);
-  }
-
   return true;
 }