Mojo JS bindings: remove usage of the connection module.

mojo/public/js/validation_unittests.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 define([
     "console",
     "file",
     "gin/test/expect",
     "mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom",
+    "mojo/public/js/bindings",
     "mojo/public/js/buffer",
     "mojo/public/js/codec",
-    "mojo/public/js/connection",
-    "mojo/public/js/connector",
     "mojo/public/js/core",
     "mojo/public/js/test/validation_test_input_parser",
-    "mojo/public/js/router",
     "mojo/public/js/validator",
 ], function(console,
             file,
             expect,
             testInterface,
+            bindings,
             buffer,
             codec,
-            connection,
-            connector,
             core,
             parser,
-            router,
             validator) {
 
   var noError = validator.validationError.NONE;
 
   function checkTestMessageParser() {
     function TestMessageParserFailure(message, input) {
       this.message = message;
       this.input = input;
     }
 
@@ skipping 228 matching lines @@
   function testResponseConformanceMessageValidation() {
     testMessageValidation("resp_conformance_", [
         testInterface.ConformanceTestInterface.validateResponse]);
   }
 
   function testResponseBoundsCheckMessageValidation() {
     testMessageValidation("resp_boundscheck_", [
         testInterface.BoundsCheckTestInterface.validateResponse]);
   }
 
-  function testIntegratedMessageValidation(testFilesPattern,
-                                           localFactory,
-                                           remoteFactory) {
+  function testIntegratedMessageValidation(testFilesPattern, endpoint) {
     var testFiles = getMessageTestFiles(testFilesPattern);
     expect(testFiles.length).toBeGreaterThan(0);
 
     var testMessagePipe = core.createMessagePipe();
     expect(testMessagePipe.result).toBe(core.RESULT_OK);
-    var testConnection = new connection.TestConnection(
-        testMessagePipe.handle1, localFactory, remoteFactory);
+
+    endpoint.bind(testMessagePipe.handle1);
+    var testingController = endpoint.enableTestingMode();
+
+    var validationError;
+    testingController.setInvalidIncomingMessageHandler(function(error) {
+      validationError = error;
+    });
 
     for (var i = 0; i < testFiles.length; i++) {
+      validationError = noError;
       var testMessage = readTestMessage(testFiles[i]);
       var handles = new Array(testMessage.handleCount);
 
       var writeMessageValue = core.writeMessage(
           testMessagePipe.handle0,
           new Uint8Array(testMessage.buffer.arrayBuffer),
           new Array(testMessage.handleCount),
           core.WRITE_MESSAGE_FLAG_NONE);
       expect(writeMessageValue).toBe(core.RESULT_OK);
 
-      var validationError = noError;
-      testConnection.router_.validationErrorHandler = function(err) {
-        validationError = err;
-      };
-
-      testConnection.router_.connector_.waitForNextMessage();
+      testingController.waitForNextMessage();
       checkValidationResult(testFiles[i], validationError);
     }
 
-    testConnection.close();
     expect(core.close(testMessagePipe.handle0)).toBe(core.RESULT_OK);
   }
 
   function testIntegratedMessageHeaderValidation() {
     testIntegratedMessageValidation(
         "integration_msghdr",
-        testInterface.IntegrationTestInterface.stubClass,
-        undefined);
+        new bindings.Binding(testInterface.IntegrationTestInterface, {}));
     testIntegratedMessageValidation(
         "integration_msghdr",
-        undefined,
-        testInterface.IntegrationTestInterface.proxyClass);
+        new testInterface.IntegrationTestInterfacePtr().ptr);
   }
 
   function testIntegratedRequestMessageValidation() {
     testIntegratedMessageValidation(
         "integration_intf_rqst",
-        testInterface.IntegrationTestInterface.stubClass,
-        undefined);
+        new bindings.Binding(testInterface.IntegrationTestInterface, {}));
   }
 
   function testIntegratedResponseMessageValidation() {
     testIntegratedMessageValidation(
         "integration_intf_resp",
-        undefined,
-        testInterface.IntegrationTestInterface.proxyClass);
+        new testInterface.IntegrationTestInterfacePtr().ptr);
   }
 
   expect(checkTestMessageParser()).toBeNull();
   testConformanceMessageValidation();
   testBoundsCheckMessageValidation();
   testResponseConformanceMessageValidation();
   testResponseBoundsCheckMessageValidation();
   testIntegratedMessageHeaderValidation();
   testIntegratedResponseMessageValidation();
   testIntegratedRequestMessageValidation();
 
   this.result = "PASS";
 });