Associated Message Validation

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, unicode) {
+], function(buffer, types, interfaceEndpointHandle, unicode) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
   var kErrorArray = "Passing non Array for array type";
   var kErrorString = "Passing non String for string type";
   var kErrorMap = "Passing non Map for map type";
+  var InterfaceEndpointHandle = interfaceEndpointHandle.InterfaceEndpointHandle;
 
   // Memory -------------------------------------------------------------------
 
   var kAlignment = 8;
 
   function align(size) {
     return size + (kAlignment - (size % kAlignment)) % kAlignment;
   }
 
   function isAligned(offset) {
     return offset >= 0 && (offset % kAlignment) === 0;
   }
 
   // Constants ----------------------------------------------------------------
 
   var kArrayHeaderSize = 8;
   var kStructHeaderSize = 8;
-  var kMessageHeaderSize = 24;
-  var kMessageWithRequestIDHeaderSize = 32;
+  var kMessageV0HeaderSize = 24;
+  var kMessageV1HeaderSize = 32;
+  var kMessageV2HeaderSize = 48;
   var kMapStructPayloadSize = 16;
 
   var kStructHeaderNumBytesOffset = 0;
   var kStructHeaderVersionOffset = 4;
+  var kMessagePayloadInterfaceIdsPointerOffset = kMessageV2HeaderSize - 8;

[yzshen1, 2017/04/12 00:50:33]

Please move this line to be below line 434

[wangjimmy, 2017/04/12 18:58:25]

Done.

 
   var kEncodedInvalidHandleValue = 0xFFFFFFFF;
 
   // Decoder ------------------------------------------------------------------
 
   function Decoder(buffer, handles, base) {
     this.buffer = buffer;
     this.handles = handles;
     this.base = base;
     this.next = base;
@@ skipping 402 matching lines @@
   };
 
   Message.prototype.getFlags = function() {
     return this.buffer.getUint32(kMessageFlagsOffset);
   };
 
   Message.prototype.getInterfaceId = function() {
     return this.buffer.getUint32(kMessageInterfaceIdOffset);
   };
 
+  Message.prototype.getPayloadInterfaceIds = function() {
+    if (this.getHeaderVersion() < 2) {
+      return null;
+    }
+
+    var decoder = new Decoder(this.buffer, this.handles,
+        kMessagePayloadInterfaceIdsPointerOffset);
+    var payloadInterfaceIds = decoder.decodeArrayPointer(Uint32);
+    return payloadInterfaceIds;
+  };
+
   Message.prototype.isResponse = function() {
     return (this.getFlags() & kMessageIsResponse) != 0;
   };
 
   Message.prototype.expectsResponse = function() {
     return (this.getFlags() & kMessageExpectsResponse) != 0;
   };
 
   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);
   };
 
 
   // 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 = kMessageHeaderSize + payloadSize;
+    var numberOfBytes = kMessageV0HeaderSize + payloadSize;
     this.buffer = new buffer.Buffer(numberOfBytes);
     this.handles = [];
-    var encoder = this.createEncoder(kMessageHeaderSize);
-    encoder.writeUint32(kMessageHeaderSize);
+    var encoder = this.createEncoder(kMessageV0HeaderSize);
+    encoder.writeUint32(kMessageV0HeaderSize);
     encoder.writeUint32(0);  // version.
     encoder.writeUint32(0);  // interface ID.
     encoder.writeUint32(messageName);
     encoder.writeUint32(0);  // flags.
     encoder.writeUint32(0);  // padding.
   }
 
   MessageBuilder.prototype.createEncoder = function(size) {
     var pointer = this.buffer.alloc(size);
     return new Encoder(this.buffer, this.handles, pointer);
@@ skipping 13 matching lines @@
     this.encoder = null;
     return message;
   };
 
   // MessageWithRequestIDBuilder -----------------------------------------------
 
   function MessageWithRequestIDBuilder(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 = kMessageWithRequestIDHeaderSize + payloadSize;
+    var numberOfBytes = kMessageV1HeaderSize + payloadSize;
     this.buffer = new buffer.Buffer(numberOfBytes);
     this.handles = [];
-    var encoder = this.createEncoder(kMessageWithRequestIDHeaderSize);
-    encoder.writeUint32(kMessageWithRequestIDHeaderSize);
+    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);
@@ skipping 295 matching lines @@
     encoder.encodeHandle(interfacePtrInfo.handle);
     encoder.writeUint32(interfacePtrInfo.version);
   };
 
   function NullableInterface(cls) {
     Interface.call(this, cls);
   }
 
   NullableInterface.prototype = Object.create(Interface.prototype);
 
