Mojo JS bindings: change module loading solution.

mojo/public/js/new_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/validator", [
-  "mojo/public/js/codec",
-], function(codec) {
+(function() {
+  var internal = mojo.internal;
 
   var validationError = {
     NONE: 'VALIDATION_ERROR_NONE',
     MISALIGNED_OBJECT: 'VALIDATION_ERROR_MISALIGNED_OBJECT',
     ILLEGAL_MEMORY_RANGE: 'VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE',
     UNEXPECTED_STRUCT_HEADER: 'VALIDATION_ERROR_UNEXPECTED_STRUCT_HEADER',
     UNEXPECTED_ARRAY_HEADER: 'VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER',
     ILLEGAL_HANDLE: 'VALIDATION_ERROR_ILLEGAL_HANDLE',
     UNEXPECTED_INVALID_HANDLE: 'VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE',
     ILLEGAL_POINTER: 'VALIDATION_ERROR_ILLEGAL_POINTER',
     UNEXPECTED_NULL_POINTER: 'VALIDATION_ERROR_UNEXPECTED_NULL_POINTER',
     MESSAGE_HEADER_INVALID_FLAGS:
         'VALIDATION_ERROR_MESSAGE_HEADER_INVALID_FLAGS',
     MESSAGE_HEADER_MISSING_REQUEST_ID:
         'VALIDATION_ERROR_MESSAGE_HEADER_MISSING_REQUEST_ID',
     DIFFERENT_SIZED_ARRAYS_IN_MAP:
         'VALIDATION_ERROR_DIFFERENT_SIZED_ARRAYS_IN_MAP',
     INVALID_UNION_SIZE: 'VALIDATION_ERROR_INVALID_UNION_SIZE',
     UNEXPECTED_NULL_UNION: 'VALIDATION_ERROR_UNEXPECTED_NULL_UNION',
     UNKNOWN_ENUM_VALUE: 'VALIDATION_ERROR_UNKNOWN_ENUM_VALUE',
   };
 
   var NULL_MOJO_POINTER = "NULL_MOJO_POINTER";
 
   function isEnumClass(cls) {
-    return cls instanceof codec.Enum;
+    return cls instanceof internal.Enum;
   }
 
   function isStringClass(cls) {
-    return cls === codec.String || cls === codec.NullableString;
+    return cls === internal.String || cls === internal.NullableString;
   }
 
   function isHandleClass(cls) {
-    return cls === codec.Handle || cls === codec.NullableHandle;
+    return cls === internal.Handle || cls === internal.NullableHandle;
   }
 
   function isInterfaceClass(cls) {
-    return cls instanceof codec.Interface;
+    return cls instanceof internal.Interface;
   }
 
   function isInterfaceRequestClass(cls) {
-    return cls === codec.InterfaceRequest ||
-        cls === codec.NullableInterfaceRequest;
+    return cls === internal.InterfaceRequest ||
+        cls === internal.NullableInterfaceRequest;
   }
 
   function isNullable(type) {
-    return type === codec.NullableString || type === codec.NullableHandle ||
-        type === codec.NullableInterface ||
-        type === codec.NullableInterfaceRequest ||
-        type instanceof codec.NullableArrayOf ||
-        type instanceof codec.NullablePointerTo;
+    return type === internal.NullableString ||
+        type === internal.NullableHandle ||
+        type === internal.NullableInterface ||
+        type === internal.NullableInterfaceRequest ||
+        type instanceof internal.NullableArrayOf ||
+        type instanceof internal.NullablePointerTo;
   }
 
   function Validator(message) {
     this.message = message;
     this.offset = 0;
     this.handleIndex = 0;
   }
 
   Object.defineProperty(Validator.prototype, "offsetLimit", {
     get: function() { return this.message.buffer.byteLength; }
@@ skipping 22 matching lines @@
 
   Validator.prototype.claimRange = function(start, numBytes) {
     if (this.isValidRange(start, numBytes)) {
       this.offset = start + numBytes;
       return true;
     }
     return false;
   };
 
   Validator.prototype.claimHandle = function(index) {
-    if (index === codec.kEncodedInvalidHandleValue)
+    if (index === internal.kEncodedInvalidHandleValue)
       return true;
 
     if (index < this.handleIndex || index >= this.handleIndexLimit)
       return false;
 
     // This is safe because handle indices are uint32.
     this.handleIndex = index + 1;
     return true;
   };
 
   Validator.prototype.validateEnum = function(offset, enumClass) {
     // Note: Assumes that enums are always 32 bits! But this matches
     // mojom::generate::pack::PackedField::GetSizeForKind, so it should be okay.
     var value = this.message.buffer.getInt32(offset);
     return enumClass.validate(value);
   }
 
   Validator.prototype.validateHandle = function(offset, nullable) {
     var index = this.message.buffer.getUint32(offset);
 
-    if (index === codec.kEncodedInvalidHandleValue)
+    if (index === internal.kEncodedInvalidHandleValue)
       return nullable ?
           validationError.NONE : validationError.UNEXPECTED_INVALID_HANDLE;
 
     if (!this.claimHandle(index))
       return validationError.ILLEGAL_HANDLE;
 
     return validationError.NONE;
   };
 
   Validator.prototype.validateInterface = function(offset, nullable) {
     return this.validateHandle(offset, nullable);
   };
 
   Validator.prototype.validateInterfaceRequest = function(offset, nullable) {
     return this.validateHandle(offset, nullable);
   };
 
   Validator.prototype.validateStructHeader = function(offset, minNumBytes) {
-    if (!codec.isAligned(offset))
+    if (!internal.isAligned(offset))
       return validationError.MISALIGNED_OBJECT;
 
-    if (!this.isValidRange(offset, codec.kStructHeaderSize))
+    if (!this.isValidRange(offset, internal.kStructHeaderSize))
       return validationError.ILLEGAL_MEMORY_RANGE;
 
     var numBytes = this.message.buffer.getUint32(offset);
 
     if (numBytes < minNumBytes)
       return validationError.UNEXPECTED_STRUCT_HEADER;
 
     if (!this.claimRange(offset, numBytes))
       return validationError.ILLEGAL_MEMORY_RANGE;
 
@@ skipping 20 matching lines @@
     return validationError.NONE;
   };
 
   Validator.prototype.isFieldInStructVersion = function(offset, fieldVersion) {
     var structVersion = this.message.buffer.getUint32(offset + 4);
     return fieldVersion <= structVersion;
   };
 
   Validator.prototype.validateMessageHeader = function() {
 
-    var err = this.validateStructHeader(0, codec.kMessageHeaderSize);
+    var err = this.validateStructHeader(0, internal.kMessageHeaderSize);
     if (err != validationError.NONE)
       return err;
 
     var numBytes = this.message.getHeaderNumBytes();
     var version = this.message.getHeaderVersion();
 
     var validVersionAndNumBytes =
-        (version == 0 && numBytes == codec.kMessageHeaderSize) ||
+        (version == 0 && numBytes == internal.kMessageHeaderSize) ||
         (version == 1 &&
-         numBytes == codec.kMessageWithRequestIDHeaderSize) ||
+         numBytes == internal.kMessageWithRequestIDHeaderSize) ||
         (version > 1 &&
-         numBytes >= codec.kMessageWithRequestIDHeaderSize);
+         numBytes >= internal.kMessageWithRequestIDHeaderSize);
     if (!validVersionAndNumBytes)
       return validationError.UNEXPECTED_STRUCT_HEADER;
 
     var expectsResponse = this.message.expectsResponse();
     var isResponse = this.message.isResponse();
 
     if (version == 0 && (expectsResponse || isResponse))
       return validationError.MESSAGE_HEADER_MISSING_REQUEST_ID;
 
     if (isResponse && expectsResponse)
@@ skipping 107 matching lines @@
     // Validate the implicit map struct:
     // struct {array<keyClass> keys; array<valueClass> values};
     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 mapEncodedSize = internal.kStructHeaderSize +
+        internal.kMapStructPayloadSize;
     var err = this.validateStructHeader(structOffset, mapEncodedSize);
     if (err !== validationError.NONE)
         return err;
 
     // Validate the keys array.
-    var keysArrayPointerOffset = structOffset + codec.kStructHeaderSize;
+    var keysArrayPointerOffset = structOffset + internal.kStructHeaderSize;
     err = this.validateArrayPointer(
         keysArrayPointerOffset, keyClass.encodedSize, keyClass, false, [0], 0);
     if (err !== validationError.NONE)
         return err;
 
     // Validate the values array.
     var valuesArrayPointerOffset = keysArrayPointerOffset + 8;
     var valuesArrayDimensions = [0]; // Validate the actual length below.
-    if (valueClass instanceof codec.ArrayOf)
+    if (valueClass instanceof internal.ArrayOf)
       valuesArrayDimensions =
           valuesArrayDimensions.concat(valueClass.dimensions());
     var err = this.validateArrayPointer(valuesArrayPointerOffset,
                                         valueClass.encodedSize,
                                         valueClass,
                                         valueIsNullable,
                                         valuesArrayDimensions,
                                         0);
     if (err !== validationError.NONE)
         return err;
 
     // Validate the lengths of the keys and values arrays.
     var keysArrayLength = this.arrayLength(keysArrayPointerOffset);
     var valuesArrayLength = this.arrayLength(valuesArrayPointerOffset);
     if (keysArrayLength != valuesArrayLength)
       return validationError.DIFFERENT_SIZED_ARRAYS_IN_MAP;
 
     return validationError.NONE;
   };
 
   Validator.prototype.validateStringPointer = function(offset, nullable) {
     return this.validateArrayPointer(
-        offset, codec.Uint8.encodedSize, codec.Uint8, nullable, [0], 0);
+        offset, internal.Uint8.encodedSize, internal.Uint8, nullable, [0], 0);
   };
 
   // Similar to Array_Data<T>::Validate()
   // mojo/public/cpp/bindings/lib/array_internal.h
 
   Validator.prototype.validateArray =
       function (offset, elementSize, elementType, expectedDimensionSizes,
                 currentDimension) {
-    if (!codec.isAligned(offset))
+    if (!internal.isAligned(offset))
       return validationError.MISALIGNED_OBJECT;
 
-    if (!this.isValidRange(offset, codec.kArrayHeaderSize))
+    if (!this.isValidRange(offset, internal.kArrayHeaderSize))
       return validationError.ILLEGAL_MEMORY_RANGE;
 
     var numBytes = this.message.buffer.getUint32(offset);
     var numElements = this.message.buffer.getUint32(offset + 4);
 
     // Note: this computation is "safe" because elementSize <= 8 and
     // numElements is a uint32.
-    var elementsTotalSize = (elementType === codec.PackedBool) ?
+    var elementsTotalSize = (elementType === internal.PackedBool) ?
         Math.ceil(numElements / 8) : (elementSize * numElements);
 
-    if (numBytes < codec.kArrayHeaderSize + elementsTotalSize)
+    if (numBytes < internal.kArrayHeaderSize + elementsTotalSize)
       return validationError.UNEXPECTED_ARRAY_HEADER;
 
     if (expectedDimensionSizes[currentDimension] != 0 &&
         numElements != expectedDimensionSizes[currentDimension]) {
       return validationError.UNEXPECTED_ARRAY_HEADER;
     }
 
     if (!this.claimRange(offset, numBytes))
       return validationError.ILLEGAL_MEMORY_RANGE;
 
     // Validate the array's elements if they are pointers or handles.
 
-    var elementsOffset = offset + codec.kArrayHeaderSize;
+    var elementsOffset = offset + internal.kArrayHeaderSize;
     var nullable = isNullable(elementType);
 
     if (isHandleClass(elementType))
       return this.validateHandleElements(elementsOffset, numElements, nullable);
     if (isInterfaceClass(elementType))
       return this.validateInterfaceElements(
           elementsOffset, numElements, nullable);
     if (isInterfaceRequestClass(elementType))
       return this.validateInterfaceRequestElements(
           elementsOffset, numElements, nullable);
     if (isStringClass(elementType))
       return this.validateArrayElements(
-          elementsOffset, numElements, codec.Uint8, nullable, [0], 0);
-    if (elementType instanceof codec.PointerTo)
+          elementsOffset, numElements, internal.Uint8, nullable, [0], 0);
+    if (elementType instanceof internal.PointerTo)
       return this.validateStructElements(
           elementsOffset, numElements, elementType.cls, nullable);
-    if (elementType instanceof codec.ArrayOf)
+    if (elementType instanceof internal.ArrayOf)
       return this.validateArrayElements(
           elementsOffset, numElements, elementType.cls, nullable,
           expectedDimensionSizes, currentDimension + 1);
     if (isEnumClass(elementType))
       return this.validateEnumElements(elementsOffset, numElements,
                                        elementType.cls);
 
     return validationError.NONE;
   };
 
   // Note: the |offset + i * elementSize| computation in the validateFooElements
   // methods below is "safe" because elementSize <= 8, offset and
   // numElements are uint32, and 0 <= i < numElements.
 
   Validator.prototype.validateHandleElements =
       function(offset, numElements, nullable) {
-    var elementSize = codec.Handle.encodedSize;
+    var elementSize = internal.Handle.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err = this.validateHandle(elementOffset, nullable);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   Validator.prototype.validateInterfaceElements =
       function(offset, numElements, nullable) {
-    var elementSize = codec.Interface.prototype.encodedSize;
+    var elementSize = internal.Interface.prototype.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err = this.validateInterface(elementOffset, nullable);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   Validator.prototype.validateInterfaceRequestElements =
       function(offset, numElements, nullable) {
-    var elementSize = codec.InterfaceRequest.encodedSize;
+    var elementSize = internal.InterfaceRequest.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err = this.validateInterfaceRequest(elementOffset, nullable);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   // The elementClass parameter is the element type of the element arrays.
   Validator.prototype.validateArrayElements =
       function(offset, numElements, elementClass, nullable,
                expectedDimensionSizes, currentDimension) {
-    var elementSize = codec.PointerTo.prototype.encodedSize;
+    var elementSize = internal.PointerTo.prototype.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err = this.validateArrayPointer(
           elementOffset, elementClass.encodedSize, elementClass, nullable,
           expectedDimensionSizes, currentDimension);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   Validator.prototype.validateStructElements =
       function(offset, numElements, structClass, nullable) {
-    var elementSize = codec.PointerTo.prototype.encodedSize;
+    var elementSize = internal.PointerTo.prototype.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err =
           this.validateStructPointer(elementOffset, structClass, nullable);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   Validator.prototype.validateEnumElements =
       function(offset, numElements, enumClass) {
-    var elementSize = codec.Enum.prototype.encodedSize;
+    var elementSize = internal.Enum.prototype.encodedSize;
     for (var i = 0; i < numElements; i++) {
       var elementOffset = offset + i * elementSize;
       var err = this.validateEnum(elementOffset, enumClass);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
-  var exports = {};
-  exports.validationError = validationError;
-  exports.Validator = Validator;
-  return exports;
-});
+  internal.validationError = validationError;
+  internal.Validator = Validator;
+})();