src/chrome/browser/task_manager/task_manager.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
   6 #define CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/callback_forward.h"
  13 #include "base/gtest_prod_util.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/singleton.h"
  16 #include "base/observer_list.h"
  17 #include "base/strings/string16.h"
  18 #include "base/timer/timer.h"
  19 #include "chrome/browser/task_manager/resource_provider.h"
  20 #include "chrome/browser/ui/host_desktop.h"
  21 #include "content/public/common/gpu_memory_stats.h"
  22 #include "third_party/WebKit/public/web/WebCache.h"
  23
  24 class PrefRegistrySimple;
  25 class TaskManagerModel;
  26 class TaskManagerModelGpuDataManagerObserver;
  27
  28 namespace base {
  29 class ProcessMetrics;
  30 }
  31
  32 namespace content {
  33 class WebContents;
  34 }
  35
  36 namespace extensions {
  37 class Extension;
  38 }
  39
  40 namespace gfx {
  41 class ImageSkia;
  42 }
  43
  44 namespace net {
  45 class URLRequest;
  46 }
  47
  48 // This class is a singleton.
  49 class TaskManager {
  50  public:
  51   static void RegisterPrefs(PrefRegistrySimple* registry);
  52
  53   // Returns true if the process at the specified index is the browser process.
  54   bool IsBrowserProcess(int index) const;
  55
  56   // Terminates the process at the specified index.
  57   void KillProcess(int index);
  58
  59   // Activates the browser tab associated with the process in the specified
  60   // index.
  61   void ActivateProcess(int index);
  62
  63   // These methods are invoked by the resource providers to add/remove resources
  64   // to the Task Manager. Note that the resources are owned by the
  65   // ResourceProviders and are not valid after StopUpdating() has been called
  66   // on the ResourceProviders.
  67   void AddResource(task_manager::Resource* resource);
  68   void RemoveResource(task_manager::Resource* resource);
  69
  70   void OnWindowClosed();
  71
  72   // Invoked when a change to a resource has occurred that should cause any
  73   // observers to completely refresh themselves (for example, the creation of
  74   // a background resource in a process). Results in all observers receiving
  75   // OnModelChanged() events.
  76   void ModelChanged();
  77
  78   // Returns the singleton instance (and initializes it if necessary).
  79   static TaskManager* GetInstance();
  80
  81   TaskManagerModel* model() const { return model_.get(); }
  82
  83   void OpenAboutMemory(chrome::HostDesktopType desktop_type);
  84
  85  private:
  86   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, Basic);
  87   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, Resources);
  88   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, RefreshCalled);
  89   FRIEND_TEST_ALL_PREFIXES(TaskManagerWindowControllerTest, Init);
  90   FRIEND_TEST_ALL_PREFIXES(TaskManagerWindowControllerTest, Sort);
  91   FRIEND_TEST_ALL_PREFIXES(TaskManagerWindowControllerTest,
  92                            SelectionAdaptsToSorting);
  93
  94   // Obtain an instance via GetInstance().
  95   TaskManager();
  96   friend struct DefaultSingletonTraits<TaskManager>;
  97
  98   ~TaskManager();
  99
 100   // The model used for gathering and processing task data. It is ref counted
 101   // because it is passed as a parameter to MessageLoop::InvokeLater().
 102   scoped_refptr<TaskManagerModel> model_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(TaskManager);
 105 };
 106
 107 class TaskManagerModelObserver {
 108  public:
 109   virtual ~TaskManagerModelObserver() {}
 110
 111   // Invoked when the model has been completely changed.
 112   virtual void OnModelChanged() = 0;
 113
 114   // Invoked when a range of items has changed.
 115   virtual void OnItemsChanged(int start, int length) = 0;
 116
 117   // Invoked when new items are added.
 118   virtual void OnItemsAdded(int start, int length) = 0;
 119
 120   // Invoked when a range of items has been removed.
 121   virtual void OnItemsRemoved(int start, int length) = 0;
 122
 123   // Invoked when a range of items is to be immediately removed. It differs
 124   // from OnItemsRemoved by the fact that the item is still in the task manager,
 125   // so it can be queried for and found.
 126   virtual void OnItemsToBeRemoved(int start, int length) {}
 127
 128   // Invoked when the initialization of the model has been finished and
 129   // periodical updates is started. The first periodical update will be done
 130   // in a few seconds. (depending on platform)
 131   virtual void OnReadyPeriodicalUpdate() {}
 132 };
 133
 134 // The model used by TaskManager.
 135 //
 136 // TaskManagerModel caches the values from all task_manager::Resources. This is
 137 // done so the UI sees a consistant view of the resources until it is told a
 138 // value has been updated.
 139 class TaskManagerModel : public base::RefCountedThreadSafe<TaskManagerModel> {
 140  public:
 141   // (start, length)
 142   typedef std::pair<int, int> GroupRange;
 143
 144   explicit TaskManagerModel(TaskManager* task_manager);
 145
 146   void AddObserver(TaskManagerModelObserver* observer);
 147   void RemoveObserver(TaskManagerModelObserver* observer);
 148
 149   // Returns number of registered resources.
 150   int ResourceCount() const;
 151   // Returns number of registered groups.
 152   int GroupCount() const;
 153
 154   // Methods to return raw resource information.
 155   int GetNaClDebugStubPort(int index) const;
 156   int64 GetNetworkUsage(int index) const;
 157   double GetCPUUsage(int index) const;
 158   int GetIdleWakeupsPerSecond(int index) const;
 159   base::ProcessId GetProcessId(int index) const;
 160   base::ProcessHandle GetProcess(int index) const;
 161
 162   // Catchall method that calls off to the appropriate GetResourceXXX method
 163   // based on |col_id|. |col_id| is an IDS_ value used to identify the column.
 164   base::string16 GetResourceById(int index, int col_id) const;
 165
 166   // Methods to return formatted resource information.
 167   const base::string16& GetResourceTitle(int index) const;
 168   const base::string16& GetResourceProfileName(int index) const;
 169   base::string16 GetResourceNaClDebugStubPort(int index) const;
 170   base::string16 GetResourceNetworkUsage(int index) const;
 171   base::string16 GetResourceCPUUsage(int index) const;
 172   base::string16 GetResourcePrivateMemory(int index) const;
 173   base::string16 GetResourceSharedMemory(int index) const;
 174   base::string16 GetResourcePhysicalMemory(int index) const;
 175   base::string16 GetResourceProcessId(int index) const;
 176   base::string16 GetResourceGDIHandles(int index) const;
 177   base::string16 GetResourceUSERHandles(int index) const;
 178   base::string16 GetResourceWebCoreImageCacheSize(int index) const;
 179   base::string16 GetResourceWebCoreScriptsCacheSize(int index) const;
 180   base::string16 GetResourceWebCoreCSSCacheSize(int index) const;
 181   base::string16 GetResourceVideoMemory(int index) const;
 182   base::string16 GetResourceSqliteMemoryUsed(int index) const;
 183   base::string16 GetResourceIdleWakeupsPerSecond(int index) const;
 184   base::string16 GetResourceV8MemoryAllocatedSize(int index) const;
 185
 186   // Gets the private memory (in bytes) that should be displayed for the passed
 187   // resource index. Caches the result since this calculation can take time on
 188   // some platforms.
 189   bool GetPrivateMemory(int index, size_t* result) const;
 190
 191   // Gets the shared memory (in bytes) that should be displayed for the passed
 192   // resource index. Caches the result since this calculation can take time on
 193   // some platforms.
 194   bool GetSharedMemory(int index, size_t* result) const;
 195
 196   // Gets the physical memory (in bytes) that should be displayed for the passed
 197   // resource index.
 198   bool GetPhysicalMemory(int index, size_t* result) const;
 199
 200   // On Windows, get the current and peak number of GDI handles in use.
 201   void GetGDIHandles(int index, size_t* current, size_t* peak) const;
 202
 203   // On Windows, get the current and peak number of USER handles in use.
 204   void GetUSERHandles(int index, size_t* current, size_t* peak) const;
 205
 206   // Gets the statuses of webkit. Return false if the resource for the given row
 207   // isn't a renderer.
 208   bool GetWebCoreCacheStats(int index,
 209                             blink::WebCache::ResourceTypeStats* result) const;
 210
 211   // Gets the GPU memory allocated of the given page.
 212   bool GetVideoMemory(int index,
 213                       size_t* video_memory,
 214                       bool* has_duplicates) const;
 215
 216   // Gets the sqlite memory (in byte). Return false if the resource for the
 217   // given row doesn't report information.
 218   bool GetSqliteMemoryUsedBytes(int index, size_t* result) const;
 219
 220   // Gets the amount of memory allocated for javascript. Returns false if the
 221   // resource for the given row isn't a renderer.
 222   bool GetV8Memory(int index, size_t* result) const;
 223
 224   // Gets the amount of memory used for javascript. Returns false if the
 225   // resource for the given row isn't a renderer.
 226   bool GetV8MemoryUsed(int index, size_t* result) const;
 227
 228   // Returns true if resource for the given row can be activated.
 229   bool CanActivate(int index) const;
 230
 231   // Returns true if the resource is first/last in its group (resources
 232   // rendered by the same process are groupped together).
 233   bool IsResourceFirstInGroup(int index) const;
 234   bool IsResourceLastInGroup(int index) const;
 235
 236   // Returns icon to be used for resource (for example a favicon).
 237   gfx::ImageSkia GetResourceIcon(int index) const;
 238
 239   // Returns the group range of resource.
 240   GroupRange GetGroupRangeForResource(int index) const;
 241
 242   // Returns an index of groups to which the resource belongs.
 243   int GetGroupIndexForResource(int index) const;
 244
 245   // Returns an index of resource which belongs to the |group_index|th group
 246   // and which is the |index_in_group|th resource in group.
 247   int GetResourceIndexForGroup(int group_index, int index_in_group) const;
 248
 249   // Compares values in column |col_id| and rows |row1|, |row2|.
 250   // Returns -1 if value in |row1| is less than value in |row2|,
 251   // 0 if they are equal, and 1 otherwise.
 252   int CompareValues(int row1, int row2, int col_id) const;
 253
 254   // Returns the unique child process ID generated by Chromium, not the OS
 255   // process id. This is used to identify processes internally and for
 256   // extensions. It is not meant to be displayed to the user.
 257   int GetUniqueChildProcessId(int index) const;
 258
 259   // Returns the type of the given resource.
 260   task_manager::Resource::Type GetResourceType(int index) const;
 261
 262   // Returns WebContents of given resource or NULL if not applicable.
 263   content::WebContents* GetResourceWebContents(int index) const;
 264
 265   void AddResource(task_manager::Resource* resource);
 266   void RemoveResource(task_manager::Resource* resource);
 267
 268   void StartUpdating();
 269   void StopUpdating();
 270
 271   // Listening involves calling StartUpdating on all resource providers. This
 272   // causes all of them to subscribe to notifications and enumerate current
 273   // resources. It differs from StartUpdating that it doesn't start the
 274   // Refresh timer. The end result is that we have a full view of resources, but
 275   // don't spend unneeded time updating, unless we have a real need to.
 276   void StartListening();
 277   void StopListening();
 278
 279   void Clear();  // Removes all items.
 280
 281   // Sends OnModelChanged() to all observers to inform them of significant
 282   // changes to the model.
 283   void ModelChanged();
 284
 285    // Updates the values for all rows.
 286   void Refresh();
 287
 288   void NotifyResourceTypeStats(
 289         base::ProcessId renderer_id,
 290         const blink::WebCache::ResourceTypeStats& stats);
 291
 292   void NotifyVideoMemoryUsageStats(
 293       const content::GPUVideoMemoryUsageStats& video_memory_usage_stats);
 294
 295   void NotifyV8HeapStats(base::ProcessId renderer_id,
 296                          size_t v8_memory_allocated,
 297                          size_t v8_memory_used);
 298
 299   void NotifyBytesRead(const net::URLRequest& request, int bytes_read);
 300
 301   void RegisterOnDataReadyCallback(const base::Closure& callback);
 302
 303   void NotifyDataReady();
 304
 305  private:
 306   friend class base::RefCountedThreadSafe<TaskManagerModel>;
 307   friend class TaskManagerBrowserTest;
 308   FRIEND_TEST_ALL_PREFIXES(ExtensionApiTest, ProcessesVsTaskManager);
 309   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, RefreshCalled);
 310   FRIEND_TEST_ALL_PREFIXES(TaskManagerWindowControllerTest,
 311                            SelectionAdaptsToSorting);
 312
 313   enum UpdateState {
 314     IDLE = 0,      // Currently not updating.
 315     TASK_PENDING,  // An update task is pending.
 316     STOPPING       // A update task is pending and it should stop the update.
 317   };
 318
 319   // The delay between updates of the information (in ms).
 320 #if defined(OS_MACOSX)
 321   // Match Activity Monitor's default refresh rate.
 322   static const int kUpdateTimeMs = 2000;
 323 #else
 324   static const int kUpdateTimeMs = 1000;
 325 #endif
 326
 327   // Values cached per resource. Values are validated on demand. The is_XXX
 328   // members indicate if a value is valid.
 329   struct PerResourceValues {
 330     PerResourceValues();
 331     ~PerResourceValues();
 332
 333     bool is_title_valid;
 334     base::string16 title;
 335
 336     bool is_profile_name_valid;
 337     base::string16 profile_name;
 338
 339     // No is_network_usage since default (0) is fine.
 340     int64 network_usage;
 341
 342     bool is_process_id_valid;
 343     base::ProcessId process_id;
 344
 345     bool is_webcore_stats_valid;
 346     blink::WebCache::ResourceTypeStats webcore_stats;
 347
 348     bool is_sqlite_memory_bytes_valid;
 349     size_t sqlite_memory_bytes;
 350
 351     bool is_v8_memory_valid;
 352     size_t v8_memory_allocated;
 353     size_t v8_memory_used;
 354   };
 355
 356   // Values cached per process. Values are validated on demand. The is_XXX
 357   // members indicate if a value is valid.
 358   struct PerProcessValues {
 359     PerProcessValues();
 360     ~PerProcessValues();
 361
 362     bool is_cpu_usage_valid;
 363     double cpu_usage;
 364
 365     bool is_idle_wakeups_valid;
 366     int idle_wakeups;
 367
 368     bool is_private_and_shared_valid;
 369     size_t private_bytes;
 370     size_t shared_bytes;
 371
 372     bool is_physical_memory_valid;
 373     size_t physical_memory;
 374
 375     bool is_video_memory_valid;
 376     size_t video_memory;
 377     bool video_memory_has_duplicates;
 378
 379     bool is_gdi_handles_valid;
 380     size_t gdi_handles;
 381     size_t gdi_handles_peak;
 382
 383     bool is_user_handles_valid;
 384     size_t user_handles;
 385     size_t user_handles_peak;
 386
 387     bool is_nacl_debug_stub_port_valid;
 388     int nacl_debug_stub_port;
 389   };
 390
 391   typedef std::vector<task_manager::Resource*> ResourceList;
 392   typedef std::vector<scoped_refptr<task_manager::ResourceProvider> >
 393       ResourceProviderList;
 394   typedef std::map<base::ProcessHandle, ResourceList> GroupMap;
 395   typedef std::map<base::ProcessHandle, base::ProcessMetrics*> MetricsMap;
 396   typedef std::map<task_manager::Resource*, int64> ResourceValueMap;
 397   typedef std::map<task_manager::Resource*,
 398                    PerResourceValues> PerResourceCache;
 399   typedef std::map<base::ProcessHandle, PerProcessValues> PerProcessCache;
 400
 401   // This struct is used to exchange information between the io and ui threads.
 402   struct BytesReadParam {
 403     BytesReadParam(int origin_pid,
 404                    int child_id,
 405                    int route_id,
 406                    int byte_count)
 407         : origin_pid(origin_pid),
 408           child_id(child_id),
 409           route_id(route_id),
 410           byte_count(byte_count) {}
 411
 412     // The process ID that triggered the request.  For plugin requests this
 413     // will differ from the renderer process ID.
 414     int origin_pid;
 415
 416     // The child ID of the process this request was routed through.
 417     int child_id;
 418
 419     int route_id;
 420     int byte_count;
 421   };
 422
 423   ~TaskManagerModel();
 424
 425   // Callback from the timer to refresh. Invokes Refresh() as appropriate.
 426   void RefreshCallback();
 427
 428   void RefreshVideoMemoryUsageStats();
 429
 430   // Returns the network usage (in bytes per seconds) for the specified
 431   // resource. That's the value retrieved at the last timer's tick.
 432   int64 GetNetworkUsageForResource(task_manager::Resource* resource) const;
 433
 434   // Called on the UI thread when some bytes are read.
 435   void BytesRead(BytesReadParam param);
 436
 437   void MultipleBytesRead(const std::vector<BytesReadParam>* params);
 438
 439   // Notifies the UI thread about all the bytes read. Allows for coalescing
 440   // multiple bytes read into a single task for the UI thread. This is important
 441   // for when downloading a lot of data on the IO thread, since posting a Task
 442   // for each one is expensive.
 443   void NotifyMultipleBytesRead();
 444
 445   // Called on the IO thread to start/stop updating byte counts.
 446   void SetUpdatingByteCount(bool is_updating);
 447
 448   // Returns the network usage (in byte per second) that should be displayed for
 449   // the passed |resource|.  -1 means the information is not available for that
 450   // resource.
 451   int64 GetNetworkUsage(task_manager::Resource* resource) const;
 452
 453   // Returns the CPU usage (in %) that should be displayed for the passed
 454   // |resource|.
 455   double GetCPUUsage(task_manager::Resource* resource) const;
 456
 457   // Returns the idle wakeups that should be displayed for the passed
 458   // |resource|.
 459   int GetIdleWakeupsPerSecond(task_manager::Resource* resource) const;
 460
 461   // Given a number, this function returns the formatted string that should be
 462   // displayed in the task manager's memory cell.
 463   base::string16 GetMemCellText(int64 number) const;
 464
 465   // Verifies the private and shared memory for |handle| is valid in
 466   // |per_process_cache_|. Returns true if the data in |per_process_cache_| is
 467   // valid.
 468   bool CachePrivateAndSharedMemory(base::ProcessHandle handle) const;
 469
 470   // Verifies |webcore_stats| in |per_resource_cache_|, returning true on
 471   // success.
 472   bool CacheWebCoreStats(int index) const;
 473
 474   // Verifies |v8_memory_allocated| and |v8_memory_used| in
 475   // |per_resource_cache_|. Returns true if valid, false if not valid.
 476   bool CacheV8Memory(int index) const;
 477
 478   // Adds a resource provider to be managed.
 479   void AddResourceProvider(task_manager::ResourceProvider* provider);
 480
 481   // Returns the PerResourceValues for the specified index.
 482   PerResourceValues& GetPerResourceValues(int index) const;
 483
 484   // Returns the Resource for the specified index.
 485   task_manager::Resource* GetResource(int index) const;
 486
 487   // The list of providers to the task manager. They are ref counted.
 488   ResourceProviderList providers_;
 489
 490   // The list of all the resources displayed in the task manager. They are owned
 491   // by the ResourceProviders.
 492   ResourceList resources_;
 493
 494   // A map to keep tracks of the grouped resources (they are grouped if they
 495   // share the same process). The groups (the Resources vectors) are owned by
 496   // the model (but the actual Resources are owned by the ResourceProviders).
 497   GroupMap group_map_;
 498
 499   // A map to retrieve the process metrics for a process. The ProcessMetrics are
 500   // owned by the model.
 501   MetricsMap metrics_map_;
 502
 503   // A map that keeps track of the number of bytes read per process since last
 504   // tick. The Resources are owned by the ResourceProviders.
 505   ResourceValueMap current_byte_count_map_;
 506
 507   // A map that contains the video memory usage for a process
 508   content::GPUVideoMemoryUsageStats video_memory_usage_stats_;
 509
 510   // Set to true when we've requested video stats and false once we get them.
 511   bool pending_video_memory_usage_stats_update_;
 512
 513   // An observer waiting for video memory usage stats updates from the GPU
 514   // process
 515   scoped_ptr<TaskManagerModelGpuDataManagerObserver>
 516       video_memory_usage_stats_observer_;
 517
 518   ObserverList<TaskManagerModelObserver> observer_list_;
 519
 520   // How many calls to StartUpdating have been made without matching calls to
 521   // StopUpdating.
 522   int update_requests_;
 523
 524   // How many calls to StartListening have been made without matching calls to
 525   // StopListening.
 526   int listen_requests_;
 527
 528   // Whether we are currently in the process of updating.
 529   UpdateState update_state_;
 530
 531   // Whether the IO thread is currently in the process of updating; accessed
 532   // only on the IO thread.
 533   bool is_updating_byte_count_;
 534
 535   // Buffer for coalescing BytesReadParam so we don't have to post a task on
 536   // each NotifyBytesRead() call.
 537   std::vector<BytesReadParam> bytes_read_buffer_;
 538
 539   std::vector<base::Closure> on_data_ready_callbacks_;
 540
 541   // All per-Resource values are stored here.
 542   mutable PerResourceCache per_resource_cache_;
 543
 544   // All per-Process values are stored here.
 545   mutable PerProcessCache per_process_cache_;
 546
 547   DISALLOW_COPY_AND_ASSIGN(TaskManagerModel);
 548 };
 549
 550 #endif  // CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_