Enable extension APIs for content scripts.

chrome/renderer/resources/extensions/schema_generated_bindings.js

 // Copyright (c) 2011 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.
 
 // This script contains privileged chrome extension related javascript APIs.
 // It is loaded by pages whose URL has the chrome-extension protocol.
 
 var chrome = chrome || {};
 (function() {
   native function GetExtensionAPIDefinition();
@@ skipping 556 matching lines @@
     for (var i = 0; i < platforms.length; i++) {
       if (platforms[i][0].test(navigator.appVersion)) {
         return platforms[i][1];
       }
     }
     return "unknown";
   }
 
   chromeHidden.onLoad.addListener(function(extensionId, isExtensionProcess,
                                            isIncognitoProcess) {
-    if (!isExtensionProcess)
-      return;
-
     // Setup the ChromeSetting class so we can use it to construct
     // ChromeSetting objects from the API definition.
     setupChromeSetting();
 
     // Setup the ContentSetting class so we can use it to construct
     // ContentSetting objects from the API definition.
     setupContentSetting();
 
     // |apiFunctions| is a hash of name -> object that stores the
     // name & definition of the apiFunction. Custom handling of api functions
     // is implemented by adding a "handleRequest" function to the object.
     var apiFunctions = {};
 
     // Read api definitions and setup api functions in the chrome namespace.
     // TODO(rafaelw): Consider defining a json schema for an api definition
     //   and validating either here, in a unit_test or both.
     // TODO(rafaelw): Handle synchronous functions.
     // TOOD(rafaelw): Consider providing some convenient override points
     //   for api functions that wish to insert themselves into the call.
-    var apiDefinitions = chromeHidden.JSON.parse(GetExtensionAPIDefinition());
+    var apiDefinitions = GetExtensionAPIDefinition();
     var platform = getPlatform();
 
     apiDefinitions.forEach(function(apiDef) {
       // Check platform, if apiDef has platforms key.
       if (apiDef.platforms && apiDef.platforms.indexOf(platform) == -1) {
         return;
       }
 
       var module = chrome;
       var namespaces = apiDef.namespace.split('.');
       for (var index = 0, name; name = namespaces[index]; index++) {
         module[name] = module[name] || {};
         module = module[name];
       }
 
       // Add types to global validationTypes
       if (apiDef.types) {
         apiDef.types.forEach(function(t) {
           chromeHidden.validationTypes.push(t);
           if (t.type == 'object' && customBindings[t.id]) {
             customBindings[t.id].prototype.setSchema(t);
           }
         });
       }
 
+      // Adds a getter that throws an access denied error to object |module|
+      // for property |name| described by |schemaNode| if necessary.
+      //
+      // Returns true if the getter was necessary (access is disallowed), or
+      // false otherwise.
+      function addUnprivilegedAccessGetter(module, name, allowUnprivileged) {
+        if (allowUnprivileged || isExtensionProcess)
+          return false;
+
+        module.__defineGetter__(name, function() {
+          throw new Error(
+              '"' + name + '" can only be used in extension processes. See ' +
+              'the content scripts documentation for more details.');
+        });
+        return true;
+      }
+
       // Setup Functions.
       if (apiDef.functions) {
         apiDef.functions.forEach(function(functionDef) {
-          // Module functions may have been defined earlier by hand. Don't
-          // clobber them.
-          if (module[functionDef.name])
+          if (functionDef.name in module ||
+              addUnprivilegedAccessGetter(module, functionDef.name,
+                                          functionDef.unprivileged)) {
             return;
+          }
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiDef.namespace + "." + functionDef.name;
           apiFunctions[apiFunction.name] = apiFunction;
 
           module[functionDef.name] = (function() {
             var args = arguments;
             if (this.updateArgumentsPreValidate)
               args = this.updateArgumentsPreValidate.apply(this, args);
@@ skipping 17 matching lines @@
               chromeHidden.validate([retval], [this.definition.returns]);
             }
             return retval;
           }).bind(apiFunction);
         });
       }
 
       // Setup Events
       if (apiDef.events) {
         apiDef.events.forEach(function(eventDef) {
-          // Module events may have been defined earlier by hand. Don't clobber
-          // them.
-          if (module[eventDef.name])
+          if (eventDef.name in module ||
+              addUnprivilegedAccessGetter(module, eventDef.name,
+                                          eventDef.unprivileged)) {
             return;
+          }
 
           var eventName = apiDef.namespace + "." + eventDef.name;
           if (apiDef.namespace == "experimental.webRequest") {
             module[eventDef.name] = new chrome.WebRequestEvent(eventName,
                 eventDef.parameters, eventDef.extraParameters);
           } else {
             module[eventDef.name] = new chrome.Event(eventName,
                 eventDef.parameters);
           }
         });
       }
 
       function addProperties(m, def) {
         // Parse any values defined for properties.
         if (def.properties) {
           forEach(def.properties, function(prop, property) {
+            if (prop in m ||
+                addUnprivilegedAccessGetter(m, prop, property.unprivileged)) {
+              return;
+            }
+
             var value = property.value;
             if (value) {
               if (property.type === 'integer') {
                 value = parseInt(value);
               } else if (property.type === 'boolean') {
                 value = value === "true";
               } else if (property["$ref"]) {
                 var constructor = customBindings[property["$ref"]];
                 var args = value;
                 // For an object property, |value| is an array of constructor
@@ skipping 13 matching lines @@
             if (value) {
               m[prop] = value;
             }
           });
         }
       }
 
       addProperties(module, apiDef);
     });
 
+    // TODO(aa): The rest of the crap below this really needs to be factored out
+    // with a clean API boundary. Right now it is too soupy for me to feel
+    // comfortable running in content scripts. What if people are just
+    // overwriting random APIs? That would bypass our content script access
+    // checks.
+    if (!isExtensionProcess)
+      return;
+
     // getTabContentses is retained for backwards compatibility
     // See http://crbug.com/21433
     chrome.extension.getTabContentses = chrome.extension.getExtensionTabs;
     // TOOD(mihaip): remove this alias once the webstore stops calling
     // beginInstallWithManifest2.
     // See http://crbug.com/100242
     chrome.webstorePrivate.beginInstallWithManifest2 =
         chrome.webstorePrivate.beginInstallWithManifest3;
 
     apiFunctions["tabs.connect"].handleRequest = function(tabId, connectInfo) {
@@ skipping 317 matching lines @@
 
   if (!chrome.tts)
     chrome.tts = {};
 
   if (!chrome.ttsEngine)
     chrome.ttsEngine = {};
 
   if (!chrome.experimental.downloads)
     chrome.experimental.downloads = {};
 })();