Put WebUSB interface factories in ContentBrowserClient

Because Blink depends on the WebUSB interfaces directly they shouldn't
be part of chrome_content_browser_manifest_overlay.json and should
instead be part of content_browser_manifest.json. Since these are still
implemented by Chrome and not //content the factory methods are moved
into ContentBrowserClient.

Change-Id: Ic34008eccca45dd24bace5afee8fff478bb9ba6d
Reviewed-on: https://chromium-review.googlesource.com/828025Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524443}

chrome/browser/chrome_content_browser_client.cc

@@ -731,49 +731,6 @@ AppLoadedInTabSource ClassifyAppLoadedInTabSource(
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
-void CreateUsbDeviceManager(device::mojom::UsbDeviceManagerRequest request,
-                            content::RenderFrameHost* render_frame_host) {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-  if (render_frame_host->GetSiteInstance()->GetSiteURL().SchemeIs(
-          extensions::kExtensionScheme)) {
-    return;
-  }
-#endif
-
-  WebContents* web_contents =
-      WebContents::FromRenderFrameHost(render_frame_host);
-  if (!web_contents) {
-    NOTREACHED();
-    return;
-  }
-
-  UsbTabHelper* tab_helper =
-      UsbTabHelper::GetOrCreateForWebContents(web_contents);
-  tab_helper->CreateDeviceManager(render_frame_host, std::move(request));
-}
-
-void CreateWebUsbChooserService(
-    device::mojom::UsbChooserServiceRequest request,
-    content::RenderFrameHost* render_frame_host) {
-#if BUILDFLAG(ENABLE_EXTENSIONS)
-  if (render_frame_host->GetSiteInstance()->GetSiteURL().SchemeIs(
-          extensions::kExtensionScheme)) {
-    return;
-  }
-#endif
-
-  WebContents* web_contents =
-      WebContents::FromRenderFrameHost(render_frame_host);
-  if (!web_contents) {
-    NOTREACHED();
-    return;
-  }
-
-  UsbTabHelper* tab_helper =
-      UsbTabHelper::GetOrCreateForWebContents(web_contents);
-  tab_helper->CreateChooserService(render_frame_host, std::move(request));
-}
-
 void CreateBudgetService(blink::mojom::BudgetServiceRequest request,
                          content::RenderFrameHost* render_frame_host) {
   BudgetServiceImpl::Create(std::move(request), render_frame_host->GetProcess(),
@@ -3625,13 +3582,6 @@ void ChromeContentBrowserClient::InitWebContextInterfaces() {
       base::MakeUnique<service_manager::BinderRegistryWithArgs<
           content::RenderProcessHost*, const url::Origin&>>();
 
-  if (base::FeatureList::IsEnabled(features::kWebUsb)) {
-    frame_interfaces_parameterized_->AddInterface(
-        base::Bind(&CreateUsbDeviceManager));
-    frame_interfaces_parameterized_->AddInterface(
-        base::Bind(&CreateWebUsbChooserService));
-  }
-
   // Register mojo ContentTranslateDriver interface only for main frame.
   // Use feature to determine whether translate or language code handles
   // language detection. See crbug.com/736929.
@@ -3794,6 +3744,58 @@ bool ChromeContentBrowserClient::ShouldForceDownloadResource(
 #endif
 }
 
+void ChromeContentBrowserClient::CreateUsbDeviceManager(
+    content::RenderFrameHost* render_frame_host,
+    device::mojom::UsbDeviceManagerRequest request) {
+  if (!base::FeatureList::IsEnabled(features::kWebUsb))
+    return;
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  // WebUSB is not supported in Apps/Extensions. https://crbug.com/770896
+  if (render_frame_host->GetSiteInstance()->GetSiteURL().SchemeIs(
+          extensions::kExtensionScheme)) {
+    return;
+  }
+#endif
+
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host);
+  if (!web_contents) {
+    NOTREACHED();
+    return;
+  }
+
+  UsbTabHelper* tab_helper =
+      UsbTabHelper::GetOrCreateForWebContents(web_contents);
+  tab_helper->CreateDeviceManager(render_frame_host, std::move(request));
+}
+
+void ChromeContentBrowserClient::CreateUsbChooserService(
+    content::RenderFrameHost* render_frame_host,
+    device::mojom::UsbChooserServiceRequest request) {
+  if (!base::FeatureList::IsEnabled(features::kWebUsb))
+    return;
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  // WebUSB is not supported in Apps/Extensions. https://crbug.com/770896
+  if (render_frame_host->GetSiteInstance()->GetSiteURL().SchemeIs(
+          extensions::kExtensionScheme)) {
+    return;
+  }
+#endif
+
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host);
+  if (!web_contents) {
+    NOTREACHED();
+    return;
+  }
+
+  UsbTabHelper* tab_helper =
+      UsbTabHelper::GetOrCreateForWebContents(web_contents);
+  tab_helper->CreateChooserService(render_frame_host, std::move(request));
+}
+
 // Static; handles rewriting Web UI URLs.
 bool ChromeContentBrowserClient::HandleWebUI(
     GURL* url,

chrome/browser/chrome_content_browser_client.h

@@ -392,6 +392,12 @@ class ChromeContentBrowserClient : public content::ContentBrowserClient {
       content::NavigationUIData* navigation_ui_data) override;
   bool ShouldForceDownloadResource(const GURL& url,
                                    const std::string& mime_type) override;
+  void CreateUsbDeviceManager(
+      content::RenderFrameHost* render_frame_host,
+      device::mojom::UsbDeviceManagerRequest request) override;
+  void CreateUsbChooserService(
+      content::RenderFrameHost* render_frame_host,
+      device::mojom::UsbChooserServiceRequest request) override;
 
  protected:
   static bool HandleWebUI(GURL* url, content::BrowserContext* browser_context);

chrome/browser/chrome_content_browser_manifest_overlay.json

@@ -71,8 +71,6 @@
           "chrome::mojom::OpenSearchDocumentDescriptionHandler",
           "chrome::mojom::PrerenderCanceler",
           "contextual_search::mojom::ContextualSearchJsApiService",
-          "device::mojom::UsbChooserService",
-          "device::mojom::UsbDeviceManager",
           "dom_distiller::mojom::DistillabilityService",
           "dom_distiller::mojom::DistillerJavaScriptService",
           "extensions::KeepAlive",

chrome/browser/usb/usb_browsertest.cc

@@ -6,9 +6,8 @@
 #include <string>
 #include <utility>
 
-#include "base/command_line.h"
 #include "base/memory/ref_counted.h"
-#include "base/supports_user_data.h"
+#include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ -63,13 +62,6 @@ class FakeChooserView : public ChooserController::View {
 
 class FakeChooserService : public device::mojom::UsbChooserService {
  public:
-  static void Create(device::mojom::UsbChooserServiceRequest request,
-                     RenderFrameHost* render_frame_host) {
-    mojo::MakeStrongBinding(
-        base::MakeUnique<FakeChooserService>(render_frame_host),
-        std::move(request));
-  }
-
   explicit FakeChooserService(RenderFrameHost* render_frame_host)
       : render_frame_host_(render_frame_host) {}
 
@@ -90,46 +82,26 @@ class FakeChooserService : public device::mojom::UsbChooserService {
   DISALLOW_COPY_AND_ASSIGN(FakeChooserService);
 };
 
-const char kUSBBrowserTest_ActiveTabObserverKey[] =
-    "usb_browsertest_active_tab_observer";
-
-class ActiveTabObserver : public content::WebContentsObserver,
-                          public base::SupportsUserData::Data {
+class TestContentBrowserClient : public ChromeContentBrowserClient {
  public:
-  static void Set(content::WebContents* contents) {
-    auto observer = base::MakeUnique<ActiveTabObserver>(contents);
-    contents->SetUserData(kUSBBrowserTest_ActiveTabObserverKey,
-                          std::move(observer));
-  }
-
-  explicit ActiveTabObserver(content::WebContents* contents)
-      : content::WebContentsObserver(contents) {
-    registry_.AddInterface(base::Bind(&FakeChooserService::Create));
-  }
-  ~ActiveTabObserver() override = default;
+  TestContentBrowserClient() {}
+  ~TestContentBrowserClient() override {}
 
- private:
-  // content::WebContentsObserver:
-  void OnInterfaceRequestFromFrame(
+  // ChromeContentBrowserClient:
+  void CreateUsbChooserService(
       content::RenderFrameHost* render_frame_host,
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle* interface_pipe) override {
-    registry_.TryBindInterface(interface_name, interface_pipe,
-                               render_frame_host);
+      device::mojom::UsbChooserServiceRequest request) override {
+    mojo::MakeStrongBinding(
+        std::make_unique<FakeChooserService>(render_frame_host),
+        std::move(request));
   }
 
-  service_manager::BinderRegistryWithArgs<content::RenderFrameHost*> registry_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActiveTabObserver);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient);
 };
 
 class WebUsbTest : public InProcessBrowserTest {
  public:
-  void SetUpCommandLine(base::CommandLine* command_line) override {
-    command_line->AppendSwitch(
-        switches::kEnableExperimentalWebPlatformFeatures);
-  }
-
   void SetUpOnMainThread() override {
     embedded_test_server()->ServeFilesFromSourceDirectory("content/test/data");
     ASSERT_TRUE(embedded_test_server()->Start());
@@ -141,6 +113,9 @@ class WebUsbTest : public InProcessBrowserTest {
     // thus may expose ordering bugs not normally encountered.
     UsbChooserContextFactory::GetForProfile(browser()->profile());
 
+    original_content_browser_client_ =
+        content::SetBrowserClientForTesting(&test_content_browser_client_);
+
     ui_test_utils::NavigateToURL(
         browser(),
         embedded_test_server()->GetURL("localhost", "/simple_page.html"));
@@ -149,8 +124,10 @@ class WebUsbTest : public InProcessBrowserTest {
         browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame();
     EXPECT_THAT(render_frame_host->GetLastCommittedOrigin().Serialize(),
                 testing::StartsWith("http://localhost:"));
-    ActiveTabObserver::Set(
-        browser()->tab_strip_model()->GetActiveWebContents());
+  }
+
+  void TearDown() override {
+    content::SetBrowserClientForTesting(original_content_browser_client_);
   }
 
   void AddMockDevice(const std::string& serial_number) {
@@ -169,6 +146,8 @@ class WebUsbTest : public InProcessBrowserTest {
  private:
   std::unique_ptr<MockDeviceClient> device_client_;
   scoped_refptr<MockUsbDevice> mock_device_;
+  TestContentBrowserClient test_content_browser_client_;
+  content::ContentBrowserClient* original_content_browser_client_;
 };
 
 IN_PROC_BROWSER_TEST_F(WebUsbTest, RequestAndGetDevices) {

content/browser/frame_host/render_frame_host_impl.cc

@@ -3127,6 +3127,12 @@ void RenderFrameHostImpl::RegisterMojoInterfaces() {
       base::IgnoreResult(&RenderFrameHostImpl::CreateWebBluetoothService),
       base::Unretained(this)));
 
+  registry_->AddInterface(base::BindRepeating(
+      &RenderFrameHostImpl::CreateUsbDeviceManager, base::Unretained(this)));
+
+  registry_->AddInterface(base::BindRepeating(
+      &RenderFrameHostImpl::CreateUsbChooserService, base::Unretained(this)));
+
   registry_->AddInterface<media::mojom::InterfaceFactory>(
       base::Bind(&RenderFrameHostImpl::BindMediaInterfaceFactoryRequest,
                  base::Unretained(this)));
@@ -4297,6 +4303,18 @@ void RenderFrameHostImpl::DeleteWebBluetoothService(
   web_bluetooth_services_.erase(it);
 }
 
+void RenderFrameHostImpl::CreateUsbDeviceManager(
+    device::mojom::UsbDeviceManagerRequest request) {
+  GetContentClient()->browser()->CreateUsbDeviceManager(this,
+                                                        std::move(request));
+}
+
+void RenderFrameHostImpl::CreateUsbChooserService(
+    device::mojom::UsbChooserServiceRequest request) {
+  GetContentClient()->browser()->CreateUsbChooserService(this,
+                                                         std::move(request));
+}
+
 void RenderFrameHostImpl::ResetFeaturePolicy() {
   RenderFrameHostImpl* parent_frame_host = GetParent();
   const blink::FeaturePolicy* parent_policy =

content/browser/frame_host/render_frame_host_impl.h

@@ -995,6 +995,10 @@ class CONTENT_EXPORT RenderFrameHostImpl
   void DeleteWebBluetoothService(
       WebBluetoothServiceImpl* web_bluetooth_service);
 
+  // Creates connections to WebUSB interfaces bound to this frame.
+  void CreateUsbDeviceManager(device::mojom::UsbDeviceManagerRequest request);
+  void CreateUsbChooserService(device::mojom::UsbChooserServiceRequest request);
+
   void CreateAudioOutputStreamFactory(
       mojom::RendererAudioOutputStreamFactoryRequest request);
 

content/public/app/mojo/content_browser_manifest.json

@@ -151,6 +151,8 @@
           "device::mojom::Geolocation",
           "device::mojom::NFC",
           "device::mojom::SensorProvider",
+          "device::mojom::UsbChooserService",
+          "device::mojom::UsbDeviceManager",
           "device::mojom::VibrationManager",
           "device::mojom::VRService",
           "device::mojom::WakeLock",

content/public/browser/BUILD.gn

@@ -331,6 +331,7 @@ jumbo_source_set("browser_sources") {
     "//cc",
     "//content/browser",  # Must not be public_deps!
     "//device/geolocation",
+    "//device/usb/public/interfaces",
     "//gpu",
     "//media",
     "//net",

content/public/browser/DEPS

@@ -2,6 +2,7 @@ include_rules = [
   "+content/common/input/input_handler.mojom.h",
   "+components/viz/common",
   "+device/geolocation/public/cpp",
+  "+device/usb/public/interfaces",
   "+device/screen_orientation/public/interfaces",
   "+services/device/public/interfaces",
   "+services/service_manager/sandbox",

content/public/browser/content_browser_client.cc

@@ -600,4 +600,12 @@ bool ContentBrowserClient::ShouldForceDownloadResource(
   return false;
 }
 
+void ContentBrowserClient::CreateUsbDeviceManager(
+    RenderFrameHost* render_frame_host,
+    device::mojom::UsbDeviceManagerRequest request) {}
+
+void ContentBrowserClient::CreateUsbChooserService(
+    RenderFrameHost* render_frame_host,
+    device::mojom::UsbChooserServiceRequest request) {}
+
 }  // namespace content

content/public/browser/content_browser_client.h

@@ -25,6 +25,8 @@
 #include "content/public/common/resource_type.h"
 #include "content/public/common/socket_permission_request.h"
 #include "content/public/common/window_container_type.mojom.h"
+#include "device/usb/public/interfaces/chooser_service.mojom.h"
+#include "device/usb/public/interfaces/device_manager.mojom.h"
 #include "media/media_features.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
 #include "net/base/mime_util.h"
@@ -984,6 +986,14 @@ class CONTENT_EXPORT ContentBrowserClient {
   // render MHTML page from http/https URLs.
   virtual bool ShouldForceDownloadResource(const GURL& url,
                                            const std::string& mime_type);
+
+  virtual void CreateUsbDeviceManager(
+      RenderFrameHost* render_frame_host,
+      device::mojom::UsbDeviceManagerRequest request);
+
+  virtual void CreateUsbChooserService(
+      RenderFrameHost* render_frame_host,
+      device::mojom::UsbChooserServiceRequest request);
 };
 
 }  // namespace content