Improving the process model extension API

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/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_processes_api_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.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_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;
 
-DictionaryValue* CreateProcessValue(int process_id,
-                                    const std::string& type,
-                                    double cpu,
-                                    int64 net,
-                                    int64 pr_mem,
-                                    int64 sh_mem) {
+DictionaryValue* CreateCacheData(
+    const WebKit::WebCache::ResourceTypeStat& stat) {
+
+  DictionaryValue* cache = new DictionaryValue();
+  cache->SetDouble(keys::kCacheSize, static_cast<double>(stat.size));
+  cache->SetDouble(keys::kCacheLiveSize, static_cast<double>(stat.liveSize));
+  return cache;
+}
+
+void SetProcessType(DictionaryValue* result,
+                    TaskManagerModel* model,
+                    int index) {
+  // Determine process type
+  std::string type = keys::kProcessTypeOther;
+  TaskManager::Resource::Type resource_type = model->GetResourceType(index);
+  switch (resource_type) {
+    case TaskManager::Resource::BROWSER:
+      type = keys::kProcessTypeBrowser;
+      break;
+    case TaskManager::Resource::RENDERER:
+      type = keys::kProcessTypeRenderer;
+      break;
+    case TaskManager::Resource::EXTENSION:
+      type = keys::kProcessTypeExtension;
+      break;
+    case TaskManager::Resource::NOTIFICATION:
+      type = keys::kProcessTypeNotification;
+      break;
+    case TaskManager::Resource::PLUGIN:
+      type = keys::kProcessTypePlugin;
+      break;
+    case TaskManager::Resource::WORKER:
+      type = keys::kProcessTypeWorker;
+      break;
+    case TaskManager::Resource::NACL:
+      type = keys::kProcessTypeNacl;
+      break;
+    case TaskManager::Resource::UTILITY:
+      type = keys::kProcessTypeUtility;
+      break;
+    case TaskManager::Resource::GPU:
+      type = keys::kProcessTypeGPU;
+      break;
+    case TaskManager::Resource::PROFILE_IMPORT:
+    case TaskManager::Resource::ZYGOTE:
+    case TaskManager::Resource::SANDBOX_HELPER:
+    case TaskManager::Resource::UNKNOWN:
+      type = keys::kProcessTypeOther;
+      break;
+    default:
+      NOTREACHED() << "Unknown resource type.";
+  }
+  result->SetString(keys::kTypeKey, type);
+}
+
+DictionaryValue* CreateProcessFromModel(int process_id,
+                                        TaskManagerModel* model,
+                                        int index) {
   DictionaryValue* result = new DictionaryValue();
+  size_t mem;
+
   result->SetInteger(keys::kIdKey, process_id);
-  result->SetString(keys::kTypeKey, type);
-  result->SetDouble(keys::kCpuKey, cpu);
+  result->SetInteger(keys::kOsProcessId, model->GetProcessId(index));
+  SetProcessType(result, model, index);
+  result->SetString(keys::kProfile,
+      model->GetResourceProfileName(index));
+  result->SetDouble(keys::kCpuKey, model->GetCPUUsage(index));
+
+  if (model->GetV8Memory(index, &mem))
+    result->SetDouble(keys::kJsMemoryAllocated,
+        static_cast<double>(mem));
+
+  if (model->GetV8MemoryUsed(index, &mem))
+    result->SetDouble(keys::kJsMemoryUsed,
+        static_cast<double>(mem));
+
+  if (model->GetSqliteMemoryUsedBytes(index, &mem))
+    result->SetDouble(keys::kSqliteMemory,
+        static_cast<double>(mem));
+
+  WebKit::WebCache::ResourceTypeStats cache_stats;
+  if (model->GetWebCoreCacheStats(index, &cache_stats)) {
+    result->Set(keys::kImageCache,
+                          CreateCacheData(cache_stats.images));

[Charlie Reis, 2012/04/23 22:19:51]

nit: Should line up with open paren.

[nasko, 2012/04/24 18:14:29]

Done.

+    result->Set(keys::kScriptCache,
+                          CreateCacheData(cache_stats.scripts));
+    result->Set(keys::kCssCache,
+                          CreateCacheData(cache_stats.cssStyleSheets));
+  }
+
+  // Network and FPS are reported by the TaskManager per resource (tab), not
+  // per process, therefore we need to iterate through the group of resources
+  // and aggregate the data.
+  float fps = 0, tmp = 0;
+  int64 net = 0;
+  int length = model->GetGroupRangeForResource(index).second;
+  for (int i = 0; i < length; ++i) {
+    net += model->GetNetworkUsage(index + i);
+    if (model->GetFPS(index + i, &tmp))
+      fps += tmp;
+  }
+  result->SetDouble(keys::kFPS, static_cast<double>(fps));
   result->SetDouble(keys::kNetworkKey, static_cast<double>(net));
+
+  return result;
+}
+
+// Since memory details are expensive to gather, we don't do it by default.
+// This function is a helper to add memory details data to an existing
+// Process object representation.
+void AddMemoryDetails(DictionaryValue* result,
+                      TaskManagerModel* model,
+                      int index) {
+  size_t mem;
+  int64 pr_mem = model->GetPrivateMemory(index, &mem) ?
+      static_cast<int64>(mem) : -1;
   result->SetDouble(keys::kPrivateMemoryKey, static_cast<double>(pr_mem));
-  result->SetDouble(keys::kSharedMemoryKey, static_cast<double>(sh_mem));
-  return result;
 }
 
 ExtensionProcessesEventRouter* ExtensionProcessesEventRouter::GetInstance() {
   return Singleton<ExtensionProcessesEventRouter>::get();
 }
 
-ExtensionProcessesEventRouter::ExtensionProcessesEventRouter() {
+ExtensionProcessesEventRouter::ExtensionProcessesEventRouter() : listeners_(0) {
   model_ = TaskManager::GetInstance()->model();
   model_->AddObserver(this);
+  model_->StartUpdating();

[Charlie Reis, 2012/04/23 22:19:51]

Why is this needed without any listeners?

[nasko, 2012/04/24 18:14:29]

The reason is that we can return CPU/Network stats from the  getProcessInfo
function.

+
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
+      content::NotificationService::AllSources());
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+      content::NotificationService::AllSources());
 }
 
 ExtensionProcessesEventRouter::~ExtensionProcessesEventRouter() {
+  registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
+      content::NotificationService::AllSources());
+  registrar_.Remove(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
+      content::NotificationService::AllSources());
+
+  model_->StopUpdating();
   model_->RemoveObserver(this);
 }
 
 void ExtensionProcessesEventRouter::ObserveProfile(Profile* profile) {
   profiles_.insert(profile);
 }
 
