Add associated interfaces & bindings.

mojo/public/js/codec.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/codec", [
   "mojo/public/js/buffer",
   "mojo/public/js/interface_types",
   "mojo/public/js/lib/interface_endpoint_handle",
   "mojo/public/js/unicode",
 ], function(buffer, types, interfaceEndpointHandle, unicode) {
@@ skipping 25 matching lines @@
   var kMessageV2HeaderSize = 48;
   var kMapStructPayloadSize = 16;
 
   var kStructHeaderNumBytesOffset = 0;
   var kStructHeaderVersionOffset = 4;
 
   var kEncodedInvalidHandleValue = 0xFFFFFFFF;
 
   // Decoder ------------------------------------------------------------------
 
-  function Decoder(buffer, handles, base) {
+  function Decoder(buffer, handles, base, associatedEndpointHandles) {

[yzshen1, 2017/04/19 21:11:34]

nit: it may make sense to re-order the parameters to have |handles| and
|associatedEndpointHandles| next to each other.

[wangjimmy, 2017/04/20 15:36:44]

Done.

     this.buffer = buffer;
     this.handles = handles;
+    this.associatedEndpointHandles = associatedEndpointHandles;
     this.base = base;
     this.next = base;
   }
 
   Decoder.prototype.align = function() {
     this.next = align(this.next);
   };
 
   Decoder.prototype.skip = function(offset) {
     this.next += offset;
@@ skipping 63 matching lines @@
     // TODO(abarth): To correctly decode a pointer, we need to know the real
     // base address of the array buffer.
     var offsetPointer = this.next;
     var offset = this.readUint64();
     if (!offset)
       return 0;
     return offsetPointer + offset;
   };
 
   Decoder.prototype.decodeAndCreateDecoder = function(pointer) {
-    return new Decoder(this.buffer, this.handles, pointer);
+    return new Decoder(this.buffer, this.handles, pointer,
+        this.associatedEndpointHandles);
   };
 
   Decoder.prototype.decodeHandle = function() {
     return this.handles[this.readUint32()] || null;
   };
 
+  Decoder.prototype.decodeAssociatedEndpointHandle = function() {
+    if (this.associatedEndpointHandles) {

[yzshen1, 2017/04/19 21:11:34]

Under what circumstances decodeAssociatedEndpointHandle would be called with
this.associatedEndpointHandles == null? Is it when the handle decoded is an
invalid handle?

[wangjimmy, 2017/04/20 15:36:43]

Yes. Before a new Decoder could be created without passing in
associatedEndpointHandles so it'd be undefined. But now a Decoder is always
passed associatedEndpointHandles either as [] or [endpointHandles...].

+      var index = this.readUint32();
+      return this.associatedEndpointHandles[index] || null;
+    }
+    return null;
+  };
+
   Decoder.prototype.decodeString = function() {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var base = this.next;
     this.next += numberOfElements;
     return unicode.decodeUtf8String(
         new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements));
   };
 
   Decoder.prototype.decodeArray = function(cls) {
@@ skipping 58 matching lines @@
     var pointer = this.decodePointer();
     if (!pointer) {
       return null;
     }
     var decoder = this.decodeAndCreateDecoder(pointer);
     return decoder.decodeMap(keyClass, valueClass);
   };
 
   // Encoder ------------------------------------------------------------------
 
-  function Encoder(buffer, handles, base) {
+  function Encoder(buffer, handles, base, associatedEndpointHandles) {

[yzshen1, 2017/04/19 21:11:34]

nit: it may make sense to re-order the parameters to have |handles| and
|associatedEndpointHandles| next to each other.

[wangjimmy, 2017/04/20 15:36:43]

Done.

     this.buffer = buffer;
     this.handles = handles;
+    this.associatedEndpointHandles = associatedEndpointHandles;
     this.base = base;
     this.next = base;
   }
 
   Encoder.prototype.align = function() {
     this.next = align(this.next);
   };
 
   Encoder.prototype.skip = function(offset) {
     this.next += offset;
@@ skipping 66 matching lines @@
       return this.writeUint64(0);
     // TODO(abarth): To correctly encode a pointer, we need to know the real
     // base address of the array buffer.
     var offset = pointer - this.next;
     this.writeUint64(offset);
   };
 
   Encoder.prototype.createAndEncodeEncoder = function(size) {
     var pointer = this.buffer.alloc(align(size));
     this.encodePointer(pointer);
-    return new Encoder(this.buffer, this.handles, pointer);
+    return new Encoder(this.buffer, this.handles, pointer,
+        this.associatedEndpointHandles);
   };
 
   Encoder.prototype.encodeHandle = function(handle) {
     if (handle) {
       this.handles.push(handle);
       this.writeUint32(this.handles.length - 1);
     } else {
       this.writeUint32(kEncodedInvalidHandleValue);
     }
   };
 
+  Encoder.prototype.encodeAssociatedEndpointHandle = function(endpointHandle) {
+    if (this.associatedEndpointHandles && endpointHandle) {

[yzshen1, 2017/04/19 21:11:34]

Under what circumstances we would want to encode a valid endpoint handle but
this.associatedEndpointHandles == null?

I think that shouldn't happen, right?

[wangjimmy, 2017/04/20 15:36:43]

Removed. It shouldn't happen. I had a check because before Encoder could be
created with associatedEndpointHandles == null when encoding messages with no
associated endpoint handles, but in that encodeAssociatedEndpointHandle would
never be called.

+      this.associatedEndpointHandles.push(endpointHandle);
+      this.writeUint32(this.associatedEndpointHandles.length - 1);
+    } else {
+      this.writeUint32(kEncodedInvalidHandleValue);
+    }
+  };
+
   Encoder.prototype.encodeString = function(val) {
     var base = this.next + kArrayHeaderSize;
     var numberOfElements = unicode.encodeUtf8String(
         val, new Uint8Array(this.buffer.arrayBuffer, base));
     var numberOfBytes = kArrayHeaderSize + numberOfElements;
     this.writeUint32(numberOfBytes);
     this.writeUint32(numberOfElements);
     this.next += numberOfElements;
   };
 
@@ skipping 101 matching lines @@
 
   var kMessageInterfaceIdOffset = kStructHeaderSize;
   var kMessageNameOffset = kMessageInterfaceIdOffset + 4;
   var kMessageFlagsOffset = kMessageNameOffset + 4;
   var kMessageRequestIDOffset = kMessageFlagsOffset + 8;
   var kMessagePayloadInterfaceIdsPointerOffset = kMessageV2HeaderSize - 8;
 
   var kMessageExpectsResponse = 1 << 0;
   var kMessageIsResponse      = 1 << 1;
 
-  function Message(buffer, handles) {
+  function Message(buffer, handles, associatedEndpointHandles) {
+    if (associatedEndpointHandles === undefined) {
+      associatedEndpointHandles = [];
+    }
+
     this.buffer = buffer;
     this.handles = handles;
+    this.associatedEndpointHandles = associatedEndpointHandles;
   }
 
   Message.prototype.getHeaderNumBytes = function() {
     return this.buffer.getUint32(kStructHeaderNumBytesOffset);
   };
 
   Message.prototype.getHeaderVersion = function() {
     return this.buffer.getUint32(kStructHeaderVersionOffset);
   };
 
@@ skipping 30 matching lines @@
 
   Message.prototype.setRequestID = function(requestID) {
     // TODO(darin): Verify that space was reserved for this field!
     this.buffer.setUint64(kMessageRequestIDOffset, requestID);
   };
 
   Message.prototype.setInterfaceId = function(interfaceId) {
     this.buffer.setUint32(kMessageInterfaceIdOffset, interfaceId);
   };
 
+  Message.prototype.setPayloadInterfaceIds = function(payloadInterfaceIds) {

[yzshen1, 2017/04/19 21:11:34]

Is this supposed to be a private method? If yes please append a trailing "_" to
the name.

[wangjimmy, 2017/04/20 15:36:43]

Done.

+    if (this.getHeaderVersion() < 2) {
+      throw new Error(
+          "Version of message does not support payload interface ids.");
+    }
+
+    var decoder = new Decoder(this.buffer, this.handles,
+        kMessageV2HeaderSize-8);

[yzshen1, 2017/04/19 21:11:34]

I thought you have defined a constant for this offset?

[wangjimmy, 2017/04/20 15:36:43]

Done. Used it in new patch. Thanks for the catch.

+    var payloadInterfaceIdsOffset = decoder.decodePointer();
+    var encoder = new Encoder(this.buffer, this.handles,
+        payloadInterfaceIdsOffset);
+    encoder.encodeArray(Uint32, payloadInterfaceIds);
+  };
+
+  Message.prototype.serializeAssociatedEndpointHandles = function(
+      associatedGroupController) {
+    if (this.associatedEndpointHandles.length > 0) {
+      if (this.getHeaderVersion() < 2) {
+        throw new Error();

[yzshen1, 2017/04/19 21:11:34]

Please give a description.

[wangjimmy, 2017/04/20 15:36:43]

Done.

+      }
+
+      var data = [];
+      for (var i = 0; i < this.associatedEndpointHandles.length; i++) {
+        var handle = this.associatedEndpointHandles[i];
+        data.push(associatedGroupController.associateInterface(handle));
+      }
+      this.associatedEndpointHandles = [];
+      this.setPayloadInterfaceIds(data);
+    }
+  };
+
+  Message.prototype.deserializeAssociatedEndpointHandles = function(
+      associatedGroupController) {
+    if (this.getHeaderVersion() < 2) {
+      return true;
+    }
+
+    this.associatedEndpointHandles = [];
+    var ids = this.getPayloadInterfaceIds();
+
+    var result = true;
+    for (var i = 0; i < ids.length; i++) {
+      var handle = associatedGroupController.createLocalEndpointHandle(ids[i]);
+      if (types.isValidInterfaceId(ids[i]) && !handle.isValid()) {
+        // |ids[i]| itself is valid but handle creation failed. In that case,
+        // mark deserialization as failed but continue to deserialize the
+        // rest of handles.
+        result = false;
+      }
+      this.associatedEndpointHandles.push(handle);
+      ids[i] = types.kInvalidInterfaceId;
+    }
+
+    this.setPayloadInterfaceIds(ids);
+    return result;
+  };
+
 
   // MessageBuilder -----------------------------------------------------------
 
   function MessageBuilder(messageName, payloadSize) {
     // Currently, we don't compute the payload size correctly ahead of time.
     // Instead, we resize the buffer at the end.
     var numberOfBytes = kMessageV0HeaderSize + payloadSize;
     this.buffer = new buffer.Buffer(numberOfBytes);
     this.handles = [];
     var encoder = this.createEncoder(kMessageV0HeaderSize);
@@ skipping 20 matching lines @@
     this.buffer.trim();
     var message = new Message(this.buffer, this.handles);
     this.buffer = null;
     this.handles = null;
     this.encoder = null;
     return message;
   };
 
   // MessageWithRequestIDBuilder -----------------------------------------------
 
   function MessageWithRequestIDBuilder(messageName, payloadSize, flags,

[yzshen1, 2017/04/19 21:11:34]

Please change this to MessageV1Builder. (And the one above to MessageV0Builder)

[wangjimmy, 2017/04/20 15:36:43]

Done.

                                        requestID) {
     // Currently, we don't compute the payload size correctly ahead of time.
     // Instead, we resize the buffer at the end.
     var numberOfBytes = kMessageV1HeaderSize + payloadSize;
     this.buffer = new buffer.Buffer(numberOfBytes);
     this.handles = [];
     var encoder = this.createEncoder(kMessageV1HeaderSize);
     encoder.writeUint32(kMessageV1HeaderSize);
     encoder.writeUint32(1);  // version.
     encoder.writeUint32(0);  // interface ID.
     encoder.writeUint32(messageName);
     encoder.writeUint32(flags);
     encoder.writeUint32(0);  // padding.
     encoder.writeUint64(requestID);
   }
 
   MessageWithRequestIDBuilder.prototype =
       Object.create(MessageBuilder.prototype);
 
   MessageWithRequestIDBuilder.prototype.constructor =
       MessageWithRequestIDBuilder;
 
+  // MessageV2 -----------------------------------------------
+
+  function MessageV2Builder(messageName, payloadSize, flags, requestID) {
+    // Currently, we don't compute the payload size correctly ahead of time.
+    // Instead, we resize the buffer at the end.
+    var numberOfBytes = kMessageV2HeaderSize + payloadSize;
+    this.buffer = new buffer.Buffer(numberOfBytes);
+    this.handles = [];
+
+    this.payload = null;
+    this.associatedEndpointHandles = [];
+
+    this.encoder = this.createEncoder(kMessageV2HeaderSize);
+    this.encoder.writeUint32(kMessageV2HeaderSize);
+    this.encoder.writeUint32(2);  // version.
+    // Gets set to an appropriate interfaceId for the endpoint by the IEC.

[yzshen1, 2017/04/19 21:11:34]

Please change IEC to the full name.

[wangjimmy, 2017/04/20 15:36:43]

Done.

+    this.encoder.writeUint32(0);  // interface ID..

[yzshen1, 2017/04/19 21:11:34]

Please remove a redundant '.'

[wangjimmy, 2017/04/20 15:36:43]

Done.

+    this.encoder.writeUint32(messageName);
+    this.encoder.writeUint32(flags);
+    this.encoder.writeUint32(0);  // padding.
+    this.encoder.writeUint64(requestID);
+  }
+
+  MessageV2Builder.prototype.createEncoder = function(size) {
+    var pointer = this.buffer.alloc(size);
+    return new Encoder(this.buffer, this.handles, pointer,
+        this.associatedEndpointHandles);
+  };
+
+  MessageV2Builder.prototype.setPayload = function(cls, val) {
+    this.payload = {cls: cls, val: val};
+  };
+
+  MessageV2Builder.prototype.finish = function() {
+    if (!this.payload) {
+      throw new Error();

[yzshen1, 2017/04/19 21:11:34]

Please add a description.

[wangjimmy, 2017/04/20 15:36:43]

Done.

+    }
+
+    this.encoder.encodeStructPointer(this.payload.cls, this.payload.val);
+    this.encoder.encodeArrayPointer(Uint32,
+        new Array(this.associatedEndpointHandles.length));
+
+    this.buffer.trim();
+    var message = new Message(this.buffer, this.handles,
+        this.associatedEndpointHandles);
+    this.buffer = null;
+    this.handles = null;
+    this.encoder = null;
+    this.payload = null;
+    this.associatedEndpointHandles = null;
+
+    return message;
+  };
+
   // MessageReader ------------------------------------------------------------
 
   function MessageReader(message) {
-    this.decoder = new Decoder(message.buffer, message.handles, 0);
+    this.decoder = new Decoder(message.buffer, message.handles, 0,
+        message.associatedEndpointHandles);
     var messageHeaderSize = this.decoder.readUint32();
     this.payloadSize = message.buffer.byteLength - messageHeaderSize;
     var version = this.decoder.readUint32();
     var interface_id = this.decoder.readUint32();
     this.messageName = this.decoder.readUint32();
     this.flags = this.decoder.readUint32();
     // Skip the padding.
     this.decoder.skip(4);
     if (version >= 1)
       this.requestID = this.decoder.readUint64();
@@ skipping 282 matching lines @@
     Interface.call(this, cls);
   }
 
   NullableInterface.prototype = Object.create(Interface.prototype);
 
   function AssociatedInterfacePtrInfo() {
   }
 
   AssociatedInterfacePtrInfo.prototype.encodedSize = 8;
 
+  AssociatedInterfacePtrInfo.decode = function(decoder) {
+    return new types.AssociatedInterfacePtrInfo(
+      decoder.decodeAssociatedEndpointHandle(), decoder.readUint32());
+  };
+
+  AssociatedInterfacePtrInfo.encode = function(encoder, val) {
+    var associatedinterfacePtrInfo =
+        val ? val : new types.AssociatedInterfacePtrInfo(null, 0);
+    encoder.encodeAssociatedEndpointHandle(
+        associatedinterfacePtrInfo.interfaceEndpointHandle);
+    encoder.writeUint32(associatedinterfacePtrInfo.version);
+  };
+
   function NullableAssociatedInterfacePtrInfo() {
   }
 
   NullableAssociatedInterfacePtrInfo.encodedSize =
       AssociatedInterfacePtrInfo.encodedSize;
 
+  NullableAssociatedInterfacePtrInfo.decode =
+      AssociatedInterfacePtrInfo.decode;
+
+  NullableAssociatedInterfacePtrInfo.encode =
+      AssociatedInterfacePtrInfo.encode;
+
   function InterfaceRequest() {
   }
 
   InterfaceRequest.encodedSize = 4;
 
   InterfaceRequest.decode = function(decoder) {
     return new types.InterfaceRequest(decoder.decodeHandle());
   };
 
   InterfaceRequest.encode = function(encoder, val) {
     encoder.encodeHandle(val ? val.handle : null);
   };
 
   function NullableInterfaceRequest() {
   }
 
   NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize;
 
   NullableInterfaceRequest.decode = InterfaceRequest.decode;
 
   NullableInterfaceRequest.encode = InterfaceRequest.encode;
 
   function AssociatedInterfaceRequest() {
   }
 
+  AssociatedInterfaceRequest.decode = function(decoder) {
+    var handle = decoder.decodeAssociatedEndpointHandle();
+    return new types.AssociatedInterfaceRequest(handle);
+  };
+
+  AssociatedInterfaceRequest.encode = function(encoder, val) {
+    encoder.encodeAssociatedEndpointHandle(
+        val ? val.interfaceEndpointHandle : null);
+  };
+
   AssociatedInterfaceRequest.encodedSize = 4;
 
   function NullableAssociatedInterfaceRequest() {
   }
 
   NullableAssociatedInterfaceRequest.encodedSize =
       AssociatedInterfaceRequest.encodedSize;
 
+  NullableAssociatedInterfaceRequest.decode =
+      AssociatedInterfaceRequest.decode;
+
+  NullableAssociatedInterfaceRequest.encode =
+      AssociatedInterfaceRequest.encode;
+
   function MapOf(keyClass, valueClass) {
     this.keyClass = keyClass;
     this.valueClass = valueClass;
   }
 
   MapOf.prototype.encodedSize = 8;
 
   MapOf.prototype.decode = function(decoder) {
     return decoder.decodeMapPointer(this.keyClass, this.valueClass);
   };
 
   MapOf.prototype.encode = function(encoder, val) {
     encoder.encodeMapPointer(this.keyClass, this.valueClass, val);
   };
 
   function NullableMapOf(keyClass, valueClass) {
     MapOf.call(this, keyClass, valueClass);
   }
 
   NullableMapOf.prototype = Object.create(MapOf.prototype);
 
   var exports = {};
   exports.align = align;
   exports.isAligned = isAligned;
   exports.Message = Message;
   exports.MessageBuilder = MessageBuilder;
+  exports.MessageV2Builder = MessageV2Builder;
   exports.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
   exports.MessageReader = MessageReader;
   exports.kArrayHeaderSize = kArrayHeaderSize;
   exports.kMapStructPayloadSize = kMapStructPayloadSize;
   exports.kStructHeaderSize = kStructHeaderSize;
   exports.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
   exports.kMessageV0HeaderSize = kMessageV0HeaderSize;
   exports.kMessageV1HeaderSize = kMessageV1HeaderSize;
   exports.kMessageV2HeaderSize = kMessageV2HeaderSize;
   exports.kMessagePayloadInterfaceIdsPointerOffset =
@@ skipping 27 matching lines @@
   exports.AssociatedInterfacePtrInfo = AssociatedInterfacePtrInfo;
   exports.NullableAssociatedInterfacePtrInfo =
       NullableAssociatedInterfacePtrInfo;
   exports.AssociatedInterfaceRequest = AssociatedInterfaceRequest;
   exports.NullableAssociatedInterfaceRequest =
       NullableAssociatedInterfaceRequest;
   exports.MapOf = MapOf;
   exports.NullableMapOf = NullableMapOf;
   return exports;
 });