Move ProfileKeyedAPI implementations to take BrowserContext in the constructor (part 2).

chrome/browser/extensions/api/processes/processes_api.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/api/processes/processes_api.h"
 
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/processes/processes_api_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_function_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/resource_provider.h"
 #include "chrome/browser/task_manager/task_manager.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/result_codes.h"
@@ skipping 170 matching lines @@
   size_t mem;
   int64 pr_mem = model->GetPrivateMemory(index, &mem) ?
       static_cast<int64>(mem) : -1;
   result->SetDouble(keys::kPrivateMemoryKey, static_cast<double>(pr_mem));
 }
 
 #endif  // defined(ENABLE_TASK_MANAGER)
 
 }  // namespace
 
-ProcessesEventRouter::ProcessesEventRouter(Profile* profile)
-    : profile_(profile),
-      listeners_(0),
-      task_manager_listening_(false) {
+ProcessesEventRouter::ProcessesEventRouter(content::BrowserContext* context)
+    : browser_context_(context), listeners_(0), task_manager_listening_(false) {
 #if defined(ENABLE_TASK_MANAGER)
   model_ = TaskManager::GetInstance()->model();
   model_->AddObserver(this);
 
   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_HANG,
       content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllSources());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
@@ skipping 233 matching lines @@
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(details->exit_code));
 
   DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::DispatchEvent(
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
-  if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
+  if (extensions::ExtensionSystem::Get(browser_context_)->event_router()) {
     scoped_ptr<extensions::Event> event(new extensions::Event(
         event_name, event_args.Pass()));
-    extensions::ExtensionSystem::Get(profile_)->event_router()->
-        BroadcastEvent(event.Pass());
+    extensions::ExtensionSystem::Get(browser_context_)
+        ->event_router()
+        ->BroadcastEvent(event.Pass());
   }
 }
 
 bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
   extensions::EventRouter* router =
-      extensions::ExtensionSystem::Get(profile_)->event_router();
+      extensions::ExtensionSystem::Get(browser_context_)->event_router();
   if (router && router->HasEventListener(event_name))
     return true;
   return false;
 }
 
-ProcessesAPI::ProcessesAPI(Profile* profile) : profile_(profile) {
-  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+ProcessesAPI::ProcessesAPI(content::BrowserContext* context)
+    : browser_context_(context) {
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
       this, processes_api_constants::kOnUpdated);
-  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
       this, processes_api_constants::kOnUpdatedWithMemory);
   ExtensionFunctionRegistry* registry =
       ExtensionFunctionRegistry::GetInstance();
   registry->RegisterFunction<extensions::GetProcessIdForTabFunction>();
   registry->RegisterFunction<extensions::TerminateFunction>();
   registry->RegisterFunction<extensions::GetProcessInfoFunction>();
 }
 
 ProcessesAPI::~ProcessesAPI() {
 }
 
 void ProcessesAPI::Shutdown() {
-  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+  ExtensionSystem::Get(browser_context_)->event_router()->UnregisterObserver(
+      this);
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<ProcessesAPI> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ProfileKeyedAPIFactory<ProcessesAPI>* ProcessesAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
-ProcessesAPI* ProcessesAPI::Get(Profile* profile) {
-  return ProfileKeyedAPIFactory<ProcessesAPI>::GetForProfile(profile);
+ProcessesAPI* ProcessesAPI::Get(content::BrowserContext* context) {
+  return ProfileKeyedAPIFactory<ProcessesAPI>::GetForProfile(context);
 }
 
 ProcessesEventRouter* ProcessesAPI::processes_event_router() {
   if (!processes_event_router_)
-    processes_event_router_.reset(new ProcessesEventRouter(profile_));
+    processes_event_router_.reset(new ProcessesEventRouter(browser_context_));
   return processes_event_router_.get();
 }
 
 void ProcessesAPI::OnListenerAdded(const EventListenerInfo& details) {
   // We lazily tell the TaskManager to start updating when listeners to the
   // processes.onUpdated or processes.onUpdatedWithMemory events arrive.
   processes_event_router()->ListenerAdded();
 }
 
 void ProcessesAPI::OnListenerRemoved(const EventListenerInfo& details) {
@@ skipping 225 matching lines @@
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions