Add a flag to specify the amount of total GPU memory available.

content/common/gpu/gpu_memory_manager_unittest.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_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_allocation.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 96 matching lines @@
   static int32 GenerateUniqueSurfaceId() {
     static int32 surface_id_ = 1;
     return surface_id_++;
   }
 
   static bool IsMoreImportant(GpuCommandBufferStubBase* lhs,
                               GpuCommandBufferStubBase* rhs) {
     return GpuMemoryManager::StubWithSurfaceComparator()(lhs, rhs);
   }
 
-  static bool IsAllocationForegroundForSurfaceYes(
+  bool IsAllocationForegroundForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return alloc.suggest_have_frontbuffer &&
            alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes >=
-               GpuMemoryManager::kMinimumAllocationForTab;
+               GetMinimumTabAllocation();

[greggman, 2012/07/31 00:30:41]

style: I don't think these are supposed to be indented.

[ccameron, 2012/07/31 00:52:49]

I'm not sure on this -- it'a a compound clause with the >= and the ==. 
Fortunately we can avoid the question by bumping off the newline.

   }
-  static bool IsAllocationBackgroundForSurfaceYes(
+  bool IsAllocationBackgroundForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return alloc.suggest_have_frontbuffer &&
            !alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes == 0;
   }
-  static bool IsAllocationHibernatedForSurfaceYes(
+  bool IsAllocationHibernatedForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return !alloc.suggest_have_frontbuffer &&
            !alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes == 0;
   }
-  static bool IsAllocationForegroundForSurfaceNo(
+  bool IsAllocationForegroundForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.suggest_have_frontbuffer &&
            !alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes ==
-               GpuMemoryManager::kMinimumAllocationForTab;
+               GetMinimumTabAllocation();
   }
-  static bool IsAllocationBackgroundForSurfaceNo(
+  bool IsAllocationBackgroundForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.suggest_have_frontbuffer &&
            !alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes ==
-               GpuMemoryManager::kMinimumAllocationForTab;
+               GetMinimumTabAllocation();
   }
-  static bool IsAllocationHibernatedForSurfaceNo(
+  bool IsAllocationHibernatedForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.suggest_have_frontbuffer &&
            !alloc.suggest_have_backbuffer &&
            alloc.gpu_resource_size_in_bytes == 0;
   }
 
   void Manage() {
     memory_manager_.Manage();
   }
 
+  size_t GetAvailableGpuMemory() {
+    return memory_manager_.GetAvailableGpuMemory();
+  }
+
+  size_t GetMinimumTabAllocation() {
+    return memory_manager_.GetMinimumTabAllocation();
+  }
+
   base::TimeTicks older_, newer_, newest_;
   FakeClient client_;
   GpuMemoryManager memory_manager_;
 };
 
 // Create fake stubs with every combination of {visibilty,last_use_time}
 // and make sure they compare correctly.  Only compare stubs with surfaces.
 // Expect {more visible, newer} surfaces to be more important, in that order.
 TEST_F(GpuMemoryManagerTest, ComparatorTests) {
   FakeCommandBufferStub stub_true1(GenerateUniqueSurfaceId(), true, older_),
@@ skipping 303 matching lines @@
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub4.allocation_));
 }
 
 #if !defined(OS_ANDROID)
 // Test GpuMemoryAllocation memory allocation bonuses:
 // When the number of visible tabs is small, each tab should get a
 // gpu_resource_size_in_bytes allocation value that is greater than
