Support packed arrays of booleans in Mojo messages

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"
 ], function(unicode) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
 
@@ skipping 211 matching lines @@
   Decoder.prototype.decodeArray = function(cls) {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var val = new Array(numberOfElements);
     for (var i = 0; i < numberOfElements; ++i) {
       val[i] = cls.decode(this);
     }
     return val;
   };
 
+  Decoder.prototype.decodeBoolArray = function() {
+    var numberOfBytes = this.readUint32();
+    var numberOfElements = this.readUint32();
+
+    var bitsLength = Math.ceil(numberOfElements / 8);
+    var bits = new Uint8Array(bitsLength);
+    for (var i = 0; i < bitsLength; ++i) {
+      bits[i] = Uint8.decode(this);
+    }
+
+    var val = new Array(numberOfElements);
+    for (var i = 0; i < numberOfElements; ++i) {
+      val[i] = (bits[Math.floor(i / 8)] & (1 << i % 8)) ? true : false;
+    }
+    return val;
+  };
+
   Decoder.prototype.decodeStruct = function(cls) {
     return cls.decode(this);
   };
 
   Decoder.prototype.decodeStructPointer = function(cls) {
     var pointer = this.decodePointer();
     if (!pointer) {
       return null;
     }
     return cls.decode(this.decodeAndCreateDecoder(pointer));
   };
 
   Decoder.prototype.decodeArrayPointer = function(cls) {
     var pointer = this.decodePointer();
     if (!pointer) {
       return null;
     }
     return this.decodeAndCreateDecoder(pointer).decodeArray(cls);
   };
 
+  Decoder.prototype.decodeBoolArrayPointer = function() {
+    var pointer = this.decodePointer();
+    if (!pointer) {
+      return null;
+    }
+    return this.decodeAndCreateDecoder(pointer).decodeBoolArray();
+  };
+
   Decoder.prototype.decodeStringPointer = function() {
     var pointer = this.decodePointer();
     if (!pointer) {
       return null;
     }
     return this.decodeAndCreateDecoder(pointer).decodeString();
   };
 
   // Encoder ------------------------------------------------------------------
 
@@ skipping 95 matching lines @@
   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;
   };
 
-  Encoder.prototype.encodeArray = function(cls, val) {
-    var numberOfElements = val.length;
-    var numberOfBytes = kArrayHeaderSize + cls.encodedSize * numberOfElements;
+  Encoder.prototype.encodeArray = function(cls, val, numberOfElements) {
+    if (numberOfElements === undefined)
+      numberOfElements = val.length;
+    var valLength = val.length;

[Matt Perry, 2014/07/07 22:45:45]

nit: why not just use val.length everywhere?

+    var numberOfBytes = kArrayHeaderSize + cls.encodedSize * valLength;
     this.writeUint32(numberOfBytes);
     this.writeUint32(numberOfElements);
-    for (var i = 0; i < numberOfElements; ++i) {
+    for (var i = 0; i < valLength; ++i) {
       cls.encode(this, val[i]);
     }
   };
 
   Encoder.prototype.encodeStruct = function(cls, val) {
     return cls.encode(this, val);
   };
 
   Encoder.prototype.encodeStructPointer = function(cls, val) {
     if (!val) {
       this.encodePointer(val);
       return;
     }
     var encoder = this.createAndEncodeEncoder(cls.encodedSize);
     cls.encode(encoder, val);
   };
 
   Encoder.prototype.encodeArrayPointer = function(cls, val) {
     if (!val) {
       this.encodePointer(val);
       return;
     }
     var encodedSize = kArrayHeaderSize + cls.encodedSize * val.length;
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeArray(cls, val);
   };
 
+  Encoder.prototype.encodeBoolArrayPointer = function(val) {
+    if (!val) {
+      this.encodePointer(val);
+      return;
+    }
+    var numberOfElements = val.length;
+    var encodedSize = kArrayHeaderSize + Math.ceil(numberOfElements / 8);

[Matt Perry, 2014/07/07 22:45:45]

do you also need to add cls.encodedSize? That reserves space for the pointer, I
thought.

+    var encoder = this.createAndEncodeEncoder(encodedSize);
+
+    var bits = new Uint8Array(Math.ceil(numberOfElements / 8));
+    for (var i = 0; i < numberOfElements; i++) {
+        if (val[i])
+            bits[Math.floor(i / 8)] |= (1 << i % 8);
+    }
+    encoder.encodeArray(Uint8, bits, numberOfElements);
+  };
+
   Encoder.prototype.encodeStringPointer = function(val) {
     if (!val) {
       this.encodePointer(val);
       return;
     }
     var encodedSize = kArrayHeaderSize + unicode.utf8Length(val);
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeString(val);
   };
 
@@ skipping 279 matching lines @@
   ArrayOf.prototype.encodedSize = 8;
 
   ArrayOf.prototype.decode = function(decoder) {
     return decoder.decodeArrayPointer(this.cls);
   };
 
   ArrayOf.prototype.encode = function(encoder, val) {
     encoder.encodeArrayPointer(this.cls, val);
   };
 
+  function ArrayOfBool() {
+  }
+
+  ArrayOfBool.prototype.encodedSize = 8;
+
+  ArrayOfBool.prototype.decode = function(decoder) {
+    return decoder.decodeBoolArrayPointer();
+  };
+
+  ArrayOfBool.prototype.encode = function(encoder, val) {
+    encoder.encodeBoolArrayPointer(val);
+  };
+
   function Handle() {
   }
 
   Handle.encodedSize = 4;
 
   Handle.decode = function(decoder) {
     return decoder.decodeHandle();
   };
 
   Handle.encode = function(encoder, val) {
@@ skipping 18 matching lines @@
   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.ArrayOfBool = ArrayOfBool;
   exports.Handle = Handle;
   return exports;
 });