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_video_memory_usage_stats_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::GetResourceVideoMemory(int index) const {
+  CHECK_LT(index, ResourceCount());
+
+  bool result;
+  size_t video_memory;
+  bool has_duplicates;
+  result = GetVideoMemory(index, &video_memory, &has_duplicates);
+
+  if (!result || !video_memory) {
+    return ASCIIToUTF16("N/A");
+  } else if (has_duplicates) {
+    return ASCIIToUTF16("(") +
+           GetMemCellText(video_memory) +
+           ASCIIToUTF16(")");
+  } else {
+    return GetMemCellText(video_memory);
+  }
+}
+
 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_VIDEO_MEMORY_COLUMN) {
+    size_t value1;
+    size_t value2;
+    bool has_duplicates;
+    if (!GetVideoMemory(row1, &value1, &has_duplicates)) value1 = 0;
+    if (!GetVideoMemory(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::GetVideoMemory(
+    int index, size_t* video_memory, bool* has_duplicates) const {
+  TaskManager::Resource* resource = resources_[index];
+  base::ProcessId pid = base::GetProcId(resource->GetProcess());
+  content::GPUVideoMemoryUsageStats::ProcessMap::const_iterator i =
+      video_memory_usage_stats_.process_map.find(pid);
+  if (i == video_memory_usage_stats_.process_map.end()) {
+    *video_memory = 0;
+    *has_duplicates = false;
+    return false;
+  }
+  *video_memory = (*i).second.video_memory;
+  *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::NotifyVideoMemoryUsageStats(
+    const content::GPUVideoMemoryUsageStats& video_memory_usage_stats) {
+  DCHECK(pending_video_memory_usage_stats_update_);
+  video_memory_usage_stats_ = video_memory_usage_stats;
+  pending_video_memory_usage_stats_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);
     }
   }
 }
 
+class TaskManagerModelGpuDataManagerObserver
+    : public content::GpuDataManagerObserver {
+ public:
+
+  TaskManagerModelGpuDataManagerObserver() {
+    content::GpuDataManager::GetInstance()->AddObserver(this);
+  }
+
+  virtual ~TaskManagerModelGpuDataManagerObserver() {
+    content::GpuDataManager::GetInstance()->RemoveObserver(this);
+  }
+
+  static void NotifyVideoMemoryUsageStats(
+      content::GPUVideoMemoryUsageStats video_memory_usage_stats) {
+    TaskManager::GetInstance()->model()->NotifyVideoMemoryUsageStats(
+        video_memory_usage_stats);
+  }
+
+  virtual void OnGpuInfoUpdate() OVERRIDE {}
+
+  virtual void OnVideoMemoryUsageStatsUpdate(
+      const content::GPUVideoMemoryUsageStats& video_memory_usage_stats)
+          OVERRIDE {
+    if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+      NotifyVideoMemoryUsageStats(video_memory_usage_stats);
+    } else {
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE, base::Bind(
+              &TaskManagerModelGpuDataManagerObserver::
+                  NotifyVideoMemoryUsageStats,
+              video_memory_usage_stats));
+    }
+    delete this;
+  }
+};
+
+void TaskManagerModel::RefreshVideoMemoryUsageStats()
+{
+  if (pending_video_memory_usage_stats_update_) return;
+  pending_video_memory_usage_stats_update_ = true;
+  new TaskManagerModelGpuDataManagerObserver;

[Lei Zhang, 2012/08/23 02:34:17]

Umm, whose job is it to delete this guy?

[ccameron, 2012/08/23 04:52:35]

It deletes itself when the response from the GPU process comes in.  But, if
there's no response, then it leaks.  We only allow one to be outstanding.

So, that's not the cleanest scheme, and it caused a memory leak in issue
10861018.  I've since changes this to be scoped to the TaskManagerModel.

+  content::GpuDataManager::GetInstance()->RequestVideoMemoryUsageStatsUpdate();
+}
+
 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
+  RefreshVideoMemoryUsageStats();
+
   // 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 284 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }