cc: Implement overdraw feedback debugging feature.

components/display_compositor/buffer_queue_unittest.cc

 // Copyright 2014 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 "components/display_compositor/buffer_queue.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 266 matching lines @@
   std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager(
       new StubGpuMemoryBufferManager);
   std::unique_ptr<BufferQueue> output_surface =
       CreateBufferQueue(GL_TEXTURE_2D, context_provider->ContextGL(),
                         gpu_memory_buffer_manager.get());
 
   EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
   ON_CALL(*context, framebufferTexture2D(_, _, _, _, _))
       .WillByDefault(Return());
 
-  output_surface->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
+  output_surface->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace(), false);
 }
 
 TEST(BufferQueueStandaloneTest, FboBinding) {
   GLenum targets[] = {GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB};
   for (size_t i = 0; i < 2; ++i) {
     GLenum target = targets[i];
 
     MockedContext* context;
     scoped_refptr<cc::TestContextProvider> context_provider =
         CreateMockedContextProvider(&context);
@@ skipping 32 matching lines @@
 
   std::unique_ptr<GLHelper> gl_helper;
   gl_helper.reset(new GLHelper(context_provider->ContextGL(),
                                context_provider->ContextSupport()));
 
   output_surface.reset(new BufferQueue(
       context_provider->ContextGL(), GL_TEXTURE_2D, GL_RGB,
       display::DisplaySnapshot::PrimaryFormat(), gl_helper.get(),
       gpu_memory_buffer_manager.get(), kFakeSurfaceHandle));
   output_surface->Initialize();
-  output_surface->Reshape(screen_size, 1.0f, gfx::ColorSpace());
+  output_surface->Reshape(screen_size, 1.0f, gfx::ColorSpace(), false);
   // Trigger a sub-buffer copy to exercise all paths.
   output_surface->BindFramebuffer();
   output_surface->SwapBuffers(screen_rect);
   output_surface->PageFlipComplete();
   output_surface->BindFramebuffer();
   output_surface->SwapBuffers(small_damage);
 
   int current_fbo = 0;
   context_provider->ContextGL()->GetIntegerv(GL_FRAMEBUFFER_BINDING,
                                              &current_fbo);
   EXPECT_EQ(static_cast<int>(output_surface->fbo()), current_fbo);
 }
 
 TEST_F(BufferQueueTest, PartialSwapReuse) {
-  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace(), false);
   ASSERT_TRUE(doublebuffering_);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, small_damage, screen_rect))
       .Times(1);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, small_damage, small_damage))
       .Times(1);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, large_damage, small_damage))
       .Times(1);
   SendFullFrame();
   SendDamagedFrame(small_damage);
   SendDamagedFrame(small_damage);
   SendDamagedFrame(large_damage);
   // Verify that the damage has propagated.
   EXPECT_EQ(next_frame()->damage, large_damage);
 }
 
 TEST_F(BufferQueueTest, PartialSwapFullFrame) {
-  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace(), false);
   ASSERT_TRUE(doublebuffering_);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, small_damage, screen_rect))
       .Times(1);
   SendFullFrame();
   SendDamagedFrame(small_damage);
   SendFullFrame();
   SendFullFrame();
   EXPECT_EQ(next_frame()->damage, screen_rect);
 }
 
 TEST_F(BufferQueueTest, PartialSwapOverlapping) {
-  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace(), false);
   ASSERT_TRUE(doublebuffering_);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, small_damage, screen_rect))
       .Times(1);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(_, _, overlapping_damage, small_damage))
       .Times(1);
 
   SendFullFrame();
   SendDamagedFrame(small_damage);
@@ skipping 89 matching lines @@
   }
 }
 
 TEST_F(BufferQueueTest, ReshapeWithInFlightSurfaces) {
   const size_t kSwapCount = 3;
   for (size_t i = 0; i < kSwapCount; ++i) {
     output_surface_->BindFramebuffer();
     SwapBuffers();
   }
 
-  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace(), false);
   EXPECT_EQ(3u, in_flight_surfaces().size());
 
   for (size_t i = 0; i < kSwapCount; ++i) {
     output_surface_->PageFlipComplete();
     EXPECT_FALSE(displayed_frame());
   }
 
   // The dummy surfacess left should be discarded.
   EXPECT_EQ(0u, available_surfaces().size());
 }
 
 TEST_F(BufferQueueTest, SwapAfterReshape) {
   DCHECK_EQ(0u, gpu_memory_buffer_manager_->set_color_space_count());
   const size_t kSwapCount = 3;
   for (size_t i = 0; i < kSwapCount; ++i) {
     output_surface_->BindFramebuffer();
     SwapBuffers();
   }
   DCHECK_EQ(kSwapCount, gpu_memory_buffer_manager_->set_color_space_count());
 
-  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace(), false);
   DCHECK_EQ(kSwapCount, gpu_memory_buffer_manager_->set_color_space_count());
 
   for (size_t i = 0; i < kSwapCount; ++i) {
     output_surface_->BindFramebuffer();
     SwapBuffers();
   }
   DCHECK_EQ(2 * kSwapCount,
             gpu_memory_buffer_manager_->set_color_space_count());
   EXPECT_EQ(2 * kSwapCount, in_flight_surfaces().size());
 
@@ skipping 91 matching lines @@
 
   // All free buffers should be destroyed, the remaining buffers should all
   // be replaced but still valid.
   EXPECT_EQ(1U, in_flight_surfaces().size());
   EXPECT_EQ(0U, available_surfaces().size());
   EXPECT_TRUE(displayed_frame());
   EXPECT_TRUE(current_frame());
 }
 
 TEST_F(BufferQueueTest, AllocateFails) {
-  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace(), false);
 
   // Succeed in the two swaps.
   output_surface_->BindFramebuffer();
   EXPECT_TRUE(current_frame());
   output_surface_->SwapBuffers(screen_rect);
 
   // Fail the next surface allocation.
   gpu_memory_buffer_manager_->set_allocate_succeeds(false);
   output_surface_->BindFramebuffer();
   EXPECT_FALSE(current_frame());
@@ skipping 29 matching lines @@
   testing::Mock::VerifyAndClearExpectations(mock_output_surface_);
   EXPECT_CALL(*mock_output_surface_,
               CopyBufferDamage(target_texture, source_texture, small_damage, _))
       .Times(1);
   output_surface_->SwapBuffers(small_damage);
   testing::Mock::VerifyAndClearExpectations(mock_output_surface_);
 }
 
 }  // namespace
 }  // namespace display_compositor