Allow omitting optional parameters for Extensions API functions

chrome/renderer/resources/extensions/json_schema.js

 // Copyright (c) 2012 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.
 
 // -----------------------------------------------------------------------------
 // NOTE: If you change this file you need to touch renderer_resources.grd to
 // have your change take effect.
 // -----------------------------------------------------------------------------
 
 //==============================================================================
@@ skipping 126 matching lines @@
   if (typeOrTypeList instanceof Array) {
     for (var i = 0; i < typeOrTypeList.length; i++) {
       addType(this, typeOrTypeList[i]);
     }
   } else {
     addType(this, typeOrTypeList);
   }
 }
 
 /**
+ * Returns a list of strings of the types that this schema accepts.
+ */
+chromeHidden.JSONSchemaValidator.prototype.getAllTypesForSchema =
+    function(schema) {
+  var schemaTypes = [];
+  if (schema.type)
+    schemaTypes.push(schema.type);
+  if (schema.choices) {
+    for (var i = 0; i < schema.choices.length; i++) {
+      var choiceTypes = this.getAllTypesForSchema(schema.choices[i]);
+      schemaTypes = schemaTypes.concat(choiceTypes);
+    }
+  }
+  if (schema['$ref']) {
+    var refTypes = this.getAllTypesForSchema(this.types[schema['$ref']]);
+    schemaTypes = schemaTypes.concat(refTypes);
+  }
+  return schemaTypes;
+};
+
+/**
+ * Returns true if |schema| would accept an argument of type |type|.
+ */
+chromeHidden.JSONSchemaValidator.prototype.isValidSchemaType =
+    function(type, schema) {
+  if (schema.optional && (type == "null" || type == "undefined"))
+    return true;
+
+  schemaTypes = this.getAllTypesForSchema(schema);
+  for (var i = 0; i < schemaTypes.length; i++) {
+    if (schemaTypes[i] == "any" || type == schemaTypes[i])
+      return true;
+  }
+  return type == "any";
+};
+
+/**
+ * Returns true if there is a non-null argument that both |schema1| and
+ * |schema2| would accept.
+ */
+chromeHidden.JSONSchemaValidator.prototype.checkSchemaOverlap =
+    function(schema1, schema2) {
+  var schema1Types = this.getAllTypesForSchema(schema1);
+  for (var i = 0; i < schema1Types.length; i++) {
+    if (this.isValidSchemaType(schema1Types[i], schema2))
+      return true;
+  }
+  return false;
+};
+
+/**
  * Validates an instance against a schema. The instance can be any JavaScript
  * value and will be validated recursively. When this method returns, the
  * |errors| property will contain a list of errors, if any.
  */
