Make names consistent in GpuMemoryManager

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 158 matching lines @@
   static int32 GenerateUniqueSurfaceId() {
     static int32 surface_id_ = 1;
     return surface_id_++;
   }
 
   bool IsAllocationForegroundForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_visible >=
-               GetMinimumTabAllocation();
+               GetMinimumClientAllocation();
   }
   bool IsAllocationBackgroundForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_not_visible <=
-               memmgr_.GetCurrentBackgroundedAvailableGpuMemory();
+               memmgr_.GetCurrentNonvisibleAvailableGpuMemory();
   }
   bool IsAllocationHibernatedForSurfaceYes(
       const GpuMemoryAllocation& alloc) {
     return !alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_not_visible <=
-               memmgr_.GetCurrentBackgroundedAvailableGpuMemory();
+               memmgr_.GetCurrentNonvisibleAvailableGpuMemory();
   }
   bool IsAllocationForegroundForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_visible ==
-               GetMinimumTabAllocation();
+               GetMinimumClientAllocation();
   }
   bool IsAllocationBackgroundForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_visible ==
-               GetMinimumTabAllocation();
+               GetMinimumClientAllocation();
   }
   bool IsAllocationHibernatedForSurfaceNo(
       const GpuMemoryAllocation& alloc) {
     return !alloc.browser_allocation.suggest_have_frontbuffer &&
            !alloc.renderer_allocation.have_backbuffer_when_not_visible &&
            alloc.renderer_allocation.bytes_limit_when_visible == 0;
   }
 
   void Manage() {
     ClientAssignmentCollector::ClearAllStats();
@@ skipping 11 matching lines @@
   size_t CalcAvailableClamped(size_t bytes) {
     bytes = std::max(bytes, memmgr_.GetDefaultAvailableGpuMemory());
     bytes = std::min(bytes, memmgr_.GetMaximumTotalGpuMemory());
     return bytes;
   }
 
   size_t GetAvailableGpuMemory() {
     return memmgr_.GetAvailableGpuMemory();
   }
 
-  size_t GetMaximumTabAllocation() {
-    return memmgr_.GetMaximumTabAllocation();
+  size_t GetMaximumClientAllocation() {
+    return memmgr_.GetMaximumClientAllocation();
   }
 
-  size_t GetMinimumTabAllocation() {
-    return memmgr_.GetMinimumTabAllocation();
+  size_t GetMinimumClientAllocation() {
+    return memmgr_.GetMinimumClientAllocation();
   }
 
   GpuMemoryManager memmgr_;
 };
 
 // Test GpuMemoryManager::Manage basic functionality.
 // Expect memory allocation to set suggest_have_frontbuffer/backbuffer
 // according to visibility and last used time for stubs with surface.
 // Expect memory allocation to be shared according to share groups for stubs
 // without a surface.
@@ skipping 200 matching lines @@
   Manage();
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub4.allocation_));
 }
 
 // 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
