Mojo JS Bindings: add support for associative arrays (Mojo map type)

mojo/public/js/bindings/validator.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/validator", [
   "mojo/public/js/bindings/codec",
 ], function(codec) {
 
   var validationError = {
     NONE: 'VALIDATION_ERROR_NONE',
@@ skipping 158 matching lines @@
 
     if (arrayOffset === NULL_MOJO_POINTER)
       return nullable ?
           validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
 
     return this.validateArray(
         arrayOffset, elementSize, expectedElementCount, elementType);
   }
 
   Validator.prototype.validateStructPointer = function(
-        offset, structClass, nullable) {
+      offset, structClass, nullable) {
     var structOffset = this.decodePointer(offset);
     if (structOffset === null)
       return validationError.ILLEGAL_POINTER;
 
     if (structOffset === NULL_MOJO_POINTER)
       return nullable ?
           validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
 
     return structClass.validate(this, structOffset);
   }
 
+  Validator.prototype.validateMapPointer = function(

[yzshen1, 2014/10/15 22:22:13]

This probably misses fixed-size array dimensions, right?
map<uint8, array<int8, 5>>

[hansmuller, 2014/10/16 20:11:04]

I've integrated the patch with the fixed-size array dimensions changes and fixed
the support for map array values.

In a subsequent patch I'd like to change the way that arrays are represented to
the validator. We should be able to just pass a codec ArrayOf type that
characterizes an array completely.

+      offset, mapIsNullable, keyClass, valueClass, valueIsNullable) {
+    var structOffset = this.decodePointer(offset);
+    if (structOffset === null)
+      return validationError.ILLEGAL_POINTER;
+
+    if (structOffset === NULL_MOJO_POINTER)
+      return mapIsNullable ?
+          validationError.NONE : validationError.UNEXPECTED_NULL_POINTER;
+
+    var mapEncodedSize = codec.kStructHeaderSize + codec.kMapStructPayloadSize;
+    var err = this.validateStructHeader(structOffset, mapEncodedSize, 2);
+    if (err !== validationError.NONE)
+        return err;
+
+    var keysArrayPointerOffset = structOffset + codec.kStructHeaderSize;
+    err = this.validateArrayPointer(
+        keysArrayPointerOffset, keyClass.encodedSize, 0, keyClass, false);
+    if (err !== validationError.NONE)
+        return err;
+
+    var keysArrayOffset = this.decodePointer(keysArrayPointerOffset);
+    var keysArrayLength = this.message.buffer.getUint32(keysArrayOffset + 4);
+
+    var valuesArrayPointerOffset = keysArrayPointerOffset + 8;
+    return this.validateArrayPointer(valuesArrayPointerOffset,
+                                     valueClass.encodedSize,
+                                     keysArrayLength,

[yzshen1, 2014/10/15 22:22:13]

This will detect the validation failure, but with a different error code.

[hansmuller, 2014/10/16 20:11:04]

I've changed this to first validate the keys and values arrays, and then verify
that their lengths are the same. 

+                                     valueClass,
+                                     valueIsNullable);
+  }
+
   Validator.prototype.validateStringPointer = function(offset, nullable) {
     return this.validateArrayPointer(
         offset, codec.Uint8.encodedSize, 0, codec.Uint8, nullable);
   }
 
   // Similar to Array_Data<T>::Validate()
   // mojo/public/cpp/bindings/lib/array_internal.h
 
   Validator.prototype.validateArray =
       function (offset, elementSize, expectedElementCount, elementType) {
@@ skipping 81 matching lines @@
         return err;
     }
     return validationError.NONE;
   }
 
   var exports = {};
   exports.validationError = validationError;
   exports.Validator = Validator;
   return exports;
 });