Color: Add SetColorSpace member to gfx::GpuMemoryBuffer

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 11 matching lines @@
 
 using ::testing::_;
 using ::testing::Expectation;
 using ::testing::Ne;
 using ::testing::Return;
 
 namespace display_compositor {
 
 class StubGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
-  StubGpuMemoryBufferImpl() {}
+  StubGpuMemoryBufferImpl(size_t* set_color_space_count)
+      : set_color_space_count_(set_color_space_count) {}
 
   // Overridden from gfx::GpuMemoryBuffer:
   bool Map() override { return false; }
   void* memory(size_t plane) override { return nullptr; }
   void Unmap() override {}
   gfx::Size GetSize() const override { return gfx::Size(); }
   gfx::BufferFormat GetFormat() const override {
     return gfx::BufferFormat::BGRX_8888;
   }
   int stride(size_t plane) const override { return 0; }
   gfx::GpuMemoryBufferId GetId() const override {
     return gfx::GpuMemoryBufferId(0);
   }
+  void SetColorSpaceForScanout(const gfx::ColorSpace& color_space) override {
+    *set_color_space_count_ += 1;
+  }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     return gfx::GpuMemoryBufferHandle();
   }
   ClientBuffer AsClientBuffer() override {
     return reinterpret_cast<ClientBuffer>(this);
   }
+
+  size_t* set_color_space_count_;
 };
 
 class StubGpuMemoryBufferManager : public cc::TestGpuMemoryBufferManager {
  public:
   StubGpuMemoryBufferManager() : allocate_succeeds_(true) {}
 
+  size_t set_color_space_count() const { return set_color_space_count_; }
+
   void set_allocate_succeeds(bool value) { allocate_succeeds_ = value; }
 
   std::unique_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
       const gfx::Size& size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       gpu::SurfaceHandle surface_handle) override {
     if (!surface_handle) {
       return TestGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
           size, format, usage, surface_handle);
     }
     if (allocate_succeeds_)
       return base::WrapUnique<gfx::GpuMemoryBuffer>(
-          new StubGpuMemoryBufferImpl);
+          new StubGpuMemoryBufferImpl(&set_color_space_count_));
     return nullptr;
   }
 
  private:
   bool allocate_succeeds_;
+  size_t set_color_space_count_ = 0;
 };
 
 #if defined(OS_WIN)
 const gpu::SurfaceHandle kFakeSurfaceHandle =
     reinterpret_cast<gpu::SurfaceHandle>(1);
 #else
 const gpu::SurfaceHandle kFakeSurfaceHandle = 1;
 #endif
 
 class MockBufferQueue : public BufferQueue {
@@ skipping 179 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);
+  output_surface->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
 }
 
 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 31 matching lines @@
   gpu_memory_buffer_manager.reset(new StubGpuMemoryBufferManager);
 
   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_RGBA, gl_helper.get(),
       gpu_memory_buffer_manager.get(), kFakeSurfaceHandle));
   output_surface->Initialize();
-  output_surface->Reshape(screen_size, 1.0f);
+  output_surface->Reshape(screen_size, 1.0f, gfx::ColorSpace());
   // 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);
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
   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);
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
   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);
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
   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);
+  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
   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);
+  output_surface_->Reshape(gfx::Size(10, 20), 1.0f, gfx::ColorSpace());
+  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());
 
   for (size_t i = 0; i < kSwapCount; ++i) {
     output_surface_->PageFlipComplete();
     EXPECT_FALSE(displayed_frame());
   }
 
   CheckUnique();
 
   for (size_t i = 0; i < kSwapCount; ++i) {
     unsigned int next_texture_id = in_flight_surfaces().front()->texture;
     output_surface_->PageFlipComplete();
     EXPECT_EQ(displayed_frame()->texture, next_texture_id);
     EXPECT_TRUE(displayed_frame());
   }
+
+  DCHECK_EQ(2 * kSwapCount,
+            gpu_memory_buffer_manager_->set_color_space_count());
+  for (size_t i = 0; i < kSwapCount; ++i) {
+    output_surface_->BindFramebuffer();
+    SwapBuffers();
+    output_surface_->PageFlipComplete();
+  }
+  DCHECK_EQ(2 * kSwapCount,
+            gpu_memory_buffer_manager_->set_color_space_count());
 }
 
 TEST_F(BufferQueueMockedContextTest, RecreateBuffers) {
   // This setup is to easily get one frame in each of:
   // - currently bound for drawing.
   // - in flight to GPU.
   // - currently displayed.
   // - free frame.
   // This tests buffers in all states.
   // Bind/swap pushes frames into the in flight list, then the PageFlipComplete
@@ skipping 58 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);
+  output_surface_->Reshape(screen_size, 1.0f, gfx::ColorSpace());
 
   // 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