Add interface versioning. Methods queryVersion and requireVersion.

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", [
   "console",
   "mojo/public/js/codec",
   "mojo/public/js/core",
   "mojo/public/js/connector",
+  "mojo/public/js/lib/control_message_handler",
   "mojo/public/js/validator",
-], function(console, codec, core, connector, validator) {
+], function(console, codec, core, connector, controlMessageHandler, validator) {
 
   var Connector = connector.Connector;
   var MessageReader = codec.MessageReader;
   var Validator = validator.Validator;
+  var ControlMessageHandler = controlMessageHandler.ControlMessageHandler;
 
-  function Router(handle, connectorFactory) {
+  function Router(handle, interface_version, 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;
 
+    if (interface_version !== undefined) {
+      this.controlMessageHandler_ = new
+          ControlMessageHandler(interface_version);
+    }
+
     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.
@@ skipping 60 matching lines @@
       this.handleValidIncomingMessage_(message);
     else
       this.handleInvalidIncomingMessage_(message, err);
   };
 
   Router.prototype.handleValidIncomingMessage_ = function(message) {
     if (this.testingController_)
       return;
 
     if (message.expectsResponse()) {
-      if (this.incomingReceiver_) {
+      if (controlMessageHandler.isControlMessage(message)) {
+        if (this.controlMessageHandler_) {
+          this.controlMessageHandler_.acceptWithResponder(message, this);
+        } else {
+          this.close();
+        }
+      } else 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);
       if (completer) {
         this.completers_.delete(requestID);
         completer.resolve(message);
       } else {
         console.log("Unexpected response with request ID: " + requestID);
       }
     } else {
-      if (this.incomingReceiver_)
+      if (controlMessageHandler.isControlMessage(message)) {
+        if (this.controlMessageHandler_) {
+          var ok = this.controlMessageHandler_.accept(message);
+          if (ok) return;
+        }
+        this.close();
+      } else if (this.incomingReceiver_) {
         this.incomingReceiver_.accept(message);
+      }
     }
   };
 
   Router.prototype.handleInvalidIncomingMessage_ = function(message, error) {
     if (!this.testingController_) {
       // TODO(yzshen): Consider 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.
       console.log("Invalid message: " + validator.validationError[error]);
@@ skipping 34 matching lines @@
   RouterTestingController.prototype.onInvalidIncomingMessage =
       function(error) {
     if (this.invalidMessageHandler_)
       this.invalidMessageHandler_(error);
   };
 
   var exports = {};
   exports.Router = Router;
   return exports;
 });