bluetooth: Create Mojo equivalent of SetBluetoothMockDataSet

third_party/WebKit/LayoutTests/bluetooth/requestDevice.html

Index: third_party/WebKit/LayoutTests/bluetooth/requestDevice.html
diff --git a/third_party/WebKit/LayoutTests/bluetooth/requestDevice.html b/third_party/WebKit/LayoutTests/bluetooth/requestDevice.html
index 243d422b9a6f8b28ed36f01203f6431517503777..0f0456bb20bac55474138c61656a562a914f87eb 100644
--- a/third_party/WebKit/LayoutTests/bluetooth/requestDevice.html
+++ b/third_party/WebKit/LayoutTests/bluetooth/requestDevice.html
@@ -10,10 +10,11 @@ test(t => { assert_true(window.testRunner instanceof Object); t.done(); },
      'window.testRunner is required for the following tests.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('FailStartDiscoveryAdapter');
-  testRunner.setBluetoothManualChooser();
+  testRunner.setBluetoothManualChooser(true);

[Jeffrey Yasskin, 2016/03/29 01:59:13]

Is this going to fail non-deterministically because the IPC ordering isn't
guaranteed, or does the fact that we get the response for a later IPC wind up
guaranteeing that the first one has completed?

[ortuno, 2016/03/29 16:05:17]

For now we are relying on the fact that requestDevice uses IPC, so we know the
chooser will always be set by the time the requestDevice request comes in the
browser. We will have to change this before moving requestDevice to mojo.

I've been thinking about making a BluetoothChooser mojo Service and exposing it
through a window.internals API in modules/bluetooth/testing. Since we can now
use Mojo from Blink, we won't have to go through as many hoops as we do for the
current implementation. I'll look deeper into it (and write a design doc) before
I start moving requestDevice to mojo.

   let requestDevicePromise =
-      requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]});
+      setBluetoothFakeAdapter('FailStartDiscoveryAdapter')
+        .then(() => requestDeviceWithKeyDown({
+          filters: [{services: ['generic_access']}]}));
   return getBluetoothManualChooserEvents(3)
     .then(events => {
       assert_array_equals(events,
@@ -31,18 +32,19 @@ promise_test(() => {
 }, 'Discovery session fails to start.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('NotPresentAdapter');
-  return assert_promise_rejects_with_message(
-    requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}),
-    new DOMException('Bluetooth adapter not available.', 'NotFoundError'),
-    'Bluetooth adapter is not present.');
+  return setBluetoothFakeAdapter('NotPresentAdapter')
+    .then(() => assert_promise_rejects_with_message(
+      requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}),
+      new DOMException('Bluetooth adapter not available.', 'NotFoundError'),
+      'Bluetooth adapter is not present.'));
 }, 'Reject with NotFoundError if the adapter is not present.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('NotPoweredAdapter');
-  testRunner.setBluetoothManualChooser();
+  testRunner.setBluetoothManualChooser(true);
   let requestDevicePromise =
