Allow API functions and events to have entries in _api_features.json

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 193 matching lines @@
     var schema = this.schema_;
 
     // 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 hasEventOrFunction = false;
 
     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, the types we depend on from other
     // namespaces will be added as needed.
     if (schema.types) {
@@ skipping 39 matching lines @@
         if (!isSchemaAccessAllowed(functionDef)) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           addUnprivilegedAccessGetter(mod, functionDef.name);
           return;
         }
 
         var apiFunction = {};
         apiFunction.definition = functionDef;
         apiFunction.name = schema.namespace + '.' + functionDef.name;
 
+        if (!GetAvailability(apiFunction.name).is_available) {
+          this.apiFunctions_.registerUnavailable(functionDef.name);
+          addUnprivilegedAccessGetter(mod, functionDef.name);
+          return;
+        }
+
+        hasEventOrFunction = true;

[not at google - send to devlin, 2013/04/27 01:02:43]

we may actually want to implement most of this in here, rather than the C++
stuff. It's more of a rework of the JS code but it'd be simpler overall I think.

[cduvall, 2013/05/01 02:51:47]

All the C++ is just to make sure that the bindings that are needed will be
registered in the correct contexts, while only checking the features files. If
we do that in here, then API schemas will be loaded when we don't want them to
be (like in web pages).

[not at google - send to devlin, 2013/05/01 20:47:04]

yep - sorry I was misreading this a bit. cool.

+
         // 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.');
@@ skipping 44 matching lines @@
         }
         if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
           return;
         if (!isSchemaAccessAllowed(eventDef)) {
           addUnprivilegedAccessGetter(mod, eventDef.name);
           return;
         }
 
         var eventName = schema.namespace + "." + eventDef.name;
         var options = eventDef.options || {};
+        if (!GetAvailability(eventName).is_available) {
+          addUnprivilegedAccessGetter(mod, eventDef.name);
+          return;
+        }
+
+        hasEventOrFunction = true;
 
         if (eventDef.filters && eventDef.filters.length > 0)
           options.supportsFilters = true;
 
         if (this.customEvent_) {
           mod[eventDef.name] = new this.customEvent_(
               eventName, eventDef.parameters, eventDef.extraParameters,
               options);
         } else if (eventDef.anonymous) {
           mod[eventDef.name] = new chrome.Event();
@@ skipping 51 matching lines @@
             throw new Error('NOT IMPLEMENTED (extension_api.json error): ' +
                 'Cannot parse values for type "' + type + '"');
           }
           m[propertyName] = value;
         }
       });
     };
 
     addProperties(mod, schema);
     this.runHooks_(mod);
+
+    var availability = GetAvailability(schema.namespace);
+    if (!availability.is_available && !hasEventOrFunction) {

[not at google - send to devlin, 2013/04/27 01:02:43]

You should be able to calculate hasEventOrFunction by just looking at the
schema.

[cduvall, 2013/05/01 02:51:47]

Done.

+      console.error('chrome.' + schema.namespace + ' is not available: ' +
+                        availability.message);
+      return;
+    }
+
     return mod;
   }
 };
 
 exports.Binding = Binding;