bluetooth: Implement simulateCentral

third_party/WebKit/LayoutTests/resources/bluetooth/web-bluetooth-test.js

 (() => {
   let mojo_;
 
   async function loadFakeBluetoothInterfaces() {
     if(typeof mojo_ !== 'undefined') {
       return mojo_;
     }
 
     if (typeof loadMojoModules === 'undefined') {
       throw 'Mojo is required for this API.'
     }
 
     mojo_ = await loadMojoModules('fakeBluetooth', [
       'mojo/public/js/bindings',
       'device/bluetooth/public/interfaces/test/fake_bluetooth.mojom'
     ]);
 
-   [mojo_.bindings, mojo_.FakeBluetooth] = mojo_.modules;
+    [mojo_.bindings, {
+      CentralState: mojo_.CentralState,
+      FakeBluetooth: mojo_.FakeBluetooth,
+      FakeBluetoothPtr: mojo_.FakeBluetoothPtr,
+      FakeCentral: mojo_.FakeCentral,
+      FakeCentralPtr: mojo_.FakeCentralPtr,
+    }] = mojo_.modules;
+
     return mojo_;
   }
 
   class FakeBluetooth {
     constructor() {
       this.fake_bluetooth_ptr_ = undefined;
     }
 
     // Set it to indicate whether the platform supports BLE. For example,
     // Windows 7 is a platform that doesn't support Low Energy. On the other
     // hand Windows 10 is a platform that does support LE, even if there is no
     // Bluetooth radio available.
     async setLESupported(available) {
       if (typeof available !== 'boolean') throw 'Type Not Supported';
       await (await this.getFakeBluetoothInterface_()).setLESupported(available);
 
       // TODO(crbug.com/569709): Remove once FakeBluetooth.setLESupported is
       // implemented in the browser.
       navigator.bluetooth.requestDevice = function() {
         return Promise.reject(new DOMException(
             'Bluetooth Low Energy is not supported on this platform.',
             'NotFoundError'));
         };
     }
 
+    // Returns a promise that resolves with a FakeCentral that clients can use
+    // to simulate events that a device in the Central/Observer role would
+    // receive as well as monitor the operations performed by the device in the
+    // Central/Observer role.
+    async simulateCentral({state}) {
+      // Call setBluetoothFakeAdapter() to clean up any fake adapters left over
+      // by legacy tests.
+      // Legacy tests that use setBluetoothFakeAdapter() sometimes fail to clean
+      // their fake adapter. This is not a problem for these tests because the
+      // next setBluetoothFakeAdapter() will clean it up anyway but it is a
+      // problem for the new tests that do not use setBluetoothFakeAdapter().
+      // TODO(crbug.com/569709): Remove once setBluetoothFakeAdapter is no
+      // longer used.
+      await setBluetoothFakeAdapter('');
+      let mojo = await loadFakeBluetoothInterfaces();
+
+      let mojo_manager_state;
+      switch (state) {
+        case 'absent':
+          mojo_manager_state = mojo.CentralState.ABSENT;
+          break;
+        case 'poweredoff':

[scheib, 2017/05/02 03:26:59]

poweredOff?

[ortuno, 2017/05/03 00:17:42]

tldr; went with powered-off/powered-on

WebIDl "strongly suggests"[1] enums should be all lower case and separated with
dashes or not at all depending on other similar APIs. I looked at Presentation,
NFC and Generic Sensors. Presentation doesn't separate[2], nfc and generic
sensors do[3][4]. So I went with separation.

[1] https://heycam.github.io/webidl/#idl-enums
[2]
https://www.w3.org/TR/presentation-api/#h-interface-presentationconnectionclo...
[3] https://w3c.github.io/web-nfc/#h-the-nfcwatchoptions-dictionary
[4] https://www.w3.org/TR/generic-sensor/#example-webidl

+          mojo_manager_state = mojo.CentralState.POWERED_OFF;
+          break;
+        case 'poweredon':
+          mojo_manager_state = mojo.CentralState.POWERED_ON;
+          break;
+        default:
+          throw `Unsupported value ${state} for state.`;
+      }
+
+      let {fake_central:fake_central_ptr} =
+        await (await this.getFakeBluetoothInterface_()).simulateCentral(
+          mojo_manager_state);
+
+      return new FakeCentral(fake_central_ptr);
+    }
+
     async getFakeBluetoothInterface_() {
       if (typeof this.fake_bluetooth_ptr_ !== 'undefined') {
         return this.fake_bluetooth_ptr_;
       }
 
       let mojo = await loadFakeBluetoothInterfaces();
 
-      this.fake_bluetooth_ptr_ = new mojo.FakeBluetooth.FakeBluetoothPtr(
-      mojo.interfaces.getInterface(
-        mojo.FakeBluetooth.FakeBluetooth.name));
+      this.fake_bluetooth_ptr_ = new mojo.FakeBluetoothPtr(
+        mojo.interfaces.getInterface(mojo.FakeBluetooth.name));
 
       return this.fake_bluetooth_ptr_;
     }
   }
 
+  // FakeCentral allows clients to simulate events that a device in the
+  // Central/Observer role would receive as well as monitor the operations
+  // performed by the device in the Central/Observer role.
+  class FakeCentral {
+    constructor(fake_central_ptr) {
+      this.fake_central_ptr = fake_central_ptr;
+    }
+  }
+
   navigator.bluetooth.test = new FakeBluetooth();
 })();