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(
+    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);
     }
   }
 }
 
+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;
 }