Add associated interfaces & bindings.

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/connector",
   "mojo/public/js/core",
   "mojo/public/js/interface_types",
   "mojo/public/js/lib/interface_endpoint_handle",
   "mojo/public/js/lib/pipe_control_message_handler",
@@ skipping 56 matching lines @@
     this.connector_.setIncomingReceiver({
         accept: this.accept.bind(this),
     });
     this.connector_.setErrorHandler({
         onError: this.onPipeConnectionError.bind(this),
     });
 
     this.setInterfaceIdNamespaceBit_ = setInterfaceIdNamespaceBit;
     this.controlMessageHandler_ = new PipeControlMessageHandler(this);
     this.controlMessageProxy_ = new PipeControlMessageProxy(this.connector_);
-    this.nextInterfaceIdValue = 1;
+    this.nextInterfaceIdValue_ = 1;
     this.encounteredError_ = false;
     this.endpoints_ = new Map();
   }
 
+  Router.prototype.associateInterface = function(handleToSend) {
+    if (!handleToSend.pendingAssociation()) {
+      return types.kInvalidInterfaceId;
+    }
+
+    var id = 0;
+    do {
+      if (this.nextInterfaceIdValue_ >= types.kInterfaceIdNamespaceMask) {
+        this.nextInterfaceIdValue_ = 1;
+      }
+      id = this.nextInterfaceIdValue_++;
+      if (this.setInterfaceIdNamespaceBit_) {
+        id += types.kInterfaceIdNamespaceMask;
+      }
+    } while (this.endpoints_.has(id));
+
+    var endpoint = new InterfaceEndpoint(this, id);
+    this.endpoints_.set(id, endpoint);
+    if (this.encounteredError_) {
+      this.updateEndpointStateMayRemove(endpoint,
+          EndpointStateUpdateType.PEER_ENDPOINT_CLOSED);
+    }
+    endpoint.handleCreated = true;
+
+    if (!handleToSend.notifyAssociation(id, this)) {
+      // The peer handle of |handleToSend|, which is supposed to join this
+      // associated group, has been closed.
+      this.updateEndpointStateMayRemove(endpoint,
+          EndpointStateUpdateType.ENDPOINT_CLOSED);
+
+      pipeControlMessageproxy.notifyPeerEndpointClosed(id,
+          handleToSend.disconnectReason());
+    }
+
+    return id;
+  };
+
   Router.prototype.attachEndpointClient = function(
       interfaceEndpointHandle, interfaceEndpointClient) {
     check(types.isValidInterfaceId(interfaceEndpointHandle.id()));
     check(interfaceEndpointClient);
 
     var endpoint = this.endpoints_.get(interfaceEndpointHandle.id());
     check(endpoint);
     check(!endpoint.client);
     check(!endpoint.closed);
     endpoint.client = interfaceEndpointClient;
@@ skipping 50 matching lines @@
     return new InterfaceEndpointHandle(interfaceId, this);
   };
 
   Router.prototype.accept = function(message) {
     var messageValidator = new Validator(message);
     var err = messageValidator.validateMessageHeader();
 
     var ok = false;
     if (err !== validator.validationError.NONE) {
       validator.reportValidationError(err);
-    } else if (controlMessageHandler.isPipeControlMessage(message)) {
-      ok = this.controlMessageHandler_.accept(message);
-    } else {
-      var interfaceId = message.getInterfaceId();
-      var endpoint = this.endpoints_.get(interfaceId);
-      if (!endpoint || endpoint.closed) {
-        return true;
+    } else if (message.deserializeAssociatedEndpointHandles(this)) {
+      if (controlMessageHandler.isPipeControlMessage(message)) {
+        ok = this.controlMessageHandler_.accept(message);
+      } else {
+        var interfaceId = message.getInterfaceId();
+        var endpoint = this.endpoints_.get(interfaceId);
+        if (!endpoint || endpoint.closed) {
+          return true;
+        }
+
+        if (!endpoint.client) {
+          // We need to wait until a client is attached in order to dispatch
+          // further messages.
+          // TODO(wangjimmy): Cache the message and send when the appropriate
+          // endpoint client is attached.
+          return false;
+        }
+        ok = endpoint.client.handleIncomingMessage(message, messageValidator);
       }
-
-      if (!endpoint.client) {
-        // We need to wait until a client is attached in order to dispatch
-        // further messages.
-        return false;
-      }
-      ok = endpoint.client.handleIncomingMessage_(message);
     }
 
     if (!ok) {
       this.handleInvalidIncomingMessage_();
     }
     return ok;
   };
 
   Router.prototype.close = function() {
     this.connector_.close();
@@ skipping 83 matching lines @@
     }
     if (endpoint.closed && endpoint.peerClosed) {
       this.endpoints_.delete(endpoint.id);
     }
   };
 
   var exports = {};
   exports.Router = Router;
   return exports;
 });