Reland r130462: Implement FeatureProvider for ExtensionAPI."

chrome/browser/extensions/extension_function_dispatcher.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 
 #include <map>
 
 #include "base/json/json_string_value_serializer.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/process_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_activity_log.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
@@ skipping 12 matching lines @@
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/resource_type.h"
 
 using extensions::ExtensionAPI;
 using content::RenderViewHost;
 using WebKit::WebSecurityOrigin;
 
+namespace {
+
 const char kAccessDenied[] = "access denied";
 const char kQuotaExceeded[] = "quota exceeded";
 
 void LogSuccess(const Extension* extension,
                 const ExtensionHostMsg_Request_Params& params) {
   ExtensionActivityLog* extension_activity_log =
       ExtensionActivityLog::GetInstance();
   if (extension_activity_log->HasObservers(extension)) {
     std::string call_signature = params.name + "(";
     ListValue::const_iterator it = params.arguments.begin();
@@ skipping 21 matching lines @@
   ExtensionActivityLog* extension_activity_log =
       ExtensionActivityLog::GetInstance();
   if (extension_activity_log->HasObservers(extension)) {
     extension_activity_log->Log(
         extension,
         ExtensionActivityLog::ACTIVITY_EXTENSION_API_BLOCK,
         func_name + ": " + reason);
   }
 }
 
+// Separate copy of ExtensionAPI used for IO thread extension functions. We need
+// this because ExtensionAPI has mutable data. It should be possible to remove
+// this once all the extension APIs are updated to the feature system.
+struct Static {
+  Static()
+      : api(extensions::ExtensionAPI::CreateWithDefaultConfiguration()) {
+  }
+  scoped_ptr<extensions::ExtensionAPI> api;
+};
+base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+
 void ExtensionFunctionDispatcher::GetAllFunctionNames(
     std::vector<std::string>* names) {
   ExtensionFunctionRegistry::GetInstance()->GetAllNames(names);
 }
 
 bool ExtensionFunctionDispatcher::OverrideFunction(
     const std::string& name, ExtensionFunctionFactory factory) {
   return ExtensionFunctionRegistry::GetInstance()->OverrideFunction(name,
                                                                     factory);
 }
 
 void ExtensionFunctionDispatcher::ResetFunctions() {
   ExtensionFunctionRegistry::GetInstance()->ResetFunctions();
 }
 
 // static
 void ExtensionFunctionDispatcher::DispatchOnIOThread(
     ExtensionInfoMap* extension_info_map,
     void* profile,
     int render_process_id,
     base::WeakPtr<ChromeRenderMessageFilter> ipc_sender,
     int routing_id,
     const ExtensionHostMsg_Request_Params& params) {
   const Extension* extension =
       extension_info_map->extensions().GetByID(params.extension_id);
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension, render_process_id,
-                              extension_info_map->process_map(), profile,
+                              extension_info_map->process_map(),
+                              g_global_io_data.Get().api.get(),
+                              profile,
                               ipc_sender, routing_id));
   if (!function) {
     LogFailure(extension, params.name, kAccessDenied);
     return;
   }
 
   IOThreadExtensionFunction* function_io =
       function->AsIOThreadExtensionFunction();
   if (!function_io) {
     NOTREACHED();
@@ skipping 62 matching lines @@
       params.extension_id);
   if (!extension)
     extension = service->extensions()->GetHostedAppByURL(ExtensionURLInfo(
         WebSecurityOrigin::createFromString(params.source_origin),
         params.source_url));
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension,
                               render_view_host->GetProcess()->GetID(),
                               *(service->process_map()),
+                              extensions::ExtensionAPI::GetSharedInstance(),
                               profile(), render_view_host,
                               render_view_host->GetRoutingID()));
   if (!function) {
     LogFailure(extension, params.name, kAccessDenied);
     return;
   }
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
@@ skipping 31 matching lines @@
   profile()->GetExtensionProcessManager()->DecrementLazyKeepaliveCount(
       extension);
 }
 
 // static
 ExtensionFunction* ExtensionFunctionDispatcher::CreateExtensionFunction(
     const ExtensionHostMsg_Request_Params& params,
     const Extension* extension,
     int requesting_process_id,
     const extensions::ProcessMap& process_map,
+    extensions::ExtensionAPI* api,
     void* profile,
     IPC::Message::Sender* ipc_sender,
     int routing_id) {
   if (!extension) {
     LOG(ERROR) << "Specified extension does not exist.";
     SendAccessDenied(ipc_sender, routing_id, params.request_id);
     return NULL;
   }
 
-  if (ExtensionAPI::GetInstance()->IsPrivileged(params.name) &&
+  if (api->IsPrivileged(params.name) &&
       !process_map.Contains(extension->id(), requesting_process_id)) {
     LOG(ERROR) << "Extension API called from incorrect process "
                << requesting_process_id
                << " from URL " << params.source_url.spec();
     SendAccessDenied(ipc_sender, routing_id, params.request_id);
     return NULL;
   }
 
   if (!extension->HasAPIPermission(params.name)) {
     LOG(ERROR) << "Extension " << extension->id() << " does not have "
@@ skipping 14 matching lines @@
   return function;
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     IPC::Message::Sender* ipc_sender, int routing_id, int request_id) {
   ipc_sender->Send(new ExtensionMsg_Response(
       routing_id, request_id, false, std::string(),
       "Access to extension API denied."));
 }