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 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) {
       forEach(schema.types, function(i, t) {
         if (!isSchemaNodeSupported(t, platform, manifestVersion))
           return;
 
         schemaUtils.schemaValidator.addTypes(t);
       }, 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;
-    };
-
     // 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 (schema.functions) {
       forEach(schema.functions, function(i, functionDef) {
         if (functionDef.name in mod) {
           throw new Error('Function ' + functionDef.name +
                           ' already defined in ' + schema.namespace);
         }
 
         if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           return;
         }
-        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);

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

Just leave it blank. No need for the unprivileged thing.

though I think we'll want to fix 234311 and apply it here somehow. ugh. I can't
think of any APIs that would benefit from it yet, though.

[cduvall, 2013/05/01 23:47:10]

Done.

+          return;
+        }
+
         // 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 37 matching lines @@
 
     // Setup Events
     if (schema.events) {
       forEach(schema.events, function(i, eventDef) {
         if (eventDef.name in mod) {
           throw new Error('Event ' + eventDef.name +
                           ' already defined in ' + schema.namespace);
         }
         if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
           return;
-        if (!isSchemaAccessAllowed(eventDef)) {
+
+        var eventName = schema.namespace + "." + eventDef.name;
+        var options = eventDef.options || {};

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

might as well define options after this block.

[cduvall, 2013/05/01 23:47:10]

Done.

+        if (!GetAvailability(eventName).is_available) {
           addUnprivilegedAccessGetter(mod, eventDef.name);

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

ditto - no unprivileged access getter, just leave it blank.

In fact, let's just delete addUnprivilegedAccessGetter entirely.

[cduvall, 2013/05/01 23:47:10]

Done.

           return;
         }
 
-        var eventName = schema.namespace + "." + eventDef.name;
-        var options = eventDef.options || {};
-
         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();
         } else {
           mod[eventDef.name] = new chrome.Event(
               eventName, eventDef.parameters, options);
         }
       }, this);
     }
 
     function addProperties(m, parentDef) {
       var properties = parentDef.properties;
       if (!properties)
         return;
 
       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);
+        if (!GetAvailability(schema.namespace + "." +
+              propertyName).is_available) {
+          addUnprivilegedAccessGetter(mod, propertyName);

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

ditto

[cduvall, 2013/05/01 23:47:10]

Done.

           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);
@@ skipping 22 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);
+
+    function hasItemOfType(typeArray) {
+      return typeArray.length && !typeArray.filter(function (def) {
+        return mod.hasOwnProperty(def.name);
+      }).length;
+    }
+
+    if (!availability.is_available &&
+        (hasItemOfType(schema.events) || hasItemOfType(schema.functions))) {

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

a simpler test may be to just check whether the module object is empty. You can
use Object.keys(mod).length == 0.

[cduvall, 2013/05/01 23:47:10]

Done.

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