Make registering custom hooks with schema_generated_bindings.js safer and

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 226 matching lines @@
       throw new Error(
           "Either the path or imageData property must be specified.");
     }
   }
 
   // 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;
   };
+  // Registers a function as existing but not available, meaning that calls to
+  // the set* methods that reference this function should be ignored rather
+  // than throwing Errors.
+  APIFunctions.prototype.registerUnavailable = function(apiName) {
+    this._unavailableApiFunctions[apiName] = apiName;
+  };
   APIFunctions.prototype._setHook =
       function(apiName, propertyName, customizedFunction) {
-    if (this._apiFunctions.hasOwnProperty(apiName))
-      this._apiFunctions[apiName][propertyName] = customizedFunction;
+    if (this._unavailableApiFunctions.hasOwnProperty(apiName))
+      return;
+    if (!this._apiFunctions.hasOwnProperty(apiName))
+      throw new Error('Tried to set hook for unknown API "' + apiName + '"');
+    this._apiFunctions[apiName][propertyName] = customizedFunction;
   };
   APIFunctions.prototype.setHandleRequest =
       function(apiName, customizedFunction) {
     return this._setHook(apiName, 'handleRequest', customizedFunction);
   };
   APIFunctions.prototype.setUpdateArgumentsPostValidate =
       function(apiName, customizedFunction) {
     return this._setHook(
       apiName, 'updateArgumentsPostValidate', customizedFunction);
   };
   APIFunctions.prototype.setUpdateArgumentsPreValidate =
       function(apiName, customizedFunction) {
     return this._setHook(
       apiName, 'updateArgumentsPreValidate', customizedFunction);
   };
   APIFunctions.prototype.setCustomCallback =
       function(apiName, customizedFunction) {
     return this._setHook(apiName, 'customCallback', customizedFunction);
   };
 
   var apiFunctions = new APIFunctions();
 
+  // Wraps the calls to the set* methods of APIFunctions with the namespace of
+  // an API, and validates that all calls to set* methods aren't prefixed with
+  // a namespace.
+  //
+  // For example, if constructed with 'browserAction', a call to
+  // handleRequest('foo') will be transformed into
+  // handleRequest('browserAction.foo').
+  //
+  // Likewise, if a call to handleRequest is called with 'browserAction.foo',
+  // it will throw an error.
+  //
+  // These help with isolating custom bindings from each other.
+  function NamespacedAPIFunctions(namespace, delegate) {
+    var self = this;
+    function wrap(methodName) {
+      self[methodName] = function(apiName, customizedFunction) {
+        var prefix = namespace + '.';
+        if (apiName.indexOf(prefix) === 0) {
+          throw new Error(methodName + ' called with "' + apiName +
+                          '" which has a "' + prefix + '" prefix. ' +
+                          'This is unnecessary and must be left out.');
+        }
+        return delegate[methodName].call(delegate,
+                                         prefix + apiName, customizedFunction);
+      };
+    }
+
+    wrap('contains');
+    wrap('setHandleRequest');
+    wrap('setUpdateArgumentsPostValidate');
+    wrap('setUpdateArgumentsPreValidate');
+    wrap('setCustomCallback');
+  }
+
   //
   // The API through which the ${api_name}_custom_bindings.js files customize
   // their API bindings beyond what can be generated.
   //
   // There are 2 types of customizations available: those which are required in
   // order to do the schema generation (registerCustomEvent and
   // registerCustomType), and those which can only run after the bindings have
   // been generated (registerCustomHook).
   //
 
@@ skipping 136 matching lines @@
         });
       }
 
       // Setup Functions.
       if (apiDef.functions) {
         apiDef.functions.forEach(function(functionDef) {
           if (functionDef.name in mod) {
             throw new Error('Function ' + functionDef.name +
                             ' already defined in ' + apiDef.namespace);
           }
-          if (!isSchemaNodeSupported(functionDef, platform, manifestVersion))
+
+          var apiFunctionName = apiDef.namespace + "." + functionDef.name;
+
+          if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
+            apiFunctions.registerUnavailable(apiFunctionName);
             return;
+          }
           if (!isSchemaAccessAllowed(functionDef)) {
+            apiFunctions.registerUnavailable(apiFunctionName);
             addUnprivilegedAccessGetter(mod, functionDef.name);
             return;
           }
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
-          apiFunction.name = apiDef.namespace + "." + functionDef.name;
-          apiFunctions.register(apiFunction.name, apiFunction);
+          apiFunction.name = apiFunctionName;
+          apiFunctions.register(apiFunctionName, apiFunction);
 
           mod[functionDef.name] = (function() {
             var args = arguments;
             if (this.updateArgumentsPreValidate)
               args = this.updateArgumentsPreValidate.apply(this, args);
             chromeHidden.validate(args, this.definition.parameters);
             if (this.updateArgumentsPostValidate)
               args = this.updateArgumentsPostValidate.apply(this, args);
 
             var retval;
@@ skipping 103 matching lines @@
         return;
 
       var hook = customHooks[apiDef.namespace];
       if (!hook)
         return;
 
       // Pass through the public API of schema_generated_bindings, to be used
       // by custom bindings JS files. Create a new one so that bindings can't
       // interfere with each other.
       hook({
-        apiFunctions: apiFunctions,
+        apiFunctions: new NamespacedAPIFunctions(apiDef.namespace,
+                                                 apiFunctions),
         sendRequest: sendRequest,
         setIcon: setIcon,
         apiDefinitions: apiDefinitions,
       }, extensionId);
     });
 
     // TODO(mihaip): remove this alias once the webstore stops calling
     // beginInstallWithManifest2.
     // See http://crbug.com/100242
     if (chrome.webstorePrivate) {
       chrome.webstorePrivate.beginInstallWithManifest2 =
           chrome.webstorePrivate.beginInstallWithManifest3;
     }
 
     if (chrome.test)
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
   });
 })();