bluetooth: Implement known_service_uuids for Peripherals.

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, {
       CentralState: mojo_.CentralState,
       FakeBluetooth: mojo_.FakeBluetooth,
       FakeBluetoothPtr: mojo_.FakeBluetoothPtr,
       FakeCentral: mojo_.FakeCentral,
       FakeCentralPtr: mojo_.FakeCentralPtr,
     }] = mojo_.modules;
 
     return mojo_;
   }
 
+  async function toMojoCentralState(state) {
+    let mojo = await loadFakeBluetoothInterfaces();
+
+    let mojo_central_state;
+    switch (state) {
+      case 'absent':
+        return  mojo.CentralState.ABSENT;
+      case 'powered-off':
+        return mojo.CentralState.POWERED_OFF;
+      case 'powered-on':
+        return mojo.CentralState.POWERED_ON;
+      default:
+        throw `Unsupported value ${state} for state.`;
+    }
+  }
+
   class FakeBluetooth {
     constructor() {
       this.fake_bluetooth_ptr_ = undefined;
+      this.fake_central_ = 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 present.
     async setLESupported(supported) {
       // Call setBluetoothFakeAdapter() to clean up any fake adapters left over
       // by legacy tests.
       // Legacy tests that use setBluetoothFakeAdapter() sometimes fail to clean
@@ skipping 24 matching lines @@
       // 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('');
 
       await this.setLESupported(true);
-      let mojo = await loadFakeBluetoothInterfaces();
-
-      let mojo_manager_state;
-      switch (state) {
-        case 'absent':
-          mojo_manager_state = mojo.CentralState.ABSENT;
-          break;
-        case 'powered-off':
-          mojo_manager_state = mojo.CentralState.POWERED_OFF;
-          break;
-        case 'powered-on':
-          mojo_manager_state = mojo.CentralState.POWERED_ON;
-          break;
-        default:
-          throw `Unsupported value ${state} for state.`;
+      if (this.fake_central_ === undefined) {

[scheib, 2017/05/09 23:33:54]

... continued from previous comment. This logic seems complicated and odd that
we have to handle simulateCentral being called more than once. Perhaps if we
want to update the state of the central later we should just call setState.

Also, code like this seems to be having too many nested awaits. Perhaps we
should have a private method that we can call at top of all FakeBluetooth
methods that ensures mojo is loaded? If code here stayed exactly the same I'd
like to remove the need for getFakeBluetoothInterface and change
toMojoCentralState to be synchronous.

[ortuno, 2017/05/10 06:32:51]

Yeah, I agree. It was a trade-off between convenience e.g. being able to call
setUpPreconnectedDevice and complexity. I guess we can avoid the complexity for
now and introduce it when/if we need it. 
I shuffled the code a bit. I'm slightly worried that toMojoCentralState doesn't
explicitly get the mojo interfaces but then again, why would we use
toMojoCentralState if we haven't initialized mojo_ yet?

+        let {fake_central:fake_central_ptr} =
+          await (await this.getFakeBluetoothInterface_()).simulateCentral(
+            await toMojoCentralState(state));
+        this.fake_central_ = new FakeCentral(fake_central_ptr);
+      } else {
+        await this.fake_central_.setState(state);
       }
 
-      let {fake_central:fake_central_ptr} =
-        await (await this.getFakeBluetoothInterface_()).simulateCentral(
-          mojo_manager_state);
-
-      return new FakeCentral(fake_central_ptr);
+      return this.fake_central_;
     }
 
     async getFakeBluetoothInterface_() {
       if (typeof this.fake_bluetooth_ptr_ !== 'undefined') {
         return this.fake_bluetooth_ptr_;
       }
 
       let mojo = await loadFakeBluetoothInterfaces();
 
       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;
       this.peripherals_ = new Map();
     }
 
-    // Simulates a peripheral with |address| and |name| that has already
-    // been connected to the system. If the peripheral existed already it
-    // updates its name.
+    // Simulates a peripheral with |address|, |name| and |known_service_uuids|

[scheib, 2017/05/09 23:33:54]

Describe that array members of known_service_uuids must be of
BluetoothServiceUUID type.

[ortuno, 2017/05/10 06:32:51]

Done.

+    // that has already been connected to the system. If the peripheral existed
+    // already it updates its name and known UUIDs.
     //
     // Platforms offer methods to retrieve devices that have already been
-    // connected to the system or weren't connected through the UA e.g. a
-    // user connected a peripheral through the system's settings. This method is
+    // connected to the system or weren't connected through the UA e.g. a user
+    // connected a peripheral through the system's settings. This method is
     // intended to simulate peripherals that those methods would return.
-    async simulatePreconnectedPeripheral({address, name}) {
+    async simulatePreconnectedPeripheral({
+      address, name, knownServiceUUIDs = []}) {
+
+      // Canonicalize and convert to mojo UUIDs.
+      knownServiceUUIDs.forEach((val, i, arr) => {
+        knownServiceUUIDs[i] = {uuid: BluetoothUUID.getService(val)};
+      });
+
       await this.fake_central_ptr_.simulatePreconnectedPeripheral(
-        address, name);
+        address, name, knownServiceUUIDs);
 
       let peripheral = this.peripherals_.get(address);
       if (peripheral === undefined) {
         peripheral = new FakePeripheral(address, this);
         this.peripherals_.set(address, peripheral);
       }
 
       return peripheral;
     }
+
+    async setState(state) {
+      await this.fake_central_ptr_.setState(await toMojoCentralState(state));
+    }
   }
 
   class FakePeripheral {
     constructor(address, fake_central) {
       this.address = address;
       this.fake_central_ = fake_central;
     }
   }
 
   navigator.bluetooth.test = new FakeBluetooth();
 })();