Splitting GpuMemoryAllocation into two parts: for renderer and browser

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 155 matching lines @@
   // Older should never be more important than newer:
   EXPECT_FALSE(is_more_important(&stub_true1, &stub_true2));
   EXPECT_FALSE(is_more_important(&stub_true1, &stub_true3));
   EXPECT_FALSE(is_more_important(&stub_true2, &stub_true3));
   EXPECT_FALSE(is_more_important(&stub_false1, &stub_false2));
   EXPECT_FALSE(is_more_important(&stub_false1, &stub_false3));
   EXPECT_FALSE(is_more_important(&stub_false2, &stub_false3));
 }
 
 // Test GpuMemoryManager::Manage basic functionality.
-// Expect memory allocation to set has_frontbuffer, has_backbuffer according
+// 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 stubs with surface.
   FakeCommandBufferStub stub1(GenerateUniqueSurfaceId(), true, older_),
                         stub2(GenerateUniqueSurfaceId(), false, older_);
   client_.stubs_.push_back(&stub1);
   client_.stubs_.push_back(&stub2);
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
 
   // Test stubs without surface, with share group of 1 stub.
   FakeCommandBufferStubWithoutSurface stub3, stub4;
   stub3.share_group_.push_back(&stub1);
   stub4.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub3);
   client_.stubs_.push_back(&stub4);
 
   Manage();
   EXPECT_EQ(stub1.allocation_, stub3.allocation_);
   EXPECT_EQ(stub2.allocation_, stub4.allocation_);
 
   // Test stub without surface, with share group of multiple stubs.
   FakeCommandBufferStubWithoutSurface stub5;
   stub5.share_group_.push_back(&stub1);
   stub5.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub5);
 
   Manage();
   EXPECT_EQ(stub1.allocation_, stub5.allocation_);
 }
 
 // Test GpuMemoryManager::Manage functionality: changing visibility.
-// Expect memory allocation to set has_frontbuffer, has_backbuffer according
+// 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) {
   FakeCommandBufferStub stub1(GenerateUniqueSurfaceId(), true, older_),
                         stub2(GenerateUniqueSurfaceId(), false, older_);
   client_.stubs_.push_back(&stub1);
   client_.stubs_.push_back(&stub2);
 
   FakeCommandBufferStubWithoutSurface stub3, stub4;
   stub3.share_group_.push_back(&stub1);
   stub4.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub3);
   client_.stubs_.push_back(&stub4);
 
   FakeCommandBufferStubWithoutSurface stub5;
   stub5.share_group_.push_back(&stub1);
   stub5.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub5);
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub1.allocation_, stub3.allocation_);
   EXPECT_EQ(stub2.allocation_, stub4.allocation_);
   EXPECT_EQ(stub1.allocation_, stub5.allocation_);
 
   stub1.surface_state_.visible = false;
   stub2.surface_state_.visible = true;
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, true);
   EXPECT_EQ(stub1.allocation_, stub3.allocation_);
   EXPECT_EQ(stub2.allocation_, stub4.allocation_);
   EXPECT_EQ(stub2.allocation_, 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) {
   FakeCommandBufferStub stub1(GenerateUniqueSurfaceId(), true, older_),
@@ skipping 10 matching lines @@
   stub6.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub5);
   client_.stubs_.push_back(&stub6);
 
   FakeCommandBufferStubWithoutSurface stub7;
   stub7.share_group_.push_back(&stub1);
   stub7.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub7);
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub3.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub3.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub4.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub4.allocation_.has_backbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub3.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub3.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub4.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub4.allocation_.suggest_have_backbuffer, true);
   EXPECT_EQ(stub5.allocation_, stub1.allocation_);
   EXPECT_EQ(stub6.allocation_, stub2.allocation_);
   EXPECT_EQ(stub7.allocation_, stub1.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) {
   FakeCommandBufferStub stub1(GenerateUniqueSurfaceId(), false, newer_),
@@ skipping 10 matching lines @@
   stub6.share_group_.push_back(&stub4);
   client_.stubs_.push_back(&stub5);
   client_.stubs_.push_back(&stub6);
 
   FakeCommandBufferStubWithoutSurface stub7;
   stub7.share_group_.push_back(&stub1);
   stub7.share_group_.push_back(&stub4);
   client_.stubs_.push_back(&stub7);
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub3.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub3.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub4.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub4.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub3.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub3.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub4.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub4.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub5.allocation_, stub1.allocation_);
   EXPECT_EQ(stub6.allocation_, stub4.allocation_);
   EXPECT_EQ(stub7.allocation_, stub1.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) {
   FakeCommandBufferStub stub1(GenerateUniqueSurfaceId(), false, newer_),
@@ skipping 10 matching lines @@
   stub6.share_group_.push_back(&stub4);
   client_.stubs_.push_back(&stub5);
   client_.stubs_.push_back(&stub6);
 
   FakeCommandBufferStubWithoutSurface stub7;
   stub7.share_group_.push_back(&stub3);
   stub7.share_group_.push_back(&stub4);
   client_.stubs_.push_back(&stub7);
 
   Manage();
-  EXPECT_EQ(stub3.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub3.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub4.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub4.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub3.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub3.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub4.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub4.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub5.allocation_, stub3.allocation_);
   EXPECT_EQ(stub6.allocation_, stub4.allocation_);
   EXPECT_EQ(stub7.allocation_, stub3.allocation_);
 
   stub3.surface_state_.last_used_time = older_;
   stub4.surface_state_.last_used_time = newer_;
 
   Manage();
-  EXPECT_EQ(stub3.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub3.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub4.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub4.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub3.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub3.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub4.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub4.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub5.allocation_, stub3.allocation_);
   EXPECT_EQ(stub6.allocation_, stub4.allocation_);
   EXPECT_EQ(stub7.allocation_, stub4.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) {
@@ skipping 10 matching lines @@
 
   FakeCommandBufferStubWithoutSurface stub3, stub4;
   stub3.share_group_.push_back(&stub1);
   stub3.share_group_.push_back(&stub2);
   stub4.share_group_.push_back(&stub1);
   stub4.share_group_.push_back(&stub2);
   client_.stubs_.push_back(&stub3);
   client_.stubs_.push_back(&stub4);
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, true);
   EXPECT_EQ(stub3.allocation_, stub1.allocation_);
   EXPECT_EQ(stub3.allocation_, stub2.allocation_);
   EXPECT_EQ(stub4.allocation_, stub1.allocation_);
   EXPECT_EQ(stub4.allocation_, stub2.allocation_);
 
   stub1.surface_state_.visible = false;
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, true);
   EXPECT_NE(stub3.allocation_, stub1.allocation_);
   EXPECT_EQ(stub3.allocation_, stub2.allocation_);
   EXPECT_NE(stub4.allocation_, stub1.allocation_);
   EXPECT_EQ(stub4.allocation_, stub2.allocation_);
 
   stub2.surface_state_.visible = false;
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub3.allocation_, stub1.allocation_);
   EXPECT_EQ(stub3.allocation_, stub2.allocation_);
   EXPECT_EQ(stub4.allocation_, stub1.allocation_);
   EXPECT_EQ(stub4.allocation_, stub2.allocation_);
 
   stub1.surface_state_.last_used_time = older_;
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, true);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, true);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
   EXPECT_NE(stub3.allocation_, stub1.allocation_);
   EXPECT_EQ(stub3.allocation_, stub2.allocation_);
   EXPECT_NE(stub4.allocation_, stub1.allocation_);
   EXPECT_EQ(stub4.allocation_, stub2.allocation_);
 
   stub2.surface_state_.last_used_time = older_;
 
   Manage();
-  EXPECT_EQ(stub1.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub1.allocation_.has_backbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_frontbuffer, false);
-  EXPECT_EQ(stub2.allocation_.has_backbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub1.allocation_.suggest_have_backbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_frontbuffer, false);
+  EXPECT_EQ(stub2.allocation_.suggest_have_backbuffer, false);
   EXPECT_EQ(stub3.allocation_, stub1.allocation_);
   EXPECT_EQ(stub3.allocation_, stub2.allocation_);
   EXPECT_EQ(stub4.allocation_, stub1.allocation_);
   EXPECT_EQ(stub4.allocation_, stub2.allocation_);
 }
+
+// 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) {
+  int gpu_resource_size_in_bytes_values[] = { 0, 1, 12345678 };
+  bool suggest_have_backbuffer_values[] = { false, true };
+  bool suggest_have_frontbuffer_values[] = { false, true };
+
+  for(int* sz = &gpu_resource_size_in_bytes_values[0];
+      sz != &gpu_resource_size_in_bytes_values[3]; ++sz) {
+    for(bool* shbb = &suggest_have_backbuffer_values[0];
+        shbb != &suggest_have_backbuffer_values[2]; ++shbb) {
+      for(bool* shfb = &suggest_have_frontbuffer_values[0];
+          shfb != &suggest_have_frontbuffer_values[2]; ++shfb) {
+        GpuMemoryAllocation allocation(*sz, *shbb, *shfb);
+        EXPECT_EQ(allocation, GpuMemoryAllocation(*sz, *shbb, *shfb));
+        EXPECT_NE(allocation, GpuMemoryAllocation(*sz+1, *shbb, *shfb));
+        EXPECT_NE(allocation, GpuMemoryAllocation(*sz, !*shbb, *shfb));
+        EXPECT_NE(allocation, GpuMemoryAllocation(*sz, *shbb, !*shfb));
+      }
+    }
+  }
+}