Add GPU memory tab to the task manager.

chrome/browser/task_manager/task_manager.cc

 // 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.
 
 #include "chrome/browser/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/task_manager/task_manager_resource_providers.h"
 #include "chrome/browser/task_manager/task_manager_worker_resource_provider.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #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"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/result_codes.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/ui_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 32 matching lines @@
       ui::FormatBytesWithUnits(stat.liveSize, ui::DATA_UNITS_KIBIBYTE, false));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 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()),
       last_unique_id_(0) {
   AddResourceProvider(
       new TaskManagerBrowserProcessResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerBackgroundContentsResourceProvider(task_manager));
   AddResourceProvider(new TaskManagerTabContentsResourceProvider(task_manager));
   AddResourceProvider(new TaskManagerPanelResourceProvider(task_manager));
@@ skipping 151 matching lines @@
 string16 TaskManagerModel::GetResourceWebCoreCSSCacheSize(
     int index) const {
   CHECK_LT(index, ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   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());
   if (!resources_[index]->ReportsFPS())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   double fps = resources_[index]->GetFPS();
   return UTF8ToUTF16(base::StringPrintf("%.0f", fps));
 }
 
 string16 TaskManagerModel::GetResourceSqliteMemoryUsed(int index) const {
@@ skipping 173 matching lines @@
     if (IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN == col_id)
       return ValueCompare<size_t>(stats1.images.size, stats2.images.size);
     if (IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN == col_id)
       return ValueCompare<size_t>(stats1.scripts.size, stats2.scripts.size);
     DCHECK_EQ(IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN, col_id);
     return ValueCompare<size_t>(stats1.cssStyleSheets.size,
                                 stats2.cssStyleSheets.size);
   } 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));
   } else if (col_id == IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN) {
     size_t value1;
     size_t value2;
     bool reports_v8_memory1 = GetV8Memory(row1, &value1);
     bool reports_v8_memory2 = GetV8Memory(row2, &value2);
     if (reports_v8_memory1 == reports_v8_memory2)
       return ValueCompare<size_t>(value1, value2);
@@ skipping 99 matching lines @@
 
 bool TaskManagerModel::GetWebCoreCacheStats(
     int index, WebKit::WebCache::ResourceTypeStats* result) const {
   if (!resources_[index]->ReportsCacheStats())
     return false;
 
   *result = resources_[index]->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())
     return false;
 
   *result = resources_[index]->GetFPS();
   return true;
 }
 
 bool TaskManagerModel::GetSqliteMemoryUsedBytes(
@@ skipping 298 matching lines @@
                                  float fps) {
   for (ResourceList::iterator it = resources_.begin();
        it != resources_.end(); ++it) {
     if (base::GetProcId((*it)->GetProcess()) == renderer_id &&
         (*it)->GetRoutingID() == routing_id) {
       (*it)->NotifyFPS(fps);
     }
   }
 }
 
+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) {
   for (ResourceList::iterator it = resources_.begin();
        it != resources_.end(); ++it) {
     if (base::GetProcId((*it)->GetProcess()) == renderer_id) {
       (*it)->NotifyV8HeapStats(v8_memory_allocated, v8_memory_used);
     }
   }
 }
 

[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_);
 
   if (update_state_ == STOPPING) {
     // We have been asked to stop.
     update_state_ = IDLE;
     return;
   }
 
   goat_salt_ = base::RandUint64();
@@ skipping 12 matching lines @@
       continue;  // Already computed.
 
     MetricsMap::iterator metrics_iter = metrics_map_.find(process);
     DCHECK(metrics_iter != metrics_map_.end());
     cpu_usage_map_[process] = metrics_iter->second->GetCPUUsage();
   }
 
   // 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 =
       base::TimeDelta::FromMilliseconds(kUpdateTimeMs);
   for (ResourceValueMap::iterator iter = current_byte_count_map_.begin();
        iter != current_byte_count_map_.end(); ++iter) {
     if (update_time > base::TimeDelta::FromSeconds(1)) {
       int divider = update_time.InSeconds();
       displayed_network_usage_map_[iter->first] = iter->second / divider;
     } else {
@@ skipping 249 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }