bluetooth: Add device list retrieval for chrome://bluetooth-internals

chrome/browser/resources/bluetooth_internals/bluetooth_internals.js

Index: chrome/browser/resources/bluetooth_internals/bluetooth_internals.js
diff --git a/chrome/browser/resources/bluetooth_internals/bluetooth_internals.js b/chrome/browser/resources/bluetooth_internals/bluetooth_internals.js
index 308779cb50e4ed62fb1168bf63515bbd91d2ec74..95f7dd79df2fb6ffe7a98381d1dfa9c6792a65b9 100644
--- a/chrome/browser/resources/bluetooth_internals/bluetooth_internals.js
+++ b/chrome/browser/resources/bluetooth_internals/bluetooth_internals.js
@@ -6,7 +6,88 @@
  * Javascript for bluetooth_internals.html, served from
  *     chrome://bluetooth-internals/.
  */
+(function() {
+  let adapterService = null;
+  let adapterClient = null;
+  let adapterHandle = null;
+  let clientHandle = null;
 
-document.addEventListener('DOMContentLoaded', function() {
-  console.log('Welcome to Bluetooth Internals.');
-});
+  /**
+   * Helper to convert callback-based define() API to a promise-based API.
+   * @param {!Array<string>} moduleNames
+   * @return {!Promise}
+   */
+  function importModules(moduleNames) {
+    return new Promise(function(resolve, reject) {
+      define(moduleNames, function(var_args) {
+        resolve(Array.prototype.slice.call(arguments, 0));
+      });
+    });
+  }
+
+  /**
+   * Initializes Mojo proxies for page and Bluetooth services.
+   * @return {!Promise}
+   */
+  function initializeProxies() {
+    return importModules([
+             'content/public/renderer/frame_interfaces',
+             'chrome/browser/ui/webui/bluetooth_internals/' +
+                 'bluetooth_internals.mojom',
+             'device/bluetooth/public/interfaces/bluetooth.mojom',
+             'mojo/public/js/connection',
+           ])
+        .then((modules) => {

[ortuno, 2016/09/26 01:57:56]

Unless I'm missing something you should be able to use destructuring to directly
assign the variables:

.then(([frameInterfaces, mojom, bluetooth, connection]) => {
  // ...

[mbrunson, 2016/09/28 02:18:22]

Done.

+          let [frameInterfaces, mojom, bluetooth, connection] = modules;
+          let pageHandler = connection.bindHandleToProxy(

[ortuno, 2016/09/26 01:57:56]

Consider moving this further down to where it is used.

[mbrunson, 2016/09/28 02:18:22]

Done.

+              frameInterfaces.getInterface(mojom.InternalsPageHandler.name),
+              mojom.InternalsPageHandler);
+
+          class AdapterClientImpl extends bluetooth.AdapterClient.stubClass {

[scheib, 2016/09/26 19:37:26]

Move the AdapterClientImpl class definition to the top level of the module,
unless it is closing over something here I didn't spot.

In the long run will you have a class that is only a ClientImpl, or perhaps
you'll simply have a single class controller for the web UI page? That is,
perhaps this is just a "class Controller extends 
bluetooth.AdapterClient.stubClass".

[mbrunson, 2016/09/28 02:18:22]

I've moved the declaration up and put the subclassing code here since
bluetooth.AdapterClient is not known until importModules is called.

+            constructor() { super(); }
+
+            /**
+             * Prints added device to console
+             * @param {!Object} device the device that was added
+             */
+            deviceAdded(device) {
+              console.log('Device added');
+              console.log(device);
+            }
+
+            /**
+             * Prints removed device to console
+             * @param {!Object} device the device that was removed
+             */
+            deviceRemoved(device) {
+              console.log('Device added');

[ortuno, 2016/09/26 01:57:56]

Device removed :)

[mbrunson, 2016/09/28 02:18:22]

Yes. That makes much more sense. :)

+              console.log(device);
+            }
+          }
+
+          adapterClient = new AdapterClientImpl();
+
+          return new Promise((resolve) => {

[ortuno, 2016/09/26 01:57:56]

There is no indication that initializeProxies() will resolve with an adapter
service. To improve readability you could just initialize the service in here:

  return new Promise((resolve) => {
    adapterHandle = connection.bindProxy(resolve, bluetooth.Adapter);
  }).then(service => {
    adapterService = service;

    // Create a message pipe and bind one end to client implementation
    clientHandle = connection.bindStubDerivedImpl(adapterClient);

    // Send interface request and other end of client message pipe to
    // C++
    pageHandler.getAdapterService(adapterHandle, clientHandle);
  });
});

Alternatively you can simplify this code if you follow the pattern explained in
bluetooth_internals.mojom

+
+            // Create adapter service interface request
+            adapterHandle = connection.bindProxy(resolve, bluetooth.Adapter);
+
+            // Create a message pipe and bind one end to client implementation
+            clientHandle = connection.bindStubDerivedImpl(adapterClient);

[ortuno, 2016/09/26 07:45:17]

You are creating a different pipe for the client. This means that there is no
order guarantee regarding the order of the messages. So if you have this in the
implementation:

callback.Run();
client_.NotifyOfSomething();

It's entirely possible that the interface client receives NotifyOfSomething()
first and then the callback.

I don't think you need the guarantee right now, in Web Bluetooth we do, but keep
it in mind in case you start seen races.

[scheib, 2016/09/26 18:00:37]

https://www.chromium.org/developers/design-documents/mojo/associated-interfaces 
is what is designed to resolve this, but
I don't know if javascript examples exist.
I suspect we'll need them eventually, if we
need them sooner ping rockot@ for help.

[mbrunson, 2016/09/28 02:18:22]

Ok. When I was writing the adapter service, I specifically wanted to avoid that
kind of pattern for this reason. I'll look into associated interfaces in
JavaScript.

+
+            // Send interface request and other end of client message pipe to
+            // C++
+            pageHandler.getAdapterService(adapterHandle, clientHandle);
+          });
+        });
+  }
+
+  document.addEventListener('DOMContentLoaded', function() {
+    initializeProxies()
+        .then((service) => {
+          adapterService = service;
+          return service.getDevices();
+        })
+        .then((response) => console.log(response.devices));
+  });
+})();