Allow omitting optional parameters for Extensions API functions

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.
 
 var chrome = chrome || {};
 (function() {
   native function GetChromeHidden();
@@ skipping 14 matching lines @@
   chromeHidden.internalAPIs = internalAPIs;
 
   function forEach(dict, f) {
     for (key in dict) {
       if (dict.hasOwnProperty(key))
         f(key, dict[key]);
     }
   }
 
   // Validate arguments.
-  chromeHidden.validationTypes = [];
-  chromeHidden.validate = function(args, schemas) {
-    if (args.length > schemas.length)
+  chromeHidden.schemaValidator = new chromeHidden.JSONSchemaValidator();

[Aaron Boodman, 2012/03/01 22:59:05]

It isn't necessary to put this on chromeHidden. It can just be a variable at
this level.

+  chromeHidden.validate = function(args, parameterSchemas) {
+    if (args.length > parameterSchemas.length)
       throw new Error("Too many arguments.");
 
-    for (var i = 0; i < schemas.length; i++) {
+    for (var i = 0; i < parameterSchemas.length; i++) {
       if (i in args && args[i] !== null && args[i] !== undefined) {
-        var validator = new chromeHidden.JSONSchemaValidator();
-        validator.addTypes(chromeHidden.validationTypes);
-        validator.validate(args[i], schemas[i]);
-        if (validator.errors.length == 0)
+        chromeHidden.schemaValidator.resetErrors();
+        chromeHidden.schemaValidator.validate(args[i], parameterSchemas[i]);
+        if (chromeHidden.schemaValidator.errors.length == 0)
           continue;
 
         var message = "Invalid value for argument " + (i + 1) + ". ";
-        for (var i = 0, err; err = validator.errors[i]; i++) {
+        for (var i = 0; i < chromeHidden.schemaValidator.length; i++) {
+          var err = chromeHidden.schemaValidator.errors[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 (!schemas[i].optional) {
+      } 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 (!chromeHidden.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 =
+          chromeHidden.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.
+  chromeHidden.updateArgumentsValidate = function(args, funDef) {
+    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 isDefinedSignatureAmbiguous(definedSignature) {
+    var signaturesAmbiguous = function(signature1, signature2) {
+      if (signature1.length != signature2.length)
+        return false;
+
+      for (var i = 0; i < signature1.length; i++) {
+        if (!chromeHidden.schemaValidator.checkSchemaOverlap(signature1[i],
+            signature2[i]))
+          return false;
+      }
+      return true;
+    };
+
+    var candidateSignatures = getSignatures(definedSignature);
+    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;
+  };
+
   // Callback handling.
   var requests = [];
   chromeHidden.handleResponse = function(requestId, name,
                                          success, response, error) {
     try {
       var request = requests[requestId];
       if (success) {
         delete chrome.extension.lastError;
       } else {
         if (!error) {
@@ skipping 351 matching lines @@
 
       // See comment on internalAPIs at the top.
       var mod = apiDef.internal ? internalAPIs : chrome;
 
       var namespaces = apiDef.namespace.split('.');
       for (var index = 0, name; name = namespaces[index]; index++) {
         mod[name] = mod[name] || {};
         mod = mod[name];
       }
 
-      // Add types to global validationTypes
+      // Add types to global schemaValidator
       if (apiDef.types) {
         apiDef.types.forEach(function(t) {
           if (!isSchemaNodeSupported(t, platform, manifestVersion))
             return;
 
-          chromeHidden.validationTypes.push(t);
+          chromeHidden.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 28 matching lines @@
           }
           if (!isSchemaAccessAllowed(functionDef)) {
             apiFunctions.registerUnavailable(apiFunctionName);
             addUnprivilegedAccessGetter(mod, functionDef.name);
             return;
           }
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiFunctionName;
-          apiFunctions.register(apiFunctionName, apiFunction);
+
+          // Validate API for ambiguity only in DEBUG mode.
+          // We do not validate 'extension.sendRequest' because we know it is
+          // ambiguous. We disambiguate calls in 'updateArgumentsPrevalidate'.
+          // 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
+          // didn't depend on so much v8::Extension machinery.
+          if (chromeHidden.validateAPI &&
+              apiFunction.name != "extension.sendRequest" &&
+              isDefinedSignatureAmbiguous(apiFunction.definition.parameters))
+            throw new Error(apiFunction.name + " is ambiguous");
+          apiFunctions.register(apiFunction.name, apiFunction);
 
           mod[functionDef.name] = (function() {
-            var args = arguments;
+            var args = Array.prototype.slice.call(arguments);
             if (this.updateArgumentsPreValidate)
               args = this.updateArgumentsPreValidate.apply(this, args);
-            chromeHidden.validate(args, this.definition.parameters);
+
+            args = chromeHidden.updateArgumentsValidate(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});
@@ skipping 117 matching lines @@
     // See http://crbug.com/100242
     if (chrome.webstorePrivate) {
       chrome.webstorePrivate.beginInstallWithManifest2 =
           chrome.webstorePrivate.beginInstallWithManifest3;
     }
 
     if (chrome.test)
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
   });
 })();