Introduce components/display_compositor

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 "content/browser/compositor/buffer_queue.h"
+#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 "content/browser/compositor/gl_helper.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"
 
 using ::testing::_;
 using ::testing::Expectation;
 using ::testing::Ne;
 using ::testing::Return;
 
-namespace content {
+namespace display_compositor {
 
 class StubGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
   StubGpuMemoryBufferImpl() {}
 
   // 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(); }
@@ skipping 216 matching lines @@
       GL_TEXTURE_2D, &context, 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);
 }
 
 TEST(BufferQueueStandaloneTest, FboBinding) {
-  GLenum targets[] = { GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB };
+  GLenum targets[] = {GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB};
   for (size_t i = 0; i < 2; ++i) {
     GLenum target = targets[i];
     MockedContext* context;
     std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager(
         new StubGpuMemoryBufferManager);
     std::unique_ptr<BufferQueue> output_surface = CreateOutputSurfaceWithMock(
         target, &context, 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))
             .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), _))
+    EXPECT_CALL(*context,
+                framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                     target, Ne(0U), _))
         .After(fb, bind_tex);
 
     output_surface->BindFramebuffer();
   }
 }
 
 TEST(BufferQueueStandaloneTest, CheckBoundFramebuffer) {
   std::unique_ptr<StubGpuMemoryBufferManager> gpu_memory_buffer_manager;
   std::unique_ptr<BufferQueue> output_surface;
   scoped_refptr<cc::TestContextProvider> context_provider =
@@ skipping 20 matching lines @@
   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);
   ASSERT_TRUE(doublebuffering_);
   EXPECT_CALL(*mock_output_surface_,
-              CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
+              CopyBufferDamage(_, _, small_damage, screen_rect))
+      .Times(1);
   EXPECT_CALL(*mock_output_surface_,
-              CopyBufferDamage(_, _, small_damage, small_damage)).Times(1);
+              CopyBufferDamage(_, _, small_damage, small_damage))
+      .Times(1);
   EXPECT_CALL(*mock_output_surface_,
-              CopyBufferDamage(_, _, large_damage, small_damage)).Times(1);
+              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);
   ASSERT_TRUE(doublebuffering_);
   EXPECT_CALL(*mock_output_surface_,
-              CopyBufferDamage(_, _, small_damage, screen_rect)).Times(1);
+              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);
   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);
+              CopyBufferDamage(_, _, small_damage, screen_rect))
+      .Times(1);
+  EXPECT_CALL(*mock_output_surface_,
+              CopyBufferDamage(_, _, overlapping_damage, small_damage))
+      .Times(1);
 
   SendFullFrame();
   SendDamagedFrame(small_damage);
   SendDamagedFrame(overlapping_damage);
   EXPECT_EQ(next_frame()->damage, overlapping_damage);
 }
 
 TEST_F(BufferQueueTest, MultipleBindCalls) {
   // Check that multiple bind calls do not create or change surfaces.
   output_surface_->BindFramebuffer();
@@ skipping 250 matching lines @@
   target_texture = current_frame()->texture;
   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 content
+}  // namespace display_compositor