+void ExtensionProcessesEventRouter::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;
+}
+
+bool ExtensionProcessesEventRouter::HasEventListeners(std::string& event_name) {

[Charlie Reis, 2012/04/23 22:19:51]

There's a fair amount going on here.  Maybe add a comment saying that we have to
look at all extensions in all profiles to make it easier to read?  

Also, is all that work really necessary?  Would it be easier to keep a count of
how many listeners we have per event (in a map)?  I'm concerned about how often
we call this, and how many extensions it might have to loop through, when most
of them will say no.

[nasko, 2012/04/24 18:14:29]

Added a comment and filed crbug.com/124804 to get a better API for doing this.

+  for (ProfileSet::iterator it = profiles_.begin();
+       it != profiles_.end(); it++) {
+    Profile* profile = *it;
+    ExtensionEventRouter* router = profile->GetExtensionEventRouter();
+    if (!router || !router->HasEventListener(event_name))
+      continue;
+
+    const ExtensionService* extension_service = profile->GetExtensionService();
+    const ExtensionSet* extensions = extension_service->extensions();
+    for (ExtensionSet::const_iterator it = extensions->begin();

[Charlie Reis, 2012/04/23 22:19:51]

FYI, this may be changing soon, so be aware of potential merge conflicts.  See:
https://chromiumcodereview.appspot.com/10113005/

[nasko, 2012/04/24 18:14:29]

Done.

+        it != extensions->end(); ++it) {
+      std::string extension_id = (*it)->id();
+      if (router->ExtensionHasEventListener(extension_id, event_name))
+        return true;
+    }
+  }
+  return false;
+}
+
 void ExtensionProcessesEventRouter::ListenerAdded() {
-  model_->StartUpdating();
+  ++listeners_;
 }
 
 void ExtensionProcessesEventRouter::ListenerRemoved() {
-  model_->StopUpdating();
+  DCHECK(listeners_ > 0);
+  --listeners_;
+}
+
+void ExtensionProcessesEventRouter::OnItemsAdded(int start, int length) {
+  DCHECK(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);
+  }
+
+  ListValue args;
+  DictionaryValue* process = CreateProcessFromModel(
+      model_->GetUniqueChildProcessId(index), model_, index);
+  DCHECK(process != NULL);
+
+  if (process == NULL)
+    return;
+
+  args.Append(Value::CreateIntegerValue(
+      model_->GetUniqueChildProcessId(start)));
+  args.Append(process);
+
+  std::string json_args;
+  base::JSONWriter::Write(&args, &json_args);
+  NotifyProfiles(keys::kOnCreated, json_args);
+}
+
+void ExtensionProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
+  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.

