JavaScript bindings for Mojo message validation

mojo/public/js/bindings/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/bindings/codec", [
   "mojo/public/js/bindings/unicode",
   "mojo/public/js/bindings/buffer"
   ], function(unicode, buffer) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
@@ skipping 13 matching lines @@
   // Constants ----------------------------------------------------------------
 
   var kArrayHeaderSize = 8;
   var kStructHeaderSize = 8;
   var kMessageHeaderSize = 16;
   var kMessageWithRequestIDHeaderSize = 24;
 
   var kStructHeaderNumBytesOffset = 0;
   var kStructHeaderNumFieldsOffset = 4;
 
+  var kEncodedInvalidHandleValue = 0xFFFFFFFF;
+
   // Decoder ------------------------------------------------------------------
 
   function Decoder(buffer, handles, base) {
     this.buffer = buffer;
     this.handles = handles;
     this.base = base;
     this.next = base;
   }
 
   Decoder.prototype.skip = function(offset) {
@@ skipping 84 matching lines @@
     var base = this.next;
     this.next += numberOfElements;
     return unicode.decodeUtf8String(
         new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements));
   };
 
   Decoder.prototype.decodeArray = function(cls) {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var val = new Array(numberOfElements);
-    if (cls.cls === PackedBool) {
+    if (cls === PackedBool) {
       var byte;
       for (var i = 0; i < numberOfElements; ++i) {
         if (i % 8 === 0)
           byte = this.readUint8();
         val[i] = (byte & (1 << i % 8)) ? true : false;
       }
     } else {
       for (var i = 0; i < numberOfElements; ++i) {
         val[i] = cls.decode(this);
       }
@@ skipping 137 matching lines @@
   Encoder.prototype.encodeArray =
       function(cls, val, numberOfElements, encodedSize) {
     if (numberOfElements === undefined)
       numberOfElements = val.length;
     if (encodedSize === undefined)
       encodedSize = kArrayHeaderSize + cls.encodedSize * numberOfElements;
 
     this.writeUint32(encodedSize);
     this.writeUint32(numberOfElements);
 
-    if (cls.cls === PackedBool) {
+    if (cls === PackedBool) {
       var byte = 0;
       for (i = 0; i < numberOfElements; ++i) {
         if (val[i])
           byte |= (1 << i % 8);
         if (i % 8 === 7 || i == numberOfElements - 1) {
           Uint8.encode(this, byte);
           byte = 0;
         }
       }
     } else {
@@ skipping 14 matching lines @@
     var encoder = this.createAndEncodeEncoder(cls.encodedSize);
     cls.encode(encoder, val);
   };
 
   Encoder.prototype.encodeArrayPointer = function(cls, val) {
     if (!val) {
       this.encodePointer(val);
       return;
     }
     var numberOfElements = val.length;
-    var encodedSize = kArrayHeaderSize + ((cls.cls === PackedBool) ?
+    var encodedSize = kArrayHeaderSize + ((cls === PackedBool) ?
         Math.ceil(numberOfElements / 8) : cls.encodedSize * numberOfElements);
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeArray(cls, val, numberOfElements, encodedSize);
   };
 
   Encoder.prototype.encodeStringPointer = function(val) {
     if (!val) {
       this.encodePointer(val);
       return;
     }
@@ skipping 17 matching lines @@
   }
 
   Message.prototype.getHeaderNumBytes = function() {
     return this.buffer.getUint32(kStructHeaderNumBytesOffset);
   };
 
   Message.prototype.getHeaderNumFields = function() {
     return this.buffer.getUint32(kStructHeaderNumFieldsOffset);
   };
 
+  Message.prototype.getName = function() {
+    return this.buffer.getUint32(kMessageNameOffset);
+  };
+
   Message.prototype.getFlags = function() {
     return this.buffer.getUint32(kMessageFlagsOffset);
   };
 
   Message.prototype.isResponse = function() {
     return (this.getFlags() & kMessageIsResponse) != 0;
   };
 
   Message.prototype.expectsResponse = function() {
     return (this.getFlags() & kMessageExpectsResponse) != 0;
@@ skipping 287 matching lines @@
 
   var exports = {};
   exports.align = align;
   exports.isAligned = isAligned;
   exports.Message = Message;
   exports.MessageBuilder = MessageBuilder;
   exports.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
   exports.MessageReader = MessageReader;
   exports.kArrayHeaderSize = kArrayHeaderSize;
   exports.kStructHeaderSize = kStructHeaderSize;
+  exports.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
   exports.kMessageHeaderSize = kMessageHeaderSize;
   exports.kMessageWithRequestIDHeaderSize = kMessageWithRequestIDHeaderSize;
   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.PointerTo = PointerTo;
   exports.ArrayOf = ArrayOf;
   exports.PackedBool = PackedBool;
   exports.Handle = Handle;
   return exports;
 });