Mojo JS bindings: update the new bindings with the associated interface feature.

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.
 
 (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',
+    ILLEGAL_INTERFACE_ID: 'VALIDATION_ERROR_ILLEGAL_INTERFACE_ID',
+    UNEXPECTED_INVALID_INTERFACE_ID:
+        'VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID',
     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";
+  var gValidationErrorObserver = null;
+
+  function reportValidationError(error) {
+    if (gValidationErrorObserver) {
+      gValidationErrorObserver.setLastError(error);
+    }
+  }
+
+  var ValidationErrorObserverForTesting = (function() {
+    function Observer() {
+      this.lastError = validationError.NONE;
+      this.callback = null;
+    }
+
+    Observer.prototype.setLastError = function(error) {
+      this.lastError = error;
+      if (this.callback) {
+        this.callback(error);
+      }
+    };
+
+    Observer.prototype.reset = function(error) {
+      this.lastError = validationError.NONE;
+      this.callback = null;
+    };
+
+    return {
+      getInstance: function() {
+        if (!gValidationErrorObserver) {
+          gValidationErrorObserver = new Observer();
+        }
+        return gValidationErrorObserver;
+      }
+    };
+  })();
+
+  function isTestingMode() {
+    return Boolean(gValidationErrorObserver);
+  }
+
+  function clearTestingMode() {
+    gValidationErrorObserver = null;
+  }
 
   function isEnumClass(cls) {
     return cls instanceof internal.Enum;
   }
 
   function isStringClass(cls) {
     return cls === internal.String || cls === internal.NullableString;
   }
 
   function isHandleClass(cls) {
     return cls === internal.Handle || cls === internal.NullableHandle;
   }
 
   function isInterfaceClass(cls) {
     return cls instanceof internal.Interface;
   }
 
   function isInterfaceRequestClass(cls) {
     return cls === internal.InterfaceRequest ||
         cls === internal.NullableInterfaceRequest;
   }
 
+  function isAssociatedInterfaceClass(cls) {
+    return cls === internal.AssociatedInterfacePtrInfo ||
+        cls === internal.NullableAssociatedInterfacePtrInfo;
+  }
+
+  function isAssociatedInterfaceRequestClass(cls) {
+    return cls === internal.AssociatedInterfaceRequest ||
+        cls === internal.NullableAssociatedInterfaceRequest;
+  }
+
   function isNullable(type) {
     return type === internal.NullableString ||
         type === internal.NullableHandle ||
+        type === internal.NullableAssociatedInterfacePtrInfo ||
+        type === internal.NullableAssociatedInterfaceRequest ||
         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;
+    this.associatedEndpointHandleIndex = 0;
+    this.payloadInterfaceIds = null;
+    this.offsetLimit = this.message.buffer.byteLength;
   }
 
-  Object.defineProperty(Validator.prototype, "offsetLimit", {
-    get: function() { return this.message.buffer.byteLength; }
-  });
-
   Object.defineProperty(Validator.prototype, "handleIndexLimit", {
     get: function() { return this.message.handles.length; }
   });
 
+  Object.defineProperty(Validator.prototype, "associatedHandleIndexLimit", {
+    get: function() {
+      return this.payloadInterfaceIds ? this.payloadInterfaceIds.length : 0;
+    }
+  });
+
   // True if we can safely allocate a block of bytes from start to
   // to start + numBytes.
   Validator.prototype.isValidRange = function(start, numBytes) {
     // Only positive JavaScript integers that are less than 2^53
     // (Number.MAX_SAFE_INTEGER) can be represented exactly.
     if (start < this.offset || numBytes <= 0 ||
         !Number.isSafeInteger(start) ||
         !Number.isSafeInteger(numBytes))
       return false;
 
@@ skipping 17 matching lines @@
       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.claimAssociatedEndpointHandle = function(index) {
+    if (index === internal.kEncodedInvalidHandleValue) {
+      return true;
+    }
+
+    if (index < this.associatedEndpointHandleIndex ||
+        index >= this.associatedHandleIndexLimit) {
+      return false;
+    }
+
+    // This is safe because handle indices are uint32.
+    this.associatedEndpointHandleIndex = 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 === internal.kEncodedInvalidHandleValue)
       return nullable ?
           validationError.NONE : validationError.UNEXPECTED_INVALID_HANDLE;
 
     if (!this.claimHandle(index))
       return validationError.ILLEGAL_HANDLE;
 
     return validationError.NONE;
   };
 
+  Validator.prototype.validateAssociatedEndpointHandle = function(offset,
+      nullable) {
+    var index = this.message.buffer.getUint32(offset);
+
+    if (index === internal.kEncodedInvalidHandleValue) {
+      return nullable ? validationError.NONE :
+          validationError.UNEXPECTED_INVALID_INTERFACE_ID;
+    }
+
+    if (!this.claimAssociatedEndpointHandle(index)) {
+      return validationError.ILLEGAL_INTERFACE_ID;
+    }
+
+    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.validateAssociatedInterface = function(offset,
+      nullable) {
+    return this.validateAssociatedEndpointHandle(offset, nullable);
+  };
+
+  Validator.prototype.validateAssociatedInterfaceRequest = function(
+      offset, nullable) {
+    return this.validateAssociatedEndpointHandle(offset, nullable);
+  };
+
   Validator.prototype.validateStructHeader = function(offset, minNumBytes) {
     if (!internal.isAligned(offset))
       return validationError.MISALIGNED_OBJECT;
 
     if (!this.isValidRange(offset, internal.kStructHeaderSize))
       return validationError.ILLEGAL_MEMORY_RANGE;
 
     var numBytes = this.message.buffer.getUint32(offset);
 
     if (numBytes < minNumBytes)
@@ skipping 24 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, internal.kMessageHeaderSize);
-    if (err != validationError.NONE)
+    var err = this.validateStructHeader(0, internal.kMessageV0HeaderSize);
+    if (err != validationError.NONE) {
       return err;
+    }
 
     var numBytes = this.message.getHeaderNumBytes();
     var version = this.message.getHeaderVersion();
 
     var validVersionAndNumBytes =
-        (version == 0 && numBytes == internal.kMessageHeaderSize) ||
-        (version == 1 &&
-         numBytes == internal.kMessageWithRequestIDHeaderSize) ||
-        (version > 1 &&
-         numBytes >= internal.kMessageWithRequestIDHeaderSize);
-    if (!validVersionAndNumBytes)
+        (version == 0 && numBytes == internal.kMessageV0HeaderSize) ||
+        (version == 1 && numBytes == internal.kMessageV1HeaderSize) ||
+        (version == 2 && numBytes == internal.kMessageV2HeaderSize) ||
+        (version > 2 && numBytes >= internal.kMessageV2HeaderSize);
+
+    if (!validVersionAndNumBytes) {
       return validationError.UNEXPECTED_STRUCT_HEADER;
+    }
 
     var expectsResponse = this.message.expectsResponse();
     var isResponse = this.message.isResponse();
 
-    if (version == 0 && (expectsResponse || isResponse))
+    if (version == 0 && (expectsResponse || isResponse)) {
       return validationError.MESSAGE_HEADER_MISSING_REQUEST_ID;
+    }
 
-    if (isResponse && expectsResponse)
+    if (isResponse && expectsResponse) {
       return validationError.MESSAGE_HEADER_INVALID_FLAGS;
+    }
+
+    if (version < 2) {
+      return validationError.NONE;
+    }
+
+    var err = this.validateArrayPointer(
+        internal.kMessagePayloadInterfaceIdsPointerOffset,
+        internal.Uint32.encodedSize, internal.Uint32, true, [0], 0);
+
+    if (err != validationError.NONE) {
+      return err;
+    }
+
+    this.payloadInterfaceIds = this.message.getPayloadInterfaceIds();
+    if (this.payloadInterfaceIds) {
+      for (var interfaceId of this.payloadInterfaceIds) {
+        if (!internal.isValidInterfaceId(interfaceId) ||
+            internal.isMasterInterfaceId(interfaceId)) {
+          return validationError.ILLEGAL_INTERFACE_ID;
+        }
+      }
+    }
+
+    // Set offset to the start of the payload and offsetLimit to the start of
+    // the payload interface Ids so that payload can be validated using the
+    // same messageValidator.
+    this.offset = this.message.getHeaderNumBytes();
+    this.offsetLimit = this.decodePointer(
+        internal.kMessagePayloadInterfaceIdsPointerOffset);
 
     return validationError.NONE;
   };
 
   Validator.prototype.validateMessageIsRequestWithoutResponse = function() {
     if (this.message.isResponse() || this.message.expectsResponse()) {
       return validationError.MESSAGE_HEADER_INVALID_FLAGS;
     }
     return validationError.NONE;
   };
@@ skipping 97 matching lines @@
     // 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 = internal.kStructHeaderSize +
-        internal.kMapStructPayloadSize;
+                         internal.kMapStructPayloadSize;
     var err = this.validateStructHeader(structOffset, mapEncodedSize);
     if (err !== validationError.NONE)
         return err;
 
     // Validate the keys array.
     var keysArrayPointerOffset = structOffset + internal.kStructHeaderSize;
     err = this.validateArrayPointer(
         keysArrayPointerOffset, keyClass.encodedSize, keyClass, false, [0], 0);
     if (err !== validationError.NONE)
         return err;
@@ skipping 64 matching lines @@
     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 (isAssociatedInterfaceClass(elementType))
+      return this.validateAssociatedInterfaceElements(
+          elementsOffset, numElements, nullable);
+    if (isAssociatedInterfaceRequestClass(elementType))
+      return this.validateAssociatedInterfaceRequestElements(
+          elementsOffset, numElements, nullable);
     if (isStringClass(elementType))
       return this.validateArrayElements(
           elementsOffset, numElements, internal.Uint8, nullable, [0], 0);
     if (elementType instanceof internal.PointerTo)
       return this.validateStructElements(
           elementsOffset, numElements, elementType.cls, nullable);
     if (elementType instanceof internal.ArrayOf)
       return this.validateArrayElements(
           elementsOffset, numElements, elementType.cls, nullable,
           expectedDimensionSizes, currentDimension + 1);
@@ skipping 37 matching lines @@
     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;
   };
 
