Lazily require types when validating Extensions API calls

chrome/renderer/resources/extensions/binding.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.
 
 require('json_schema');
 require('event_bindings');
 var chrome = requireNative('chrome').GetChrome();
 var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
 var forEach = require('utils').forEach;
 var GetAvailability = requireNative('v8_context').GetAvailability;
 var logging = requireNative('logging');
 var process = requireNative('process');
 var contextType = process.GetContextType();
 var extensionId = process.GetExtensionId();
 var manifestVersion = process.GetManifestVersion();
 var schemaRegistry = requireNative('schema_registry');
 var schemaUtils = require('schemaUtils');
 var sendRequest = require('sendRequest').sendRequest;
 var utils = require('utils');
+var CHECK = requireNative('logging').CHECK;
 
 // 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) {
@@ skipping 80 matching lines @@
 function isManifestVersionSupported(schemaNode, manifestVersion) {
   return !schemaNode.maximumManifestVersion ||
       manifestVersion <= schemaNode.maximumManifestVersion;
 }
 
 function isSchemaNodeSupported(schemaNode, platform, manifestVersion) {
   return isPlatformSupported(schemaNode, platform) &&
       isManifestVersionSupported(schemaNode, manifestVersion);
 }
 
+function createCustomType(type) {
+  var jsModuleName = type.js_module;
+  CHECK(jsModuleName, 'Custom type ' + type.id +
+      ' has no "js_module" property.');
+  var jsModule = require(jsModuleName);
+  CHECK(jsModule, 'No module ' + jsModuleName + ' found for ' + type.id + '.');
+  var customType = jsModule[jsModuleName];
+  CHECK(customType, jsModuleName + ' must export itself.');
+  customType.prototype = new CustomBindingsObject();
+  customType.prototype.setSchema(type);
+  return customType;
+}
+
 var platform = getPlatform();
 
 function Binding(schema) {
   this.schema_ = schema;
   this.apiFunctions_ = new APIFunctions();
   this.customEvent_ = null;
-  this.customTypes_ = {};
   this.customHooks_ = [];
 };
 
 Binding.create = function(apiName) {
   return new Binding(schemaRegistry.GetSchema(apiName));
 };
 
 Binding.prototype = {
   // 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 type referenced via "$ref" fields in the API schema
-  // JSON.
-  registerCustomType: function(typeName, customTypeFactory) {
-    var customType = customTypeFactory();
-    customType.prototype = new CustomBindingsObject();
-    this.customTypes_[typeName] = customType;
-  },
 
   // Registers a custom event type for the API identified by |namespace|.
   // |event| is the event's constructor.
   registerCustomEvent: function(event) {
     this.customEvent_ = 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
@@ skipping 16 matching lines @@
         schema: this.schema_,
         compiledApi: api
       }, extensionId, contextType);
     }, this);
   },
 
   // Generates the bindings from |this.schema_| and integrates any custom
   // bindings that might be present.
   generate: function() {
     var schema = this.schema_;
-    var customTypes = this.customTypes_;
 
     // TODO(kalman/cduvall): Make GetAvailability handle this, then delete the
     // supporting code.
     if (!isSchemaNodeSupported(schema, platform, manifestVersion)) {
       console.error('chrome.' + schema.namespace + ' is not supported on ' +
                     'this platform or manifest version');
       return undefined;
     }
 
     var availability = GetAvailability(schema.namespace);
     if (!availability.is_available) {
       console.error('chrome.' + schema.namespace + ' is not available: ' +
                     availability.message);
       return undefined;
     }
 
     // See comment on internalAPIs at the top.
     var mod = {};
 
     var namespaces = schema.namespace.split('.');
     for (var index = 0, name; name = namespaces[index]; index++) {
       mod[name] = mod[name] || {};
       mod = mod[name];
     }
 
-    // Add types to global schemaValidator
+    // Add types to global schemaValidator, the types we depend on from other
+    // namespaces will be added as needed.
     if (schema.types) {
       forEach(schema.types, function(i, t) {
         if (!isSchemaNodeSupported(t, platform, manifestVersion))
           return;
 
         schemaUtils.schemaValidator.addTypes(t);
-        if (t.type == 'object' && this.customTypes_[t.id]) {
-          var parts = t.id.split(".");
-          this.customTypes_[t.id].prototype.setSchema(t);
-          mod[parts[parts.length - 1]] = this.customTypes_[t.id];
-        }
       }, this);
     }
 
     // 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') ||
              schema.unprivileged ||
              itemSchema.unprivileged;
@@ skipping 129 matching lines @@
           // 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']) {
-            if (propertyDef['$ref'] in customTypes) {
-              var constructor = customTypes[propertyDef['$ref']];
-            } else {
-              var refParts = propertyDef['$ref'].split('.');
-              // This should never try to load a $ref in the current namespace.
-              var constructor = utils.loadRefDependency(
-                  propertyDef['$ref'])[refParts[refParts.length - 1]];
-            }
-            if (!constructor)
-              throw new Error('No custom binding for ' + propertyDef['$ref']);
+            var ref = propertyDef['$ref'];
+            var type = utils.loadTypeSchema(propertyDef['$ref'], schema);
+            CHECK(type, 'Schema for $ref type ' + ref + ' not found');
+            var constructor = createCustomType(type);
             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, schema);
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;