Mojo JS bindings: switch most usage of "connection"/"router" module to "bindings".

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

 'use strict';
 
 var test_text_data = 'Test text data.';
 var test_text_byte_array = new TextEncoder('utf-8').encode(test_text_data);
 var test_number_data = 42;
 var test_json_data = {level: 1, score: 100, label: 'Game'};
 var test_url_data = 'https://w3c.github.io/web-nfc/';
 var test_message_origin = 'https://127.0.0.1:8443';
 var test_buffer_data = new ArrayBuffer(test_text_byte_array.length);
 var test_buffer_view = new Uint8Array(test_buffer_data).set(test_text_byte_array);
@@ skipping 52 matching lines @@
   return createRecord('opaque', 'application/octet-stream', buffer);
 }
 
 function createUrlRecord(url) {
   return createRecord('url', 'text/plain', url);
 }
 
 function nfc_mocks(mojo) {
   return define('NFC mocks', [
     'mojo/public/js/bindings',
-    'mojo/public/js/connection',
     'device/nfc/nfc.mojom',
-  ], (bindings, connection, nfc) => {
+  ], (bindings, nfc) => {
 
     function toMojoNFCRecordType(type) {
       switch (type) {
       case 'text':
         return nfc.NFCRecordType.TEXT;
       case 'url':
         return nfc.NFCRecordType.URL;
       case 'json':
         return nfc.NFCRecordType.JSON;
       case 'opaque':
@@ skipping 166 matching lines @@
       }
     }
 
     function createNFCError(type) {
       return { error: type ?
           new nfc.NFCError({ error_type: type }) : null };
     }
 
     class MockNFC {
       constructor() {
+        this.bindingSet = new bindings.BindingSet(nfc.NFC);
+
         this.hw_status_ = NFCHWStatus.ENABLED;
         this.pushed_message_ = null;
         this.push_options_ = null;
         this.pending_promise_func_ = null;
         this.push_timeout_id_ = null;
         this.push_completed_ = true;
         this.client_ = null;
         this.watch_id_ = 0;
         this.watchers_ = [];
       }
 
-      // NFC.stubClass delegate functions
+      // NFC delegate functions
       push(message, options) {
         let error = this.isReady();
         if (error)
           return Promise.resolve(error);
 
         this.pushed_message_ = message;
         this.push_options_ = options;
 
         return new Promise((resolve, reject) => {
           this.pending_promise_func_ = resolve;
@@ skipping 47 matching lines @@
 
       cancelAllWatches() {
         if (this.watchers_.length === 0) {
           return Promise.resolve(createNFCError(nfc.NFCErrorType.NOT_FOUND));
         }
 
         this.watchers_.splice(0, this.watchers_.length);
         return Promise.resolve(createNFCError(null));
       }
 
-
-      // Mock utility functions
-      bindToPipe(pipe) {
-        this.stub_ = connection.bindHandleToStub(
-            pipe, nfc.NFC);
-        bindings.StubBindings(this.stub_).delegate = this;
-      }
-
       isReady() {
         if (this.hw_status_ === NFCHWStatus.DISABLED)
           return createNFCError(nfc.NFCErrorType.DEVICE_DISABLED);
         if (this.hw_status_ === NFCHWStatus.NOT_SUPPORTED)
           return createNFCError(nfc.NFCErrorType.NOT_SUPPORTED);
         return null;
       }
 
       setHWStatus(status) {
         this.hw_status_ = status;
@@ skipping 42 matching lines @@
         assert_true(this.client_ !== null);
         if (this.watchers_.length > 0) {
           this.client_.onWatch([id], toMojoNFCMessage(message));
         }
       }
     }
 
     let mockNFC = new MockNFC;
     mojo.frameInterfaces.addInterfaceOverrideForTesting(
         nfc.NFC.name,
-        pipe => {
-          mockNFC.bindToPipe(pipe);
+        handle => {
+          mockNFC.bindingSet.addBinding(mockNFC, handle);
         });
 
     return Promise.resolve({
       mockNFC: mockNFC,
       assertNFCMessagesEqual: assertNFCMessagesEqual,
       assertNFCPushOptionsEqual: assertNFCPushOptionsEqual,
       assertWebNFCMessagesEqual: assertWebNFCMessagesEqual,
       assertNFCWatchOptionsEqual: assertNFCWatchOptionsEqual,
     });
   });
 }
 
 function nfc_test(func, name, properties) {
   mojo_test(mojo => nfc_mocks(mojo).then(nfc => {
     let result = Promise.resolve(func(nfc));
     let cleanUp = () => nfc.mockNFC.reset();
     result.then(cleanUp, cleanUp);
     return result;
   }), name, properties);
 }