+  Validator.prototype.validateAssociatedInterfaceElements =
+      function(offset, numElements, nullable) {
+    var elementSize = internal.AssociatedInterfacePtrInfo.prototype.encodedSize;
+    for (var i = 0; i < numElements; i++) {
+      var elementOffset = offset + i * elementSize;
+      var err = this.validateAssociatedInterface(elementOffset, nullable);
+      if (err != validationError.NONE) {
+        return err;
+      }
+    }
+    return validationError.NONE;
+  };
+
+  Validator.prototype.validateAssociatedInterfaceRequestElements =
+      function(offset, numElements, nullable) {
+    var elementSize = internal.AssociatedInterfaceRequest.encodedSize;
+    for (var i = 0; i < numElements; i++) {
+      var elementOffset = offset + i * elementSize;
+      var err = this.validateAssociatedInterfaceRequest(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 = 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);
@@ skipping 23 matching lines @@
       var elementOffset = offset + i * elementSize;
       var err = this.validateEnum(elementOffset, enumClass);
       if (err != validationError.NONE)
         return err;
     }
     return validationError.NONE;
   };
 
   internal.validationError = validationError;
   internal.Validator = Validator;
+  internal.ValidationErrorObserverForTesting =
+      ValidationErrorObserverForTesting;
+  internal.reportValidationError = reportValidationError;
+  internal.isTestingMode = isTestingMode;
+  internal.clearTestingMode = clearTestingMode;
 })();