Refactor extension event distribution to use Values instead of JSON strings.

chrome/browser/extensions/extension_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 "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 293 matching lines @@
   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);
   }
 
-  ListValue args;
+  ListValue* args = new ListValue();
   DictionaryValue* process = CreateProcessFromModel(
       model_->GetUniqueChildProcessId(index), model_, index, false);
   DCHECK(process != NULL);
 
   if (process == NULL)
     return;
 
-  args.Append(process);
+  args->Append(process);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
-  NotifyProfiles(keys::kOnCreated, json_args);
+  NotifyProfiles(keys::kOnCreated, args);
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ExtensionProcessesEventRouter::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 24 matching lines @@
   if (updated) {
     IDMap<DictionaryValue>::iterator it(&processes_map);
     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());
     }
 
-    ListValue args;
-    args.Append(processes);
-    std::string json_args;
-    base::JSONWriter::Write(&args, &json_args);
-    NotifyProfiles(keys::kOnUpdated, json_args);
+    ListValue* args = new ListValue();
+    args->Append(processes);
+    NotifyProfiles(keys::kOnUpdated, args);
   }
 
   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());
     }
 
-    ListValue args;
-    args.Append(processes);
-    std::string json_args;
-    base::JSONWriter::Write(&args, &json_args);
-    NotifyProfiles(keys::kOnUpdatedWithMemory, json_args);
+    ListValue* args = new ListValue();
+    args->Append(processes);
+    NotifyProfiles(keys::kOnUpdatedWithMemory, args);
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ExtensionProcessesEventRouter::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.
-  ListValue args;
+  ListValue* args = new ListValue();
 
   // First arg: The id of the process that was closed.
-  args.Append(Value::CreateIntegerValue(
+  args->Append(Value::CreateIntegerValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
-  args.Append(Value::CreateIntegerValue(0));
+  args->Append(Value::CreateIntegerValue(0));
 
   // Third arg: The exit code for the process.
-  args.Append(Value::CreateIntegerValue(0));
+  args->Append(Value::CreateIntegerValue(0));
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
-  NotifyProfiles(keys::kOnExited, json_args);
+  NotifyProfiles(keys::kOnExited, args);
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ExtensionProcessesEventRouter::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;
 
-  ListValue args;
-  args.Append(process);
+  ListValue* args = new ListValue();
+  args->Append(process);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
-  NotifyProfiles(keys::kOnUnresponsive, json_args);
+  NotifyProfiles(keys::kOnUnresponsive, args);
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ExtensionProcessesEventRouter::ProcessClosedEvent(
     content::RenderProcessHost* rph,
     content::RenderProcessHost::RendererClosedDetails* details) {
 #if defined(ENABLE_TASK_MANAGER)
   // The callback function parameters.
-  ListValue args;
+  ListValue* args = new ListValue();
 
   // First arg: The id of the process that was closed.
-  args.Append(Value::CreateIntegerValue(rph->GetID()));
+  args->Append(Value::CreateIntegerValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
-  args.Append(Value::CreateIntegerValue(details->status));
+  args->Append(Value::CreateIntegerValue(details->status));
 
   // Third arg: The exit code for the process.
-  args.Append(Value::CreateIntegerValue(details->exit_code));
+  args->Append(Value::CreateIntegerValue(details->exit_code));
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
-  NotifyProfiles(keys::kOnExited, json_args);
+  NotifyProfiles(keys::kOnExited, args);
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ExtensionProcessesEventRouter::DispatchEvent(
     Profile* profile,
     const char* event_name,
-    const std::string& json_args) {
+    ListValue* event_args) {
   if (profile && profile->GetExtensionEventRouter()) {
     profile->GetExtensionEventRouter()->DispatchEventToRenderers(
-        event_name, json_args, NULL, GURL(), EventFilteringInfo());
+        event_name, event_args, NULL, GURL(), EventFilteringInfo());
   }
 }
 
 void ExtensionProcessesEventRouter::NotifyProfiles(const char* event_name,
-                                                   std::string json_args) {
+                                                   ListValue* event_args) {
+  scoped_ptr<ListValue> delete_event_args(event_args);

[miket_OOO, 2012/07/10 22:33:19]

That's pretty tricky. I am only about 51% sure it's better than a delete at the
end. I guess it's protection against a hypothetical future early return.

   for (ProfileSet::iterator it = profiles_.begin();
        it != profiles_.end(); it++) {
     Profile* profile = *it;
-    DispatchEvent(profile, event_name, json_args);
+    DispatchEvent(profile, event_name, event_args->DeepCopy());
   }
 }
 
 // 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) {
   for (ProfileSet::iterator it = profiles_.begin();
        it != profiles_.end(); it++) {
@@ skipping 232 matching lines @@
     DCHECK(process_ids_.size() == 0);
   }
 
   result_.reset(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }