Moving extension_processes_api to api/processes

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/extension_processes_api.h"
+#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/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function_util.h"
-#include "chrome/browser/extensions/extension_processes_api_constants.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/task_manager.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "content/public/browser/browser_thread.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/web_contents.h"
 #include "content/public/common/result_codes.h"
 
-namespace keys = extension_processes_api_constants;
-namespace errors = extension_processes_api_constants;
+namespace extensions {
+
+namespace keys = processes_api_constants;
+namespace errors = processes_api_constants;
 
 namespace {
 
 #if defined(ENABLE_TASK_MANAGER)
 
 DictionaryValue* CreateCacheData(
     const WebKit::WebCache::ResourceTypeStat& stat) {
 
   DictionaryValue* cache = new DictionaryValue();
   cache->SetDouble(keys::kCacheSize, static_cast<double>(stat.size));
@@ skipping 154 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)
 
 } // local namespace
 
-ExtensionProcessesEventRouter* ExtensionProcessesEventRouter::GetInstance() {
-  return Singleton<ExtensionProcessesEventRouter>::get();
+ProcessesEventRouter* ProcessesEventRouter::GetInstance() {
+  return Singleton<ProcessesEventRouter>::get();
 }
 
-ExtensionProcessesEventRouter::ExtensionProcessesEventRouter()
+ProcessesEventRouter::ProcessesEventRouter()
     : 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)
 }
 
-ExtensionProcessesEventRouter::~ExtensionProcessesEventRouter() {
+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 ExtensionProcessesEventRouter::ObserveProfile(Profile* profile) {
+void ProcessesEventRouter::ObserveProfile(Profile* profile) {
   profiles_.insert(profile);
 }
 
-void ExtensionProcessesEventRouter::ListenerAdded() {
+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 ExtensionProcessesEventRouter::ListenerRemoved() {
+void ProcessesEventRouter::ListenerRemoved() {
   DCHECK(listeners_ > 0);
   --listeners_;
 #if defined(ENABLE_TASK_MANAGER)
   // The task manager has its own ref count to balance other callers of
   // StartUpdating/StopUpdating.
   model_->StopUpdating();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::StartTaskManagerListening() {
+void ProcessesEventRouter::StartTaskManagerListening() {
 #if defined(ENABLE_TASK_MANAGER)
   if (!task_manager_listening_) {
     model_->StartListening();
     task_manager_listening_ = true;
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::Observe(
+void ProcessesEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
 
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_HANG:
       ProcessHangEvent(
           content::Source<content::RenderWidgetHost>(source).ptr());
       break;
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED:
       ProcessClosedEvent(
           content::Source<content::RenderProcessHost>(source).ptr(),
           content::Details<content::RenderProcessHost::RendererClosedDetails>(
               details).ptr());
       break;
     default:
       NOTREACHED() << "Unexpected observe of type " << type;
   }
   return;
 }
 
-void ExtensionProcessesEventRouter::OnItemsAdded(int start, int length) {
+void ProcessesEventRouter::OnItemsAdded(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   DCHECK_EQ(length, 1);
   int index = start;
 
   std::string event(keys::kOnCreated);
   if (!HasEventListeners(event))
     return;
 
   // If the item being added is not the first one in the group, find the base
   // index and use it for retrieving the process data.
   if (!model_->IsResourceFirstInGroup(start)) {
     index = model_->GetGroupIndexForResource(start);
   }
 
   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());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::OnItemsChanged(int start, int length) {
+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_)
     return;
 
   // We need to know which type of onUpdated events to fire and whether to
   // collect memory or not.
@@ skipping 46 matching lines @@
         processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
     scoped_ptr<ListValue> args(new ListValue());
     args->Append(processes);
     NotifyProfiles(keys::kOnUpdatedWithMemory, args.Pass());
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
+void ProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   DCHECK(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());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::ProcessHangEvent(
-    content::RenderWidgetHost* widget) {
+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());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::ProcessClosedEvent(
+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());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ExtensionProcessesEventRouter::DispatchEvent(
-    Profile* profile,
-    const char* event_name,
-    scoped_ptr<ListValue> event_args) {
+void ProcessesEventRouter::DispatchEvent(Profile* profile,
+                                         const char* event_name,
+                                         scoped_ptr<ListValue> event_args) {
   if (profile && profile->GetExtensionEventRouter()) {
     profile->GetExtensionEventRouter()->DispatchEventToRenderers(
         event_name, event_args.Pass(), NULL, GURL(),
         extensions::EventFilteringInfo());
   }
 }
 
-void ExtensionProcessesEventRouter::NotifyProfiles(
-    const char* event_name,
-    scoped_ptr<ListValue> event_args) {
+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());
   }
 }
 
 // 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 ExtensionProcessesEventRouter::HasEventListeners(std::string& event_name) {
+bool ProcessesEventRouter::HasEventListeners(std::string& event_name) {
   for (ProfileSet::iterator it = profiles_.begin();
        it != profiles_.end(); it++) {
     Profile* profile = *it;
     extensions::EventRouter* router = profile->GetExtensionEventRouter();
     if (!router)
       continue;
 
     if (router->HasEventListener(event_name))
       return true;
   }
   return false;
 }
 
 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 (ExtensionProcessesEventRouter::GetInstance()->
-          is_task_manager_listening()) {
+  if (ProcessesEventRouter::GetInstance()->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());
-    ExtensionProcessesEventRouter::GetInstance()->
-        StartTaskManagerListening();
+    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
   }
 
   return true;
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void GetProcessIdForTabFunction::Observe(
@@ skipping 30 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 (ExtensionProcessesEventRouter::GetInstance()->
-          is_task_manager_listening()) {
+  if (ProcessesEventRouter::GetInstance()->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());
-    ExtensionProcessesEventRouter::GetInstance()->
-        StartTaskManagerListening();
+    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
   }
 
   return true;
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void TerminateFunction::Observe(
@@ skipping 54 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 (ExtensionProcessesEventRouter::GetInstance()->
-          is_task_manager_listening()) {
+  if (ProcessesEventRouter::GetInstance()->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());
-    ExtensionProcessesEventRouter::GetInstance()->
-        StartTaskManagerListening();
+    ProcessesEventRouter::GetInstance()->StartTaskManagerListening();
   }
   return true;
 
 #else
   error_ = errors::kExtensionNotSupported;
   return false;
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void GetProcessInfoFunction::Observe(
@@ skipping 45 matching lines @@
     DCHECK(process_ids_.size() == 0);
   }
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
+
+}  // namespace extensions