-// kMinimumAllocationForTab, and when the number of tabs is large, each should
-// get exactly kMinimumAllocationForTab and not less.
+// GetMinimumTabAllocation(), and when the number of tabs is large, each should
+// get exactly GetMinimumTabAllocation() and not less.
 TEST_F(GpuMemoryManagerTest, TestForegroundStubsGetBonusAllocation) {
   size_t max_stubs_before_no_bonus =
-      GpuMemoryManager::kMaximumAllocationForTabs /
-          (GpuMemoryManager::kMinimumAllocationForTab + 1);
+      GetAvailableGpuMemory() / (GetMinimumTabAllocation() + 1);
 
   std::vector<FakeCommandBufferStub> stubs;
   for (size_t i = 0; i < max_stubs_before_no_bonus; ++i) {
     stubs.push_back(
         FakeCommandBufferStub(GenerateUniqueSurfaceId(), true, older_));
   }
   for (size_t i = 0; i < stubs.size(); ++i) {
     client_.stubs_.push_back(&stubs[i]);
   }
 
   Manage();
   for (size_t i = 0; i < stubs.size(); ++i) {
     EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stubs[i].allocation_));
     EXPECT_GT(stubs[i].allocation_.gpu_resource_size_in_bytes,
-              static_cast<size_t>(GpuMemoryManager::kMinimumAllocationForTab));
+              static_cast<size_t>(GetMinimumTabAllocation()));
   }
 
   FakeCommandBufferStub extra_stub(GenerateUniqueSurfaceId(), true, older_);
   client_.stubs_.push_back(&extra_stub);
 
   Manage();
   for (size_t i = 0; i < stubs.size(); ++i) {
     EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stubs[i].allocation_));
     EXPECT_EQ(stubs[i].allocation_.gpu_resource_size_in_bytes,
-              GpuMemoryManager::kMinimumAllocationForTab);
+              GetMinimumTabAllocation());
   }
 }
 #else
 // Test GpuMemoryAllocation memory allocation bonuses:
 // When the size of tab contents is small, bonus allocation should be 0.
 // As the size of tab contents increases, bonus allocation should increase
 // until finally reaching the maximum allocation limit.
 TEST_F(GpuMemoryManagerTest, TestForegroundStubsGetBonusAllocationAndroid) {
   FakeCommandBufferStub stub(GenerateUniqueSurfaceId(), true, older_);
   client_.stubs_.push_back(&stub);
 
   stub.size_ = gfx::Size(1,1);
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub.allocation_));
   EXPECT_EQ(stub.allocation_.gpu_resource_size_in_bytes,
-            GpuMemoryManager::kMinimumAllocationForTab);
+            GetMinimumTabAllocation());
 
   // Keep increasing size, making sure allocation is always increasing
   // Until it finally reaches the maximum.
   while (stub.allocation_.gpu_resource_size_in_bytes <
-      GpuMemoryManager::kMaximumAllocationForTabs) {
+      GetAvailableGpuMemory()) {
     size_t previous_allocation = stub.allocation_.gpu_resource_size_in_bytes;
 
     stub.size_ = stub.size_.Scale(1, 2);
 
     Manage();
     EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub.allocation_));
     EXPECT_GE(stub.allocation_.gpu_resource_size_in_bytes,
-              GpuMemoryManager::kMinimumAllocationForTab);
+              GetMinimumTabAllocation());
     EXPECT_LE(stub.allocation_.gpu_resource_size_in_bytes,
-              GpuMemoryManager::kMaximumAllocationForTabs);
+              GetAvailableGpuMemory());
     EXPECT_GE(stub.allocation_.gpu_resource_size_in_bytes,
               previous_allocation);
   }
 
   // One final size increase to confirm it stays capped at maximum.
   stub.size_ = stub.size_.Scale(1, 2);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub.allocation_));
   EXPECT_EQ(stub.allocation_.gpu_resource_size_in_bytes,
-            GpuMemoryManager::kMaximumAllocationForTabs);
+            GetAvailableGpuMemory());
 }
 #endif
 
 // Test GpuMemoryAllocation comparison operators: Iterate over all possible
 // combinations of gpu_resource_size_in_bytes, suggest_have_backbuffer, and
 // suggest_have_frontbuffer, and make sure allocations with equal values test
 // equal and non equal values test not equal.
 TEST_F(GpuMemoryManagerTest, GpuMemoryAllocationCompareTests) {
   std::vector<int> gpu_resource_size_in_bytes_values;
   gpu_resource_size_in_bytes_values.push_back(0);
@@ skipping 99 matching lines @@
   EXPECT_EQ(stats.size(), 3ul);
   EXPECT_FALSE(stats[&stub1].visible);
   EXPECT_FALSE(stats[&stub2].visible);
   EXPECT_TRUE(stats[&stub3].visible);
   EXPECT_EQ(stub1allocation4, 0ul);
   EXPECT_GE(stub2allocation4, 0ul);
   EXPECT_GT(stub3allocation4, 0ul);
   if (compositors_get_bonus_allocation)
     EXPECT_GT(stub3allocation4, stub3allocation3);
 }