Integrate WebUSB with Feature Policy

chrome/browser/usb/usb_tab_helper.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_tab_helper.h"
 
 #include <memory>
 #include <utility>
 
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/usb/web_usb_permission_provider.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/common/content_features.h"
 #include "device/usb/mojo/device_manager_impl.h"
+#include "mojo/public/cpp/bindings/message.h"
+#include "third_party/WebKit/public/platform/WebFeaturePolicy.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/usb/web_usb_chooser_service_android.h"
 #else
 #include "chrome/browser/usb/web_usb_chooser_service.h"
 #endif  // defined(OS_ANDROID)
 
 using content::RenderFrameHost;
 using content::WebContents;
 
+namespace {
+
+// The renderer performs its own feature policy checks so a request that gets
+// to the browser process indicates malicous code.
+const char kFeaturePolicyViolation[] =
+    "Feature policy blocks access to WebUSB.";
+
+}  // namespace
+
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(UsbTabHelper);
 
 struct FrameUsbServices {
   std::unique_ptr<WebUSBPermissionProvider> permission_provider;
 #if defined(OS_ANDROID)
   std::unique_ptr<WebUsbChooserServiceAndroid> chooser_service;
 #else
   std::unique_ptr<WebUsbChooserService> chooser_service;
 #endif  // defined(OS_ANDROID)
   int device_connection_count_ = 0;
 };
 
 // static
 UsbTabHelper* UsbTabHelper::GetOrCreateForWebContents(
     WebContents* web_contents) {
   UsbTabHelper* tab_helper = FromWebContents(web_contents);
   if (!tab_helper) {
     CreateForWebContents(web_contents);
     tab_helper = FromWebContents(web_contents);
   }
   return tab_helper;
 }
 
 UsbTabHelper::~UsbTabHelper() {}
 
 void UsbTabHelper::CreateDeviceManager(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<device::mojom::UsbDeviceManager> request) {
-  DCHECK(WebContents::FromRenderFrameHost(render_frame_host) == web_contents());
+  if (!AllowedByFeaturePolicy(render_frame_host)) {
+    mojo::ReportBadMessage(kFeaturePolicyViolation);
+    return;
+  }
   device::usb::DeviceManagerImpl::Create(
       GetPermissionProvider(render_frame_host), std::move(request));
 }
 
 void UsbTabHelper::CreateChooserService(
     content::RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<device::mojom::UsbChooserService> request) {
+  if (!AllowedByFeaturePolicy(render_frame_host)) {
+    mojo::ReportBadMessage(kFeaturePolicyViolation);
+    return;
+  }
   GetChooserService(render_frame_host, std::move(request));
 }
 
 void UsbTabHelper::IncrementConnectionCount(
     RenderFrameHost* render_frame_host) {
   auto it = frame_usb_services_.find(render_frame_host);
   DCHECK(it != frame_usb_services_.end());
   it->second->device_connection_count_++;
   NotifyTabStateChanged();
 }
@@ skipping 67 matching lines @@
 #if !defined(OS_ANDROID)
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
   if (browser) {
     TabStripModel* tab_strip_model = browser->tab_strip_model();
     tab_strip_model->UpdateWebContentsStateAt(
         tab_strip_model->GetIndexOfWebContents(web_contents()),
         TabStripModelObserver::ALL);
   }
 #endif
 }
+
+bool UsbTabHelper::AllowedByFeaturePolicy(
+    RenderFrameHost* render_frame_host) const {
+  DCHECK(WebContents::FromRenderFrameHost(render_frame_host) == web_contents());
+  if (base::FeatureList::IsEnabled(features::kFeaturePolicy)) {
+    return render_frame_host->IsFeatureEnabled(
+        blink::WebFeaturePolicyFeature::kUsb);
+  }
+  return web_contents()->GetMainFrame() == render_frame_host;
+}