Rename SurfaceState to MemoryManagerState

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 "ui/gfx/size_conversions.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 class FakeCommandBufferStub : public GpuCommandBufferStubBase {
  public:
-  SurfaceState surface_state_;
+  MemoryManagerState memory_manager_state_;
   GpuMemoryAllocation allocation_;
   gfx::Size size_;
 
   FakeCommandBufferStub()
-      : surface_state_(0, false, base::TimeTicks()) {
+      : memory_manager_state_(0, false, base::TimeTicks()) {
+    memory_manager_state_.client_has_memory_allocation_changed_callback = true;
   }
 
   FakeCommandBufferStub(int32 surface_id,
                         bool visible,
                         base::TimeTicks last_used_time)
-      : surface_state_(surface_id, visible, last_used_time) {
+      : memory_manager_state_(surface_id != 0, visible, last_used_time) {
+    memory_manager_state_.client_has_memory_allocation_changed_callback = true;
   }
 
-  virtual bool client_has_memory_allocation_changed_callback() const {
-    return true;
-  }
-  virtual bool has_surface_state() const {
-    return surface_state_.surface_id != 0;
-  }
-  virtual const SurfaceState& surface_state() const {
-    return surface_state_;
+  virtual const MemoryManagerState& memory_manager_state() const {
+    return memory_manager_state_;
   }
 
   virtual gfx::Size GetSurfaceSize() const {
     return size_;
   }
   virtual bool IsInSameContextShareGroup(
       const GpuCommandBufferStubBase& stub) const {
     return false;
   }
   virtual void SetMemoryAllocation(const GpuMemoryAllocation& alloc) {
     allocation_ = alloc;
   }
   virtual bool GetTotalGpuMemory(size_t* bytes) {
     return false;
   }
 };
 
 class FakeCommandBufferStubWithoutSurface : public GpuCommandBufferStubBase {
  public:
+  MemoryManagerState memory_manager_state_;
   GpuMemoryAllocation allocation_;
   std::vector<GpuCommandBufferStubBase*> share_group_;
 
-  FakeCommandBufferStubWithoutSurface() {
+  FakeCommandBufferStubWithoutSurface()
+      : memory_manager_state_(false, true, base::TimeTicks()) {
+    memory_manager_state_.client_has_memory_allocation_changed_callback = true;
   }
 
-  virtual bool client_has_memory_allocation_changed_callback() const {
-    return true;
-  }
-  virtual bool has_surface_state() const {
-    return false;
-  }
-  virtual const SurfaceState& surface_state() const {
-    NOTREACHED();
-    static SurfaceState* surface_state_;
-    return *surface_state_;
+  virtual const MemoryManagerState& memory_manager_state() const {
+    return memory_manager_state_;
   }
 
   virtual gfx::Size GetSurfaceSize() const {
     return gfx::Size();
   }
   virtual bool IsInSameContextShareGroup(
       const GpuCommandBufferStubBase& stub) const {
     return std::find(share_group_.begin(),
                      share_group_.end(),
                      &stub) != share_group_.end();
@@ skipping 217 matching lines @@
   stub5.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub5);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub4.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub5.allocation_));
 
-  stub1.surface_state_.visible = false;
-  stub2.surface_state_.visible = true;
+  stub1.memory_manager_state_.visible = false;
+  stub2.memory_manager_state_.visible = true;
 
   Manage();
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub4.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub5.allocation_));
 }
 
 // Test GpuMemoryManager::Manage functionality: Test more than threshold number
@@ skipping 90 matching lines @@
 
   Manage();
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub3.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub4.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub5.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub6.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub7.allocation_));
 
-  stub3.surface_state_.last_used_time = older_;
-  stub4.surface_state_.last_used_time = newer_;
+  stub3.memory_manager_state_.last_used_time = older_;
+  stub4.memory_manager_state_.last_used_time = newer_;
 
   Manage();
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub3.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub4.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub5.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub6.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub7.allocation_));
 }
@@ skipping 21 matching lines @@
   stub4.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub3);
   client_.stubs_.push_back(&stub4);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub4.allocation_));
 
-  stub1.surface_state_.visible = false;
+  stub1.memory_manager_state_.visible = false;
 
   Manage();
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub4.allocation_));
 
-  stub2.surface_state_.visible = false;
+  stub2.memory_manager_state_.visible = false;
 
   Manage();
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub4.allocation_));
 
-  stub1.surface_state_.last_used_time = older_;
+  stub1.memory_manager_state_.last_used_time = older_;
 
   Manage();
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub4.allocation_));
 
-  stub2.surface_state_.last_used_time = older_;
+  stub2.memory_manager_state_.last_used_time = older_;
 
   Manage();
   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:
@@ skipping 168 matching lines @@
   EXPECT_TRUE(stats[&stub1].visible);
   EXPECT_TRUE(stats[&stub2].visible);
   EXPECT_TRUE(stats[&stub3].visible);
   EXPECT_GT(stub1allocation3, 0ul);
   EXPECT_GT(stub2allocation3, 0ul);
   EXPECT_GT(stub3allocation3, 0ul);
   if (compositors_get_bonus_allocation &&
       stub1allocation3 != GetMaximumTabAllocation())
     EXPECT_LT(stub1allocation3, stub1allocation2);
 
-  stub1.surface_state_.visible = false;
+  stub1.memory_manager_state_.visible = false;
   Manage();
   stats = memory_manager_.stub_memory_stats_for_last_manage();
   size_t stub1allocation4 = stats[&stub1].allocation.gpu_resource_size_in_bytes;
   size_t stub2allocation4 = stats[&stub2].allocation.gpu_resource_size_in_bytes;
   size_t stub3allocation4 = stats[&stub3].allocation.gpu_resource_size_in_bytes;
 
   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 &&
       stub3allocation3 != GetMaximumTabAllocation())
     EXPECT_GT(stub3allocation4, stub3allocation3);
 }