Allow updateArgumentsPostValidate to support callbacks and added / removed arguments.

chrome/renderer/resources/extensions/schema_generated_bindings.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.
 
 // This script contains privileged chrome extension related javascript APIs.
 // It is loaded by pages whose URL has the chrome-extension protocol.
 
   // TODO(battre): cleanup the usage of packages everywhere, as described here
   // http://codereview.chromium.org/10392008/diff/38/chrome/renderer/resources/extensions/schema_generated_bindings.js
 
   require('json_schema');
   require('event_bindings');
   var GetExtensionAPIDefinition =
       requireNative('apiDefinitions').GetExtensionAPIDefinition;
   var sendRequest = require('sendRequest').sendRequest;
   var utils = require('utils');
   var isDevChannel = requireNative('channel').IsDevChannel;
   var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
+  var schemaUtils = require('schemaUtils');
 
   // The object to generate the bindings for "internal" APIs in, so that
   // extensions can't directly call them (without access to chromeHidden),
   // but are still needed for internal mechanisms of extensions (e.g. events).
   //
   // This is distinct to the "*Private" APIs which are controlled via
   // having strict permissions and aren't generated *anywhere* unless needed.
   var internalAPIs = {};
   chromeHidden.internalAPIs = internalAPIs;
 
-  // Validate arguments.
-  var schemaValidator = new chromeHidden.JSONSchemaValidator();
-  chromeHidden.validate = function(args, parameterSchemas) {
-    if (args.length > parameterSchemas.length)
-      throw new Error("Too many arguments.");
-
-    for (var i = 0; i < parameterSchemas.length; i++) {
-      if (i in args && args[i] !== null && args[i] !== undefined) {
-        schemaValidator.resetErrors();
-        schemaValidator.validate(args[i], parameterSchemas[i]);
-        if (schemaValidator.errors.length == 0)
-          continue;
-
-        var message = "Invalid value for argument " + (i + 1) + ". ";
-        for (var i = 0, err; err = schemaValidator.errors[i]; i++) {
-          if (err.path) {
-            message += "Property '" + err.path + "': ";
-          }
-          message += err.message;
-          message = message.substring(0, message.length - 1);
-          message += ", ";
-        }
-        message = message.substring(0, message.length - 2);
-        message += ".";
-
-        throw new Error(message);
-      } else if (!parameterSchemas[i].optional) {
-        throw new Error("Parameter " + (i + 1) + " is required.");
-      }
-    }
-  };
-
-  // Generate all possible signatures for a given API function.
-  function getSignatures(parameterSchemas) {
-    if (parameterSchemas.length === 0)
-      return [[]];
-
-    var signatures = [];
-    var remaining = getSignatures(parameterSchemas.slice(1));
-    for (var i = 0; i < remaining.length; i++)
-      signatures.push([parameterSchemas[0]].concat(remaining[i]))
-
-    if (parameterSchemas[0].optional)
-      return signatures.concat(remaining);
-    return signatures;
-  };
-
-  // Return true if arguments match a given signature's schema.
-  function argumentsMatchSignature(args, candidateSignature) {
-    if (args.length != candidateSignature.length)
-      return false;
-
-    for (var i = 0; i < candidateSignature.length; i++) {
-      var argType =  chromeHidden.JSONSchemaValidator.getType(args[i]);
-      if (!schemaValidator.isValidSchemaType(argType, candidateSignature[i]))
-        return false;
-    }
-    return true;
-  };
-
-  // Finds the function signature for the given arguments.
-  function resolveSignature(args, definedSignature) {
-    var candidateSignatures = getSignatures(definedSignature);
-    for (var i = 0; i < candidateSignatures.length; i++) {
-      if (argumentsMatchSignature(args, candidateSignatures[i]))
-        return candidateSignatures[i];
-    }
-    return null;
-  };
-
-  // Returns a string representing the defined signature of the API function.
-  // Example return value for chrome.windows.getCurrent:
-  // "windows.getCurrent(optional object populate, function callback)"
-  function getParameterSignatureString(name, definedSignature) {
-    var getSchemaTypeString = function(schema) {
-      var schemaTypes = schemaValidator.getAllTypesForSchema(schema);
-      var typeName = schemaTypes.join(" or ") + " " + schema.name;
-      if (schema.optional)
-        return "optional " + typeName;
-      return typeName;
-    };
-
-    var typeNames = definedSignature.map(getSchemaTypeString);
-    return name + "(" + typeNames.join(", ") + ")";
-  };
-
-  // Returns a string representing a call to an API function.
-  // Example return value for call: chrome.windows.get(1, callback) is:
-  // "windows.get(int, function)"
-  function getArgumentSignatureString(name, args) {
-    var typeNames = args.map(chromeHidden.JSONSchemaValidator.getType);
-    return name + "(" + typeNames.join(", ") + ")";
-  };
-
-  // Finds the correct signature for the given arguments, then validates the
-  // arguments against that signature. Returns a 'normalized' arguments list
-  // where nulls are inserted where optional parameters were omitted.
-  function normalizeArgumentsAndValidate(args, funDef) {
-    if (funDef.allowAmbiguousOptionalArguments) {
-      chromeHidden.validate(args, funDef.definition.parameters);
-      return args;
-    }
-
-    var definedSignature = funDef.definition.parameters;
-    var resolvedSignature = resolveSignature(args, definedSignature);
-    if (!resolvedSignature)
-      throw new Error("Invocation of form " +
-          getArgumentSignatureString(funDef.name, args) +
-          " doesn't match definition " +
-          getParameterSignatureString(funDef.name, definedSignature));
-
-    chromeHidden.validate(args, resolvedSignature);
-
-    var normalizedArgs = [];
-    var ai = 0;
-    for (var si = 0; si < definedSignature.length; si++) {
-      if (definedSignature[si] === resolvedSignature[ai])
-        normalizedArgs.push(args[ai++]);
-      else
-        normalizedArgs.push(null);
-    }
-    return normalizedArgs;
-  };
-
-  // Validates that a given schema for an API function is not ambiguous.
-  function isFunctionSignatureAmbiguous(functionDef) {
-    if (functionDef.allowAmbiguousOptionalArguments)
-      return false;
-
-    var signaturesAmbiguous = function(signature1, signature2) {
-      if (signature1.length != signature2.length)
-        return false;
-
-      for (var i = 0; i < signature1.length; i++) {
-        if (!schemaValidator.checkSchemaOverlap(signature1[i], signature2[i]))
-          return false;
-      }
-      return true;
-    };
-
-    var candidateSignatures = getSignatures(functionDef.parameters);
-    for (var i = 0; i < candidateSignatures.length; i++) {
-      for (var j = i + 1; j < candidateSignatures.length; j++) {
-        if (signaturesAmbiguous(candidateSignatures[i], candidateSignatures[j]))
-          return true;
-      }
-    }
-    return false;
-  };
-
   // Stores the name and definition of each API function, with methods to
   // modify their behaviour (such as a custom way to handle requests to the
   // API, a custom callback, etc).
   function APIFunctions() {
     this._apiFunctions = {};
     this._unavailableApiFunctions = {};
   }
   APIFunctions.prototype.register = function(apiName, apiFunction) {
     this._apiFunctions[apiName] = apiFunction;
   };