-chromeHidden.JSONSchemaValidator.prototype.validate = function(
-    instance, schema, opt_path) {
+chromeHidden.JSONSchemaValidator.prototype.validate =
+    function(instance, schema, opt_path) {
   var path = opt_path || "";
 
   if (!schema) {
     this.addError(path, "schemaRequired");
     return;
   }
 
   // If this schema defines itself as reference type, save it in this.types.
   if (schema.id)
     this.types[schema.id] = schema;
@@ skipping 46 matching lines @@
         this.validateNumber(instance, schema, path);
         break;
     }
   }
 };
 
 /**
  * Validates an instance against a choices schema. The instance must match at
  * least one of the provided choices.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateChoices = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateChoices =
+    function(instance, schema, path) {
   var originalErrors = this.errors;
 
   for (var i = 0; i < schema.choices.length; i++) {
     this.errors = [];
     this.validate(instance, schema.choices[i], path);
     if (this.errors.length == 0) {
       this.errors = originalErrors;
       return;
     }
   }
 
   this.errors = originalErrors;
   this.addError(path, "invalidChoice");
 };
 
 /**
  * Validates an instance against a schema with an enum type. Populates the
  * |errors| property, and returns a boolean indicating whether the instance
  * validates.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateEnum = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateEnum =
+    function(instance, schema, path) {
   for (var i = 0; i < schema.enum.length; i++) {
     if (instance === schema.enum[i])
       return true;
   }
 
   this.addError(path, "invalidEnum", [schema.enum.join(", ")]);
   return false;
 };
 
 /**
  * Validates an instance against an object schema and populates the errors
  * property.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateObject = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateObject =
+    function(instance, schema, path) {
   if (schema.properties) {
     for (var prop in schema.properties) {
       // It is common in JavaScript to add properties to Object.prototype. This
       // check prevents such additions from being interpreted as required
       // schema properties.
       // TODO(aa): If it ever turns out that we actually want this to work,
       // there are other checks we could put here, like requiring that schema
       // properties be objects that have a 'type' property.
       if (!schema.properties.hasOwnProperty(prop))
         continue;
@@ skipping 41 matching lines @@
       this.validate(instance[prop], schema.additionalProperties, propPath);
     else
       this.addError(propPath, "unexpectedProperty");
   }
 };
 
 /**
  * Validates an instance against an array schema and populates the errors
  * property.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateArray = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateArray =
+    function(instance, schema, path) {
   var typeOfItems = chromeHidden.JSONSchemaValidator.getType(schema.items);
 
   if (typeOfItems == 'object') {
     if (schema.minItems && instance.length < schema.minItems) {
       this.addError(path, "arrayMinItems", [schema.minItems]);
     }
 
     if (typeof schema.maxItems != "undefined" &&
         instance.length > schema.maxItems) {
       this.addError(path, "arrayMaxItems", [schema.maxItems]);
@@ skipping 25 matching lines @@
       if (instance.length > schema.items.length) {
         this.addError(path, "arrayMaxItems", [schema.items.length]);
       }
     }
   }
 };
 
 /**
  * Validates a string and populates the errors property.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateString = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateString =
+    function(instance, schema, path) {
   if (schema.minLength && instance.length < schema.minLength)
     this.addError(path, "stringMinLength", [schema.minLength]);
 
   if (schema.maxLength && instance.length > schema.maxLength)
     this.addError(path, "stringMaxLength", [schema.maxLength]);
 
   if (schema.pattern && !schema.pattern.test(instance))
     this.addError(path, "stringPattern", [schema.pattern]);
 };
 
 /**
  * Validates a number and populates the errors property. The instance is
  * assumed to be a number.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateNumber = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateNumber =
+    function(instance, schema, path) {
 
   // Forbid NaN, +Infinity, and -Infinity.  Our APIs don't use them, and
   // JSON serialization encodes them as 'null'.  Re-evaluate supporting
   // them if we add an API that could reasonably take them as a parameter.
   if (isNaN(instance) ||
       instance == Number.POSITIVE_INFINITY ||
       instance == Number.NEGATIVE_INFINITY )
     this.addError(path, "numberFiniteNotNan", [instance]);
 
   if (schema.minimum !== undefined && instance < schema.minimum)
     this.addError(path, "numberMinValue", [schema.minimum]);
 
   if (schema.maximum !== undefined && instance > schema.maximum)
     this.addError(path, "numberMaxValue", [schema.maximum]);
 
   // Check for integer values outside of -2^31..2^31-1.
   if (schema.type === "integer" && (instance | 0) !== instance)
     this.addError(path, "numberIntValue", []);
 
   if (schema.maxDecimal && instance * Math.pow(10, schema.maxDecimal) % 1)
     this.addError(path, "numberMaxDecimal", [schema.maxDecimal]);
 };
 
 /**
  * Validates the primitive type of an instance and populates the errors
  * property. Returns true if the instance validates, false otherwise.
  */
-chromeHidden.JSONSchemaValidator.prototype.validateType = function(
-    instance, schema, path) {
+chromeHidden.JSONSchemaValidator.prototype.validateType =
+    function(instance, schema, path) {
   var actualType = chromeHidden.JSONSchemaValidator.getType(instance);
   if (schema.type != actualType && !(schema.type == "number" &&
       actualType == "integer")) {
     this.addError(path, "invalidType", [schema.type, actualType]);
     return false;
   }
 
   return true;
 };
 
 /**
  * Adds an error message. |key| is an index into the |messages| object.
  * |replacements| is an array of values to replace '*' characters in the
  * message.
  */
-chromeHidden.JSONSchemaValidator.prototype.addError = function(
-    path, key, replacements) {
+chromeHidden.JSONSchemaValidator.prototype.addError =
+    function(path, key, replacements) {
   this.errors.push({
     path: path,
     message: chromeHidden.JSONSchemaValidator.formatError(key, replacements)
   });
 };
 
+/**
+ * Resets errors to an empty list so you can call 'validate' again.
+ */
+chromeHidden.JSONSchemaValidator.prototype.resetErrors = function() {
+  this.errors = [];
+};
+
 })();