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..f4d6f558beb47e9fcf6a21b6d342ba3e705aff92 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(
+    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,
   }
 }
 
+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 =