Move gpu memory calculations to Compositor.

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_manager.h"
 
 #include "content/common/gpu/gpu_memory_manager_client.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 89 matching lines @@
     client_state_.reset(
         memmgr_->CreateClientState(this, surface_id != 0, visible));
   }
 
   ~FakeClient() override {
     client_state_.reset();
     tracking_group_.reset();
     memory_tracker_ = NULL;
   }
 
-  void SetMemoryAllocation(const MemoryAllocation& alloc) override {
-    allocation_ = alloc;
-    ClientAssignmentCollector::AddClientStat(this, alloc);
-  }
-
   void SuggestHaveFrontBuffer(bool suggest_have_frontbuffer) override {
     suggest_have_frontbuffer_ = suggest_have_frontbuffer;
   }
 
   bool GetTotalGpuMemory(uint64* bytes) override {
     if (total_gpu_memory_) {
       *bytes = total_gpu_memory_;
       return true;
     }
     return false;
@@ skipping 60 matching lines @@
   }
 
   void Manage() {
     ClientAssignmentCollector::ClearAllStats();
     memmgr_.Manage();
   }
 
   GpuMemoryManager memmgr_;
 };
 
+// Disabled, as gpumemorymanager doesnt do much work now.
+// TODO(sohanjg): Clean up as part of crbug.com/537563.

[piman, 2015/09/30 19:04:33]

Just delete all of them instead? They don't provide any value any more, and will
disappear anyway.

[sohanjg, 2015/10/01 07:14:13]

Done.

+
 // 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.
-TEST_F(GpuMemoryManagerTest, TestManageBasicFunctionality) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageBasicFunctionality) {
   // Test stubs with surface.
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), false);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
 
   // Test stubs without surface, with share group of 1 stub.
   FakeClient stub3(&memmgr_, &stub1), stub4(&memmgr_, &stub2);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub4.allocation_));
 
   // Test stub without surface, with share group of multiple stubs.
   FakeClient stub5(&memmgr_ , &stub2);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub4.allocation_));
 }
 
 // Test GpuMemoryManager::Manage functionality: changing visibility.
 // 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.
-TEST_F(GpuMemoryManagerTest, TestManageChangingVisibility) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageChangingVisibility) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), false);
 
   FakeClient stub3(&memmgr_, &stub1), stub4(&memmgr_, &stub2);
   FakeClient stub5(&memmgr_ , &stub2);
 
   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.SetVisible(false);
   stub2.SetVisible(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
 // of visible stubs.
 // Expect all allocations to continue to have frontbuffer.
-TEST_F(GpuMemoryManagerTest, TestManageManyVisibleStubs) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageManyVisibleStubs) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub3(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub4(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   FakeClient stub5(&memmgr_ , &stub1), stub6(&memmgr_ , &stub2);
   FakeClient stub7(&memmgr_ , &stub2);
 
   Manage();
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub3.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceYes(stub4.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub5.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub6.allocation_));
   EXPECT_TRUE(IsAllocationForegroundForSurfaceNo(stub7.allocation_));
 }
 
 // Test GpuMemoryManager::Manage functionality: Test more than threshold number
 // of not visible stubs.
 // Expect the stubs surpassing the threshold to not have a backbuffer.
-TEST_F(GpuMemoryManagerTest, TestManageManyNotVisibleStubs) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageManyNotVisibleStubs) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub3(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub4(&memmgr_, GenerateUniqueSurfaceId(), true);
   stub4.SetVisible(false);
   stub3.SetVisible(false);
   stub2.SetVisible(false);
   stub1.SetVisible(false);
 
   FakeClient stub5(&memmgr_ , &stub1), stub6(&memmgr_ , &stub4);
   FakeClient stub7(&memmgr_ , &stub1);
 
   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_));
 }
 
 // Test GpuMemoryManager::Manage functionality: Test changing the last used
 // time of stubs when doing so causes change in which stubs surpass threshold.
 // Expect frontbuffer to be dropped for the older stub.
-TEST_F(GpuMemoryManagerTest, TestManageChangingLastUsedTime) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageChangingLastUsedTime) {
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub3(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub4(&memmgr_, GenerateUniqueSurfaceId(), true);
 
   FakeClient stub5(&memmgr_ , &stub3), stub6(&memmgr_ , &stub4);
   FakeClient stub7(&memmgr_ , &stub3);
 
   // Make stub4 be the least-recently-used client
   stub4.SetVisible(false);
@@ skipping 23 matching lines @@
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceYes(stub4.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub5.allocation_));
   EXPECT_TRUE(IsAllocationBackgroundForSurfaceNo(stub6.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub7.allocation_));
 }
 
 // Test GpuMemoryManager::Manage functionality: Test changing importance of
 // enough stubs so that every stub in share group crosses threshold.
 // Expect memory allocation of the stubs without surface to share memory
 // allocation with the most visible stub in share group.
-TEST_F(GpuMemoryManagerTest, TestManageChangingImportanceShareGroup) {
+TEST_F(GpuMemoryManagerTest, DISABLED_TestManageChangingImportanceShareGroup) {
   FakeClient stub_ignore_a(&memmgr_, GenerateUniqueSurfaceId(), true),
              stub_ignore_b(&memmgr_, GenerateUniqueSurfaceId(), false),
              stub_ignore_c(&memmgr_, GenerateUniqueSurfaceId(), false);
   FakeClient stub1(&memmgr_, GenerateUniqueSurfaceId(), false),
              stub2(&memmgr_, GenerateUniqueSurfaceId(), false);
 
   FakeClient stub3(&memmgr_, &stub2), stub4(&memmgr_, &stub2);
 
   // stub1 and stub2 keep their non-hibernated state because they're
   // either visible or the 2 most recently used clients (through the
@@ skipping 37 matching lines @@
   stub_ignore_c.SetVisible(true);
   stub_ignore_c.SetVisible(false);
   Manage();
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub1.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceYes(stub2.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub3.allocation_));
   EXPECT_TRUE(IsAllocationHibernatedForSurfaceNo(stub4.allocation_));
 }
 
 }  // namespace content