[WIP] Mojo native bindings interface.

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();
@@ skipping 10 matching lines @@
           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,
+], (router, frameInterfaces, interfaces, frameInterfaceRegistry,
     interfaceRegistry) => {
   let tearDown = () => {
     frameInterfaces.clearInterfaceOverridesForTesting();
     interfaces.clearInterfaceOverridesForTesting();
   };
   addEventListener('unload', tearDown);
   if (window.add_completion_callback)
     add_completion_callback(tearDown);
 
   return {
-    core,
     router,
-    support,
     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.
@@ skipping 11 matching lines @@
 // 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) {
+    let watcher = pipe.watch({ readable: true }, watchResult => {
+      watcher.cancel();
+      if (watchResult != Mojo.RESULT_OK) {
+        reject(watchResult);
+        return;
+      }
+      let { result, buffer, handles } = pipe.readMessage();
+      if (result !== Mojo.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 });
     });
   });
 };