Fifo order should be preserved for messages on associated interfaces.

third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html

Index: third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html
diff --git a/third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html b/third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html
index 361cff3aafd65806a8fb85df09decb293d72ddd5..8a74d632b6308324e1f32c9c7869ae26e5f934b0 100644
--- a/third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html
+++ b/third_party/WebKit/LayoutTests/mojo/associated_interface_ptr.html
@@ -13,20 +13,23 @@ define([
     "mojo/public/js/bindings",
 ], function(testAssociatedInterfaces, associatedBindings, bindings) {
 
-  function IntegerSenderImpl(callback) {
+  function SenderImpl(callback) {
     this.callback = callback;
   }
 
-  IntegerSenderImpl.prototype.echo = function(value) {
+  SenderImpl.prototype.echo = function(value) {
     return Promise.resolve({value: value});
   };
 
-  IntegerSenderImpl.prototype.send = function(value) {
+  SenderImpl.prototype.send = function(value) {
     if (this.callback) {
       this.callback(value);
     }
   };
 
+  var IntegerSenderImpl = SenderImpl;
+  var StringSenderImpl = SenderImpl;
+
   function IntegerSenderConnectionImpl() {
     this.integerSenderBinding_ = null;
   }
@@ -77,6 +80,33 @@ define([
         {custom_reason: 42, description: 'hey'});
   };
 
+  function SenderConnectionBindLaterImpl(resolve, reject) {
+    this.resolve = resolve;
+    this.reject = reject;
+    this.integerSenderBinding_ = null;
+    this.stringSenderBinding_ = null;
+  }
+
+  SenderConnectionBindLaterImpl.prototype.getIntegerSender =
+      function(integerSenderRequest, callback_type) {
+    setTimeout(() => {
+      this.integerSenderBinding_ = new associatedBindings.AssociatedBinding(
+          testAssociatedInterfaces.IntegerSender,
+          new IntegerSenderImpl(callback_type ? this.resolve : this.reject),
+          integerSenderRequest);
+    }, 0);
+  };
+
+  SenderConnectionBindLaterImpl.prototype.getStringSender =
+      function(stringSenderRequest, callback_type) {
+    setTimeout(() => {
+      this.stringSenderBinding_ = new associatedBindings.AssociatedBinding(
+          testAssociatedInterfaces.StringSender,
+          new StringSenderImpl(callback_type ? this.resolve : this.reject),
+          stringSenderRequest);
+    }, 0);
+  };
+
   promise_test(async () => {
     var integerSenderConnection = new
         testAssociatedInterfaces.IntegerSenderConnectionPtr();
@@ -220,6 +250,58 @@ define([
     await Promise.all([connectionErrorHandler0, connectionErrorHandler1]);
   }, 'all endpoints connectionErrorHandler called on master interface reset');
 
+  promise_test(async () => {
+    var value = await new Promise(function(resolve, reject) {

[yzshen1, 2017/04/24 17:30:46]

I feel that this test is unnecessarily complex.

If we want to test FIFO-ness, we could set up two (or more) associated
interfaces on a pipe, say, impl0 and impl1. And let them record the calls they
received into a shared array.

And at the end we examine the values in this array and check that the elements
are in order.

That seems much easier to understand (and extensible).
WDYT?

[wangjimmy, 2017/04/24 19:03:36]

Done. Modified mojom to not be passing in callback type (resolve or reject).

+      var senderConnection = new
+          testAssociatedInterfaces.SenderConnectionBindLaterPtr();
+      var senderConnectionBinding = new bindings.Binding(
+          testAssociatedInterfaces.SenderConnectionBindLater,
+          new SenderConnectionBindLaterImpl(resolve, reject),
+          bindings.makeRequest(senderConnection));
+
+      var callbackType = {REJECT_CALLBACK: 0, RESOLVE_CALLBACK: 1};
+
+      // Sending AssociatedInterfaceRequest.
+      var stringSenderPtrInfo = new
+          associatedBindings.AssociatedInterfacePtrInfo();
+      var stringSenderRequest = associatedBindings.makeRequest(
+          stringSenderPtrInfo);
+
+      var stringSender = new
+          testAssociatedInterfaces.AssociatedStringSenderPtr();
+      stringSender.ptr.bind(stringSenderPtrInfo);
+      senderConnection.getStringSender(stringSenderRequest,
+          callbackType.REJECT_CALLBACK);
+
+      // Wait for associated endpoint handle to be bound to the binding side
+      // and for method call to return a value. This tests that the message
+      // is cached properly because the handle is bound later.
+      stringSender.echo('hello').then((result) => {
+        assert_equals(result.value, 'hello');
+
+        // integerSender whose binding side has not bound the associated
+        // endpoint handle.
+        var integerSenderPtrInfo = new
+            associatedBindings.AssociatedInterfacePtrInfo();
+        var integerSenderRequest = associatedBindings.makeRequest(
+            integerSenderPtrInfo);
+        var integerSender = new
+            testAssociatedInterfaces.AssociatedIntegerSenderPtr();
+        integerSender.ptr.bind(integerSenderPtrInfo);
+        senderConnection.getIntegerSender(integerSenderRequest,
+            callbackType.RESOLVE_CALLBACK);
+
+        // Test FIFO arrival order of message.
+        integerSender.send(456); // This message should arrive first.
+        stringSender.send('goodbye');
+      });
+    });
+
+    assert_equals(value, 456);
+  }, `cache current message and pause processing incoming messages if endpoint

[yzshen1, 2017/04/24 17:30:46]

int: I think you could convert this long description into a comment. And make
this description shorter? It will be more consistent with other test cases.

[wangjimmy, 2017/04/24 19:03:36]

Done.

+  does not have client attached yet. fifo order should be preserved for
+  messages`);
+
   done();
 });