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);
     }

[Ryan Sleevi, 2014/12/30 04:54:17]

The original code had the benefit that it properly handled ES6 array-like
objects, such as the ArrayBufferView family. This change loses this property,
which has prevented rolling an updated Mojo into Chrome (see
https://codereview.chromium.org/795593004 )

This may be what you desired, but it's certainly not intuitive when using JS
bindings.

https://people.mozilla.org/~jorendorff/es6-draft.html#sec-createlistfromarray...
is the canonical ES6 algorithm for handling array-like objects into sequenced
lists, and it seems useful here when talking about IDL bindings.

     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 string literals, not objects like new String("foo").
+    if (typeof(val) !== "string") {
+      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)) {

[Ryan Sleevi, 2014/12/30 04:54:17]

This is another surprising change, as it prevents map-like objects and iterables
from working. Again, this may be desirable, but it certainly strikes as
surprising.

+      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;
 });