-// GetMinimumTabAllocation(), and when the number of tabs is large, each should
-// get exactly GetMinimumTabAllocation() and not less.
+// GetMinimumClientAllocation(), and when the number of tabs is large,
+// each should get exactly GetMinimumClientAllocation() and not less.
 TEST_F(GpuMemoryManagerTest, TestForegroundStubsGetBonusAllocation) {
   size_t max_stubs_before_no_bonus =
-      GetAvailableGpuMemory() / (GetMinimumTabAllocation() + 1);
+      GetAvailableGpuMemory() / (GetMinimumClientAllocation() + 1);
 
   std::vector<FakeClient*> stubs;
   for (size_t i = 0; i < max_stubs_before_no_bonus; ++i) {
     stubs.push_back(
         new FakeClient(&memmgr_, GenerateUniqueSurfaceId(), true));
   }
 
   Manage();
   for (size_t i = 0; i < stubs.size(); ++i) {
     EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stubs[i]->allocation_));
     EXPECT_GT(
         stubs[i]->allocation_.renderer_allocation.bytes_limit_when_visible,
-        static_cast<size_t>(GetMinimumTabAllocation()));
+        static_cast<size_t>(GetMinimumClientAllocation()));
   }
 
   FakeClient extra_stub(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   Manage();
   for (size_t i = 0; i < stubs.size(); ++i) {
     EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stubs[i]->allocation_));
     EXPECT_EQ(
         stubs[i]->allocation_.renderer_allocation.bytes_limit_when_visible,
-        GetMinimumTabAllocation());
+        GetMinimumClientAllocation());
   }
 
   for (size_t i = 0; i < max_stubs_before_no_bonus; ++i) {
     delete stubs[i];
   }
 }
 
 // Test GpuMemoryManager::UpdateAvailableGpuMemory functionality
 TEST_F(GpuMemoryManagerTest, TestUpdateAvailableGpuMemory) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
@@ skipping 92 matching lines @@
   EXPECT_EQ(stats.count(&stub1), 1ul);
   size_t stub1allocation2 =
       stats[&stub1].allocation.renderer_allocation.bytes_limit_when_visible;
   EXPECT_EQ(stats.count(&stub2), 1ul);
   size_t stub2allocation2 =
       stats[&stub2].allocation.renderer_allocation.bytes_limit_when_visible;
 
   EXPECT_EQ(stats.size(), 2ul);
   EXPECT_GT(stub1allocation2, 0ul);
   EXPECT_GT(stub2allocation2, 0ul);
-  if (stub1allocation2 != GetMaximumTabAllocation())
+  if (stub1allocation2 != GetMaximumClientAllocation())
     EXPECT_LT(stub1allocation2, stub1allocation1);
 
   FakeClient stub3(&memmgr_, GenerateUniqueSurfaceId(), true);
   Manage();
   stats = ClientAssignmentCollector::GetClientStatsForLastManage();
   size_t stub1allocation3 =
       stats[&stub1].allocation.renderer_allocation.bytes_limit_when_visible;
   size_t stub2allocation3 =
       stats[&stub2].allocation.renderer_allocation.bytes_limit_when_visible;
   size_t stub3allocation3 =
       stats[&stub3].allocation.renderer_allocation.bytes_limit_when_visible;
 
   EXPECT_EQ(stats.size(), 3ul);
   EXPECT_GT(stub1allocation3, 0ul);
   EXPECT_GT(stub2allocation3, 0ul);
   EXPECT_GT(stub3allocation3, 0ul);
-  if (stub1allocation3 != GetMaximumTabAllocation())
+  if (stub1allocation3 != GetMaximumClientAllocation())
     EXPECT_LT(stub1allocation3, stub1allocation2);
 
   stub1.SetVisible(false);
 
   Manage();
   stats = ClientAssignmentCollector::GetClientStatsForLastManage();
   size_t stub1allocation4 =
       stats[&stub1].allocation.renderer_allocation.bytes_limit_when_visible;
   size_t stub2allocation4 =
       stats[&stub2].allocation.renderer_allocation.bytes_limit_when_visible;
   size_t stub3allocation4 =
       stats[&stub3].allocation.renderer_allocation.bytes_limit_when_visible;
 
   EXPECT_EQ(stats.size(), 3ul);
   EXPECT_GT(stub1allocation4, 0ul);
   EXPECT_GE(stub2allocation4, 0ul);
   EXPECT_GT(stub3allocation4, 0ul);
