Enable extension APIs for content scripts.

chrome/renderer/extensions/chrome_v8_extension.cc

 // 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.
 
 #include "chrome/renderer/extensions/chrome_v8_extension.h"
 
 #include "base/logging.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_set.h"
+#include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
 
+using extensions::ExtensionAPI;
 using WebKit::WebFrame;
 using WebKit::WebView;
 
 namespace {
 
 const char kChromeHidden[] = "chromeHidden";
 
 #ifndef NDEBUG
 const char kValidateCallbacks[] = "validateCallbacks";
 #endif
@@ skipping 86 matching lines @@
     return NULL;  // this can happen as a tab is closing.
 
   GURL url = renderview->GetWebView()->mainFrame()->document().url();
   const ExtensionSet* extensions = extension_dispatcher_->extensions();
   if (!extensions->ExtensionBindingsAllowed(url))
     return NULL;
 
   return extensions->GetByURL(url);
 }
 
-bool ChromeV8Extension::CheckPermissionForCurrentRenderView(
+bool ChromeV8Extension::CheckCurrentContextAccessToExtensionAPI(
     const std::string& function_name) const {
-  const ::Extension* extension = GetExtensionForCurrentRenderView();
-  if (extension &&
-      extension_dispatcher_->IsExtensionActive(extension->id()) &&
-      extension->HasAPIPermission(function_name))
-    return true;
+  ChromeV8Context* context =
+      extension_dispatcher_->v8_context_set().GetCurrent();
+  if (!context) {
+    DLOG(ERROR) << "Not in a v8::Context";
+    return false;
+  }
 
-  static const char kMessage[] =
-      "You do not have permission to use '%s'. Be sure to declare"
-      " in your manifest what permissions you need.";
-  std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
+  const ::Extension* extension = NULL;
+  if (!context->extension_id().empty()) {
+    extension =
+        extension_dispatcher_->extensions()->GetByID(context->extension_id());
+  }
 
-  v8::ThrowException(v8::Exception::Error(v8::String::New(error_msg.c_str())));
-  return false;
+  if (!extension || !extension->HasAPIPermission(function_name)) {
+    static const char kMessage[] =
+        "You do not have permission to use '%s'. Be sure to declare"
+        " in your manifest what permissions you need.";
+    std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
+    v8::ThrowException(
+        v8::Exception::Error(v8::String::New(error_msg.c_str())));
+    return false;
+  }
+
+  if (!extension_dispatcher_->IsExtensionActive(extension->id()) &&
+      ExtensionAPI::GetInstance()->IsPrivileged(function_name)) {
+    static const char kMessage[] =
+        "%s can only be used in an extension process.";
+    std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
+    v8::ThrowException(
+        v8::Exception::Error(v8::String::New(error_msg.c_str())));
+    return false;
+  }
+
+  return true;
 }
 
 v8::Handle<v8::FunctionTemplate>
     ChromeV8Extension::GetNativeFunction(v8::Handle<v8::String> name) {
   if (name->Equals(v8::String::New("GetChromeHidden"))) {
     return v8::FunctionTemplate::New(GetChromeHidden);
   }
 
   if (name->Equals(v8::String::New("Print"))) {
     return v8::FunctionTemplate::New(Print);
@@ skipping 39 matching lines @@
     const v8::Handle<v8::Context>& context) {
   v8::Local<v8::Object> global = context->Global();
   v8::Local<v8::Value> hidden = global->GetHiddenValue(
       v8::String::New(kChromeHidden));
 
   if (hidden.IsEmpty() || hidden->IsUndefined()) {
     hidden = v8::Object::New();
     global->SetHiddenValue(v8::String::New(kChromeHidden), hidden);
 
 #ifndef NDEBUG
-    // Tell extension_process_bindings.js to validate callbacks and events
+    // Tell schema_generated_bindings.js to validate callbacks and events
     // against their schema definitions in api/extension_api.json.
     v8::Local<v8::Object>::Cast(hidden)
         ->Set(v8::String::New(kValidateCallbacks), v8::True());
 #endif
   }
 
   DCHECK(hidden->IsObject());
   return v8::Local<v8::Object>::Cast(hidden);
 }
 
 v8::Handle<v8::Value> ChromeV8Extension::Print(const v8::Arguments& args) {
   if (args.Length() < 1)
     return v8::Undefined();
 
   std::vector<std::string> components;
   for (int i = 0; i < args.Length(); ++i)
     components.push_back(*v8::String::Utf8Value(args[i]->ToString()));
 
   LOG(ERROR) << JoinString(components, ',');
   return v8::Undefined();
 }