Exposing the child process unique ID through the task manager.

chrome/browser/task_manager/task_manager_resource_providers.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/task_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 97 matching lines @@
       render_view_host_(render_view_host),
       pending_stats_update_(false),
       fps_(0.0f),
       pending_fps_update_(false),
       v8_memory_allocated_(0),
       v8_memory_used_(0),
       pending_v8_memory_allocated_update_(false) {
   // We cache the process and pid as when a Tab/BackgroundContents is closed the
   // process reference becomes NULL and the TaskManager still needs it.
   pid_ = base::GetProcId(process_);
+  unique_process_id_ = render_view_host_->GetProcess()->GetID();
   memset(&stats_, 0, sizeof(stats_));
 }
 
 TaskManagerRendererResource::~TaskManagerRendererResource() {
 }
 
 void TaskManagerRendererResource::Refresh() {
   if (!pending_stats_update_) {
     render_view_host_->Send(new ChromeViewMsg_GetCacheResourceStats);
     pending_stats_update_ = true;
@@ skipping 41 matching lines @@
     size_t v8_memory_allocated, size_t v8_memory_used) {
   v8_memory_allocated_ = v8_memory_allocated;
   v8_memory_used_ = v8_memory_used;
   pending_v8_memory_allocated_update_ = false;
 }
 
 base::ProcessHandle TaskManagerRendererResource::GetProcess() const {
   return process_;
 }
 
+int TaskManagerRendererResource::GetUniqueChildProcessId() const {
+  return unique_process_id_;
+}
+
 TaskManager::Resource::Type TaskManagerRendererResource::GetType() const {
   return RENDERER;
 }
 
 int TaskManagerRendererResource::GetRoutingID() const {
   return render_view_host_->GetRoutingID();
 }
 
 bool TaskManagerRendererResource::ReportsCacheStats() const {
   return true;
@@ skipping 600 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 SkBitmap* TaskManagerChildProcessResource::default_icon_ = NULL;
 
 TaskManagerChildProcessResource::TaskManagerChildProcessResource(
     content::ProcessType type,
     const string16& name,
-    base::ProcessHandle handle)
+    base::ProcessHandle handle,
+    int unique_process_id)
     : type_(type),
       name_(name),
       handle_(handle),
+      unique_process_id_(unique_process_id),
       network_usage_support_(false) {
   // We cache the process id because it's not cheap to calculate, and it won't
   // be available when we get the plugin disconnected notification.
   pid_ = base::GetProcId(handle);
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
     // TODO(jabdelmalek): use different icon for web workers.
   }
 }
@@ skipping 14 matching lines @@
 }
 
 SkBitmap TaskManagerChildProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerChildProcessResource::GetProcess() const {
   return handle_;
 }
 
+int TaskManagerChildProcessResource::GetUniqueChildProcessId() const {
+  return unique_process_id_;
+}
+
 TaskManager::Resource::Type TaskManagerChildProcessResource::GetType() const {
   // Translate types to TaskManager::ResourceType, since ChildProcessData's type
   // is not available for all TaskManager resources.
   switch (type_) {
     case content::PROCESS_TYPE_PLUGIN:
     case content::PROCESS_TYPE_PPAPI_PLUGIN:
     case content::PROCESS_TYPE_PPAPI_BROKER:
       return TaskManager::Resource::PLUGIN;
     case content::PROCESS_TYPE_NACL_LOADER:
     case content::PROCESS_TYPE_NACL_BROKER:
@@ skipping 213 matching lines @@
   // Finally, delete the resource.
   delete resource;
 }
 
 void TaskManagerChildProcessResourceProvider::AddToTaskManager(
     const content::ChildProcessData& child_process_data) {
   TaskManagerChildProcessResource* resource =
       new TaskManagerChildProcessResource(
           child_process_data.type,
           child_process_data.name,
-          child_process_data.handle);
+          child_process_data.handle,
+          child_process_data.id);
   resources_[child_process_data.handle] = resource;
   pid_to_resources_[resource->process_id()] = resource;
   task_manager_->AddResource(resource);
 }
 
 // The ChildProcessData::Iterator has to be used from the IO thread.
 void TaskManagerChildProcessResourceProvider::RetrieveChildProcessData() {
   std::vector<content::ChildProcessData> child_processes;
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     // Only add processes which are already started, since we need their handle.
@@ skipping 24 matching lines @@
 SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
 TaskManagerExtensionProcessResource::TaskManagerExtensionProcessResource(
     ExtensionHost* extension_host)
     : extension_host_(extension_host) {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
   }
   process_handle_ = extension_host_->render_process_host()->GetHandle();
+  unique_process_id_ = extension_host_->render_process_host()->GetID();
   pid_ = base::GetProcId(process_handle_);
   string16 extension_name = UTF8ToUTF16(GetExtension()->name());
   DCHECK(!extension_name.empty());
 
   int message_id = GetMessagePrefixID(GetExtension()->is_app(), true,
       extension_host_->profile()->IsOffTheRecord(), false, false);
   title_ = l10n_util::GetStringFUTF16(message_id, extension_name);
 }
 
 TaskManagerExtensionProcessResource::~TaskManagerExtensionProcessResource() {
@@ skipping 15 matching lines @@
 }
 
 SkBitmap TaskManagerExtensionProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerExtensionProcessResource::GetProcess() const {
   return process_handle_;
 }
 
+int TaskManagerExtensionProcessResource::GetUniqueChildProcessId() const {
+  return unique_process_id_;
+}
+
 TaskManager::Resource::Type
 TaskManagerExtensionProcessResource::GetType() const {
   return EXTENSION;
 }
 
 bool TaskManagerExtensionProcessResource::CanInspect() const {
   return true;
 }
 
 void TaskManagerExtensionProcessResource::Inspect() const {
@@ skipping 212 matching lines @@
 }
 
 size_t TaskManagerBrowserProcessResource::SqliteMemoryUsedBytes() const {
   return static_cast<size_t>(sqlite3_memory_used());
 }
 
 base::ProcessHandle TaskManagerBrowserProcessResource::GetProcess() const {
   return base::GetCurrentProcessHandle();  // process_;
 }
 
+int TaskManagerBrowserProcessResource::GetUniqueChildProcessId() const {
+  return 0;
+}
+
 TaskManager::Resource::Type TaskManagerBrowserProcessResource::GetType() const {
   return BROWSER;
 }
 
 bool TaskManagerBrowserProcessResource::SupportNetworkUsage() const {
   return true;
 }
 
 void TaskManagerBrowserProcessResource::SetSupportNetworkUsage() {
   NOTREACHED();
@@ skipping 49 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }