Distribute extra memory evenly among visible clients

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_memory_allocation.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_memory_manager_client.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "ui/gfx/size_conversions.h"
 
@@ skipping 765 matching lines @@
             stub1.BytesWhenNotVisible());
   EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub2.BytesWhenNotVisible());
 }
 
 // Test GpuMemoryManager's background MRU behavior
 TEST_F(GpuMemoryManagerTest, TestBackgroundMru) {
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
 
+  uint64 bytes_when_not_visible_expected =
+      memmgr_.GetCurrentNonvisibleAvailableGpuMemory();
+#if defined (OS_ANDROID)
+  bytes_when_not_visible_expected = 0;
+#endif
+
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
   FakeClient stub2(&memmgr_, GenerateUniqueSurfaceId(), true);
   FakeClient stub3(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   // When all are visible, they should all be allowed to have memory
   // should they become nonvisible.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(7, 24, 7, false));
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(7, 24, 7, false));
   stub3.SetManagedMemoryStats(GpuManagedMemoryStats(7, 24, 7, false));
   Manage();
   EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
             memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub3.BytesWhenNotVisible());
-
+  EXPECT_EQ(stub1.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub2.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub3.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
 
   // Background stubs 1 and 2, and they should fit
   stub2.SetVisible(false);
   stub1.SetVisible(false);
   Manage();
   EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
-            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub3.BytesWhenNotVisible());
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub1.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub2.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub3.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
 
   // Now background stub 3, and it should cause stub 2 to be
   // evicted because it was set non-visible first
   stub3.SetVisible(false);
   Manage();
   EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
             memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub1.BytesWhenNotVisible());
-  EXPECT_EQ(0ul,
-            stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
-            stub3.BytesWhenNotVisible());
+  EXPECT_EQ(stub1.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
+  EXPECT_EQ(stub2.BytesWhenNotVisible(),
+            0ul);
+  EXPECT_EQ(stub3.BytesWhenNotVisible(),
+            bytes_when_not_visible_expected);
 }
 
 // Test GpuMemoryManager's tracking of unmanaged (e.g, WebGL) memory.
 TEST_F(GpuMemoryManagerTest, TestUnmanagedTracking) {
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetUnmanagedLimitStep(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
 
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
@@ skipping 46 matching lines @@
 
 // Test nonvisible MRU behavior (the most recently used nonvisible clients
 // keep their contents).
 TEST_F(GpuMemoryManagerTestNonuniform, BackgroundMru) {
   // Set memory manager constants for this test
   memmgr_.TestingSetUseNonuniformMemoryPolicy(true);
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
 
+  uint64 bytes_when_not_visible_expected = 6u;
+#if defined (OS_ANDROID)
+  bytes_when_not_visible_expected = 0;
+#endif
+
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
   FakeClient stub2(&memmgr_, GenerateUniqueSurfaceId(), true);
   FakeClient stub3(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   // When all are visible, they should all be allowed to have memory
   // should they become nonvisible.
   SetClientStats(&stub1, 6, 23);
   SetClientStats(&stub2, 6, 23);
   SetClientStats(&stub3, 6, 23);
   Manage();
   EXPECT_GE(stub1.BytesWhenVisible(), 20u);
   EXPECT_GE(stub2.BytesWhenVisible(), 20u);
   EXPECT_GE(stub3.BytesWhenVisible(), 20u);
   EXPECT_LT(stub1.BytesWhenVisible(), 22u);
   EXPECT_LT(stub2.BytesWhenVisible(), 22u);
   EXPECT_LT(stub3.BytesWhenVisible(), 22u);
-  EXPECT_GE(stub1.BytesWhenNotVisible(), 6u);
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 6u);
-  EXPECT_GE(stub3.BytesWhenNotVisible(), 6u);
+  EXPECT_GE(stub1.BytesWhenNotVisible(), bytes_when_not_visible_expected);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
+  EXPECT_GE(stub3.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 
   // Background stubs 1 and 2, and they should fit. All stubs should
   // have their full nicetohave budget should they become visible.
   stub2.SetVisible(false);
   stub1.SetVisible(false);
   Manage();
   EXPECT_GE(stub1.BytesWhenVisible(), 23u);
   EXPECT_GE(stub2.BytesWhenVisible(), 23u);
   EXPECT_GE(stub3.BytesWhenVisible(), 23u);
   EXPECT_LT(stub1.BytesWhenVisible(), 32u);
   EXPECT_LT(stub2.BytesWhenVisible(), 32u);
-  EXPECT_LT(stub3.BytesWhenVisible(), 32u);
-  EXPECT_GE(stub1.BytesWhenNotVisible(), 6u);
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 6u);
-  EXPECT_GE(stub3.BytesWhenNotVisible(), 6u);
+  EXPECT_GE(stub1.BytesWhenNotVisible(), bytes_when_not_visible_expected);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
+  EXPECT_GE(stub3.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 
   // Now background stub 3, and it should cause stub 2 to be
   // evicted because it was set non-visible first
   stub3.SetVisible(false);
   Manage();
-  EXPECT_GE(stub1.BytesWhenNotVisible(), 6u);
+  EXPECT_GE(stub1.BytesWhenNotVisible(), bytes_when_not_visible_expected);
   EXPECT_EQ(stub2.BytesWhenNotVisible(), 0u);
-  EXPECT_GE(stub3.BytesWhenNotVisible(), 6u);
+  EXPECT_GE(stub3.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 }
 
 // Test that once a backgrounded client has dropped its resources, it
 // doesn't get them back until it becomes visible again.
 TEST_F(GpuMemoryManagerTestNonuniform, BackgroundDiscardPersistent) {
   // Set memory manager constants for this test
   memmgr_.TestingSetUseNonuniformMemoryPolicy(true);
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
 
+  uint64 bytes_when_not_visible_expected = 10ul;
+#if defined (OS_ANDROID)
+  bytes_when_not_visible_expected = 0;
+#endif
+
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
   FakeClient stub2(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   // Both clients should be able to keep their contents should one of
   // them become nonvisible.
   SetClientStats(&stub1, 10, 20);
   SetClientStats(&stub2, 10, 20);
   Manage();
-  EXPECT_GE(stub1.BytesWhenNotVisible(), 10u);
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 10u);
+  EXPECT_GE(stub1.BytesWhenNotVisible(), bytes_when_not_visible_expected);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 
   // If they both go nonvisible, then only the most recently used client
   // should keep its contents.
   stub1.SetVisible(false);
   stub2.SetVisible(false);
   Manage();
   EXPECT_EQ(stub1.BytesWhenNotVisible(), 0u);
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 10u);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 
   // When becoming visible, stub 2 should get its contents back, and
   // retain them next time it is made nonvisible.
   stub2.SetVisible(true);
   Manage();
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 10u);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
   stub2.SetVisible(false);
   Manage();
-  EXPECT_GE(stub2.BytesWhenNotVisible(), 10u);
+  EXPECT_GE(stub2.BytesWhenNotVisible(), bytes_when_not_visible_expected);
 }
 
 // Test tracking of unmanaged (e.g, WebGL) memory.
 TEST_F(GpuMemoryManagerTestNonuniform, UnmanagedTracking) {
   // Set memory manager constants for this test
   memmgr_.TestingSetUseNonuniformMemoryPolicy(true);
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
   memmgr_.TestingSetUnmanagedLimitStep(16);
@@ skipping 47 matching lines @@
 TEST_F(GpuMemoryManagerTestNonuniform, DefaultAllocation) {
   // Set memory manager constants for this test
   memmgr_.TestingSetUseNonuniformMemoryPolicy(true);
   memmgr_.TestingSetAvailableGpuMemory(64);
   memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
   memmgr_.TestingSetDefaultClientAllocation(16);
 
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
 
-  // Expect that a client which has not sent stats receive the
-  // default allocation.
+  // Expect that a client which has not sent stats receive at
+  // least the default allocation.
   Manage();
-  EXPECT_EQ(stub1.BytesWhenVisible(),
+  EXPECT_GE(stub1.BytesWhenVisible(),
             memmgr_.GetDefaultClientAllocation());
   EXPECT_EQ(stub1.BytesWhenNotVisible(), 0u);
 }
 
 }  // namespace content