chrome/renderer/resources/extensions/schema_generated_bindings.js - chromium/src - Git at Google

 // 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.

 // Generates the chrome.* API bindings from a list of schemas.

   // 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 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;

   // 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._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).
   //

   // Registers a custom event type for the API identified by |namespace|.
   // |event| is the event's constructor.
   var customEvents = {};
   chromeHidden.registerCustomEvent = function(namespace, event) {
     if (typeof(namespace) !== 'string') {
       throw new Error("registerCustomEvent requires the namespace of the " +
                       "API as its first argument");
     }
     customEvents[namespace] = event;
   };

   // Registers a function |hook| to run after the schema for all APIs has been
   // generated.  The hook is passed as its first argument an "API" object to
   // interact with, and second the current extension ID. See where
   // |customHooks| is used.
   var customHooks = {};
   chromeHidden.registerCustomHook = function(namespace, fn) {
     if (typeof(namespace) !== 'string') {
       throw new Error("registerCustomHook requires the namespace of the " +
                       "API as its first argument");
     }
     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.functionSchemas = {};
     schema.functions.forEach(function(f) {
       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;
   };

   // Get the platform from navigator.appVersion.
   function getPlatform() {
     var platforms = [
       [/CrOS Touch/, "chromeos touch"],
       [/CrOS/, "chromeos"],
       [/Linux/, "linux"],
       [/Mac/, "mac"],
       [/Win/, "win"],
     ];

     for (var i = 0; i < platforms.length; i++) {
       if (platforms[i][0].test(navigator.appVersion)) {
         return platforms[i][1];
       }
     }
     return "unknown";
   }

   function isPlatformSupported(schemaNode, platform) {
     return !schemaNode.platforms ||
         schemaNode.platforms.indexOf(platform) > -1;
   }

   function isManifestVersionSupported(schemaNode, manifestVersion) {
     return !schemaNode.maximumManifestVersion ||
         manifestVersion <= schemaNode.maximumManifestVersion;
   }

   function isSchemaNodeSupported(schemaNode, platform, manifestVersion) {
     return isPlatformSupported(schemaNode, platform) &&
         isManifestVersionSupported(schemaNode, manifestVersion);
   }

   chromeHidden.onLoad.addListener(function(extensionId,
                                            contextType,
                                            isIncognitoProcess,
                                            manifestVersion) {
     var apiDefinitions = GetExtensionAPIDefinition();

     // Read api definitions and setup api functions in the chrome namespace.
     var platform = getPlatform();

     apiDefinitions.forEach(function(apiDef) {
       // TODO(kalman): Remove this, or refactor schema_generated_bindings.js so
       // that it isn't necessary. For now, chrome.app and chrome.webstore are
       // entirely handwritten.
       if (['app', 'webstore'].indexOf(apiDef.namespace) >= 0)
         return;

       if (!isSchemaNodeSupported(apiDef, platform, manifestVersion))
         return;

       // 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 schemaValidator
       if (apiDef.types) {
         apiDef.types.forEach(function(t) {
           if (!isSchemaNodeSupported(t, platform, manifestVersion))
             return;

           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) {
         return (contextType == 'BLESSED_EXTENSION') ||
                apiDef.unprivileged ||
                itemSchema.unprivileged;
       }

       // Adds a getter that throws an access denied error to object |mod|
       // for property |name|.
       function addUnprivilegedAccessGetter(mod, name) {
         mod.__defineGetter__(name, function() {
           throw new Error(
               '"' + name + '" can only be used in extension processes. See ' +
               'the content scripts documentation for more details.');
         });
       }

       // 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);
           }

           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 = 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 &&
               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 = 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 {
               var optArgs = {
                 customCallback: this.customCallback
               };
               retval = sendRequest(this.name, args,
                                    this.definition.parameters,
                                    optArgs);
             }

             // Validate return value if defined - only in debug.
             if (chromeHidden.validateCallbacks &&
                 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) {
             throw new Error('Event ' + eventDef.name +
                             ' already defined in ' + apiDef.namespace);
           }
           if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
             return;
           if (!isSchemaAccessAllowed(eventDef)) {
             addUnprivilegedAccessGetter(mod, eventDef.name);
             return;
           }

           var eventName = apiDef.namespace + "." + eventDef.name;
           var customEvent = customEvents[apiDef.namespace];
           var options = eventDef.options || {};

           if (eventDef.filters && eventDef.filters.length > 0)
             options.supportsFilters = true;

           if (customEvent) {
             mod[eventDef.name] = new customEvent(
                 eventName, eventDef.parameters, eventDef.extraParameters,
                 options);
           } else if (eventDef.anonymous) {
             mod[eventDef.name] = new chrome.Event();
           } else {
             mod[eventDef.name] = new chrome.Event(
                 eventName, eventDef.parameters, options);
           }
         });
       }

       function addProperties(m, parentDef) {
         var properties = parentDef.properties;
         if (!properties)
           return;

         utils.forEach(properties, function(propertyName, propertyDef) {
           if (propertyName in m)
             return;  // TODO(kalman): be strict like functions/events somehow.
           if (!isSchemaNodeSupported(propertyDef, platform, manifestVersion))
             return;
           if (!isSchemaAccessAllowed(propertyDef)) {
             addUnprivilegedAccessGetter(m, propertyName);
             return;
           }

           var value = propertyDef.value;
           if (value) {
             // Values may just have raw types as defined in the JSON, such
             // as "WINDOW_ID_NONE": { "value": -1 }. We handle this here.
             // TODO(kalman): enforce that things with a "value" property can't
             // define their own types.
             var type = propertyDef.type || typeof(value);
             if (type === 'integer' || type === 'number') {
               value = parseInt(value);
             } else if (type === 'boolean') {
               value = value === "true";
             } else if (propertyDef["$ref"]) {
               var constructor = customTypes[propertyDef["$ref"]];
               if (!constructor)
                 throw new Error("No custom binding for " + propertyDef["$ref"]);
               var args = value;
               // For an object propertyDef, |value| is an array of constructor
               // arguments, but we want to pass the arguments directly (i.e.
               // not as an array), so we have to fake calling |new| on the
               // constructor.
               value = { __proto__: constructor.prototype };
               constructor.apply(value, args);
               // Recursively add properties.
               addProperties(value, propertyDef);
             } else if (type === 'object') {
               // Recursively add properties.
               addProperties(value, propertyDef);
             } else if (type !== 'string') {
               throw new Error("NOT IMPLEMENTED (extension_api.json error): " +
                   "Cannot parse values for type \"" + type + "\"");
             }
             m[propertyName] = value;
           }
         });
       }

       addProperties(mod, apiDef);
     });

     // Run the non-declarative custom hooks after all the schemas have been
     // generated, in case hooks depend on other APIs being available.
     apiDefinitions.forEach(function(apiDef) {
       if (!isSchemaNodeSupported(apiDef, platform, manifestVersion))
         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: new NamespacedAPIFunctions(apiDef.namespace,
                                                  apiFunctions),
         apiDefinitions: apiDefinitions,
       }, extensionId, contextType);
     });

     if (chrome.test)
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
   });
	// 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.

	// Generates the chrome.* API bindings from a list of schemas.

	// 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 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;

	// 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._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).
	//

	// Registers a custom event type for the API identified by \|namespace\|.
	// \|event\| is the event's constructor.
	var customEvents = {};
	chromeHidden.registerCustomEvent = function(namespace, event) {
	if (typeof(namespace) !== 'string') {
	throw new Error("registerCustomEvent requires the namespace of the " +
	"API as its first argument");
	}
	customEvents[namespace] = event;
	};

	// Registers a function \|hook\| to run after the schema for all APIs has been
	// generated. The hook is passed as its first argument an "API" object to
	// interact with, and second the current extension ID. See where
	// \|customHooks\| is used.
	var customHooks = {};
	chromeHidden.registerCustomHook = function(namespace, fn) {
	if (typeof(namespace) !== 'string') {
	throw new Error("registerCustomHook requires the namespace of the " +
	"API as its first argument");
	}
	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.functionSchemas = {};
	schema.functions.forEach(function(f) {
	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;
	};

	// Get the platform from navigator.appVersion.
	function getPlatform() {
	var platforms = [
	[/CrOS Touch/, "chromeos touch"],
	[/CrOS/, "chromeos"],
	[/Linux/, "linux"],
	[/Mac/, "mac"],
	[/Win/, "win"],
	];

	for (var i = 0; i < platforms.length; i++) {
	if (platforms[i][0].test(navigator.appVersion)) {
	return platforms[i][1];
	}
	}
	return "unknown";
	}

	function isPlatformSupported(schemaNode, platform) {
	return !schemaNode.platforms \|\|
	schemaNode.platforms.indexOf(platform) > -1;
	}

	function isManifestVersionSupported(schemaNode, manifestVersion) {
	return !schemaNode.maximumManifestVersion \|\|
	manifestVersion <= schemaNode.maximumManifestVersion;
	}

	function isSchemaNodeSupported(schemaNode, platform, manifestVersion) {
	return isPlatformSupported(schemaNode, platform) &&
	isManifestVersionSupported(schemaNode, manifestVersion);
	}

	chromeHidden.onLoad.addListener(function(extensionId,
	contextType,
	isIncognitoProcess,
	manifestVersion) {
	var apiDefinitions = GetExtensionAPIDefinition();

	// Read api definitions and setup api functions in the chrome namespace.
	var platform = getPlatform();

	apiDefinitions.forEach(function(apiDef) {
	// TODO(kalman): Remove this, or refactor schema_generated_bindings.js so
	// that it isn't necessary. For now, chrome.app and chrome.webstore are
	// entirely handwritten.
	if (['app', 'webstore'].indexOf(apiDef.namespace) >= 0)
	return;

	if (!isSchemaNodeSupported(apiDef, platform, manifestVersion))
	return;

	// 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 schemaValidator
	if (apiDef.types) {
	apiDef.types.forEach(function(t) {
	if (!isSchemaNodeSupported(t, platform, manifestVersion))
	return;

	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) {
	return (contextType == 'BLESSED_EXTENSION') \|\|
	apiDef.unprivileged \|\|
	itemSchema.unprivileged;
	}

	// Adds a getter that throws an access denied error to object \|mod\|
	// for property \|name\|.
	function addUnprivilegedAccessGetter(mod, name) {
	mod.__defineGetter__(name, function() {
	throw new Error(
	'"' + name + '" can only be used in extension processes. See ' +
	'the content scripts documentation for more details.');
	});
	}

	// 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);
	}

	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 = 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 &&
	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 = 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 {
	var optArgs = {
	customCallback: this.customCallback
	};
	retval = sendRequest(this.name, args,
	this.definition.parameters,
	optArgs);
	}

	// Validate return value if defined - only in debug.
	if (chromeHidden.validateCallbacks &&
	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) {
	throw new Error('Event ' + eventDef.name +
	' already defined in ' + apiDef.namespace);
	}
	if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
	return;
	if (!isSchemaAccessAllowed(eventDef)) {
	addUnprivilegedAccessGetter(mod, eventDef.name);
	return;
	}

	var eventName = apiDef.namespace + "." + eventDef.name;
	var customEvent = customEvents[apiDef.namespace];
	var options = eventDef.options \|\| {};

	if (eventDef.filters && eventDef.filters.length > 0)
	options.supportsFilters = true;

	if (customEvent) {
	mod[eventDef.name] = new customEvent(
	eventName, eventDef.parameters, eventDef.extraParameters,
	options);
	} else if (eventDef.anonymous) {
	mod[eventDef.name] = new chrome.Event();
	} else {
	mod[eventDef.name] = new chrome.Event(
	eventName, eventDef.parameters, options);
	}
	});
	}

	function addProperties(m, parentDef) {
	var properties = parentDef.properties;
	if (!properties)
	return;

	utils.forEach(properties, function(propertyName, propertyDef) {
	if (propertyName in m)
	return; // TODO(kalman): be strict like functions/events somehow.
	if (!isSchemaNodeSupported(propertyDef, platform, manifestVersion))
	return;
	if (!isSchemaAccessAllowed(propertyDef)) {
	addUnprivilegedAccessGetter(m, propertyName);
	return;
	}

	var value = propertyDef.value;
	if (value) {
	// Values may just have raw types as defined in the JSON, such
	// as "WINDOW_ID_NONE": { "value": -1 }. We handle this here.
	// TODO(kalman): enforce that things with a "value" property can't
	// define their own types.
	var type = propertyDef.type \|\| typeof(value);
	if (type === 'integer' \|\| type === 'number') {
	value = parseInt(value);
	} else if (type === 'boolean') {
	value = value === "true";
	} else if (propertyDef["$ref"]) {
	var constructor = customTypes[propertyDef["$ref"]];
	if (!constructor)
	throw new Error("No custom binding for " + propertyDef["$ref"]);
	var args = value;
	// For an object propertyDef, \|value\| is an array of constructor
	// arguments, but we want to pass the arguments directly (i.e.
	// not as an array), so we have to fake calling \|new\| on the
	// constructor.
	value = { __proto__: constructor.prototype };
	constructor.apply(value, args);
	// Recursively add properties.
	addProperties(value, propertyDef);
	} else if (type === 'object') {
	// Recursively add properties.
	addProperties(value, propertyDef);
	} else if (type !== 'string') {
	throw new Error("NOT IMPLEMENTED (extension_api.json error): " +
	"Cannot parse values for type \"" + type + "\"");
	}
	m[propertyName] = value;
	}
	});
	}

	addProperties(mod, apiDef);
	});

	// Run the non-declarative custom hooks after all the schemas have been
	// generated, in case hooks depend on other APIs being available.
	apiDefinitions.forEach(function(apiDef) {
	if (!isSchemaNodeSupported(apiDef, platform, manifestVersion))
	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: new NamespacedAPIFunctions(apiDef.namespace,
	apiFunctions),
	apiDefinitions: apiDefinitions,
	}, extensionId, contextType);
	});

	if (chrome.test)
	chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
	});