Final batch adding real histogram values for extension events.

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/location.h"
@@ skipping 296 matching lines @@
   scoped_ptr<base::ListValue> args(new base::ListValue());
   base::DictionaryValue* process = CreateProcessFromModel(
       model_->GetUniqueChildProcessId(index), model_, index, false);
   DCHECK(process != NULL);
 
   if (process == NULL)
     return;
 
   args->Append(process);
 
-  DispatchEvent(keys::kOnCreated, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_CREATED, 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 27 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<base::ListValue> args(new base::ListValue());
     args->Append(processes);
-    DispatchEvent(keys::kOnUpdated, args.Pass());
+    DispatchEvent(events::PROCESSES_ON_UPDATED, keys::kOnUpdated, args.Pass());
   }
 
   if (updated_memory) {
     IDMap<base::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<base::ListValue> args(new base::ListValue());
     args->Append(processes);
-    DispatchEvent(keys::kOnUpdatedWithMemory, args.Pass());
+    DispatchEvent(events::PROCESSES_ON_UPDATED_WITH_MEMORY,
+                  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) == task_manager::Resource::RENDERER)
     return;
 
   // The callback function parameters.
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(new base::FundamentalValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
   args->Append(new base::FundamentalValue(0));
 
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(0));
 
-  DispatchEvent(keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, 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;
 
   base::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;
       }
     }
   }
 
   if (process == NULL)
     return;
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(process);
 
-  DispatchEvent(keys::kOnUnresponsive, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_UNRESPONSIVE, 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<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(new base::FundamentalValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
   args->Append(new base::FundamentalValue(details->status));
 
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(details->exit_code));
 
-  DispatchEvent(keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::DispatchEvent(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
-    scoped_ptr<extensions::Event> event(new extensions::Event(
-        extensions::events::UNKNOWN, event_name, event_args.Pass()));
+    scoped_ptr<Event> event(
+        new Event(histogram_value, event_name, event_args.Pass()));
     event_router->BroadcastEvent(event.Pass());
   }
 }
 
 bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   return event_router && event_router->HasEventListener(event_name);
 }
 
 ProcessesAPI::ProcessesAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   event_router->RegisterObserver(this, processes_api_constants::kOnUpdated);
   event_router->RegisterObserver(this,
                                  processes_api_constants::kOnUpdatedWithMemory);
   ExtensionFunctionRegistry* registry =
       ExtensionFunctionRegistry::GetInstance();
-  registry->RegisterFunction<extensions::GetProcessIdForTabFunction>();
-  registry->RegisterFunction<extensions::TerminateFunction>();
-  registry->RegisterFunction<extensions::GetProcessInfoFunction>();
+  registry->RegisterFunction<GetProcessIdForTabFunction>();
+  registry->RegisterFunction<TerminateFunction>();
+  registry->RegisterFunction<GetProcessInfoFunction>();
 }
 
 ProcessesAPI::~ProcessesAPI() {
 }
 
 void ProcessesAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<ProcessesAPI> >
@@ skipping 69 matching lines @@
 void GetProcessIdForTabFunction::GetProcessIdForTab() {
   content::WebContents* contents = NULL;
   int tab_index = -1;
   if (!ExtensionTabUtil::GetTabById(tab_id_,
                                     GetProfile(),
                                     include_incognito(),
                                     NULL,
                                     NULL,
                                     &contents,
                                     &tab_index)) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        extensions::tabs_constants::kTabNotFoundError,
-        base::IntToString(tab_id_));
+    error_ = ErrorUtils::FormatErrorMessage(tabs_constants::kTabNotFoundError,
+                                            base::IntToString(tab_id_));
     SetResult(new base::FundamentalValue(-1));
     SendResponse(false);
   } else {
     int process_id = contents->GetRenderProcessHost()->GetID();
     SetResult(new base::FundamentalValue(process_id));
     SendResponse(true);
   }
 
   // Balance the AddRef in the RunAsync.
   Release();
@@ skipping 83 matching lines @@
 
 GetProcessInfoFunction::~GetProcessInfoFunction() {
 }
 
 bool GetProcessInfoFunction::RunAsync() {
 #if defined(ENABLE_TASK_MANAGER)
   base::Value* processes = NULL;
 
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &processes));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &memory_));
-
-  EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
-      processes, &process_ids_));
+  EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(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 (ProcessesAPI::Get(GetProfile())
@@ skipping 61 matching lines @@
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunAsync.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions