bluetooth: FakeBluetoothChooserClient impl.

Adds a FakeBluetoothChooserClient associated interface that will be used by
FakeBluetoothChooser to send FakeBluetoothChooserEvents to the client as
they happen. Since this feature completes the Fake Bluetooth scanning
API, this change also converts a test to use the new API.

BUG=719827

Change-Id: I2770b3642ae93339e16b594591e4b4075e8246c5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/961719
Commit-Queue: Ovidio de Jesús Ruiz-Henríquez <odejesush@chromium.org>
Reviewed-by: Mike West <mkwst@chromium.org>
Reviewed-by: Giovanni Ortuño Urquidi <ortuno@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#659096}

content/shell/BUILD.gn

@@ -166,6 +166,8 @@ jumbo_static_library("content_shell_lib") {
     "browser/web_test/devtools_protocol_test_bindings.h",
     "browser/web_test/fake_bluetooth_chooser.cc",
     "browser/web_test/fake_bluetooth_chooser.h",
+    "browser/web_test/fake_bluetooth_chooser_factory.cc",
+    "browser/web_test/fake_bluetooth_chooser_factory.h",
     "browser/web_test/fake_bluetooth_scanning_prompt.cc",
     "browser/web_test/fake_bluetooth_scanning_prompt.h",
     "browser/web_test/leak_detector.cc",

content/shell/browser/shell_content_browser_client.cc

@@ -156,21 +156,21 @@ int GetCrashSignalFD(const base::CommandLine& command_line) {
 #endif  // defined(OS_ANDROID)
 
 const service_manager::Manifest& GetContentBrowserOverlayManifest() {
-  static base::NoDestructor<service_manager::Manifest> manifest {
-    service_manager::ManifestBuilder()
-        .ExposeCapability(
-            "renderer",
-            service_manager::Manifest::InterfaceList<
-                mojom::MojoWebTestHelper, mojom::FakeBluetoothChooser,
-                mojom::WebTestBluetoothFakeAdapterSetter,
-                bluetooth::mojom::FakeBluetooth>())
-        .RequireCapability(echo::mojom::kServiceName, "echo")
-        .ExposeInterfaceFilterCapability_Deprecated(
-            "navigation:frame", "renderer",
-            service_manager::Manifest::InterfaceList<
-                mojom::MojoWebTestHelper>())
-        .Build()
-  };
+  static base::NoDestructor<service_manager::Manifest> manifest{
+      service_manager::ManifestBuilder()
+          .ExposeCapability(
+              "renderer",
+              service_manager::Manifest::InterfaceList<
+                  mojom::MojoWebTestHelper, mojom::FakeBluetoothChooser,
+                  mojom::FakeBluetoothChooserFactory,
+                  mojom::WebTestBluetoothFakeAdapterSetter,
+                  bluetooth::mojom::FakeBluetooth>())
+          .RequireCapability(echo::mojom::kServiceName, "echo")
+          .ExposeInterfaceFilterCapability_Deprecated(
+              "navigation:frame", "renderer",
+              service_manager::Manifest::InterfaceList<
+                  mojom::MojoWebTestHelper>())
+          .Build()};
   return *manifest;
 }
 

content/shell/browser/web_test/blink_test_controller.cc

@@ -776,12 +776,16 @@ std::unique_ptr<BluetoothChooser> BlinkTestController::RunBluetoothChooser(
     return bluetooth_chooser_factory_->RunBluetoothChooser(frame,
                                                            event_handler);
   }
+
   auto next_fake_bluetooth_chooser =
       WebTestContentBrowserClient::Get()->GetNextFakeBluetoothChooser();
   if (next_fake_bluetooth_chooser) {
-    next_fake_bluetooth_chooser->SetEventHandler(event_handler);
+    const url::Origin origin = frame->GetLastCommittedOrigin();
+    DCHECK(!origin.opaque());
+    next_fake_bluetooth_chooser->OnRunBluetoothChooser(event_handler, origin);
     return next_fake_bluetooth_chooser;
   }
+
   return std::make_unique<WebTestFirstDeviceBluetoothChooser>(event_handler);
 }
 

content/shell/browser/web_test/fake_bluetooth_chooser.cc

@@ -13,66 +13,89 @@
 
 namespace content {
 
+FakeBluetoothChooser::FakeBluetoothChooser(
+    mojom::FakeBluetoothChooserRequest request,
+    mojom::FakeBluetoothChooserClientAssociatedPtrInfo client_ptr_info)
+    : binding_(this, std::move(request)),
+      client_ptr_(std::move(client_ptr_info)) {
+  SetTestBluetoothScanDuration(BluetoothTestScanDurationSetting::kNeverTimeout);
+}
+
 FakeBluetoothChooser::~FakeBluetoothChooser() {
   SetTestBluetoothScanDuration(
       BluetoothTestScanDurationSetting::kImmediateTimeout);
-  // TODO(https://crbug.com/719826): Send a
-  // mojom::ChooserEventType::CHOOSER_CLOSED event to the client.
-}
 
-// static
-std::unique_ptr<FakeBluetoothChooser> FakeBluetoothChooser::Create(
-    mojom::FakeBluetoothChooserRequest request) {
-  SetTestBluetoothScanDuration(BluetoothTestScanDurationSetting::kNeverTimeout);
-  return std::unique_ptr<FakeBluetoothChooser>(
-      new FakeBluetoothChooser(std::move(request)));
+  client_ptr_->OnEvent(mojom::FakeBluetoothChooserEvent::New(
+      mojom::ChooserEventType::CHOOSER_CLOSED, /*origin=*/base::nullopt,
+      /*peripheral_address=*/base::nullopt));
 }
 
-void FakeBluetoothChooser::SetEventHandler(const EventHandler& event_handler) {
+void FakeBluetoothChooser::OnRunBluetoothChooser(
+    const EventHandler& event_handler,
+    const url::Origin& origin) {
   event_handler_ = event_handler;
+  client_ptr_->OnEvent(mojom::FakeBluetoothChooserEvent::New(
+      mojom::ChooserEventType::CHOOSER_OPENED, origin,
+      /*peripheral_address=*/base::nullopt));
 }
 
 // mojom::FakeBluetoothChooser overrides
-
-void FakeBluetoothChooser::WaitForEvents(uint32_t num_of_events,
-                                         WaitForEventsCallback callback) {
-  // TODO(https://crbug.com/719826): Implement this function according to the
-  // Web Bluetooth Test Scanning design document.
-  // https://docs.google.com/document/d/1XFl_4ZAgO8ddM6U53A9AfUuZeWgJnlYD5wtbXqEpzeg
-  NOTREACHED();
-}
-
 void FakeBluetoothChooser::SelectPeripheral(
     const std::string& peripheral_address) {
+  DCHECK(event_handler_);
   event_handler_.Run(BluetoothChooser::Event::SELECTED, peripheral_address);
 }
 
 void FakeBluetoothChooser::Cancel() {
-  // TODO(https://crbug.com/719826): Send a BluetoothChooser::CANCELLED event to
-  // |event_handler_| and a mojom::ChooserEventType::CHOOSER_CLOSED to the
-  // client.
-  NOTREACHED();
+  DCHECK(event_handler_);
+  event_handler_.Run(BluetoothChooser::Event::CANCELLED, std::string());
+  client_ptr_->OnEvent(mojom::FakeBluetoothChooserEvent::New(
+      mojom::ChooserEventType::CHOOSER_CLOSED, /*origin=*/base::nullopt,
+      /*peripheral_address=*/base::nullopt));
 }
 
 void FakeBluetoothChooser::Rescan() {
-  // TODO(https://crbug.com/719826): Send a BluetoothChooser::RESCAN event to
-  // |event_handler_| and the appropriate mojom::ChooserEventType to describe
-  // the discovery session.
-  NOTREACHED();
+  DCHECK(event_handler_);
+  event_handler_.Run(BluetoothChooser::Event::RESCAN, std::string());
+  client_ptr_->OnEvent(mojom::FakeBluetoothChooserEvent::New(
+      mojom::ChooserEventType::DISCOVERING, /*origin=*/base::nullopt,
+      /*peripheral_address=*/base::nullopt));
 }
 
 // BluetoothChooser overrides
 
 void FakeBluetoothChooser::SetAdapterPresence(AdapterPresence presence) {
-  // TODO(https://crbug.com/719826): Send the appropriate
-  // mojom::ChooserEventType to the client.
-  NOTREACHED();
+  mojom::FakeBluetoothChooserEventPtr event_ptr =
+      mojom::FakeBluetoothChooserEvent::New();
+  switch (presence) {
+    case AdapterPresence::ABSENT:
+      event_ptr->type = mojom::ChooserEventType::ADAPTER_REMOVED;
+      break;
+    case AdapterPresence::POWERED_OFF:
+      event_ptr->type = mojom::ChooserEventType::ADAPTER_DISABLED;
+      break;
+    case AdapterPresence::POWERED_ON:
+      event_ptr->type = mojom::ChooserEventType::ADAPTER_ENABLED;
+      break;
+  }
+  client_ptr_->OnEvent(std::move(event_ptr));
 }
 
 void FakeBluetoothChooser::ShowDiscoveryState(DiscoveryState state) {
-  // TODO(https://crbug.com/719826): Send the appropriate
-  // mojom::ChooserEventType to the client.
-  NOTREACHED();
+  mojom::FakeBluetoothChooserEventPtr event_ptr =
+      mojom::FakeBluetoothChooserEvent::New();
+  switch (state) {
+    case DiscoveryState::FAILED_TO_START:
+      event_ptr->type = mojom::ChooserEventType::DISCOVERY_FAILED_TO_START;
+      break;
+    case DiscoveryState::DISCOVERING:
+      event_ptr->type = mojom::ChooserEventType::DISCOVERING;
+      break;
+    case DiscoveryState::IDLE:
+      event_ptr->type = mojom::ChooserEventType::DISCOVERY_IDLE;
+      break;
+  }
+  client_ptr_->OnEvent(std::move(event_ptr));
 }
 
 void FakeBluetoothChooser::AddOrUpdateDevice(const std::string& device_id,
@@ -81,15 +104,9 @@ void FakeBluetoothChooser::AddOrUpdateDevice(const std::string& device_id,
                                              bool is_gatt_connected,
                                              bool is_paired,
                                              int signal_strength_level) {
-  // TODO(https://crbug.com/719826): Send a
-  // mojom::ChooserEventType::ADD_OR_UPDATE_DEVICE to the client.
-  NOTREACHED();
+  client_ptr_->OnEvent(mojom::FakeBluetoothChooserEvent::New(
+      mojom::ChooserEventType::ADD_OR_UPDATE_DEVICE,
+      /*origin=*/base::nullopt, /*peripheral_address=*/device_id));
 }
 
-// private
-
-FakeBluetoothChooser::FakeBluetoothChooser(
-    mojom::FakeBluetoothChooserRequest request)
-    : binding_(this, std::move(request)) {}
-
 }  // namespace content

content/shell/browser/web_test/fake_bluetooth_chooser.h

@@ -9,7 +9,9 @@
 
 #include "content/public/browser/bluetooth_chooser.h"
 #include "content/shell/common/web_test/fake_bluetooth_chooser.mojom.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "url/origin.h"
 
 namespace content {
 
@@ -28,24 +30,25 @@ namespace content {
 class FakeBluetoothChooser : public mojom::FakeBluetoothChooser,
                              public BluetoothChooser {
  public:
-  // Resets the test scan duration to timeout immediately.
-  ~FakeBluetoothChooser() override;
-
-  // WebTestContentBrowserClient will create an instance of this class when a
-  // request is bound. It will maintain ownership of the instance temporarily
-  // until the chooser is opened. When the chooser is opened, ownership of this
-  // instance will shift to the caller of
+  // FakeBluetoothChooserFactory will create an instance of this class when its
+  // CreateFakeBluetoothChooser() method is called. It will maintain ownership
+  // of the instance temporarily until the chooser is opened. When the chooser
+  // is opened, ownership of this instance will shift to the caller of
   // WebContentsDelegate::RunBluetoothChooser.
-  static std::unique_ptr<FakeBluetoothChooser> Create(
-      mojom::FakeBluetoothChooserRequest request);
+  FakeBluetoothChooser(
+      mojom::FakeBluetoothChooserRequest request,
+      mojom::FakeBluetoothChooserClientAssociatedPtrInfo client_ptr_info);
 
-  // Sets the EventHandler that will handle events produced by the chooser.
-  void SetEventHandler(const EventHandler& event_handler);
+  // Resets the test scan duration to timeout immediately and sends a
+  // |CHOOSER_CLOSED| event to the client.
+  ~FakeBluetoothChooser() override;
 
-  // mojom::FakeBluetoothChooser overrides:
+  // Sets the EventHandler that will handle events produced by the chooser, and
+  // sends a |CHOOSER_OPENED| event to the client with the |origin|.
+  void OnRunBluetoothChooser(const EventHandler& event_handler,
+                             const url::Origin& origin);
 
-  void WaitForEvents(uint32_t num_of_events,
-                     WaitForEventsCallback callback) override;
+  // mojom::FakeBluetoothChooser overrides:
   void SelectPeripheral(const std::string& peripheral_address) override;
   void Cancel() override;
   void Rescan() override;
@@ -62,13 +65,15 @@ class FakeBluetoothChooser : public mojom::FakeBluetoothChooser,
                          int signal_strength_level) override;
 
  private:
-  explicit FakeBluetoothChooser(mojom::FakeBluetoothChooserRequest request);
-
   // Stores the callback function that handles chooser events.
   EventHandler event_handler_;
 
   mojo::Binding<mojom::FakeBluetoothChooser> binding_;
 
+  // Stores the associated pointer to the client that will be receiving events
+  // from FakeBluetoothChooser.
+  mojom::FakeBluetoothChooserClientAssociatedPtr client_ptr_;
+
   DISALLOW_COPY_AND_ASSIGN(FakeBluetoothChooser);
 };
 

content/shell/browser/web_test/fake_bluetooth_chooser_factory.cc

+// Copyright 2019 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 "content/shell/browser/web_test/fake_bluetooth_chooser_factory.h"
+
+#include "content/shell/browser/web_test/fake_bluetooth_chooser.h"
+
+namespace content {
+
+FakeBluetoothChooserFactory::~FakeBluetoothChooserFactory() {}
+
+void FakeBluetoothChooserFactory::CreateFakeBluetoothChooser(
+    mojom::FakeBluetoothChooserRequest request,
+    mojom::FakeBluetoothChooserClientAssociatedPtrInfo client_ptr_info) {
+  DCHECK(!next_fake_bluetooth_chooser_);
+  next_fake_bluetooth_chooser_ = std::make_unique<FakeBluetoothChooser>(
+      std::move(request), std::move(client_ptr_info));
+}
+
+std::unique_ptr<FakeBluetoothChooser>
+FakeBluetoothChooserFactory::GetNextFakeBluetoothChooser() {
+  return std::move(next_fake_bluetooth_chooser_);
+}
+
+FakeBluetoothChooserFactory::FakeBluetoothChooserFactory(
+    mojom::FakeBluetoothChooserFactoryRequest request)
+    : binding_(this, std::move(request)) {}
+
+}  // namespace content

content/shell/browser/web_test/fake_bluetooth_chooser_factory.h

+// Copyright 2019 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.
+
+#ifndef CONTENT_SHELL_BROWSER_WEB_TEST_FAKE_BLUETOOTH_CHOOSER_FACTORY_H_
+#define CONTENT_SHELL_BROWSER_WEB_TEST_FAKE_BLUETOOTH_CHOOSER_FACTORY_H_
+
+#include <memory>
+
+#include "content/shell/common/web_test/fake_bluetooth_chooser.mojom.h"
+#include "mojo/public/cpp/bindings/binding.h"
+
+namespace content {
+
+class FakeBluetoothChooser;
+
+// Implementation of FakeBluetoothChooserFactory in
+// src/content/shell/common/web_test/fake_bluetooth_chooser.mojom to create
+// FakeBluetoothChoosers with a FakeBluetoothChooserClientAssociatedPtr that
+// they can use to send events to the client.
+//
+// The implementation details for FakeBluetoothChooser can be found in the Web
+// Bluetooth Test Scanning design document.
+// https://docs.google.com/document/d/1XFl_4ZAgO8ddM6U53A9AfUuZeWgJnlYD5wtbXqEpzeg
+//
+// Intended to only be used through the FakeBluetoothChooser Mojo interface.
+class FakeBluetoothChooserFactory : public mojom::FakeBluetoothChooserFactory {
+ public:
+  ~FakeBluetoothChooserFactory() override;
+
+  // WebTestContentBrowserClient will create an instance of this class when a
+  // request is bound. It will maintain ownership of the instance.
+  static std::unique_ptr<FakeBluetoothChooserFactory> Create(
+      mojom::FakeBluetoothChooserFactoryRequest request) {
+    return std::unique_ptr<FakeBluetoothChooserFactory>(
+        new FakeBluetoothChooserFactory(std::move(request)));
+  }
+
+  // Creates an instance of FakeBluetoothChooser and stores it in
+  // |next_fake_bluetooth_chooser_|. This will DCHECK if
+  // |next_fake_bluetooth_chooser_| is not null.
+  void CreateFakeBluetoothChooser(
+      mojom::FakeBluetoothChooserRequest request,
+      mojom::FakeBluetoothChooserClientAssociatedPtrInfo client_ptr_info)
+      override;
+
+  // Transfers ownership of |next_fake_bluetooth_chooser_| to the caller.
+  std::unique_ptr<FakeBluetoothChooser> GetNextFakeBluetoothChooser();
+
+ private:
+  explicit FakeBluetoothChooserFactory(
+      mojom::FakeBluetoothChooserFactoryRequest request);
+
+  mojo::Binding<mojom::FakeBluetoothChooserFactory> binding_;
+
+  std::unique_ptr<FakeBluetoothChooser> next_fake_bluetooth_chooser_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_SHELL_BROWSER_WEB_TEST_FAKE_BLUETOOTH_CHOOSER_FACTORY_H_

content/shell/browser/web_test/web_test_content_browser_client.cc

@@ -28,6 +28,7 @@
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/web_test/blink_test_controller.h"
 #include "content/shell/browser/web_test/fake_bluetooth_chooser.h"
+#include "content/shell/browser/web_test/fake_bluetooth_chooser_factory.h"
 #include "content/shell/browser/web_test/mojo_web_test_helper.h"
 #include "content/shell/browser/web_test/web_test_bluetooth_fake_adapter_setter_impl.h"
 #include "content/shell/browser/web_test/web_test_browser_context.h"
@@ -114,7 +115,9 @@ void WebTestContentBrowserClient::ResetMockClipboardHost() {
 
 std::unique_ptr<FakeBluetoothChooser>
 WebTestContentBrowserClient::GetNextFakeBluetoothChooser() {
-  return std::move(next_fake_bluetooth_chooser_);
+  if (!fake_bluetooth_chooser_factory_)
+    return nullptr;
+  return fake_bluetooth_chooser_factory_->GetNextFakeBluetoothChooser();
 }
 
 void WebTestContentBrowserClient::RenderProcessWillLaunch(
@@ -148,7 +151,7 @@ void WebTestContentBrowserClient::ExposeInterfacesToRenderer(
   // base::Unretained in all binders.
   registry->AddInterface(
       base::BindRepeating(
-          &WebTestContentBrowserClient::CreateFakeBluetoothChooser,
+          &WebTestContentBrowserClient::CreateFakeBluetoothChooserFactory,
           base::Unretained(this)),
       ui_task_runner);
   registry->AddInterface(base::BindRepeating(&MojoWebTestHelper::Create));
@@ -327,11 +330,11 @@ std::unique_ptr<LoginDelegate> WebTestContentBrowserClient::CreateLoginDelegate(
 }
 
 // private
-void WebTestContentBrowserClient::CreateFakeBluetoothChooser(
-    mojom::FakeBluetoothChooserRequest request) {
-  DCHECK(!next_fake_bluetooth_chooser_);
-  next_fake_bluetooth_chooser_ =
-      FakeBluetoothChooser::Create(std::move(request));
+void WebTestContentBrowserClient::CreateFakeBluetoothChooserFactory(
+    mojom::FakeBluetoothChooserFactoryRequest request) {
+  DCHECK(!fake_bluetooth_chooser_factory_);
+  fake_bluetooth_chooser_factory_ =
+      FakeBluetoothChooserFactory::Create(std::move(request));
 }
 
 }  // namespace content

content/shell/browser/web_test/web_test_content_browser_client.h

@@ -14,6 +14,7 @@
 namespace content {
 
 class FakeBluetoothChooser;
+class FakeBluetoothChooserFactory;
 class WebTestBrowserContext;
 class MockClipboardHost;
 class MockPlatformNotificationService;
@@ -88,17 +89,17 @@ class WebTestContentBrowserClient : public ShellContentBrowserClient {
       LoginAuthRequiredCallback auth_required_callback) override;
 
  private:
-  // Creates and stores a FakeBluetoothChooser instance.
-  void CreateFakeBluetoothChooser(mojom::FakeBluetoothChooserRequest request);
+  // Creates and stores a FakeBluetoothChooserFactory instance.
+  void CreateFakeBluetoothChooserFactory(
+      mojom::FakeBluetoothChooserFactoryRequest request);
   void BindClipboardHost(blink::mojom::ClipboardHostRequest request);
 
   std::unique_ptr<MockPlatformNotificationService>
       mock_platform_notification_service_;
   bool block_popups_ = false;
 
-  // Stores the next instance of FakeBluetoothChooser that is to be returned
-  // when GetNextFakeBluetoothChooser is called.
-  std::unique_ptr<FakeBluetoothChooser> next_fake_bluetooth_chooser_;
+  // Stores the FakeBluetoothChooserFactory that produces FakeBluetoothChoosers.
+  std::unique_ptr<FakeBluetoothChooserFactory> fake_bluetooth_chooser_factory_;
   std::unique_ptr<MockClipboardHost> mock_clipboard_host_;
 };
 

content/shell/common/web_test/fake_bluetooth_chooser.mojom

@@ -39,11 +39,6 @@ enum ChooserEventType {
 // FakeBluetoothChooser allows clients to control the global state of the
 // Bluetooth chooser during a web test.
 interface FakeBluetoothChooser {
-  // Waits until at least |num_of_events| have been recorded before returning
-  // |num_of_events| FakeBluetoothChooserEvents.
-  WaitForEvents(
-      uint32 num_of_events) => (array<FakeBluetoothChooserEvent> events);
-
   // Simulates a user selecting the given |peripheral_address| in the Bluetooth
   // chooser.
   SelectPeripheral(string peripheral_address);
@@ -55,6 +50,13 @@ interface FakeBluetoothChooser {
   Rescan();
 };
 
+// FakeBluetoothChooserFactory ensures that FakeBluetoothChoosers are created
+// with an associated FakeBluetoothChooserClient.
+interface FakeBluetoothChooserFactory {
+  CreateFakeBluetoothChooser(FakeBluetoothChooser& fake_chooser,
+      associated FakeBluetoothChooserClient client);
+};
+
 // FakeBluetoothChooserEvent describes the type of chooser event that has been
 // produced by the FakeBluetoothChooser.
 struct FakeBluetoothChooserEvent {
@@ -67,3 +69,8 @@ struct FakeBluetoothChooserEvent {
   // Describes the MAC address of the Bluetooth device.
   string? peripheral_address;
 };
+
+// Classes that implement this interface will be notified of chooser events.
+interface FakeBluetoothChooserClient {
+  OnEvent(FakeBluetoothChooserEvent event);
+};

third_party/blink/web_tests/TestExpectations

@@ -4628,7 +4628,6 @@ crbug.com/825733 [ Win ] media/color-profile-video-seek-filter.html [ Pass Timeo
 crbug.com/754986 media/video-transformed.html [ Pass Failure ]
 
 # Sheriff 2018-03-29
-crbug.com/827088 bluetooth/requestDevice/chooser/new-scan-device-added.html [ Pass Crash ]
 crbug.com/827209 [ Win ] fast/events/middleClickAutoscroll-latching.html [ Pass Timeout Failure ]
 crbug.com/827209 [ Linux ] fast/events/middleClickAutoscroll-latching.html [ Pass Timeout Failure ]
 crbug.com/827209 [ Win ] virtual/mouseevent_fractional/fast/events/middleClickAutoscroll-latching.html [ Pass Timeout Failure ]

third_party/blink/web_tests/bluetooth/requestDevice/chooser/new-scan-device-added.html

@@ -6,23 +6,44 @@
 <script src="../../../external/wpt/bluetooth/resources/bluetooth-helpers.js"></script>
 <script>
 'use strict';
-bluetooth_test(() => {
-  setBluetoothManualChooser(true);
-
-  let requestDevicePromise = setBluetoothFakeAdapter('DeviceEventAdapter')
-                                 .then(
-                                     () => requestDeviceWithTrustedClick(
-                                         {filters: [{services: ['glucose']}]}));
-  return getBluetoothManualChooserEvents(4).then(events => {
-    assert_equals(events[0], 'chooser-opened(file://)');
-    assert_equals(events[1], 'discovering');
-    let idsByName = new AddDeviceEventSet();
-    idsByName.assert_add_device_event(events[2]);
-    assert_true(idsByName.has('New Glucose Device'));
-    assert_equals(events[3], 'discovery-idle');
-    sendBluetoothManualChooserEvent(
-        'selected', idsByName.get('New Glucose Device'));
-    return requestDevicePromise;
+const test_desc = 'The chooser should display newly detected devices.';
+
+bluetooth_test(async () => {
+  let fake_central =
+      await navigator.bluetooth.test.simulateCentral({state: 'powered-on'});
+  let fake_chooser = await navigator.bluetooth.test.getManualChooser();
+
+  // 1. Open the chooser.
+  let requestDevicePromise = requestDeviceWithTrustedClick({
+    filters: [{services: ['health_thermometer']}]
   });
-});
+
+  let events = await fake_chooser.waitForEvents(2);
+  assert_equals(events.length, 2);
+  assert_equals(events[0].type, 'chooser-opened');
+  assert_equals(events[0].origin.scheme, 'file');
+  assert_equals(events[1].type, 'discovering');
+
+  // 2. Send the advertisement packet to central.
+  let fake_peripheral =
+      await fake_central.simulateAdvertisementReceived(
+          health_thermometer_ad_packet);
+
+  events = await fake_chooser.waitForEvents(1);
+  assert_equals(events.length, 1);
+  assert_equals(events[0].type, 'add-or-update-device');
+  assert_equals(events[0].peripheral_address,
+      health_thermometer_ad_packet.scanRecord.deviceAddress);
+
+  // 3. Select the device on the chooser.
+  await fake_chooser.selectPeripheral(fake_peripheral);
+
+  events = await fake_chooser.waitForEvents(1);
+  assert_equals(events.length, 1);
+  assert_equals(events[0].type, 'chooser-closed');
+
+  // 4. Check that the device and advertisement packet have the same name.
+  let device = await requestDevicePromise;
+  assert_equals(device.name, health_thermometer_ad_packet.scanRecord.name);
+}, test_desc);
 </script>

third_party/blink/web_tests/external/wpt/resources/chromium/web-bluetooth-test.js

@@ -45,6 +45,22 @@ const CHARACTERISTIC_PROPERTIES_WEB_TO_MOJO = {
   extended_properties: 'extended_properties',
 };
 
+// Mapping of the Mojo ChooserEventType enum to a string.
+const MOJO_CHOOSER_EVENT_TYPE_MAP = (() => {
+  const ChooserEventType = content.mojom.ChooserEventType;
+  return {
+    [ChooserEventType.CHOOSER_OPENED]: 'chooser-opened',
+    [ChooserEventType.CHOOSER_CLOSED]: 'chooser-closed',
+    [ChooserEventType.ADAPTER_REMOVED]: 'adapter-removed',
+    [ChooserEventType.ADAPTER_DISABLED]: 'adapter-disabled',
+    [ChooserEventType.ADAPTER_ENABLED]: 'adapter-enabled',
+    [ChooserEventType.DISCOVERY_FAILED_TO_START]: 'discovery-failed-to-start',
+    [ChooserEventType.DISCOVERING]: 'discovering',
+    [ChooserEventType.DISCOVERY_IDLE]: 'discovery-idle',
+    [ChooserEventType.ADD_OR_UPDATE_DEVICE]: 'add-or-update-device',
+  }
+})();
+
 function ArrayToMojoCharacteristicProperties(arr) {
   let struct = new bluetooth.mojom.CharacteristicProperties();
 
@@ -504,14 +520,51 @@ class FakeRemoteGATTDescriptor {
   }
 }
 
-// FakeChooser allows clients to simulate events that a user would trigger when
-// using the Bluetooth chooser, and monitor the events that are produced.
+// FakeChooser allows clients to simulate user actions on a Bluetooth chooser,
+// and records the events produced by the Bluetooth chooser.
 class FakeChooser {
   constructor() {
+    let fakeBluetoothChooserFactoryPtr =
+        new content.mojom.FakeBluetoothChooserFactoryPtr();
+    Mojo.bindInterface(content.mojom.FakeBluetoothChooserFactory.name,
+        mojo.makeRequest(fakeBluetoothChooserFactoryPtr).handle, 'process');
+
     this.fake_bluetooth_chooser_ptr_ =
         new content.mojom.FakeBluetoothChooserPtr();
-    Mojo.bindInterface(content.mojom.FakeBluetoothChooser.name,
-        mojo.makeRequest(this.fake_bluetooth_chooser_ptr_).handle, 'process');
+
+    let clientPtrInfo = new mojo.AssociatedInterfacePtrInfo();
+    this.fake_bluetooth_chooser_client_binding_ =
+        new mojo.AssociatedBinding(content.mojom.FakeBluetoothChooserClient,
+            this, mojo.makeRequest(clientPtrInfo));
+
+    fakeBluetoothChooserFactoryPtr.createFakeBluetoothChooser(
+        mojo.makeRequest(this.fake_bluetooth_chooser_ptr_), clientPtrInfo);
+
+    this.events_ = new Array();
+    this.event_listener_ = null;
+  }
+
+  // If the chooser has received more events than |numOfEvents| this function
+  // will reject the promise, else it will wait until |numOfEvents| events are
+  // received before resolving with an array of |FakeBluetoothChooserEvent|
+  // objects.
+  async waitForEvents(numOfEvents) {
+    return new Promise(resolve => {
+      if (this.events_.length > numOfEvents) {
+        throw `Asked for ${numOfEvents} event(s), but received ` +
+            `${this.events_.length}.`;
+      }
+
+      this.event_listener_ = () => {
+         if (this.events_.length === numOfEvents) {
+          let result = Array.from(this.events_);
+          this.event_listener_ = null;
+          this.events_ = [];
+          resolve(result);
+        }
+      };
+      this.event_listener_();
+    });
   }
 
   async selectPeripheral(peripheral) {
@@ -520,6 +573,22 @@ class FakeChooser {
     }
     await this.fake_bluetooth_chooser_ptr_.selectPeripheral(peripheral.address);
   }
+
+  async cancel() {
+    await this.fake_bluetooth_chooser_ptr_.cancel();
+  }
+
+  async rescan() {
+    await this.fake_bluetooth_chooser_ptr_.rescan();
+  }
+
+  onEvent(chooserEvent) {
+    chooserEvent.type = MOJO_CHOOSER_EVENT_TYPE_MAP[chooserEvent.type];
+    this.events_.push(chooserEvent);
+    if (this.event_listener_ !== null) {
+      this.event_listener_();
+    }
+  }
 }
 
 // If this line fails, it means that current environment does not support the