Convert ExtensionFunctionDispatcher from Profile to BrowserContext

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 "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
 #include "chrome/browser/extensions/activity_log/activity_log.h"
 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/browser/quota_service.h"
 #include "extensions/common/extension_api.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "webkit/common/resource_type.h"
 
 using extensions::Extension;
 using extensions::ExtensionAPI;
+using extensions::ExtensionSystem;
 using extensions::Feature;
 using content::RenderViewHost;
 
 namespace {
 
 void LogSuccess(const std::string& extension_id,
                 const std::string& api_name,
                 scoped_ptr<base::ListValue> args,
-                Profile* profile) {
+                content::BrowserContext* browser_context) {
   // The ActivityLog can only be accessed from the main (UI) thread.  If we're
   // running on the wrong thread, re-dispatch from the main thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&LogSuccess,
                                        extension_id,
                                        api_name,
                                        base::Passed(&args),
-                                       profile));
+                                       browser_context));
   } else {
     extensions::ActivityLog* activity_log =
-        extensions::ActivityLog::GetInstance(profile);
+        extensions::ActivityLog::GetInstance(browser_context);
     scoped_refptr<extensions::Action> action =
         new extensions::Action(extension_id,
                                base::Time::Now(),
                                extensions::Action::ACTION_API_CALL,
                                api_name);
     action->set_args(args.Pass());
     activity_log->LogAction(action);
   }
 }
 
@@ skipping 151 matching lines @@
                                                                     factory);
 }
 
 void ExtensionFunctionDispatcher::ResetFunctions() {
   ExtensionFunctionRegistry::GetInstance()->ResetFunctions();
 }
 
 // static
 void ExtensionFunctionDispatcher::DispatchOnIOThread(
     extensions::InfoMap* extension_info_map,
-    void* profile,
+    void* browser_context,
     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);
-  Profile* profile_cast = static_cast<Profile*>(profile);
 
   ExtensionFunction::ResponseCallback callback(
       base::Bind(&IOThreadResponseCallback, ipc_sender, routing_id,
                  params.request_id));
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension, render_process_id,
                               extension_info_map->process_map(),
                               g_global_io_data.Get().api.get(),
-                              profile, callback));
+                              browser_context, callback));
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
 
   if (!function.get())
     return;
 
   IOThreadExtensionFunction* function_io =
       function->AsIOThreadExtensionFunction();
   if (!function_io) {
     NOTREACHED();
     return;
   }
   function_io->set_ipc_sender(ipc_sender, routing_id);
   function_io->set_extension_info_map(extension_info_map);
   function->set_include_incognito(
       extension_info_map->IsIncognitoEnabled(extension->id()));
 
   if (!CheckPermissions(function.get(), extension, params, callback))
     return;
 
   extensions::QuotaService* quota = extension_info_map->GetQuotaService();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
     LogSuccess(extension->id(),
                params.name,
                args.Pass(),
-               profile_cast);
+               static_cast<content::BrowserContext*>(browser_context));
     function->Run();
   } else {
     function->OnQuotaExceeded(violation_error);
   }
 }
 
 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(
     content::BrowserContext* browser_context,
     Delegate* delegate)
-    : profile_(Profile::FromBrowserContext(browser_context)),
+    : browser_context_(browser_context),
       delegate_(delegate) {
 }
 
 ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() {
 }
 
 void ExtensionFunctionDispatcher::Dispatch(
     const ExtensionHostMsg_Request_Params& params,
     RenderViewHost* render_view_host) {
   UIThreadResponseCallbackWrapperMap::const_iterator
@@ skipping 10 matching lines @@
   DispatchWithCallback(params, render_view_host,
                        callback_wrapper->CreateCallback(params.request_id));
 }
 
 void ExtensionFunctionDispatcher::DispatchWithCallback(
     const ExtensionHostMsg_Request_Params& params,
     RenderViewHost* render_view_host,
     const ExtensionFunction::ResponseCallback& callback) {
   // TODO(yzshen): There is some shared logic between this method and
   // DispatchOnIOThread(). It is nice to deduplicate.
-  ExtensionService* service = profile()->GetExtensionService();
-  extensions::ProcessManager* process_manager =
-      extensions::ExtensionSystem::Get(profile())->process_manager();
+  ExtensionSystem* extension_system =
+      ExtensionSystem::GetForBrowserContext(browser_context_);
+  ExtensionService* service = extension_system->extension_service();
   extensions::ProcessMap* process_map = service->process_map();
-  if (!service || !process_map)
+  if (!process_map)
     return;
 
   const Extension* extension = service->extensions()->GetByID(
       params.extension_id);
   if (!extension)
     extension = service->extensions()->GetHostedAppByURL(params.source_url);
 
   scoped_refptr<ExtensionFunction> function(
-      CreateExtensionFunction(params, extension,
+      CreateExtensionFunction(params,
+                              extension,
                               render_view_host->GetProcess()->GetID(),
-                              *(service->process_map()),
+                              *process_map,
                               extensions::ExtensionAPI::GetSharedInstance(),
-                              profile(), callback));
+                              browser_context_,
+                              callback));
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
 
   if (!function.get())
     return;
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
     NOTREACHED();
     return;
   }
   function_ui->SetRenderViewHost(render_view_host);
   function_ui->set_dispatcher(AsWeakPtr());
-  function_ui->set_context(profile_);
+  function_ui->set_context(browser_context_);
   function->set_include_incognito(extension_util::CanCrossIncognito(extension,
                                                                     service));
 
   if (!CheckPermissions(function.get(), extension, params, callback))
     return;
 
   extensions::QuotaService* quota = service->quota_service();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
     // See crbug.com/39178.
     ExternalProtocolHandler::PermitLaunchUrl();
-    LogSuccess(extension->id(), params.name, args.Pass(), profile());
+    LogSuccess(extension->id(), params.name, args.Pass(), browser_context_);
     function->Run();
   } else {
     function->OnQuotaExceeded(violation_error);
   }
 
   // Note: do not access |this| after this point. We may have been deleted
   // if function->Run() ended up closing the tab that owns us.
 
   // Check if extension was uninstalled by management.uninstall.
   if (!service->extensions()->GetByID(params.extension_id))
     return;
 
   // We only adjust the keepalive count for UIThreadExtensionFunction for
   // now, largely for simplicity's sake. This is OK because currently, only
   // the webRequest API uses IOThreadExtensionFunction, and that API is not
   // compatible with lazy background pages.
-  process_manager->IncrementLazyKeepaliveCount(extension);
+  extension_system->process_manager()->IncrementLazyKeepaliveCount(extension);
 }
 
 void ExtensionFunctionDispatcher::OnExtensionFunctionCompleted(
     const Extension* extension) {
-  extensions::ExtensionSystem::Get(profile())->process_manager()->
+  ExtensionSystem::GetForBrowserContext(browser_context_)->process_manager()->
       DecrementLazyKeepaliveCount(extension);
 }
 
 // static
 bool ExtensionFunctionDispatcher::CheckPermissions(
     ExtensionFunction* function,
     const Extension* extension,
     const ExtensionHostMsg_Request_Params& params,
     const ExtensionFunction::ResponseCallback& callback) {
   if (!function->HasPermission()) {
@@ skipping 85 matching lines @@
   return function;
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback) {
   ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.");
 }