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 184 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 checkUnprivileged = schema['check_unprivileged'];

[not at google - send to devlin, 2013/05/03 04:58:14]

to answer your question in IRC - yeah let's fix this stuff up in a follow-up.

however, for now, can you just search over the whole API object looking for an
object with an "unprivileged" property? It's a bit inefficient, but, not really
that bad, less than total work. and it's evaluated lazily anyway.

 
     // 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);
     }
 
+    // TODO(cduvall): Take out when all APIs have been converted to features.
     // 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 ||
+            (checkUnprivileged && !isSchemaAccessAllowed(functionDef))) {
+          this.apiFunctions_.registerUnavailable(functionDef.name);
+          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)) {
-          addUnprivilegedAccessGetter(mod, eventDef.name);
+
+        var eventName = schema.namespace + "." + eventDef.name;
+        if (!GetAvailability(eventName).is_available ||
+            (checkUnprivileged && !isSchemaAccessAllowed(eventDef))) {
           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 ||
+            (checkUnprivileged && !isSchemaAccessAllowed(propertyDef))) {
           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 21 matching lines @@
           } 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);
+
+    var availability = GetAvailability(schema.namespace);
+    if (!availability.is_available && Object.keys(mod).length == 0) {
+      console.error('chrome.' + schema.namespace + ' is not available: ' +
+                        availability.message);
+      return;
+    }
+
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;