Fix Task Manager to correctly display network usage of plug-in processes.

chrome/browser/task_manager/task_manager_resource_providers.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_RESOURCE_PROVIDERS_H_
 #define CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_RESOURCE_PROVIDERS_H_
 #pragma once
 
 #include <map>
 #include <vector>
@@ skipping 81 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerTabContentsResource);
 };
 
 class TaskManagerTabContentsResourceProvider
     : public TaskManager::ResourceProvider,
       public NotificationObserver {
  public:
   explicit TaskManagerTabContentsResourceProvider(TaskManager* task_manager);
 
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // NotificationObserver method:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
@@ skipping 48 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TaskManagerBackgroundContentsResource);
 };
 
 class TaskManagerBackgroundContentsResourceProvider
     : public TaskManager::ResourceProvider,
       public NotificationObserver {
  public:
   explicit TaskManagerBackgroundContentsResourceProvider(
       TaskManager* task_manager);
 
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // NotificationObserver method:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
@@ skipping 29 matching lines @@
   virtual ~TaskManagerChildProcessResource();
 
   // TaskManagerResource methods:
   virtual std::wstring GetTitle() const;
   virtual SkBitmap GetIcon() const;
   virtual base::ProcessHandle GetProcess() const;
   virtual Type GetType() const;
   virtual bool SupportNetworkUsage() const;
   virtual void SetSupportNetworkUsage();
 
-  // Returns the pid of the child process.
-  int process_id() const { return pid_; }
+  // Return the child process' unique child ID for use by GetResource()
+  int id() { return child_process_.id(); }
 
  private:
   ChildProcessInfo child_process_;
-  int pid_;
   mutable std::wstring title_;
   bool network_usage_support_;
 
   // The icon painted for the child processs.
   // TODO(jcampan): we should have plugin specific icons for well-known
   // plugins.
   static SkBitmap* default_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerChildProcessResource);
 };
 
 class TaskManagerChildProcessResourceProvider
     : public TaskManager::ResourceProvider,
       public NotificationObserver {
  public:
   explicit TaskManagerChildProcessResourceProvider(TaskManager* task_manager);
 
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // NotificationObserver method:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
@@ skipping 19 matching lines @@
   void AddToTaskManager(const ChildProcessInfo& child_process_info);
 
   TaskManager* task_manager_;
 
   // Maps the actual resources (the ChildProcessInfo) to the Task Manager
   // resources.
   std::map<ChildProcessInfo, TaskManagerChildProcessResource*> resources_;
 
   // Maps the pids to the resources (used for quick access to the resource on
   // byte read notifications).
-  std::map<int, TaskManagerChildProcessResource*> pid_to_resources_;
+  std::map<int, TaskManagerChildProcessResource*> child_id_to_resources_;
 
   // A scoped container for notification registries.
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerChildProcessResourceProvider);
 };
 
 class TaskManagerExtensionProcessResource : public TaskManager::Resource {
  public:
   explicit TaskManagerExtensionProcessResource(ExtensionHost* extension_host);
   virtual ~TaskManagerExtensionProcessResource();
 
   // TaskManagerResource methods:
   virtual std::wstring GetTitle() const;
   virtual SkBitmap GetIcon() const;
   virtual base::ProcessHandle GetProcess() const;
   virtual Type GetType() const;
   virtual bool SupportNetworkUsage() const;
   virtual void SetSupportNetworkUsage();
   virtual const Extension* GetExtension() const;
 
-  // Returns the pid of the extension process.
-  int process_id() const { return pid_; }
-
   // Returns true if the associated extension has a background page.
   virtual bool IsBackground() const;
 
+  int id() { return id_; }
  private:
   // The icon painted for the extension process.
   static SkBitmap* default_icon_;
 
   ExtensionHost* extension_host_;
 
   // Cached data about the extension.
   base::ProcessHandle process_handle_;
-  int pid_;
   std::wstring title_;
+  int id_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerExtensionProcessResource);
 };
 
 class TaskManagerExtensionProcessResourceProvider
     : public TaskManager::ResourceProvider,
       public NotificationObserver {
  public:
   explicit TaskManagerExtensionProcessResourceProvider(
       TaskManager* task_manager);
 
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // NotificationObserver method:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   virtual ~TaskManagerExtensionProcessResourceProvider();
 
   void AddToTaskManager(ExtensionHost* extension_host);
   void RemoveFromTaskManager(ExtensionHost* extension_host);
 
   TaskManager* task_manager_;
 
   // Maps the actual resources (ExtensionHost*) to the Task Manager resources.
   std::map<ExtensionHost*, TaskManagerExtensionProcessResource*> resources_;
 
   // Maps the pids to the resources (used for quick access to the resource on
   // byte read notifications).
-  std::map<int, TaskManagerExtensionProcessResource*> pid_to_resources_;
+  std::map<int, TaskManagerExtensionProcessResource*> child_id_to_resources_;
 
   // A scoped container for notification registries.
   NotificationRegistrar registrar_;
 
   bool updating_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerExtensionProcessResourceProvider);
 };
 
 class TaskManagerNotificationResource : public TaskManager::Resource {
@@ skipping 24 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TaskManagerNotificationResource);
 };
 
 class TaskManagerNotificationResourceProvider
     : public TaskManager::ResourceProvider,
       public NotificationObserver {
  public:
   explicit TaskManagerNotificationResourceProvider(TaskManager* task_manager);
 
   // TaskManager::ResourceProvider interface
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // NotificationObserver interface
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
@@ skipping 26 matching lines @@
   virtual SkBitmap GetIcon() const;
   virtual base::ProcessHandle GetProcess() const;
   virtual Type GetType() const;
 
   virtual bool SupportNetworkUsage() const;
   virtual void SetSupportNetworkUsage();
 
   virtual bool ReportsSqliteMemoryUsed() const;
   virtual size_t SqliteMemoryUsedBytes() const;
 
-  // Returns the pid of the browser process.
-  int process_id() const { return pid_; }
-
  private:
   base::ProcessHandle process_;
-  int pid_;
   mutable std::wstring title_;
 
   static SkBitmap* default_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerBrowserProcessResource);
 };
 
 class TaskManagerBrowserProcessResourceProvider
     : public TaskManager::ResourceProvider {
  public:
   explicit TaskManagerBrowserProcessResourceProvider(
       TaskManager* task_manager);
 
-  virtual TaskManager::Resource* GetResource(int origin_pid,
+  virtual TaskManager::Resource* GetResource(int origin_child_id,
                                              int render_process_host_id,
                                              int routing_id);
   virtual void StartUpdating();
   virtual void StopUpdating();
 
   // Whether we are currently reporting to the task manager. Used to ignore
   // notifications sent after StopUpdating().
   bool updating_;
 
  private:
   virtual ~TaskManagerBrowserProcessResourceProvider();
 
   void AddToTaskManager(ChildProcessInfo child_process_info);
 
   TaskManager* task_manager_;
   TaskManagerBrowserProcessResource resource_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerBrowserProcessResourceProvider);
 };
 
 #endif  // CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_RESOURCE_PROVIDERS_H_