-  if (stub3allocation3 != GetMaximumTabAllocation())
+  if (stub3allocation3 != GetMaximumClientAllocation())
     EXPECT_GT(stub3allocation4, stub3allocation3);
 }
 
 // Test GpuMemoryManager's managed memory tracking
 TEST_F(GpuMemoryManagerTest, TestManagedUsageTracking) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), false);
   EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Set memory allocations and verify the results are reflected.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 5, false));
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 7, false));
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Remove a visible client
   stub1.client_state_.reset();
   EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
   EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
   stub1.client_state_.reset(memmgr_.CreateClientState(&stub1, true, true));
   EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 5, false));
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
-  // Remove a backgrounded client
+  // Remove a nonvisible client
   stub2.client_state_.reset();
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_nonvisible_);
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_nonvisible_);
   stub2.client_state_.reset(memmgr_.CreateClientState(&stub2, true, false));
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(0ul, memmgr_.bytes_allocated_managed_nonvisible_);
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 7, false));
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Create and then destroy some stubs, and verify their allocations go away.
   {
     FakeClient stub3(&memmgr_, GenerateUniqueSurfaceId(), true),
                stub4(&memmgr_, GenerateUniqueSurfaceId(), false);
     stub3.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 1, false));
     stub4.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 2, false));
     EXPECT_EQ(6ul, memmgr_.bytes_allocated_managed_visible_);
-    EXPECT_EQ(9ul, memmgr_.bytes_allocated_managed_backgrounded_);
+    EXPECT_EQ(9ul, memmgr_.bytes_allocated_managed_nonvisible_);
   }
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Do no-op changes to stubs' visibility and make sure nothing chnages.
   stub1.SetVisible(true);
   stub2.SetVisible(false);
   EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Change visbility state.
   stub1.SetVisible(false);
   stub2.SetVisible(true);
   EXPECT_EQ(7ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(5ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Increase allocation amounts.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 6, false));
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 8, false));
   EXPECT_EQ(8ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(6ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(6ul, memmgr_.bytes_allocated_managed_nonvisible_);
 
   // Decrease allocation amounts.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 4, false));
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(0, 0, 6, false));
   EXPECT_EQ(6ul, memmgr_.bytes_allocated_managed_visible_);
-  EXPECT_EQ(4ul, memmgr_.bytes_allocated_managed_backgrounded_);
+  EXPECT_EQ(4ul, memmgr_.bytes_allocated_managed_nonvisible_);
 }
 
 // Test GpuMemoryManager's background cutoff threshoulds
 TEST_F(GpuMemoryManagerTest, TestBackgroundCutoff) {
   memmgr_.TestingSetAvailableGpuMemory(64);
-  memmgr_.TestingSetBackgroundedAvailableGpuMemory(16);
+  memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
 
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   // stub1's requirements are not <=16, so it should just dump
   // everything when it goes invisible.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(17, 24, 18, false));
   Manage();
   EXPECT_EQ(0ul, stub1.BytesWhenNotVisible());
 
   // stub1 now fits, so it should have a full budget.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(16, 24, 18, false));
   Manage();
-  EXPECT_EQ(memmgr_.bytes_backgrounded_available_gpu_memory_,
-            memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
+            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
 
   // Background stub1.
   stub1.SetManagedMemoryStats(GpuManagedMemoryStats(16, 24, 16, false));
   stub1.SetVisible(false);
 
   // Add stub2 that uses almost enough memory to evict
   // stub1, but not quite.
   FakeClient stub2(&memmgr_, GenerateUniqueSurfaceId(), true);
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(16, 50, 48, false));
   Manage();
-  EXPECT_EQ(memmgr_.bytes_backgrounded_available_gpu_memory_,
-            memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
+            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub2.BytesWhenNotVisible());
 
   // Increase stub2 to force stub1 to be evicted.
   stub2.SetManagedMemoryStats(GpuManagedMemoryStats(16, 50, 49, false));
   Manage();
   EXPECT_EQ(0ul,
             stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub2.BytesWhenNotVisible());
 }
 
 // Test GpuMemoryManager's background MRU behavior
 TEST_F(GpuMemoryManagerTest, TestBackgroundMru) {
   memmgr_.TestingSetAvailableGpuMemory(64);
-  memmgr_.TestingSetBackgroundedAvailableGpuMemory(16);
+  memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
 
   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 backgrounded.
+  // 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_backgrounded_available_gpu_memory_,
-            memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
+            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub3.BytesWhenNotVisible());
 
 
   // Background stubs 1 and 2, and they should fit
   stub2.SetVisible(false);
   stub1.SetVisible(false);
   Manage();
