Mojo JS bindings: remove usage of the connection module.

mojo/public/js/router.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("mojo/public/js/router", [
   "mojo/public/js/codec",
   "mojo/public/js/core",
   "mojo/public/js/connector",
   "mojo/public/js/validator",
 ], function(codec, core, connector, validator) {
 
   var Connector = connector.Connector;
   var MessageReader = codec.MessageReader;
   var Validator = validator.Validator;
 
   function Router(handle, connectorFactory) {
     if (!core.isHandle(handle))
       throw new Error("Router constructor: Not a handle");
     if (connectorFactory === undefined)
       connectorFactory = Connector;
     this.connector_ = new connectorFactory(handle);
     this.incomingReceiver_ = null;
     this.errorHandler_ = null;
     this.nextRequestID_ = 0;
     this.completers_ = new Map();
     this.payloadValidators_ = [];
+    this.testingController_ = null;
 
     this.connector_.setIncomingReceiver({
         accept: this.handleIncomingMessage_.bind(this),
     });
     this.connector_.setErrorHandler({
         onError: this.handleConnectionError_.bind(this),
     });
   }
 
   Router.prototype.close = function() {
     this.completers_.clear();  // Drop any responders.
     this.connector_.close();
+    this.testingController_ = null;
   };
 
   Router.prototype.accept = function(message) {
     this.connector_.accept(message);
   };
 
   Router.prototype.reject = function(message) {
     // TODO(mpcomplete): no way to trasmit errors over a Connection.
   };
 
@@ skipping 25 matching lines @@
   };
 
   Router.prototype.setErrorHandler = function(handler) {
     this.errorHandler_ = handler;
   };
 
   Router.prototype.encounteredError = function() {
     return this.connector_.encounteredError();
   };
 
+  Router.prototype.enableTestingMode = function() {
+    this.testingController_ = new RouterTestingController(this.connector_);
+    return this.testingController_;
+  };
+
   Router.prototype.handleIncomingMessage_ = function(message) {
     var noError = validator.validationError.NONE;
     var messageValidator = new Validator(message);
     var err = messageValidator.validateMessageHeader();
     for (var i = 0; err === noError && i < this.payloadValidators_.length; ++i)
       err = this.payloadValidators_[i](messageValidator);
 
     if (err == noError)
       this.handleValidIncomingMessage_(message);
     else
       this.handleInvalidIncomingMessage_(message, err);
   };
 
   Router.prototype.handleValidIncomingMessage_ = function(message) {
+    if (this.testingController_)
+      return;
+
     if (message.expectsResponse()) {
       if (this.incomingReceiver_) {
         this.incomingReceiver_.acceptWithResponder(message, this);
       } else {
         // If we receive a request expecting a response when the client is not
         // listening, then we have no choice but to tear down the pipe.
         this.close();
       }
     } else if (message.isResponse()) {
       var reader = new MessageReader(message);
       var requestID = reader.requestID;
       var completer = this.completers_.get(requestID);
       this.completers_.delete(requestID);
       completer.resolve(message);
     } else {
       if (this.incomingReceiver_)
         this.incomingReceiver_.accept(message);
     }
-  }
+  };
 
   Router.prototype.handleInvalidIncomingMessage_ = function(message, error) {
-    this.close();
-  }
+    if (!this.testingController_) {
+      // TODO(yzshen): Consider logging and notifying the embedder.
+      // TODO(yzshen): This should also trigger connection error handler.
+      // Consider making accept() return a boolean and let the connector deal
+      // with this, as the C++ code does.
+      this.close();
+      return;
+    }
+
+    this.testingController_.onInvalidIncomingMessage(error);
+  };
 
   Router.prototype.handleConnectionError_ = function(result) {
     this.completers_.forEach(function(value) {
       value.reject(result);
     });
     if (this.errorHandler_)
       this.errorHandler_();
     this.close();
   };
 
-  // The TestRouter subclass is only intended to be used in unit tests.
-  // It defeats valid message handling and delgates invalid message handling.
+  // The RouterTestingController is used in unit tests. It defeats valid message
+  // handling and delgates invalid message handling.
 
-  function TestRouter(handle, connectorFactory) {
-    Router.call(this, handle, connectorFactory);
+  function RouterTestingController(connector) {
+    this.connector_ = connector;
+    this.invalidMessageHandler_ = null;
   }
 
-  TestRouter.prototype = Object.create(Router.prototype);
-
-  TestRouter.prototype.handleValidIncomingMessage_ = function() {
+  RouterTestingController.prototype.waitForNextMessage = function() {
+    this.connector_.waitForNextMessageForTesting();
   };
 
-  TestRouter.prototype.handleInvalidIncomingMessage_ =
-      function(message, error) {
-        this.validationErrorHandler(error);
-      };
+  RouterTestingController.prototype.setInvalidIncomingMessageHandler =
+      function(callback) {
+    this.invalidMessageHandler_ = callback;
+  };
+
+  RouterTestingController.prototype.onInvalidIncomingMessage =
+      function(error) {
+    if (this.invalidMessageHandler_)
+      this.invalidMessageHandler_(error);
+  };
 
   var exports = {};
   exports.Router = Router;
-  exports.TestRouter = TestRouter;
   return exports;
 });