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/connector',
      'content/public/renderer/frame_interfaces',
      'content/public/renderer/interfaces',
    ],
    (core, router, support, connector, frameInterfaces, interfaces) => {
      let tearDown = () => {
        connector.clearInterfaceOverridesForTesting();
        frameInterfaces.clearInterfaceOverridesForTesting();
        interfaces.clearInterfaceOverridesForTesting();
      };
      addEventListener('unload', tearDown);
      if (window.add_completion_callback)
        add_completion_callback(tearDown);

      return {
          core,
          router,
          support,
          connector,
          frameInterfaces,
          interfaces,
      };
    });

// 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;
  });
}

// Runs a promise_test which depends on the Mojo system API modules available to
// all layout tests. The test implementation function is called with an Object
// that exposes common Mojo module interfaces.
function mojo_test(func, name, properties) {
  promise_test(() => loadMojoModules(name).then(mojo => {
    return Promise.resolve(func(mojo));
  }), name, properties);
}

// Waits for a message to become available on a pipe.
function mojo_wait_for_incoming_message(mojo, pipe) {
  return new Promise((resolve, reject) => {
    mojo.support.asyncWait(pipe, mojo.core.HANDLE_SIGNAL_READABLE, result => {
      if (result != mojo.core.RESULT_OK) {
        reject(result);
        return;
      }
      let buffer, handles;
      ({ result, buffer, handles } = mojo.core.readMessage(pipe, 0));
      if (result !== mojo.core.RESULT_OK) {
        reject(result);
        return;
      }
      resolve({ buffer, handles });
    });
  });
};