Fifo order should be preserved for messages on associated interfaces.

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 54 matching lines @@
     this.connector_ = new Connector(handle);
 
     this.connector_.setIncomingReceiver({
         accept: this.accept.bind(this),
     });
     this.connector_.setErrorHandler({
         onError: this.onPipeConnectionError.bind(this),
     });
 
     this.setInterfaceIdNamespaceBit_ = setInterfaceIdNamespaceBit;
+    // |cachedMessageData| caches infomation about a message, so it can be
+    // processed later if a client is not yet attached to the target endpoint.
+    this.cachedMessageData = null;
     this.controlMessageHandler_ = new PipeControlMessageHandler(this);
     this.controlMessageProxy_ = new PipeControlMessageProxy(this.connector_);
     this.nextInterfaceIdValue_ = 1;
     this.encounteredError_ = false;
     this.endpoints_ = new Map();
   }
 
   Router.prototype.associateInterface = function(handleToSend) {
     if (!handleToSend.pendingAssociation()) {
       return types.kInvalidInterfaceId;
@@ skipping 40 matching lines @@
     check(endpoint);
     check(!endpoint.client);
     check(!endpoint.closed);
     endpoint.client = interfaceEndpointClient;
 
     if (endpoint.peerClosed) {
       timer.createOneShot(0,
           endpoint.client.notifyError.bind(endpoint.client));
     }
 
+    if (this.cachedMessageData && interfaceEndpointHandle.id() ===
+            this.cachedMessageData.message.getInterfaceId()) {
+      timer.createOneShot(0, (function() {

[wangjimmy, 2017/04/24 19:04:33]

TODO(wangjimmy): Check endpoint client still exists here.

[yzshen1, 2017/04/24 19:21:49]

I hope this could be addressed in this CL, which shouldn't be too difficult.

When the timer fires, you need to use the interface ID from the
cachedMessageData to loop up the endpoints map, and see whether it has got a
client attached, if yes, you can directly called into client.

[wangjimmy, 2017/04/24 21:16:39]

Done.

+        var ok = interfaceEndpointClient.handleIncomingMessage(
+            this.cachedMessageData.message,
+            this.cachedMessageData.messageValidator);
+
+        if (!ok) {
+          this.handleInvalidIncomingMessage_();
+        }
+        this.cachedMessageData = null;
+        this.connector_.resumeIncomingMethodCallProcessing();
+      }).bind(this));
+    }
+
     return endpoint;
   };
 
   Router.prototype.detachEndpointClient = function(
       interfaceEndpointHandle) {
     check(types.isValidInterfaceId(interfaceEndpointHandle.id()));
     var endpoint = this.endpoints_.get(interfaceEndpointHandle.id());
     check(endpoint);
     check(endpoint.client);
     check(!endpoint.closed);
@@ skipping 47 matching lines @@
       } 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;
+          this.cachedMessageData = {message: message,
+              messageValidator: messageValidator};
+          this.connector_.pauseIncomingMethodCallProcessing();
+          return true;
         }
         ok = endpoint.client.handleIncomingMessage(message, messageValidator);
       }
     }
 
     if (!ok) {
       this.handleInvalidIncomingMessage_();
     }
     return ok;
   };
@@ skipping 86 matching lines @@
     }
     if (endpoint.closed && endpoint.peerClosed) {
       this.endpoints_.delete(endpoint.id);
     }
   };
 
   var exports = {};
   exports.Router = Router;
   return exports;
 });