Add GPU memory tab to the task manager.

chrome/browser/task_manager/task_manager.cc

Index: chrome/browser/task_manager/task_manager.cc
diff --git a/chrome/browser/task_manager/task_manager.cc b/chrome/browser/task_manager/task_manager.cc
index 9561a6d7f47fdce732d49197b1650642ae44d5e3..5a14b77c69d675f4e4c60964640959ba323bdfe8 100644
--- a/chrome/browser/task_manager/task_manager.cc
+++ b/chrome/browser/task_manager/task_manager.cc
@@ -31,6 +31,8 @@
 #include "chrome/common/view_type.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/gpu_data_manager.h"
+#include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
@@ -83,7 +85,8 @@ string16 FormatStatsSize(const WebKit::WebCache::ResourceTypeStat& stat) {
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
-    : update_requests_(0),
+    : pending_vidmem_update_(false),
+      update_requests_(0),
       listen_requests_(0),
       update_state_(IDLE),
       goat_salt_(base::RandUint64()),
@@ -255,6 +258,26 @@ string16 TaskManagerModel::GetResourceWebCoreCSSCacheSize(
   return FormatStatsSize(stats.cssStyleSheets);
 }
 
+string16 TaskManagerModel::GetResourceVidmem(

[ccameron, 2012/08/09 20:55:39]

This will print N/A for all processes that have no GPU resources.

This will print the total across all processes in the GPU process' column.  That
column will be in (), to draw attention to the fact that it is unique.

+    int index) const {
+  CHECK_LT(index, ResourceCount());
+
+  bool result;
+  size_t vidmem;
+  bool has_duplicates;
+  result = GetVidmem(index, &vidmem, &has_duplicates);
+
+  if (!result || !vidmem) {
+    return ASCIIToUTF16("N/A");
+  } else if (has_duplicates) {
+    return UTF8ToUTF16("(") +
+             GetMemCellText(vidmem) +
+             UTF8ToUTF16(")");
+  } else {
+    return GetMemCellText(vidmem);
+  }
+}
+
 string16 TaskManagerModel::GetResourceFPS(
     int index) const {
   CHECK_LT(index, ResourceCount());
@@ -448,6 +471,13 @@ int TaskManagerModel::CompareValues(int row1, int row2, int col_id) const {
   } else if (col_id == IDS_TASK_MANAGER_FPS_COLUMN) {
     return ValueCompare<float>(resources_[row1]->GetFPS(),
                                resources_[row2]->GetFPS());
+  } else if (col_id == IDS_TASK_MANAGER_VIDMEM_COLUMN) {
+    size_t value1;
+    size_t value2;
+    bool has_duplicates;
+    if (!GetVidmem(row1, &value1, &has_duplicates)) value1 = 0;
+    if (!GetVidmem(row2, &value2, &has_duplicates)) value2 = 0;
+    return ValueCompare<size_t>(value1, value2);
   } else if (col_id == IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN) {
     return ValueCompare<int>(GetGoatsTeleported(row1),
                              GetGoatsTeleported(row2));
@@ -567,6 +597,22 @@ bool TaskManagerModel::GetWebCoreCacheStats(
   return true;
 }
 
+bool TaskManagerModel::GetVidmem(
+    int index, size_t* vidmem, bool* has_duplicates) const {
+  TaskManager::Resource* resource = resources_[index];
+  base::ProcessId pid = base::GetProcId(resource->GetProcess());
+  content::GPUVidmem::ProcessMap::const_iterator i =
+    vidmem_.process_map.find(pid);
+  if (i == vidmem_.process_map.end()) {
+    *vidmem = 0;
+    *has_duplicates = false;
+    return false;
+  }
+  *vidmem = (*i).second.vidmem;
+  *has_duplicates = (*i).second.has_duplicates;
+  return true;
+}
+
 bool TaskManagerModel::GetFPS(int index, float* result) const {
   *result = 0;
   if (!resources_[index]->ReportsFPS())
@@ -885,6 +931,12 @@ void TaskManagerModel::NotifyFPS(base::ProcessId renderer_id,
   }
 }
 
+void TaskManagerModel::NotifyVidmem(const content::GPUVidmem& vidmem) {
+  DCHECK(pending_vidmem_update_);
+  vidmem_ = vidmem;
+  pending_vidmem_update_ = false;
+}
+
 void TaskManagerModel::NotifyV8HeapStats(base::ProcessId renderer_id,
                                          size_t v8_memory_allocated,
                                          size_t v8_memory_used) {
@@ -896,6 +948,44 @@ void TaskManagerModel::NotifyV8HeapStats(base::ProcessId renderer_id,
   }
 }
 

[ccameron, 2012/08/09 20:55:39]

Is there a preferred location for this class?

+class TaskManagerModelGpuDataManagerObserver
+  : public content::GpuDataManagerObserver {
+ public:
+
+  TaskManagerModelGpuDataManagerObserver() {
+    content::GpuDataManager::GetInstance()->AddObserver(this);
+  }
+
+  virtual ~TaskManagerModelGpuDataManagerObserver() {
+    content::GpuDataManager::GetInstance()->RemoveObserver(this);
+  }
+
+  static void NotifyVidmem(content::GPUVidmem vidmem) {
+    TaskManager::GetInstance()->model()->NotifyVidmem(vidmem);
+  }
+
+  virtual void OnGpuInfoUpdate() OVERRIDE {}
+
+  virtual void OnVidmemUpdate(const content::GPUVidmem& vidmem) OVERRIDE {
+    if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+      NotifyVidmem(vidmem);
+    } else {
+      BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, base::Bind(
+          &TaskManagerModelGpuDataManagerObserver::NotifyVidmem, vidmem));
+    }
+    delete this;
+  }
+};
+
+void TaskManagerModel::RefreshVidmem()
+{
+  if (pending_vidmem_update_) return;
+  pending_vidmem_update_ = true;
+  new TaskManagerModelGpuDataManagerObserver;
+  content::GpuDataManager::GetInstance()->RequestVidmemUpdate();
+}
+
 void TaskManagerModel::Refresh() {
   DCHECK_NE(IDLE, update_state_);
 
@@ -928,6 +1018,9 @@ void TaskManagerModel::Refresh() {
   // Clear the memory values so they can be querried lazily.
   memory_usage_map_.clear();
 
+  // Send a request to refresh GPU memory consumption values
+  RefreshVidmem();
+
   // Compute the new network usage values.
   displayed_network_usage_map_.clear();
   base::TimeDelta update_time =