@@ skipping 99 matching lines @@
     }
     customHooks[namespace] = fn;
   };
 
   function CustomBindingsObject() {
   }
   CustomBindingsObject.prototype.setSchema = function(schema) {
     // The functions in the schema are in list form, so we move them into a
     // dictionary for easier access.
     var self = this;
-    self.parameters = {};
+    self.functionSchemas = {};
     schema.functions.forEach(function(f) {
-      self.parameters[f.name] = f.parameters;
+      self.functionSchemas[f.name] = {
+        name: f.name,
+        definition: f
+      }
     });
   };
 
   // Registers a custom type referenced via "$ref" fields in the API schema
   // JSON.
   var customTypes = {};
   chromeHidden.registerCustomType = function(typeName, customTypeFactory) {
     var customType = customTypeFactory();
     customType.prototype = new CustomBindingsObject();
     customTypes[typeName] = customType;
@@ skipping 72 matching lines @@
         mod[name] = mod[name] || {};
         mod = mod[name];
       }
 
       // Add types to global schemaValidator
       if (apiDef.types) {
         apiDef.types.forEach(function(t) {
           if (!isSchemaNodeSupported(t, platform, manifestVersion))
             return;
 
-          schemaValidator.addTypes(t);
+          schemaUtils.schemaValidator.addTypes(t);
           if (t.type == 'object' && customTypes[t.id]) {
             customTypes[t.id].prototype.setSchema(t);
           }
         });
       }
 
       // Returns whether access to the content of a schema should be denied,
       // based on the presence of "unprivileged" and whether this is an
       // extension process (versus e.g. a content script).
       function isSchemaAccessAllowed(itemSchema) {
@@ skipping 33 matching lines @@
           }
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiFunctionName;
 
           // TODO(aa): It would be best to run this in a unit test, but in order
           // to do that we would need to better factor this code so that it
           // doesn't depend on so much v8::Extension machinery.
           if (chromeHidden.validateAPI &&
-              isFunctionSignatureAmbiguous(apiFunction.definition)) {
+              schemaUtils.isFunctionSignatureAmbiguous(
+                  apiFunction.definition)) {
             throw new Error(
                 apiFunction.name + ' has ambiguous optional arguments. ' +
                 'To implement custom disambiguation logic, add ' +
                 '"allowAmbiguousOptionalArguments" to the function\'s schema.');
           }
 
           apiFunctions.register(apiFunction.name, apiFunction);
 
           mod[functionDef.name] = (function() {
             var args = Array.prototype.slice.call(arguments);
             if (this.updateArgumentsPreValidate)
               args = this.updateArgumentsPreValidate.apply(this, args);
 
-            args = normalizeArgumentsAndValidate(args, this);
+            args = schemaUtils.normalizeArgumentsAndValidate(args, this);
             if (this.updateArgumentsPostValidate)
               args = this.updateArgumentsPostValidate.apply(this, args);
 
             var retval;
             if (this.handleRequest) {
               retval = this.handleRequest.apply(this, args);
             } else {
               retval = sendRequest(this.name, args,
                                    this.definition.parameters,
                                    {customCallback: this.customCallback});
             }
 
             // Validate return value if defined - only in debug.
             if (chromeHidden.validateCallbacks &&
-                chromeHidden.validate &&
                 this.definition.returns) {
-              chromeHidden.validate([retval], [this.definition.returns]);
+              schemaUtils.validate([retval], [this.definition.returns]);
             }
             return retval;
           }).bind(apiFunction);
         });
       }
 
       // Setup Events
       if (apiDef.events) {
         apiDef.events.forEach(function(eventDef) {
           if (eventDef.name in mod) {
@@ skipping 100 matching lines @@
     // beginInstallWithManifest2.
     // See http://crbug.com/100242
     if (chrome.webstorePrivate) {
       chrome.webstorePrivate.beginInstallWithManifest2 =
           chrome.webstorePrivate.beginInstallWithManifest3;
     }
 
     if (chrome.test)
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
   });