Add associated interfaces & bindings.

mojo/public/js/lib/interface_endpoint_client.js

 // Copyright 2017 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/lib/interface_endpoint_client", [
   "console",
   "mojo/public/js/codec",
   "mojo/public/js/lib/control_message_handler",
   "mojo/public/js/lib/control_message_proxy",
   "mojo/public/js/lib/interface_endpoint_handle",
   "mojo/public/js/validator",
   "timer",
 ], function(console,
             codec,
             controlMessageHandler,
             controlMessageProxy,
             interfaceEndpointHandle,
             validator,
             timer) {
 
   var ControlMessageHandler = controlMessageHandler.ControlMessageHandler;
   var ControlMessageProxy = controlMessageProxy.ControlMessageProxy;
   var MessageReader = codec.MessageReader;
-  var Validator = validator.Validator;
   var InterfaceEndpointHandle = interfaceEndpointHandle.InterfaceEndpointHandle;
+  var AssociationEvent = interfaceEndpointHandle.AssociationEvent;
 
   function InterfaceEndpointClient(interfaceEndpointHandle, receiver,
       interfaceVersion) {
     this.controller_ = null;
     this.encounteredError_ = false;
     this.handle_ = interfaceEndpointHandle;
     this.incomingReceiver_ = receiver;
 
     if (interfaceVersion !== undefined) {
       this.controlMessageHandler_ = new ControlMessageHandler(
@@ skipping 19 matching lines @@
     if (this.controller_ || this.handle_.pendingAssociation()) {
       return;
     }
 
     this.controller_ = this.handle_.groupController().attachEndpointClient(
         this.handle_, this);
   };
 
   InterfaceEndpointClient.prototype.onAssociationEvent = function(
       associationEvent) {
-    if (associationEvent ===
-        InterfaceEndpointHandle.AssociationEvent.ASSOCIATED) {
+    if (associationEvent === AssociationEvent.ASSOCIATED) {
       this.initControllerIfNecessary_();
     } else if (associationEvent ===
-        InterfaceEndpointHandle.AssociationEvent
-                               .PEER_CLOSED_BEFORE_ASSOCIATION) {
+          AssociationEvent.PEER_CLOSED_BEFORE_ASSOCIATION) {
       timer.createOneShot(0, this.notifyError.bind(this,
           this.handle_.disconnectReason()));
     }
   };
 
   InterfaceEndpointClient.prototype.passHandle = function() {
     if (!this.handle_.isValid()) {
       return new InterfaceEndpointHandle();
     }
 
     // Used to clear the previously set callback.
     this.handle_.setAssociationEventHandler(undefined);
 
     if (this.controller_) {
       this.controller_ = null;
       this.handle_.groupController().detachEndpointClient(this.handle_);
     }
     var handle = this.handle_;
     this.handle_ = null;
     return handle;
   };
 
   InterfaceEndpointClient.prototype.close = function(reason) {
     var handle = this.passHandle();
     handle.reset(reason);
   };
 
   InterfaceEndpointClient.prototype.accept = function(message) {
+    if (message.associatedEndpointHandles.length > 0) {
+      message.serializeAssociatedEndpointHandles(
+          this.handle_.groupController());
+    }
+
     if (this.encounteredError_) {
       return false;
     }
 
     this.initControllerIfNecessary_();
     return this.controller_.sendMessage(message);
   };
 
   InterfaceEndpointClient.prototype.acceptAndExpectResponse = function(
       message) {
+    if (message.associatedEndpointHandles.length > 0) {
+      message.serializeAssociatedEndpointHandles(
+          this.handle_.groupController());
+    }
+
     if (this.encounteredError_) {
       return Promise.reject();
     }
 
     this.initControllerIfNecessary_();
 
     // Reserve 0 in case we want it to convey special meaning in the future.
     var requestID = this.nextRequestID_++;
     if (requestID === 0)
       requestID = this.nextRequestID_++;
@@ skipping 18 matching lines @@
 
   InterfaceEndpointClient.prototype.setIncomingReceiver = function(receiver) {
     this.incomingReceiver_ = receiver;
   };
 
   InterfaceEndpointClient.prototype.setConnectionErrorHandler = function(
       handler) {
     this.connectionErrorHandler_ = handler;
   };
 
-  InterfaceEndpointClient.prototype.handleIncomingMessage_ = function(
-      message) {
+  InterfaceEndpointClient.prototype.handleIncomingMessage = function(message,
+      messageValidator) {
     var noError = validator.validationError.NONE;
-    var messageValidator = new Validator(message);
     var err = noError;
     for (var i = 0; err === noError && i < this.payloadValidators_.length; ++i)
       err = this.payloadValidators_[i](messageValidator);
 
     if (err == noError) {
       return this.handleValidIncomingMessage_(message);
     } else {
       validator.reportValidationError(err);
       return false;
     }
@@ skipping 62 matching lines @@
 
   InterfaceEndpointClient.prototype.requireVersion = function(version) {
     this.controlMessageProxy_.requireVersion(version);
   };
 
   var exports = {};
   exports.InterfaceEndpointClient = InterfaceEndpointClient;
 
   return exports;
 });