[Charlie Reis, 2012/04/23 22:19:51]

But we do use the Task Manager's ToBeRemoved for non-renderer processes?  Maybe
add that to the comment.

[nasko, 2012/04/24 18:14:29]

Done.

+  if (model_->GetResourceType(start) == TaskManager::Resource::RENDERER)
+    return;
+
+  // The callback function parameters.
+  ListValue args;
+
+  // 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.

[Charlie Reis, 2012/04/23 22:19:51]

Thanks for documenting these.  Is it not possible for them to be non-zero, or is
this just a simplification because we don't have access to the real exit
types/codes?

[nasko, 2012/04/24 18:14:29]

It is just a simplification, since we don't have the data. I could omit them,
but that would mean that extension developers will might need to explicitly test
for them.

+  args.Append(Value::CreateIntegerValue(0));
+
+  std::string json_args;
+  base::JSONWriter::Write(&args, &json_args);
+  NotifyProfiles(keys::kOnExited, json_args);
 }
 
 void ExtensionProcessesEventRouter::OnItemsChanged(int start, int length) {
-  if (model_) {
+  // 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.
+  std::string updated_event(keys::kOnUpdated);
+  std::string updated_event_memory(keys::kOnUpdatedWithMemory);
+  bool updated = HasEventListeners(updated_event);
+  bool updated_memory = HasEventListeners(updated_event_memory);
+
+  DCHECK(updated || updated_memory);
+
+  IDMap<DictionaryValue> processes_map;
+  for (int i = start; i < start + length; i++) {
+    if (model_->IsResourceFirstInGroup(i)) {
+      int id = model_->GetUniqueChildProcessId(i);
+      DictionaryValue* process = CreateProcessFromModel(id, model_, i);
+      processes_map.AddWithID(process, i);
+    }
+  }
+
+  int id;
+  std::string idkey(keys::kIdKey);
+  DictionaryValue* processes = new DictionaryValue();
+
+  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

[Charlie Reis, 2012/04/23 22:19:51]

nit: End with period, here and below.  (Yep, probably my fault.)

[nasko, 2012/04/24 18:14:29]

Done.

+      processes->Set(base::IntToString(id), it.GetCurrentValue());
+    }
+
     ListValue args;
-    DictionaryValue* processes = new DictionaryValue();
-    for (int i = start; i < start + length; i++) {
-      if (model_->IsResourceFirstInGroup(i)) {
-        int id = model_->GetProcessId(i);
-
-        // Determine process type
-        std::string type = keys::kProcessTypeOther;
-        TaskManager::Resource::Type resource_type = model_->GetResourceType(i);
-        switch (resource_type) {
-          case TaskManager::Resource::BROWSER:
-            type = keys::kProcessTypeBrowser;
-            break;
-          case TaskManager::Resource::RENDERER:
-            type = keys::kProcessTypeRenderer;
-            break;
-          case TaskManager::Resource::EXTENSION:
-            type = keys::kProcessTypeExtension;
-            break;
-          case TaskManager::Resource::NOTIFICATION:
-            type = keys::kProcessTypeNotification;
-            break;
-          case TaskManager::Resource::PLUGIN:
-            type = keys::kProcessTypePlugin;
-            break;
-          case TaskManager::Resource::WORKER:
-            type = keys::kProcessTypeWorker;
-            break;
-          case TaskManager::Resource::NACL:
-            type = keys::kProcessTypeNacl;
-            break;
-          case TaskManager::Resource::UTILITY:
-            type = keys::kProcessTypeUtility;
-            break;
-          case TaskManager::Resource::GPU:
-            type = keys::kProcessTypeGPU;
-            break;
-          case TaskManager::Resource::PROFILE_IMPORT:
-          case TaskManager::Resource::ZYGOTE:
-          case TaskManager::Resource::SANDBOX_HELPER:
-          case TaskManager::Resource::UNKNOWN:
-            type = keys::kProcessTypeOther;
-            break;
-          default:
-            NOTREACHED() << "Unknown resource type.";
-        }
-
-        // Get process metrics as numbers
-        double cpu = model_->GetCPUUsage(i);
-
-        // TODO(creis): Network is actually reported per-resource (tab),
-        // not per-process.  We should aggregate it here.
-        int64 net = model_->GetNetworkUsage(i);
-        size_t mem;
-        int64 pr_mem = model_->GetPrivateMemory(i, &mem) ?
-            static_cast<int64>(mem) : -1;
-        int64 sh_mem = model_->GetSharedMemory(i, &mem) ?
-            static_cast<int64>(mem) : -1;
-
-        // Store each process indexed by the string version of its id
-        processes->Set(base::IntToString(id),
-                       CreateProcessValue(id, type, cpu, net, pr_mem, sh_mem));
-      }
-    }
     args.Append(processes);
-
     std::string json_args;
     base::JSONWriter::Write(&args, &json_args);
-
-    // Notify each profile that is interested.
-    for (ProfileSet::iterator it = profiles_.begin();
-         it != profiles_.end(); it++) {
-      Profile* profile = *it;
-      DispatchEvent(profile, keys::kOnUpdated, json_args);
-    }
-  }
-}
-
-void ExtensionProcessesEventRouter::DispatchEvent(Profile* profile,
+    NotifyProfiles(keys::kOnUpdated, json_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());

[Charlie Reis, 2012/04/23 22:19:51]

Hmm.  I was thinking we could combine the two loops and just put the
"updated_memory" conditional on this line, but I suppose that would make
onUpdated listeners hear memory stats if anyone happened to be listening to
memory...

I still wonder if there's some redundancy here.  For example, it looks like we
don't need to do the processes->Set(...) call if "updated" is true, since we
already did it above.

[nasko, 2012/04/24 18:14:29]

As we discussed verbally, the goal is to keep the external API consistent, so we
won't be providing memory to onUpdated listeners. 

Yes, we can skip the processes->Set() call, so I've added this.

+      // 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::kOnUpdatedWithMemory, json_args);
+  }
+}
+
+void ExtensionProcessesEventRouter::ProcessHangEvent(

[Charlie Reis, 2012/04/23 22:19:51]

Should we skip this if no one is listening, like OnItemsChanged?  Or is that not
necessary here?

[nasko, 2012/04/24 18:14:29]

Good catch!

+    content::RenderWidgetHost* widget) {
+  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);
+        break;
+      }
+    }
+  }
+
+  DCHECK(process != NULL);
+  if (process == NULL)
+    return;
+
+  ListValue args;
+  args.Append(process);
+
+  std::string json_args;
+  base::JSONWriter::Write(&args, &json_args);
+  NotifyProfiles(keys::kOnUnresponsive, json_args);
+}
+
+void ExtensionProcessesEventRouter::ProcessClosedEvent(
+    content::RenderProcessHost* rph,
+    content::RenderProcessHost::RendererClosedDetails* details) {
+  // The callback function parameters.
+  ListValue args;
+
+  // 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));
+
+  std::string json_args;
+  base::JSONWriter::Write(&args, &json_args);
+  NotifyProfiles(keys::kOnExited, json_args);
+}
+
+void ExtensionProcessesEventRouter::DispatchEvent(
+    Profile* profile,
     const char* event_name,
     const std::string& json_args) {
   if (profile && profile->GetExtensionEventRouter()) {
     profile->GetExtensionEventRouter()->DispatchEventToRenderers(
         event_name, json_args, NULL, GURL());
   }
 }
 
