Reland 166821 - Lazy initialization for ProcessesEventRouter.

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/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 
 #include "chrome/browser/extensions/api/processes/processes_api_constants.h"
+#include "chrome/browser/extensions/api/processes/processes_api_factory.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_error_utils.h"
@@ skipping 179 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::GetInstance() {
-  return Singleton<ProcessesEventRouter>::get();
-}
-
-ProcessesEventRouter::ProcessesEventRouter()
-    : listeners_(0),
+ProcessesEventRouter::ProcessesEventRouter(Profile* profile)
+    : profile_(profile),
+      listeners_(0),
       task_manager_listening_(false) {
 #if defined(ENABLE_TASK_MANAGER)
   model_ = TaskManager::GetInstance()->model();
   model_->AddObserver(this);
 
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
       content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllSources());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 ProcessesEventRouter::~ProcessesEventRouter() {
 #if defined(ENABLE_TASK_MANAGER)
   registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
       content::NotificationService::AllSources());
   registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllSources());
 
   if (task_manager_listening_)
     model_->StopListening();
 
   model_->RemoveObserver(this);
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ProcessesEventRouter::ObserveProfile(Profile* profile) {
-  profiles_.insert(profile);
-}
-
 void ProcessesEventRouter::ListenerAdded() {
 #if defined(ENABLE_TASK_MANAGER)
   // The task manager has its own ref count to balance other callers of
   // StartUpdating/StopUpdating.
   model_->StartUpdating();
 #endif  // defined(ENABLE_TASK_MANAGER)
   ++listeners_;
 }
 
 void ProcessesEventRouter::ListenerRemoved() {
@@ skipping 55 matching lines @@
   scoped_ptr<ListValue> args(new ListValue());
   DictionaryValue* process = CreateProcessFromModel(
       model_->GetUniqueChildProcessId(index), model_, index, false);
   DCHECK(process != NULL);
 
   if (process == NULL)
     return;
 
   args->Append(process);
 
-  NotifyProfiles(keys::kOnCreated, args.Pass());
+  DispatchEvent(keys::kOnCreated, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::OnItemsChanged(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   // If we don't have any listeners, return immediately.
   if (listeners_ == 0)
     return;
 
   if (!model_)
@@ skipping 26 matching lines @@
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       // Store each process indexed by the string version of its id.
       processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
     scoped_ptr<ListValue> args(new ListValue());
     args->Append(processes);
-    NotifyProfiles(keys::kOnUpdated, args.Pass());
+    DispatchEvent(keys::kOnUpdated, args.Pass());
   }
 
   if (updated_memory) {
     IDMap<DictionaryValue>::iterator it(&processes_map);
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       AddMemoryDetails(it.GetCurrentValue(), model_, it.GetCurrentKey());
 
       // Store each process indexed by the string version of its id if we didn't
       // already insert it as part of the onUpdated processing above.
       if (!updated)
         processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
     scoped_ptr<ListValue> args(new ListValue());
     args->Append(processes);
-    NotifyProfiles(keys::kOnUpdatedWithMemory, args.Pass());
+    DispatchEvent(keys::kOnUpdatedWithMemory, args.Pass());
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   DCHECK_EQ(length, 1);
 
   // Process exit for renderer processes has the data about exit code and
   // termination status, therefore we will rely on notifications and not on
   // the Task Manager data. We do use the rest of this method for non-renderer
   // processes.
   if (model_->GetResourceType(start) == TaskManager::Resource::RENDERER)
     return;
 
   // The callback function parameters.
   scoped_ptr<ListValue> args(new ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(Value::CreateIntegerValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
   args->Append(Value::CreateIntegerValue(0));
 
   // Third arg: The exit code for the process.
   args->Append(Value::CreateIntegerValue(0));
 
-  NotifyProfiles(keys::kOnExited, args.Pass());
+  DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessHangEvent(content::RenderWidgetHost* widget) {
 #if defined(ENABLE_TASK_MANAGER)
   std::string event(keys::kOnUnresponsive);
   if (!HasEventListeners(event))
     return;
 
   DictionaryValue* process = NULL;
   int count = model_->ResourceCount();
   int id = widget->GetProcess()->GetID();
 
   for (int i = 0; i < count; ++i) {
     if (model_->IsResourceFirstInGroup(i)) {
       if (id == model_->GetUniqueChildProcessId(i)) {
         process = CreateProcessFromModel(id, model_, i, false);
         break;
       }
     }
   }
 
   DCHECK(process);
   if (process == NULL)
     return;
 
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(process);
 
-  NotifyProfiles(keys::kOnUnresponsive, args.Pass());
+  DispatchEvent(keys::kOnUnresponsive, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessClosedEvent(
     content::RenderProcessHost* rph,
     content::RenderProcessHost::RendererClosedDetails* details) {
 #if defined(ENABLE_TASK_MANAGER)
   // The callback function parameters.
   scoped_ptr<ListValue> args(new ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(Value::CreateIntegerValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
   args->Append(Value::CreateIntegerValue(details->status));
 
   // Third arg: The exit code for the process.
   args->Append(Value::CreateIntegerValue(details->exit_code));
 
-  NotifyProfiles(keys::kOnExited, args.Pass());
+  DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ProcessesEventRouter::DispatchEvent(Profile* profile,
-                                         const char* event_name,
+void ProcessesEventRouter::DispatchEvent(const char* event_name,
                                          scoped_ptr<ListValue> event_args) {
-  if (profile && extensions::ExtensionSystem::Get(profile)->event_router()) {
-    extensions::ExtensionSystem::Get(profile)->event_router()->
+  if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
+    extensions::ExtensionSystem::Get(profile_)->event_router()->
         DispatchEventToRenderers(event_name, event_args.Pass(), NULL, GURL(),
                                  extensions::EventFilteringInfo());
   }
 }
 
-void ProcessesEventRouter::NotifyProfiles(const char* event_name,
-                                          scoped_ptr<ListValue> event_args) {
-  for (ProfileSet::iterator it = profiles_.begin();
-       it != profiles_.end(); ++it) {
-    Profile* profile = *it;
-    scoped_ptr<ListValue> event_args_copy(event_args->DeepCopy());
-    DispatchEvent(profile, event_name, event_args_copy.Pass());
-  }
+bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
+  extensions::EventRouter* router =
+      extensions::ExtensionSystem::Get(profile_)->event_router();
+    if (router && router->HasEventListener(event_name))
+      return true;
+  return false;
 }
 
-// In order to determine whether there are any listeners for the event of
-// interest, we need to ask each profile whether it has one registered.
-// We only need to look for the profiles that have registered with the
-// this extension API.
-bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
-  for (ProfileSet::iterator it = profiles_.begin();
-       it != profiles_.end(); ++it) {
-    Profile* profile = *it;
-    extensions::EventRouter* router =
-        extensions::ExtensionSystem::Get(profile)->event_router();
-    if (!router)
-      continue;
+ProcessesAPI::ProcessesAPI(Profile* profile) : profile_(profile) {
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, processes_api_constants::kOnUpdated);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, processes_api_constants::kOnUpdatedWithMemory);
+}
 
-    if (router->HasEventListener(event_name))
-      return true;
-  }
-  return false;
+ProcessesAPI::~ProcessesAPI() {
+}
+
+void ProcessesAPI::Shutdown() {
+  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+}
+
+// static
+ProcessesAPI* ProcessesAPI::Get(Profile* profile) {
+  return ProcessesAPIFactory::GetForProfile(profile);
+}
+
+ProcessesEventRouter* ProcessesAPI::processes_event_router() {
+  if (!processes_event_router_)
+    processes_event_router_.reset(new ProcessesEventRouter(profile_));
+  return processes_event_router_.get();
+}
+
+void ProcessesAPI::OnListenerAdded(const std::string& event_name) {
+  // 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 std::string& event_name) {
+  // If a processes.onUpdated or processes.onUpdatedWithMemory event listener
+  // is removed (or a process with one exits), then we let the extension API
+  // know that it has one fewer listener.
+  processes_event_router()->ListenerRemoved();
 }
 
 GetProcessIdForTabFunction::GetProcessIdForTabFunction() : tab_id_(-1) {
 }
 
 bool GetProcessIdForTabFunction::RunImpl() {
 #if defined(ENABLE_TASK_MANAGER)
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id_));
 
   // Add a reference, which is balanced in GetProcessIdForTab to keep the object
   // around and allow for the callback to be invoked.
   AddRef();
 
   // If the task manager is already listening, just post a task to execute
   // which will invoke the callback once we have returned from this function.
   // Otherwise, wait for the notification that the task manager is done with
   // the data gathering.
-  if (ProcessesEventRouter::GetInstance()->is_task_manager_listening()) {
+  if (ProcessesAPI::Get(profile_)->processes_event_router()->
+      is_task_manager_listening()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &GetProcessIdForTabFunction::GetProcessIdForTab, this));
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TASK_MANAGER_CHILD_PROCESSES_DATA_READY,
                    content::NotificationService::AllSources());
-    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
+    ProcessesAPI::Get(profile_)->processes_event_router()->
+        StartTaskManagerListening();
   }
 
   return true;
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void GetProcessIdForTabFunction::Observe(
@@ skipping 33 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &process_id_));
 
   // Add a reference, which is balanced in TerminateProcess to keep the object
   // around and allow for the callback to be invoked.
   AddRef();
 
   // If the task manager is already listening, just post a task to execute
   // which will invoke the callback once we have returned from this function.
   // Otherwise, wait for the notification that the task manager is done with
   // the data gathering.
-  if (ProcessesEventRouter::GetInstance()->is_task_manager_listening()) {
+  if (ProcessesAPI::Get(profile_)->processes_event_router()->
+      is_task_manager_listening()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &TerminateFunction::TerminateProcess, this));
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TASK_MANAGER_CHILD_PROCESSES_DATA_READY,
                    content::NotificationService::AllSources());
-    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
+    ProcessesAPI::Get(profile_)->processes_event_router()->
+        StartTaskManagerListening();
   }
 
   return true;
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void TerminateFunction::Observe(
@@ skipping 58 matching lines @@
       processes, &process_ids_));
 
   // Add a reference, which is balanced in GatherProcessInfo to keep the object
   // around and allow for the callback to be invoked.
   AddRef();
 
   // If the task manager is already listening, just post a task to execute
   // which will invoke the callback once we have returned from this function.
   // Otherwise, wait for the notification that the task manager is done with
   // the data gathering.
-  if (ProcessesEventRouter::GetInstance()->is_task_manager_listening()) {
+  if (ProcessesAPI::Get(profile_)->processes_event_router()->
+      is_task_manager_listening()) {
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &GetProcessInfoFunction::GatherProcessInfo, this));
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_TASK_MANAGER_CHILD_PROCESSES_DATA_READY,
                    content::NotificationService::AllSources());
-    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
+    ProcessesAPI::Get(profile_)->processes_event_router()->
+        StartTaskManagerListening();
   }
   return true;
 
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void GetProcessInfoFunction::Observe(
@@ skipping 47 matching lines @@
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions