Add GPU memory tab to the task manager.

content/common/gpu/gpu_memory_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 "content/common/gpu/gpu_memory_manager.h"
 
 #if defined(ENABLE_GPU)
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
+#include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
+#include "content/common/gpu/gpu_memory_tracking.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 
 namespace {
 
 const int kDelayedScheduleManageTimeoutMs = 67;
 
 bool IsInSameContextShareGroupAsAnyOf(
     const GpuCommandBufferStubBase* stub,
     const std::vector<GpuCommandBufferStubBase*>& stubs) {
   for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
@@ skipping 57 matching lines @@
   } else {
 #if defined(OS_ANDROID)
     bytes_available_gpu_memory_ = 64 * 1024 * 1024;
 #else
     bytes_available_gpu_memory_ = 448 * 1024 * 1024;
 #endif
   }
 }
 
 GpuMemoryManager::~GpuMemoryManager() {
+  DCHECK(tracking_groups_.empty());
 }
 
 bool GpuMemoryManager::StubWithSurfaceComparator::operator()(
     GpuCommandBufferStubBase* lhs,
     GpuCommandBufferStubBase* rhs) {
   DCHECK(lhs->has_surface_state() && rhs->has_surface_state());
   const GpuCommandBufferStubBase::SurfaceState& lhs_ss = lhs->surface_state();
   const GpuCommandBufferStubBase::SurfaceState& rhs_ss = rhs->surface_state();
   if (lhs_ss.visible)
     return !rhs_ss.visible || (lhs_ss.last_used_time > rhs_ss.last_used_time);
@@ skipping 17 matching lines @@
     delayed_manage_callback_.Reset(base::Bind(&GpuMemoryManager::Manage,
                                               AsWeakPtr()));
     MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       delayed_manage_callback_.callback(),
       base::TimeDelta::FromMilliseconds(kDelayedScheduleManageTimeoutMs));
   }
 }
 
 void GpuMemoryManager::TrackMemoryAllocatedChange(size_t old_size,
-                                                  size_t new_size)
-{
+                                                  size_t new_size) {
   if (new_size < old_size) {
     size_t delta = old_size - new_size;
     DCHECK(bytes_allocated_current_ >= delta);
     bytes_allocated_current_ -= delta;
   } else {
     size_t delta = new_size - old_size;
     bytes_allocated_current_ += delta;
     if (bytes_allocated_current_ > bytes_allocated_historical_max_) {
       bytes_allocated_historical_max_ = bytes_allocated_current_;
     }
   }
   if (new_size != old_size) {
     TRACE_COUNTER_ID1("GpuMemoryManager",
                       "GpuMemoryUsage",
                       this,
                       bytes_allocated_current_);
   }
 }
 
+void GpuMemoryManager::AddTrackingGroup(
+    GpuMemoryTrackingGroup* tracking_group) {
+  tracking_groups_.insert(tracking_group);
+}
+
+void GpuMemoryManager::RemoveTrackingGroup(
+    GpuMemoryTrackingGroup* tracking_group) {
+  tracking_groups_.erase(tracking_group);
+}
+
+void GpuMemoryManager::GetVideoMemoryUsageStats(
+    content::GPUVideoMemoryUsageStats& video_memory_usage_stats) const {
+  // For each context group, assign its memory usage to its PID
+  video_memory_usage_stats.process_map.clear();
+  for (std::set<GpuMemoryTrackingGroup*>::const_iterator i =
+       tracking_groups_.begin(); i != tracking_groups_.end(); ++i) {
+    const GpuMemoryTrackingGroup* tracking_group = (*i);
+    video_memory_usage_stats.process_map[
+        tracking_group->GetPid()].video_memory += tracking_group->GetSize();
+  }
+
+  // Assign the total across all processes in the GPU process
+  video_memory_usage_stats.process_map[
+      base::GetCurrentProcId()].video_memory = bytes_allocated_current_;
+  video_memory_usage_stats.process_map[
+      base::GetCurrentProcId()].has_duplicates = true;
+}
+
 // The current Manage algorithm simply classifies contexts (stubs) into
 // "foreground", "background", or "hibernated" categories.
 // For each of these three categories, there are predefined memory allocation
 // limits and front/backbuffer states.
 //
 // Stubs may or may not have a surfaces, and the rules are different for each.
 //
 // The rules for categorizing contexts with a surface are:
 //  1. Foreground: All visible surfaces.
 //                 * Must have both front and back buffer.
@@ skipping 138 matching lines @@
       false);
 
   AssignMemoryAllocations(
       &stub_memory_stats_for_last_manage_,
       stubs_without_surface_hibernated,
       GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
       false);
 }
 
 #endif