+void ExtensionProcessesEventRouter::NotifyProfiles(const char* event_name,
+                                                   std::string json_args) {
+  for (ProfileSet::iterator it = profiles_.begin();
+       it != profiles_.end(); it++) {
+    Profile* profile = *it;
+    DispatchEvent(profile, event_name, json_args);
+  }
+}
+
 bool GetProcessIdForTabFunction::RunImpl() {
   int tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabContentsWrapper* contents = NULL;
   int tab_index = -1;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile(), include_incognito(),
                                     NULL, NULL, &contents, &tab_index)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         extension_tabs_module_constants::kTabNotFoundError,
         base::IntToString(tab_id));
     return false;
   }
 
-  // Return the process ID of the tab as an integer.
-  int id = base::GetProcId(contents->web_contents()->
-      GetRenderProcessHost()->GetHandle());
-  result_.reset(Value::CreateIntegerValue(id));
+  int process_id = base::GetProcId(
+      contents->web_contents()->GetRenderProcessHost()->GetHandle());
+
+  TaskManagerModel* model = TaskManager::GetInstance()->model();
+  int count = model->ResourceCount();
+
+  for (int i = 0; i < count; ++i) {
+    if (model->IsResourceFirstInGroup(i)) {
+      if (process_id == model->GetProcessId(i)) {
+        // Return the unique ID of the process as an integer.
+        result_.reset(Value::CreateIntegerValue(
+            model->GetUniqueChildProcessId(i)));
+        return true;
+      }
+    }
+  }
+
+  error_ = ExtensionErrorUtils::FormatErrorMessage(errors::kProcessNotFound,
+      base::IntToString(process_id));
+  return false;
+}
+
+
+bool TerminateFunction::RunImpl() {
+  int process_id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &process_id));
+
+  // Since we use the RenderProcessHost unique IDs to give to extensions, it is
+  // safe to just search for the corresponding RPH and kill its process.
+  // This will ensure we are not killing random non-Chrome processes.
+  content::RenderProcessHost* rph = content::RenderProcessHost::FromID(
+      process_id);
+  if (rph == NULL) {
+    error_ = ExtensionErrorUtils::FormatErrorMessage(errors::kProcessNotFound,
+        base::IntToString(process_id));
+    return false;
+  }
+
+  bool killed = false;
+  killed = base::KillProcess(rph->GetHandle(),
+                             content::RESULT_CODE_KILLED,
+                             true);

