Allow top-level frames to request any USB device.

chrome/browser/usb/usb_browsertest.cc

+// Copyright 2016 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 <memory>
+#include <string>
+
+#include "base/command_line.h"
+#include "base/memory/ref_counted.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/usb/usb_chooser_controller.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/test/browser_test_utils.h"
+#include "device/base/mock_device_client.h"
+#include "device/usb/mock_usb_device.h"
+#include "device/usb/mock_usb_service.h"
+#include "device/usb/public/interfaces/chooser_service.mojom.h"
+#include "device/usb/webusb_descriptors.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
+
+using content::RenderFrameHost;
+using device::MockDeviceClient;
+using device::MockUsbDevice;
+
+namespace {
+
+class FakeChooserView : public ChooserController::View {
+ public:
+  explicit FakeChooserView(std::unique_ptr<ChooserController> controller)
+      : controller_(std::move(controller)) {
+    controller_->set_view(this);
+  }
+
+  ~FakeChooserView() override { controller_->set_view(nullptr); }
+
+  void OnOptionsInitialized() override {
+    if (controller_->NumOptions())
+      controller_->Select({0});
+    else
+      controller_->Cancel();
+    delete this;
+  }
+
+  void OnOptionAdded(size_t index) override { NOTREACHED(); }
+  void OnOptionRemoved(size_t index) override { NOTREACHED(); }
+  void OnOptionUpdated(size_t index) override { NOTREACHED(); }
+  void OnAdapterEnabledChanged(bool enabled) override { NOTREACHED(); }
+  void OnRefreshStateChanged(bool refreshing) override { NOTREACHED(); }
+
+ private:
+  std::unique_ptr<ChooserController> controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeChooserView);
+};
+
+class FakeChooserService : public device::usb::ChooserService {
+ public:
+  static void Create(RenderFrameHost* render_frame_host,
+                     device::usb::ChooserServiceRequest request) {
+    mojo::MakeStrongBinding(
+        base::MakeUnique<FakeChooserService>(render_frame_host),
+        std::move(request));
+  }
+
+  explicit FakeChooserService(RenderFrameHost* render_frame_host)
+      : render_frame_host_(render_frame_host) {}
+
+  ~FakeChooserService() override {}
+
+  // device::usb::ChooserService:
+  void GetPermission(std::vector<device::usb::DeviceFilterPtr> device_filters,
+                     const GetPermissionCallback& callback) override {
+    auto chooser_controller = base::MakeUnique<UsbChooserController>(
+        render_frame_host_, std::move(device_filters), callback);
+    new FakeChooserView(std::move(chooser_controller));
+  }
+
+ private:
+  RenderFrameHost* const render_frame_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeChooserService);
+};
+
+class WebUsbTest : public InProcessBrowserTest {
+ public:
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitch(
+        switches::kEnableExperimentalWebPlatformFeatures);
+    InProcessBrowserTest::SetUpCommandLine(command_line);
+  }
+
+  void SetUpOnMainThread() override {
+    embedded_test_server()->ServeFilesFromSourceDirectory("content/test/data");
+    ASSERT_TRUE(embedded_test_server()->Start());
+
+    device_client_.reset(new MockDeviceClient());

[scheib, 2017/01/04 19:06:02]

Add some comments here, and in the last test, highlighting how fake devices are
setup and how the test is using them to validate the origin restriction. --
it'll make it much easier to parse and understand later.

+    scoped_refptr<MockUsbDevice> mock_device(
+        new MockUsbDevice(0, 0, "Test Manufacturer", "Test Device", "123456"));
+    device_client_->usb_service()->AddDevice(mock_device);
+
+    mock_device =
+        new MockUsbDevice(1, 0, "Test Manufacturer", "Test Device", "ABCDEF");
+    auto allowed_origins = base::MakeUnique<device::WebUsbAllowedOrigins>();
+    allowed_origins->origins.push_back(
+        embedded_test_server()->GetURL("localhost", "/").GetOrigin());
+    mock_device->set_webusb_allowed_origins(std::move(allowed_origins));
+    device_client_->usb_service()->AddDevice(mock_device);
+  }
+
+ private:
+  std::unique_ptr<MockDeviceClient> device_client_;
+};
+
+IN_PROC_BROWSER_TEST_F(WebUsbTest, RequestAndGetDevices) {
+  ui_test_utils::NavigateToURL(
+      browser(),
+      embedded_test_server()->GetURL("localhost", "/simple_page.html"));
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
+  EXPECT_THAT(render_frame_host->GetLastCommittedOrigin().Serialize(),
+              testing::StartsWith("http://localhost:"));
+
+  render_frame_host->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&FakeChooserService::Create, render_frame_host));
+
+  std::string result;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      web_contents,
+      "navigator.usb.requestDevice({ filters: [ { vendorId: 0 } ] })"
+      "    .then(device => {"
+      "        domAutomationController.send(device.serialNumber);"
+      "     });",
+      &result));
+  EXPECT_EQ("123456", result);
+
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      web_contents,
+      "navigator.usb.getDevices()"
+      "    .then(devices => {"
+      "        domAutomationController.send(devices.length.toString());"
+      "     });",
+      &result));
+  EXPECT_EQ("1", result);
+}
+
+IN_PROC_BROWSER_TEST_F(WebUsbTest, RequestAndGetDevicesInIframe) {
+  ui_test_utils::NavigateToURL(
+      browser(),
+      embedded_test_server()->GetURL("localhost", "/page_with_iframe.html"));
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  RenderFrameHost* main_frame = web_contents->GetMainFrame();
+  EXPECT_THAT(main_frame->GetLastCommittedOrigin().Serialize(),
+              testing::StartsWith("http://localhost:"));
+  RenderFrameHost* embedded_frame = ChildFrameAt(main_frame, 0);
+  EXPECT_THAT(embedded_frame->GetLastCommittedOrigin().Serialize(),
+              testing::StartsWith("http://localhost:"));
+
+  embedded_frame->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&FakeChooserService::Create, embedded_frame));
+
+  std::string result;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      embedded_frame,
+      "navigator.usb.requestDevice({ filters: [ { vendorId: 0 } ] })"
+      "    .catch(e => { domAutomationController.send(e.toString()); });",
+      &result));
+  EXPECT_EQ("NotFoundError: No device selected.", result);
+
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      embedded_frame,
+      "navigator.usb.requestDevice({ filters: [ { vendorId: 1 } ] })"
+      "    .then(device => {"
+      "        domAutomationController.send(device.serialNumber);"
+      "     });",
+      &result));
+  EXPECT_EQ("ABCDEF", result);
+
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      embedded_frame,
+      "navigator.usb.getDevices()"
+      "    .then(devices => {"
+      "        domAutomationController.send(devices.length.toString());"
+      "     });",
+      &result));
+  EXPECT_EQ("1", result);
+}
+
+}  // namespace