Add GPU memory tab to the task manager.

chrome/browser/task_manager/task_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 #define CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/process_util.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
+#include "content/public/common/gpu_memory_stats.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCache.h"
 
 class TaskManagerModel;
 
 namespace base {
 class ProcessMetrics;
 }
 
 namespace content {
 class WebContents;
@@ skipping 274 matching lines @@
   string16 GetResourceProfileName(int index) const;
   string16 GetResourceNetworkUsage(int index) const;
   string16 GetResourceCPUUsage(int index) const;
   string16 GetResourcePrivateMemory(int index) const;
   string16 GetResourceSharedMemory(int index) const;
   string16 GetResourcePhysicalMemory(int index) const;
   string16 GetResourceProcessId(int index) const;
   string16 GetResourceWebCoreImageCacheSize(int index) const;
   string16 GetResourceWebCoreScriptsCacheSize(int index) const;
   string16 GetResourceWebCoreCSSCacheSize(int index) const;
+  string16 GetResourceVideoMemory(int index) const;
   string16 GetResourceFPS(int index) const;
   string16 GetResourceSqliteMemoryUsed(int index) const;
   string16 GetResourceGoatsTeleported(int index) const;
   string16 GetResourceV8MemoryAllocatedSize(int index) const;
 
   // Gets the private memory (in bytes) that should be displayed for the passed
   // resource index. Caches the result since this calculation can take time on
   // some platforms.
   bool GetPrivateMemory(int index, size_t* result) const;
 
   // Gets the shared memory (in bytes) that should be displayed for the passed
   // resource index. Caches the result since this calculation can take time on
   // some platforms.
   bool GetSharedMemory(int index, size_t* result) const;
 
   // Gets the physical memory (in bytes) that should be displayed for the passed
   // resource index.
   bool GetPhysicalMemory(int index, size_t* result) const;
 
   // Gets the statuses of webkit. Return false if the resource for the given row
   // isn't a renderer.
   bool GetWebCoreCacheStats(int index,
                             WebKit::WebCache::ResourceTypeStats* result) const;
 
+  // Gets the GPU memory allocated of the given page.
+  bool GetVideoMemory(int index,
+                      size_t* video_memory,
+                      bool* has_duplicates) const;
+
   // Gets the fps of the given page. Return false if the resource for the given
   // row isn't a renderer.
   bool GetFPS(int index, float* result) const;
 
   // Gets the sqlite memory (in byte). Return false if the resource for the
   // given row doesn't report information.
   bool GetSqliteMemoryUsedBytes(int index, size_t* result) const;
 
   // Gets the amount of memory allocated for javascript. Returns false if the
   // resource for the given row isn't a renderer.
@@ skipping 81 matching lines @@
   void ModelChanged();
 
   void NotifyResourceTypeStats(
         base::ProcessId renderer_id,
         const WebKit::WebCache::ResourceTypeStats& stats);
 
   void NotifyFPS(base::ProcessId renderer_id,
                  int routing_id,
                  float fps);
 
+  void NotifyVideoMemoryUsageStats(
+      const content::GPUVideoMemoryUsageStats& video_memory_usage_stats);
+
   void NotifyV8HeapStats(base::ProcessId renderer_id,
                          size_t v8_memory_allocated,
                          size_t v8_memory_used);
 
   void NotifyBytesRead(const net::URLRequest& request, int bytes_read);
 
  private:
   friend class base::RefCountedThreadSafe<TaskManagerModel>;
   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, RefreshCalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionApiTest, ProcessesVsTaskManager);
@@ skipping 35 matching lines @@
   typedef std::map<base::ProcessHandle, base::ProcessMetrics*> MetricsMap;
   typedef std::map<base::ProcessHandle, double> CPUUsageMap;
   typedef std::map<TaskManager::Resource*, int64> ResourceValueMap;
   // Private memory in bytes, shared memory in bytes.
   typedef std::pair<size_t, size_t> MemoryUsageEntry;
   typedef std::map<base::ProcessHandle, MemoryUsageEntry> MemoryUsageMap;
 
   // Updates the values for all rows.
   void Refresh();
 
+  void RefreshVideoMemoryUsageStats();
+
   void AddItem(TaskManager::Resource* resource, bool notify_table);
   void RemoveItem(TaskManager::Resource* resource);
 
   // Returns the network usage (in bytes per seconds) for the specified
   // resource. That's the value retrieved at the last timer's tick.
   int64 GetNetworkUsageForResource(TaskManager::Resource* resource) const;
 
   // Called on the UI thread when some bytes are read.
   void BytesRead(BytesReadParam param);
 
@@ skipping 44 matching lines @@
   ResourceValueMap current_byte_count_map_;
 
   // A map that contains the network usage is displayed in the table, in bytes
   // per second. It is computed every time the timer ticks. The Resources are
   // owned by the ResourceProviders.
   ResourceValueMap displayed_network_usage_map_;
 
   // A map that contains the CPU usage (in %) for a process since last refresh.
   CPUUsageMap cpu_usage_map_;
 
+  // A map that contains the video memory usage for a process
+  content::GPUVideoMemoryUsageStats video_memory_usage_stats_;
+  bool pending_video_memory_usage_stats_update_;
+
   // A map that contains the private/shared memory usage of the process. We
   // cache this because the same APIs are called on linux and windows, and
   // because the linux call takes >10ms to complete. This cache is cleared on
   // every Refresh().
   mutable MemoryUsageMap memory_usage_map_;
 
   ObserverList<TaskManagerModelObserver> observer_list_;
 
   // How many calls to StartUpdating have been made without matching calls to
   // StopUpdating.
   int update_requests_;
 
   // How many calls to StartListening have been made without matching calls to
   // StopListening.
   int listen_requests_;
 
   // Whether we are currently in the process of updating.
   UpdateState update_state_;
 
   // A salt lick for the goats.
   uint64 goat_salt_;
 
   // Resource identifier that is unique within single session.
   int last_unique_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerModel);
 };
 
 #endif  // CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_