Refactor Blink's ServiceConnector and add ability to mock in layout tests

third_party/WebKit/LayoutTests/resources/mojo-helpers.js

 /*
  * mojo-helpers contains extensions to testharness.js useful for consuming
  * and mocking Mojo services directly within test code.
  */
 'use strict';
 
 // Fix up the global window.define, since all baked-in Mojo modules expect to
 // find it there. This define() also returns a promise to the module.
 let define = (function(){
   let moduleCache = new Map();
 
   return function(name, deps, factory) {
     let promise = moduleCache.get(name);
     if (promise === undefined) {
       // This promise must be cached as gin.define will only call the factory
       // function the first time the module is defined.
       promise = new Promise(resolve => {
         gin.define(name, deps, (...modules) => {
           let result = factory(...modules);
           resolve(result);
           return result;
         });
       });
       moduleCache.set(name, promise);
     }
     return promise;
   }
 })();
 
-define('Mojo Helpers', [
-    'mojo/public/js/core',
-    'mojo/public/js/router',
-    'mojo/public/js/support',
-    'content/public/renderer/frame_interfaces',
-    'content/public/renderer/interfaces',
-    'content/shell/renderer/layout_test/frame_interface_registry',
-    'content/shell/renderer/layout_test/interface_registry',
-], (core, router, support, frameInterfaces, interfaces, frameInterfaceRegistry,
-    interfaceRegistry) => {
-  let tearDown = () => {
-    frameInterfaces.clearInterfaceOverridesForTesting();
-    interfaces.clearInterfaceOverridesForTesting();
-  };
-  addEventListener('unload', tearDown);
-  if (window.add_completion_callback)
-    add_completion_callback(tearDown);
+define(
+    'Mojo Helpers',
+    [
+      'mojo/public/js/core',
+      'mojo/public/js/router',
+      'mojo/public/js/support',
+      'content/public/renderer/connector',
+      'content/public/renderer/frame_interfaces',
+      'content/public/renderer/interfaces',
+      'content/shell/renderer/layout_test/frame_interface_registry',
+      'content/shell/renderer/layout_test/interface_registry',
+    ],
+    (core, router, support, connector, frameInterfaces, interfaces,
+     frameInterfaceRegistry, interfaceRegistry) => {
+      let tearDown = () => {
+        connector.clearInterfaceOverridesForTesting();

[dcheng, 2017/03/21 18:56:18]

Do we have any documentation about the differences between these three things?
If I wanted to write a layout test and mock out interfaces, which one of these
things should I be mocking interfaces against?

I guess connector is to let us mock interfaces for things that Blink connects
*to*, while frameInterfaces / interfaces are for mocking interfaces that Blink
implements itself? Do I have this roughly correct? =)

[Ken Rockot(use gerrit already), 2017/03/23 04:56:04]

No, they're all different ways for the client (blink) to connect *to* things,
each with their own API for locally intercepting those outgoing connections and
routing them back to fake local impls. e.g. you have a web API with a C++ impl
that talks to some mojom interface normally implemented in the browser, and
within a layout test you can intercept its requests and route them instead to a
JS mock impl of the target interface.

interfaces is the original thing - we didn't have services way back then, just a
big open interface registry in the RPH, and this is an interface provider which
routes interface requests to that with no additional context. This is
essentially deprecated but still in use (of course). We'll delete it soon.

frameInterfaces is similarly an interface provider, but scoped to an RFH. I
expect that this will stick around in some form, as we still have no better way
of arranging for some frame hosting/navigation service to broker interface
requests on a frame's behalf.

connector is the generic service manager connector API that services should
generally use to connect to each other. It binds requests in the form of
(target_service, interface_request), brokered through the service manager. There
is no reason why existing uses of the RPH interface registry cannot be trivially
ported to uses of connector which bind to ("content_browser",
whatever_interface), for example, which is how we plan to get rid of the first
thing.

+        frameInterfaces.clearInterfaceOverridesForTesting();
+        interfaces.clearInterfaceOverridesForTesting();
+      };
+      addEventListener('unload', tearDown);
+      if (window.add_completion_callback)
+        add_completion_callback(tearDown);
 
-  return {
-    core,
-    router,
-    support,
-    frameInterfaces,
-    frameInterfaceRegistry,
-    interfaces,
-    interfaceRegistry,
-  };
-});
+      return {
+          core,
+          router,
+          support,
+          connector,
+          frameInterfaces,
+          frameInterfaceRegistry,
+          interfaces,
+          interfaceRegistry,
+      };
+    });
 
 // Returns a promise to an object that exposes common Mojo module interfaces.
 // Additional modules to load can be specified in the |modules| parameter. The
 // result will contain them, in the same order, in the |modules| field.
 function loadMojoModules(name, modules = []) {
   return define('Mojo modules: ' + name,
                 [ 'Mojo Helpers' ].concat(modules),
                 (mojo, ...rest) => {
     mojo.modules = rest
     return mojo;
@@ skipping 20 matching lines @@
       let buffer, handles;
       ({ result, buffer, handles } = mojo.core.readMessage(pipe, 0));
       if (result !== mojo.core.RESULT_OK) {
         reject(result);
         return;
       }
       resolve({ buffer, handles });
     });
   });
 };