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 kMessageV2HeaderSize = 48;
   var kMapStructPayloadSize = 16;
 
   var kStructHeaderNumBytesOffset = 0;
   var kStructHeaderVersionOffset = 4;
 
   var kEncodedInvalidHandleValue = 0xFFFFFFFF;
 
   // Decoder ------------------------------------------------------------------
 
   function Decoder(buffer, handles, base) {
@@ skipping 406 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) {
+      throw new Error(
+          "Version of message does not support payload interface ids.");
+    }
+
+    var decoder = new Decoder(this.buffer, this.handles,
+        kMessageV2HeaderSize-8);

[Ken Rockot(use gerrit already), 2017/04/10 22:20:17]

nit: Perhaps this should be its own "constant" like
kMessage2HeaderSizeWithoutInterfaceIds? Maybe with a brief comment explaining
what it is?

[wangjimmy, 2017/04/11 00:21:24]

var messageV2PayloadInterfaceIdsPointer = kMessageV2HeaderSize - 8;
var decoder = new Decoder(this.buffer, this.handles,
    messageV2PayloadInterfaceIdsPointer);

Used a variable to describe what the value calculated is.

+    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!
@@ skipping 361 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;
+
+  AssociatedInterfacePtrInfo.decode = function(decoder) {
+    return new types.AssociatedInterfacePtrInfo(
+        new InterfaceEndpointHandle(decoder.decodeHandle()),
+            decoder.readUint32());
+  };
+
+  AssociatedInterfacePtrInfo.encode = function(encoder, val) {
+    var associatedinterfacePtrInfo =
+        val ? val : new types.AssociatedInterfacePtrInfo(null, 0);
+    encoder.encodeHandle(
+        associatedinterfacePtrInfo.interfaceEndpointHandle.id());
+    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.encodedSize = 4;
+
+  AssociatedInterfaceRequest.decode = function(decoder) {
+    return new types.AssociatedInterfaceRequest(new InterfaceEndpointHandle(
+        decoder.decodeHandle()));
+  };
+
+  AssociatedInterfaceRequest.encode = function(encoder, val) {
+    encoder.encodeHandle(val ? val.interfaceEndpointHandle.id() : null);
+  };
+
+  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);
   };
@@ skipping 14 matching lines @@
   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.kMessageV2HeaderSize = kMessageV2HeaderSize;
   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;
 });