Add GPU memory tab to the task manager.

content/common/gpu/gpu_memory_manager.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_
 
 #if defined(ENABLE_GPU)
 
 #include <vector>
+#include <set>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/weak_ptr.h"
+#include "base/process.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
+#include "content/public/common/gpu_info.h"
 #include "ui/gfx/size.h"
 
 class GpuCommandBufferStubBase;
+class GpuMemoryTrackingGroup;
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 template<>
 struct hash<GpuCommandBufferStubBase*> {
   size_t operator()(GpuCommandBufferStubBase* ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
   }
 };
 } // namespace BASE_HASH_NAMESPACE
@@ skipping 25 matching lines @@
                    size_t max_surfaces_with_frontbuffer_soft_limit);
   ~GpuMemoryManager();
 
   // Schedule a Manage() call. If immediate is true, we PostTask without delay.
   // Otherwise PostDelayedTask using a CancelableClosure and allow multiple
   // delayed calls to "queue" up. This way, we do not spam clients in certain
   // lower priority situations. An immediate schedule manage will cancel any
   // queued delayed manage.
   void ScheduleManage(bool immediate);
 
+  // Retrieve GPU Resource consumption statistics for the task manager
+  void GetVidmem(content::GPUVidmem& vidmem) const;
+
+  // Add and remove structures to track context groups' memory consumption
+  void AddTrackingGroup(GpuMemoryTrackingGroup* tracking_group);
+  void RemoveTrackingGroup(GpuMemoryTrackingGroup* tracking_group);
+
   // Returns StubMemoryStat's for each GpuCommandBufferStubBase, which were
   // assigned during the most recent call to Manage().
   // Useful for tracking the memory-allocation-related presumed state of the
   // system, as seen by GpuMemoryManager.
   typedef base::hash_map<GpuCommandBufferStubBase*, StubMemoryStat>
       StubMemoryStatMap;
   const StubMemoryStatMap& stub_memory_stats_for_last_manage() const {
     return stub_memory_stats_for_last_manage_;
   }
 
   // Track a change in memory allocated by any context
   void TrackMemoryAllocatedChange(size_t old_size, size_t new_size);
 
  private:
   friend class GpuMemoryManagerTest;
 
   void Manage();
 
+  // The context groups' tracking structures
+  std::set<GpuMemoryTrackingGroup*> tracking_groups_;
+
   size_t CalculateBonusMemoryAllocationBasedOnSize(gfx::Size size) const;
 
   size_t GetAvailableGpuMemory() const {
     return bytes_available_gpu_memory_;
   }
 
   // The minimum non-zero amount of memory that a tab may be assigned
   size_t GetMinimumTabAllocation() const {
 #if defined(OS_ANDROID)
     return 32 * 1024 * 1024;
@@ skipping 20 matching lines @@
   // The maximum amount of memory that may be allocated for GPU resources
   size_t bytes_available_gpu_memory_;
 
   // The current total memory usage, and historical maximum memory usage
   size_t bytes_allocated_current_;
   size_t bytes_allocated_historical_max_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMemoryManager);
 };
 
+// All decoders in a context group point to a single GpuMemoryTrackingGroup,
+// which tracks GPU resource consumption for the entire context group.
+class GpuMemoryTrackingGroup {
+ public:
+  GpuMemoryTrackingGroup(
+    base::ProcessId pid, GpuMemoryManager* memory_manager) :
+    pid_(pid),
+    size_(0),
+    memory_manager_(memory_manager) {
+    memory_manager_->AddTrackingGroup(this);
+  }
+  ~GpuMemoryTrackingGroup() {
+    memory_manager_->RemoveTrackingGroup(this);
+  }
+  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) {
+    if (old_size < new_size) {
+      size_t delta = new_size - old_size;
+      size_ += delta;
+    }
+    if (new_size < old_size) {
+      size_t delta = old_size - new_size;
+      DCHECK(size_ >= delta);
+      size_ -= delta;
+    }
+    memory_manager_->TrackMemoryAllocatedChange(old_size, new_size);
+  }
+  base::ProcessId GetPid() const {
+    return pid_;
+  }
+  size_t GetSize() const {
+    return size_;
+  }
+
+ private:
+  base::ProcessId pid_;
+  size_t size_;
+  GpuMemoryManager* memory_manager_;
+};
+
 #endif
 
 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_H_