-  EXPECT_EQ(memmgr_.bytes_backgrounded_available_gpu_memory_,
-            memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
+            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub3.BytesWhenNotVisible());
 
   // 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_backgrounded_available_gpu_memory_,
-            memmgr_.GetCurrentBackgroundedAvailableGpuMemory());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.bytes_nonvisible_available_gpu_memory_,
+            memmgr_.GetCurrentNonvisibleAvailableGpuMemory());
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub1.BytesWhenNotVisible());
   EXPECT_EQ(0ul,
             stub2.BytesWhenNotVisible());
-  EXPECT_EQ(memmgr_.GetCurrentBackgroundedAvailableGpuMemory(),
+  EXPECT_EQ(memmgr_.GetCurrentNonvisibleAvailableGpuMemory(),
             stub3.BytesWhenNotVisible());
 }
 
 // Test GpuMemoryManager's tracking of unmanaged (e.g, WebGL) memory.
 TEST_F(GpuMemoryManagerTest, TestUnmanagedTracking) {
   memmgr_.TestingSetAvailableGpuMemory(64);
-  memmgr_.TestingSetBackgroundedAvailableGpuMemory(16);
+  memmgr_.TestingSetNonvisibleAvailableGpuMemory(16);
   memmgr_.TestingSetUnmanagedLimitStep(16);
   memmgr_.TestingSetMinimumClientAllocation(8);
 
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   // Expect that the one stub get the maximum tab allocation.
   Manage();
-  EXPECT_EQ(memmgr_.GetMaximumTabAllocation(),
+  EXPECT_EQ(memmgr_.GetMaximumClientAllocation(),
             stub1.BytesWhenVisible());
 
   // Now allocate some unmanaged memory and make sure the amount
   // goes down.
   memmgr_.TrackMemoryAllocatedChange(
       stub1.tracking_group_.get(),
       0,
       48,
       gpu::gles2::MemoryTracker::kUnmanaged);
   Manage();
-  EXPECT_GT(memmgr_.GetMaximumTabAllocation(),
+  EXPECT_GT(memmgr_.GetMaximumClientAllocation(),
             stub1.BytesWhenVisible());
 
   // Now allocate the entire FB worth of unmanaged memory, and
   // make sure that we stay stuck at the minimum tab allocation.
   memmgr_.TrackMemoryAllocatedChange(
       stub1.tracking_group_.get(),
       48,
       64,
       gpu::gles2::MemoryTracker::kUnmanaged);
   Manage();
-  EXPECT_EQ(memmgr_.GetMinimumTabAllocation(),
+  EXPECT_EQ(memmgr_.GetMinimumClientAllocation(),
             stub1.BytesWhenVisible());
 
   // Far-oversubscribe the entire FB, and make sure we stay at
   // the minimum allocation, and don't blow up.
   memmgr_.TrackMemoryAllocatedChange(
       stub1.tracking_group_.get(),
       64,
       999,
       gpu::gles2::MemoryTracker::kUnmanaged);
   Manage();
-  EXPECT_EQ(memmgr_.GetMinimumTabAllocation(),
+  EXPECT_EQ(memmgr_.GetMinimumClientAllocation(),
             stub1.BytesWhenVisible());
 
   // Delete all tracked memory so we don't hit leak checks.
   memmgr_.TrackMemoryAllocatedChange(
       stub1.tracking_group_.get(),
       999,
       0,
       gpu::gles2::MemoryTracker::kUnmanaged);
 }
 
 }  // namespace content