[Charlie Reis, 2012/04/23 22:19:51]

Given our recent experiences, I wonder if we want to add a UMA histogram for
this so that we don't think Chrome is horribly broken if extensions start using
this a lot.

[nasko, 2012/04/24 18:14:29]

This is a good idea. I would suggest we add it in a separate CL though, along
with the actual histogram definition for it.

[Charlie Reis, 2012/04/27 22:01:55]

I found out that the timing of the histogram CL doesn't matter, so we might as
well just include it here.

+
+  result_.reset(Value::CreateBooleanValue(killed));
   return true;
 }
+
+// Borrowed from the tabs extension. Allows us to support both list and single
+// integer parameters as input from extensions.

[Charlie Reis, 2012/04/23 22:19:51]

Sounds useful.  Is there any shared place we can put this to avoid duplicating
it?

[nasko, 2012/04/24 18:14:29]

Not quite sure. I will look around to see if there is a good common place this
can be moved to.

[Charlie Reis, 2012/04/27 22:01:55]

extension_tab_util.h, perhaps?

+bool ReadOneOrMoreIntegers(Value* value, std::vector<int>* result) {
+  if (value->IsType(Value::TYPE_INTEGER)) {
+    int id = -1;
+    if (!value->GetAsInteger(&id))
+      return false;
+    result->push_back(id);
+    return true;
+  } else if (value->IsType(Value::TYPE_LIST)) {
+    ListValue* ids = static_cast<ListValue*>(value);
+    for (size_t i = 0; i < ids->GetSize(); ++i) {
+      int id = -1;
+      if (!ids->GetInteger(i, &id))
+        return false;
+      result->push_back(id);
+    }
+    return true;
+  }
+  return false;
+}
+
+bool GetProcessInfoFunction::RunImpl() {
+  Value* args = NULL;
+  bool memory = false;
+
+  EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &args));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &memory));
+
+  std::vector<int> process_ids;
+  EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(args, &process_ids));
+
+  TaskManagerModel* model = TaskManager::GetInstance()->model();
+  DictionaryValue* processes = new DictionaryValue();
+
+  // If there are no process IDs specified, it means we need to return all of
+  // the ones we know of.
+  if (process_ids.size() == 0) {
+    int resources = model->ResourceCount();
+    for (int i = 0; i < resources; ++i) {
+      if (model->IsResourceFirstInGroup(i)) {
+        int id = model->GetUniqueChildProcessId(i);
+        DictionaryValue* d = CreateProcessFromModel(id, model, i);
+        if (memory)
+          AddMemoryDetails(d, model, i);
+        processes->Set(base::IntToString(id), d);
+      }
+    }
+  } else {
+    int resources = model->ResourceCount();
+    for (int i = 0; i < resources; ++i) {
+      if (model->IsResourceFirstInGroup(i)) {
+        int id = model->GetUniqueChildProcessId(i);
+        std::vector<int>::iterator proc_id = std::find(process_ids.begin(),
+                                                       process_ids.end(), id);
+        if (proc_id != process_ids.end()) {
+          DictionaryValue* d = CreateProcessFromModel(id, model, i);
+          if (memory)
+            AddMemoryDetails(d, model, i);
+          processes->Set(base::IntToString(id), d);
+
+          process_ids.erase(proc_id);
+          if (process_ids.size() == 0)
+            break;
+        }
+      }
+    }
+    DCHECK(process_ids.size() == 0);
+  }
+
+  result_.reset(processes);
+  return true;
+}