ozone: Consolidate primary plane format.

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>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "components/display_compositor/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/display/types/display_snapshot.h"
 
 using ::testing::_;
 using ::testing::Expectation;
 using ::testing::Ne;
 using ::testing::Return;
 
 namespace display_compositor {
 
 class StubGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
@@ skipping 62 matching lines @@
 
 class MockBufferQueue : public BufferQueue {
  public:
   MockBufferQueue(gpu::gles2::GLES2Interface* gl,
                   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                   unsigned int target,
                   unsigned int internalformat)
       : BufferQueue(gl,
                     target,
                     internalformat,
+                    ui::DisplaySnapshot::PrimaryFormat(),
                     nullptr,
                     gpu_memory_buffer_manager,
                     kFakeSurfaceHandle) {}
   MOCK_METHOD4(CopyBufferDamage,
                void(int, int, const gfx::Rect&, const gfx::Rect&));
 };
 
 class BufferQueueTest : public ::testing::Test {
  public:
   BufferQueueTest() : doublebuffering_(true), first_frame_(true) {}
 
   void SetUp() override {
     InitWithContext(cc::TestWebGraphicsContext3D::Create());
   }
 
   void InitWithContext(std::unique_ptr<cc::TestWebGraphicsContext3D> context) {
     context_provider_ = cc::TestContextProvider::Create(std::move(context));
     context_provider_->BindToCurrentThread();
     gpu_memory_buffer_manager_.reset(new StubGpuMemoryBufferManager);
     mock_output_surface_ = new MockBufferQueue(context_provider_->ContextGL(),
                                                gpu_memory_buffer_manager_.get(),
-                                               GL_TEXTURE_2D, GL_RGBA);
+                                               GL_TEXTURE_2D, GL_RGB);
     output_surface_.reset(mock_output_surface_);
     output_surface_->Initialize();
   }
 
   unsigned current_surface() {
     return output_surface_->current_surface_
                ? output_surface_->current_surface_->image
                : 0;
   }
   const std::vector<std::unique_ptr<BufferQueue::AllocatedSurface>>&
@@ skipping 119 matching lines @@
       cc::TestContextProvider::Create(std::move(owned_context));
   context_provider->BindToCurrentThread();
   return context_provider;
 }
 
 std::unique_ptr<BufferQueue> CreateBufferQueue(
     unsigned int target,
     gpu::gles2::GLES2Interface* gl,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
   std::unique_ptr<BufferQueue> buffer_queue(
-      new BufferQueue(gl, target, GL_RGBA, nullptr, gpu_memory_buffer_manager,
-                      kFakeSurfaceHandle));
+      new BufferQueue(gl, target, GL_RGB, ui::DisplaySnapshot::PrimaryFormat(),
+                      nullptr, gpu_memory_buffer_manager, kFakeSurfaceHandle));
   buffer_queue->Initialize();
   return buffer_queue;
 }
 
 TEST(BufferQueueStandaloneTest, FboInitialization) {
   MockedContext* context;
   scoped_refptr<cc::TestContextProvider> context_provider =
       CreateMockedContextProvider(&context);
   std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager(
       new StubGpuMemoryBufferManager);
@@ skipping 17 matching lines @@
     scoped_refptr<cc::TestContextProvider> context_provider =
         CreateMockedContextProvider(&context);
     std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager(
         new StubGpuMemoryBufferManager);
     std::unique_ptr<BufferQueue> output_surface = CreateBufferQueue(
         target, context_provider->ContextGL(), gpu_memory_buffer_manager.get());
 
     EXPECT_CALL(*context, bindTexture(target, Ne(0U)));
     EXPECT_CALL(*context, destroyImageCHROMIUM(1));
     Expectation image =
-        EXPECT_CALL(*context, createImageCHROMIUM(_, 0, 0, GL_RGBA))
+        EXPECT_CALL(*context, createImageCHROMIUM(_, 0, 0, GL_RGB))
             .WillOnce(Return(1));
     Expectation fb =
         EXPECT_CALL(*context, bindFramebuffer(GL_FRAMEBUFFER, Ne(0U)));
     Expectation tex = EXPECT_CALL(*context, bindTexture(target, Ne(0U)));
     Expectation bind_tex =
         EXPECT_CALL(*context, bindTexImage2DCHROMIUM(target, 1))
             .After(tex, image);
     EXPECT_CALL(*context,
                 framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                      target, Ne(0U), _))
         .After(fb, bind_tex);
 
     output_surface->BindFramebuffer();
   }
 }
 
 TEST(BufferQueueStandaloneTest, CheckBoundFramebuffer) {
   scoped_refptr<cc::TestContextProvider> context_provider =
       cc::TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager;
   std::unique_ptr<BufferQueue> output_surface;
   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.reset(
+      new BufferQueue(context_provider->ContextGL(), GL_TEXTURE_2D, GL_RGB,
+                      ui::DisplaySnapshot::PrimaryFormat(), gl_helper.get(),
+                      gpu_memory_buffer_manager.get(), kFakeSurfaceHandle));
   output_surface->Initialize();
   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;
@@ skipping 228 matching lines @@
   EXPECT_TRUE(displayed_frame());
   EXPECT_TRUE(current_frame());
 
   auto* current = current_frame();
   auto* displayed = displayed_frame();
   auto* in_flight = in_flight_surfaces().front().get();
   auto* available = available_surfaces().front().get();
 
   // Expect all 4 images to be destroyed, 3 of the existing textures to be
   // copied from and 3 new images to be created.
-  EXPECT_CALL(*context_, createImageCHROMIUM(_, 0, 0, GL_RGBA)).Times(3);
+  EXPECT_CALL(*context_, createImageCHROMIUM(_, 0, 0, GL_RGB)).Times(3);
   Expectation copy1 = EXPECT_CALL(*mock_output_surface_,
                                   CopyBufferDamage(_, displayed->texture, _, _))
                           .Times(1);
   Expectation copy2 = EXPECT_CALL(*mock_output_surface_,
                                   CopyBufferDamage(_, current->texture, _, _))
                           .Times(1);
   Expectation copy3 = EXPECT_CALL(*mock_output_surface_,
                                   CopyBufferDamage(_, in_flight->texture, _, _))
                           .Times(1);
 
@@ skipping 73 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