-      requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]});
+    setBluetoothFakeAdapter('NotPoweredAdapter')
+      .then(() => requestDeviceWithKeyDown({
+        filters: [{services: ['generic_access']}]}));
   return getBluetoothManualChooserEvents(2)
     .then(events => {
       assert_array_equals(events,
@@ -59,21 +61,21 @@ promise_test(() => {
 }, 'Reject with NotFoundError if the adapter is off.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('EmptyAdapter');
-  return assert_promise_rejects_with_message(
-    requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}),
-    new DOMException('User cancelled the requestDevice() chooser.',
-                     'NotFoundError'),
-    'No Bluetooth devices in range.');
+  return setBluetoothFakeAdapter('EmptyAdapter')
+    .then(() => assert_promise_rejects_with_message(
+      requestDeviceWithKeyDown({filters: [{services: ['generic_access']}]}),
+      new DOMException('User cancelled the requestDevice() chooser.',
+                       'NotFoundError'),
+      'No Bluetooth devices in range.'));
 }, 'Reject with NotFoundError if there are no devices around.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('HeartRateAdapter');
-  return Promise.all([
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}),
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}),
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]})
-  ]).then(devices => {
+  return setBluetoothFakeAdapter('HeartRateAdapter')
+    .then(() => Promise.all([
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}),
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}),
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]})
+  ])).then(devices => {
     devices.forEach(device => {
       assert_equals(device.constructor.name, 'BluetoothDevice');
     });
@@ -81,31 +83,35 @@ promise_test(() => {
 }, 'Mock will resolve.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('HeartRateAdapter');
-  return assert_promise_rejects(
-    navigator.bluetooth.requestDevice({filters: [{services: ['heart_rate']}]}),
-    new DOMException('', 'SecurityError'));
+  return setBluetoothFakeAdapter('HeartRateAdapter')
+    .then(() => assert_promise_rejects(
+      navigator.bluetooth.requestDevice({
+        filters: [{services: ['heart_rate']}]}),
+      new DOMException('', 'SecurityError')));
 }, 'Requires a user gesture.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('HeartRateAdapter');
-  return callWithKeyDown(() => {
-    var first = navigator.bluetooth.requestDevice({filters: [{services: ['heart_rate']}]});
-    var second = navigator.bluetooth.requestDevice({filters: [{services: ['heart_rate']}]});
-    return Promise.all([
-      first.then(device => assert_equals(device.constructor.name, 'BluetoothDevice')),
-      assert_promise_rejects(second, new DOMException('', 'SecurityError')),
-    ]);
-  });
+  return setBluetoothFakeAdapter('HeartRateAdapter')
+    .then(() => callWithKeyDown(() => {
+      var first = navigator.bluetooth.requestDevice({
+        filters: [{services: ['heart_rate']}]});
+      var second = navigator.bluetooth.requestDevice({
+        filters: [{services: ['heart_rate']}]});
+      return Promise.all([
+        first.then(device => assert_equals(
+          device.constructor.name, 'BluetoothDevice')),
+        assert_promise_rejects(second, new DOMException('', 'SecurityError')),
+      ]);
+    }));
 }, 'Consumes a user gesture.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('HeartRateAdapter');
-  return Promise.all([
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}),
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}),
-    requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]})
-  ]).then(devices => {
+  return setBluetoothFakeAdapter('HeartRateAdapter')
+    .then(() => Promise.all([
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.alias]}]}),
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.name]}]}),
+      requestDeviceWithKeyDown({filters: [{services: [heart_rate.uuid]}]})
+  ])).then(devices => {
     // requestDevice should return the same object if it was created
     // earlier. https://crbug.com/495270
     // TODO(ortuno): Change to assert_equals.
@@ -115,27 +121,26 @@ promise_test(() => {
 }, 'Returned device should always be the same.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('ScanFilterCheckingAdapter');
   // The work of this test is done in the ScanFilterCheckingAdapter. It asserts
   // that this requestDevice() call tells the platform to scan for only devices
   // that include the Battery, Glucose, or Heart Rate services.
-  return requestDeviceWithKeyDown({
-    filters: [
-      {services: ['battery_service']},
-      {services: ['glucose', 'heart_rate']}
-    ],
-    // The optionalServices shouldn't affect the platform's scan.
-    optionalServices: ['generic_access']
-  });
+  return setBluetoothFakeAdapter('ScanFilterCheckingAdapter')
+    .then(() => requestDeviceWithKeyDown({
+      filters: [{services: ['battery_service']},
+                {services: ['glucose', 'heart_rate']}],
+      // The optionalServices shouldn't affect the platform's scan.
+      optionalServices: ['generic_access']
+    }));
 }, 'Filters restrict the platform\'s Bluetooth scan.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
-  testRunner.setBluetoothManualChooser();
-  let requestDevicePromise = requestDeviceWithKeyDown({
-    filters: [{services: ['glucose']},
-              {services: ['heart_rate']}]
-  });
+  testRunner.setBluetoothManualChooser(true);
+  let requestDevicePromise =
+    setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+      .then(() => requestDeviceWithKeyDown({
+        filters: [{services: ['glucose']},
+                  {services: ['heart_rate']}]
+      }));
   return getBluetoothManualChooserEvents(5)
     .then(events => {
       assert_equals(events.length, 5, events);
@@ -155,30 +160,32 @@ promise_test(() => {
 }, 'The chooser includes all devices.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
-  return requestDeviceWithKeyDown({filters: [{services: ['glucose']}]})
+  return setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+    .then(() => requestDeviceWithKeyDown({
+      filters: [{services: ['glucose']}]}))
     .then(device => assert_equals(device.name, 'Glucose Device'));
 }, 'Simple filter selects matching device.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
-  return requestDeviceWithKeyDown({
-    filters: [{services: ['glucose', 'tx_power']}]
-  }).then(device => assert_equals(device.name, 'Glucose Device'));
+  return setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+    .then(() => requestDeviceWithKeyDown({
+      filters: [{services: ['glucose', 'tx_power']}]
+    })).then(device => assert_equals(device.name, 'Glucose Device'));
 }, 'Filter with 2 services returns a matching device.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
-  return requestDeviceWithKeyDown({
-    filters: [{services: ['battery_service']},
-              {services: ['heart_rate']}]
-  }).then(device => assert_equals(device.name, 'Heart Rate Device'));
+  return setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+    .then(() => requestDeviceWithKeyDown({
+      filters: [{services: ['battery_service']},
+                {services: ['heart_rate']}]
+    })).then(device => assert_equals(device.name, 'Heart Rate Device'));
 }, 'An extra filter doesn\'t prevent matching.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
-  return requestDeviceWithKeyDown({filters: [{services: ['glucose']}],
-                                   optionalServices: ['tx_power']})
+  return setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+    .then(() => requestDeviceWithKeyDown({
+      filters: [{services: ['glucose']}],
+      optionalServices: ['tx_power']}))
     .then(device => {
       assert_equals(device.uuids.length, 2);
       assert_in_array(BluetoothUUID.getService('glucose'), device.uuids);
@@ -188,23 +195,25 @@ promise_test(() => {
 
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('GlucoseHeartRateAdapter');
   // Both devices support the Generic Access service, but things need to
   // support both services to pass the filter, and neither has a Battery
   // service.
-  return assert_promise_rejects(requestDeviceWithKeyDown({
+  return setBluetoothFakeAdapter('GlucoseHeartRateAdapter')
+    .then(() => assert_promise_rejects(
+      requestDeviceWithKeyDown({
     filters: [{services: ['heart_rate', 'battery_service']}]
-  }), new DOMException('', 'NotFoundError'));
+      }), new DOMException('', 'NotFoundError')));
 }, 'Too-strict filters do prevent matching.');
 
 promise_test(() => {
-  testRunner.setBluetoothMockDataSet('SecondDiscoveryFindsHeartRateAdapter');
-  testRunner.setBluetoothManualChooser();
+  testRunner.setBluetoothManualChooser(true);
 
   // Open the chooser, looking for a Heart Rate device.
-  let requestDevicePromise = requestDeviceWithKeyDown({
-    filters: [{services: ['heart_rate']}]
-  });
+  let requestDevicePromise =
+    setBluetoothFakeAdapter('SecondDiscoveryFindsHeartRateAdapter')
+      .then(() => requestDeviceWithKeyDown({
+        filters: [{services: ['heart_rate']}]
+      }));
 
   // The adapter finds nothing, so we just see discovery start and stop.
   return getBluetoothManualChooserEvents(3).then(events => {