Add more type validation to codec.js

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/unicode",
   "mojo/public/js/buffer",
 ], function(unicode, buffer) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
-  var kErrorArray = "Passing non-array-like to array";
+  var kErrorArray = "Passing non Array for array type";
+  var kErrorString = "Passing non String for string type";
+  var kErrorMap = "Passing non Map for map type";
 
   // Memory -------------------------------------------------------------------
 
   var kAlignment = 8;
 
   function align(size) {
     return size + (kAlignment - (size % kAlignment)) % kAlignment;
   }
 
   function isAligned(offset) {
@@ skipping 324 matching lines @@
     var encoder = this.createAndEncodeEncoder(cls.encodedSize);
     cls.encode(encoder, val);
   };
 
   Encoder.prototype.encodeArrayPointer = function(cls, val) {
     if (val == null) {
       // Also handles undefined, since undefined == null.
       this.encodePointer(val);
       return;
     }
-    if (val.length === undefined) {
+    if (!(val instanceof Array)) {
       throw new Error(kErrorArray);
     }
     var numberOfElements = val.length;
     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 == null) {
       // Also handles undefined, since undefined == null.
       this.encodePointer(val);
       return;
     }
+    // This only accepts literal strings, not new String("foo").
+    if (typeof(val) !== "string") {

[hansmuller, 2014/12/16 01:10:41]

Don't you mean primitive strings? 

[eseidel, 2014/12/16 01:13:04]

I'm not sure what you mean.

I mean string literals, like "foo" vs. new String("foo").

I should probably should have written "string literals" isntead of "literal
strings" if that's what you mean?

+      throw new Error(kErrorString);
+    }
     var encodedSize = kArrayHeaderSize + unicode.utf8Length(val);
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeString(val);
   };
 
   Encoder.prototype.encodeMap = function(keyClass, valueClass, val) {
     var keys = new Array(val.size);
     var values = new Array(val.size);
     var i = 0;
     val.forEach(function(value, key) {
       values[i] = value;
       keys[i++] = key;
     });
     this.writeUint32(kStructHeaderSize + kMapStructPayloadSize);
     this.writeUint32(2); // two fields: keys, values
     this.encodeArrayPointer(keyClass, keys);
     this.encodeArrayPointer(valueClass, values);
   }
 
   Encoder.prototype.encodeMapPointer = function(keyClass, valueClass, val) {
     if (val == null) {
       // Also handles undefined, since undefined == null.
       this.encodePointer(val);
       return;
     }
+    if (!(val instanceof Map)) {
+      throw new Error(kErrorMap);
+    }
     var encodedSize = kStructHeaderSize + kMapStructPayloadSize;
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeMap(keyClass, valueClass, val);
   };
 
   // Message ------------------------------------------------------------------
 
   var kMessageNameOffset = kStructHeaderSize;
   var kMessageFlagsOffset = kMessageNameOffset + 4;
   var kMessageRequestIDOffset = kMessageFlagsOffset + 4;
@@ skipping 403 matching lines @@
   exports.NullablePointerTo = NullablePointerTo;
   exports.ArrayOf = ArrayOf;
   exports.NullableArrayOf = NullableArrayOf;
   exports.PackedBool = PackedBool;
   exports.Handle = Handle;
   exports.NullableHandle = NullableHandle;
   exports.MapOf = MapOf;
   exports.NullableMapOf = NullableMapOf;
   return exports;
 });