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;
@@ skipping 99 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(t) {
+  var customType = require(t['js_module'])[t['js_module']];

[not at google - send to devlin, 2013/03/21 00:01:13]

* t -> type
* save reference to t['js_module;] (also: t.js_module)
* CHECK things (assume that people will leave out js_module and you need to help
them)

btw we should add a CHECK to logging.

[cduvall, 2013/03/21 00:59:51]

Done.

+  customType.prototype = new CustomBindingsObject();
+  customType.prototype.setSchema(t);
+  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

[not at google - send to devlin, 2013/03/21 00:01:13]

"the ones for the types we depend on will be added as needed"

[cduvall, 2013/03/21 00:59:51]

Done.

[not at google - send to devlin, 2013/03/21 01:36:55]

my bad grammar sorry. 'the types we depend on from other namespaces...'

[cduvall, 2013/03/21 17:16:07]

Done.

     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];
+        if (t.type == 'object' && 'js_module' in t) {

[not at google - send to devlin, 2013/03/21 00:01:13]

i think this type == 'object' thing isn't necessary

[cduvall, 2013/03/21 00:59:51]

Done, took it all out.

+          var parts = t.id.split('.');
+          mod[parts[parts.length - 1]] = createCustomType(t);

[not at google - send to devlin, 2013/03/21 00:01:13]

looks like this splitting shenanigans also unnecessary

wait... what does this even do? it seems like it adds e.g. a
chrome.storage.StorageArea property, but I don't see it there. nor it is
necessary. what happens if you leave it all out (except for the addTypes part of
course).

[cduvall, 2013/03/21 00:59:51]

Done.

         }
       }, 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 ||
@@ skipping 130 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]];
-            }
+            var constructor;

[not at google - send to devlin, 2013/03/21 00:01:13]

not initializing things makes me slightly uncomfortable, C++ thing I suppose,
but = null?

[cduvall, 2013/03/21 00:59:51]

Done.

+            var type = utils.loadRefType(propertyDef['$ref'], schema);
+            if (type)
+              var constructor = createCustomType(type);

[not at google - send to devlin, 2013/03/21 00:01:13]

var here doesn't make sense

[cduvall, 2013/03/21 00:59:51]

Done.

             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.
@@ skipping 10 matching lines @@
       });
     };
 
     addProperties(mod, schema);
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;