+  function AssociatedInterfacePtrInfo() {
+  }
+
+  AssociatedInterfacePtrInfo.prototype.encodedSize = 8;
+
+  function NullableAssociatedInterfacePtrInfo() {
+  }
+
+  NullableAssociatedInterfacePtrInfo.encodedSize =
+      AssociatedInterfacePtrInfo.encodedSize;
+
   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.encodedSize = 4;
+
+  function NullableAssociatedInterfaceRequest() {
+  }
+
+  NullableAssociatedInterfaceRequest.encodedSize =
+      AssociatedInterfaceRequest.encodedSize;
+
   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);
   };
@@ skipping 12 matching lines @@
   exports.align = align;
   exports.isAligned = isAligned;
   exports.Message = Message;
   exports.MessageBuilder = MessageBuilder;
   exports.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
   exports.MessageReader = MessageReader;
   exports.kArrayHeaderSize = kArrayHeaderSize;
   exports.kMapStructPayloadSize = kMapStructPayloadSize;
   exports.kStructHeaderSize = kStructHeaderSize;
   exports.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
-  exports.kMessageHeaderSize = kMessageHeaderSize;
-  exports.kMessageWithRequestIDHeaderSize = kMessageWithRequestIDHeaderSize;
+  exports.kMessageV0HeaderSize = kMessageV0HeaderSize;
+  exports.kMessageV1HeaderSize = kMessageV1HeaderSize;
+  exports.kMessageV2HeaderSize = kMessageV2HeaderSize;
+  exports.kMessagePayloadInterfaceIdsPointerOffset =

[yzshen1, 2017/04/12 00:50:33]

Is it necessary to export this value?

[wangjimmy, 2017/04/12 18:58:25]

Yes, I use it as the offset for validateArrayPointer in validator.js when
validating the payloadInterfaceIds. I can calculate it using
kMessageV2HeaderSize - 8; if that's preferred.

+      kMessagePayloadInterfaceIdsPointerOffset;
   exports.kMessageExpectsResponse = kMessageExpectsResponse;
   exports.kMessageIsResponse = kMessageIsResponse;
   exports.Int8 = Int8;
   exports.Uint8 = Uint8;
   exports.Int16 = Int16;
   exports.Uint16 = Uint16;
   exports.Int32 = Int32;
   exports.Uint32 = Uint32;
   exports.Int64 = Int64;
   exports.Uint64 = Uint64;
   exports.Float = Float;
   exports.Double = Double;
   exports.String = String;
   exports.Enum = Enum;
   exports.NullableString = NullableString;
   exports.PointerTo = PointerTo;
   exports.NullablePointerTo = NullablePointerTo;
   exports.ArrayOf = ArrayOf;
   exports.NullableArrayOf = NullableArrayOf;
   exports.PackedBool = PackedBool;
   exports.Handle = Handle;
   exports.NullableHandle = NullableHandle;
   exports.Interface = Interface;
   exports.NullableInterface = NullableInterface;
   exports.InterfaceRequest = InterfaceRequest;
   exports.NullableInterfaceRequest = NullableInterfaceRequest;
+  exports.AssociatedInterfacePtrInfo = AssociatedInterfacePtrInfo;
+  exports.NullableAssociatedInterfacePtrInfo =
+      NullableAssociatedInterfacePtrInfo;
+  exports.AssociatedInterfaceRequest = AssociatedInterfaceRequest;
+  exports.NullableAssociatedInterfaceRequest =
+      NullableAssociatedInterfaceRequest;
   exports.MapOf = MapOf;
   exports.NullableMapOf = NullableMapOf;
   return exports;
 });