Add GetStubStats and related functions in GpuMemoryManager.

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>
 
@@ skipping 30 matching lines @@
                      componentsPerPixel * bytesPerComponent;
   if (limit < GpuMemoryManager::kMinimumAllocationForTab)
     limit = GpuMemoryManager::kMinimumAllocationForTab;
   else if (limit > GpuMemoryManager::kMaximumAllocationForTabs)
     limit = GpuMemoryManager::kMaximumAllocationForTabs;
   return limit - GpuMemoryManager::kMinimumAllocationForTab;
 }
 #endif
 
 void AssignMemoryAllocations(
-    std::vector<GpuCommandBufferStubBase*>& stubs,
-    GpuMemoryAllocation allocation) {
-  for (std::vector<GpuCommandBufferStubBase*>::iterator it = stubs.begin();
-      it != stubs.end(); ++it) {
+    GpuMemoryManager::StubMemoryStatMap* stub_memory_stats,
+    const std::vector<GpuCommandBufferStubBase*>& stubs,
+    GpuMemoryAllocation allocation,
+    bool visible) {
+  for (std::vector<GpuCommandBufferStubBase*>::const_iterator it =
+          stubs.begin();
+      it != stubs.end();
+      ++it) {
     (*it)->SetMemoryAllocation(allocation);
+    (*stub_memory_stats)[*it].allocation = allocation;
+    (*stub_memory_stats)[*it].visible = visible;
   }
 }
 
 }
 
 GpuMemoryManager::GpuMemoryManager(GpuMemoryManagerClient* client,
         size_t max_surfaces_with_frontbuffer_soft_limit)
     : client_(client),
       manage_immediate_scheduled_(false),
       max_surfaces_with_frontbuffer_soft_limit_(
-          max_surfaces_with_frontbuffer_soft_limit) {
+          max_surfaces_with_frontbuffer_soft_limit),
+      peak_assigned_allocation_sum_(0) {
 }
 
 GpuMemoryManager::~GpuMemoryManager() {
 }
 
 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();
@@ skipping 19 matching lines @@
       return;
     delayed_manage_callback_.Reset(base::Bind(&GpuMemoryManager::Manage,
                                               AsWeakPtr()));
     MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       delayed_manage_callback_.callback(),
       base::TimeDelta::FromMilliseconds(kDelayedScheduleManageTimeoutMs));
   }
 }
 
+size_t GpuMemoryManager::GetAvailableGpuMemory() const {
+  // TODO(mmocny): Implement this with real system figures.
+  return kMaximumAllocationForTabs;
+}
+
 // 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 93 matching lines @@
       !stubs_with_surface_foreground.empty())
     bonus_allocation = (kMaximumAllocationForTabs - base_allocation_size) /
                            stubs_with_surface_foreground.size();
 #else
   // On android, calculate bonus allocation based on surface size.
   if (!stubs_with_surface_foreground.empty())
     bonus_allocation = CalculateBonusMemoryAllocationBasedOnSize(
         stubs_with_surface_foreground[0]->GetSurfaceSize());
 #endif
 
+  stub_memory_stats_for_last_manage_.clear();
+
   // Now give out allocations to everyone.
-  AssignMemoryAllocations(stubs_with_surface_foreground,
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_with_surface_foreground,
       GpuMemoryAllocation(kMinimumAllocationForTab + bonus_allocation,
           GpuMemoryAllocation::kHasFrontbuffer |
-          GpuMemoryAllocation::kHasBackbuffer));
+          GpuMemoryAllocation::kHasBackbuffer),
+      true);
 
-  AssignMemoryAllocations(stubs_with_surface_background,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasFrontbuffer));
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_with_surface_background,
+      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasFrontbuffer),
+      false);
 
-  AssignMemoryAllocations(stubs_with_surface_hibernated,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers));
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_with_surface_hibernated,
+      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
+      false);
 
-  AssignMemoryAllocations(stubs_without_surface_foreground,
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_without_surface_foreground,
       GpuMemoryAllocation(kMinimumAllocationForTab,
-          GpuMemoryAllocation::kHasNoBuffers));
+          GpuMemoryAllocation::kHasNoBuffers),
+      true);
 
-  AssignMemoryAllocations(stubs_without_surface_background,
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_without_surface_background,
       GpuMemoryAllocation(kMinimumAllocationForTab,
-          GpuMemoryAllocation::kHasNoBuffers));
+          GpuMemoryAllocation::kHasNoBuffers),
+      false);
 
-  AssignMemoryAllocations(stubs_without_surface_hibernated,
-      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers));
+  AssignMemoryAllocations(
+      &stub_memory_stats_for_last_manage_,
+      stubs_without_surface_hibernated,
+      GpuMemoryAllocation(0, GpuMemoryAllocation::kHasNoBuffers),
+      false);
+
+  size_t assigned_allocation_sum = 0;
+  for (StubMemoryStatMap::iterator it =
+          stub_memory_stats_for_last_manage_.begin();
+      it != stub_memory_stats_for_last_manage_.end();
+      ++it) {
+    assigned_allocation_sum += it->second.allocation.gpu_resource_size_in_bytes;
+  }
+
+  if (assigned_allocation_sum > peak_assigned_allocation_sum_)
+    peak_assigned_allocation_sum_ = assigned_allocation_sum;
 }
 
 #endif