Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 31 matching lines @@
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_internals_for_test.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/skia_common.h"
-#include "cc/test/test_delegating_output_surface.h"
+#include "cc/test/test_compositor_frame_sink.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/transform_node.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 365 matching lines @@
   bool did_notify_ready_to_draw_;
   bool did_draw_;
 };
 
 // Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
 // single threaded mode.
 SINGLE_THREAD_TEST_F(LayerTreeHostTestReadyToDrawVisibility);
 
 class LayerTreeHostContextCacheTest : public LayerTreeHostTest {
  public:
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     // Create the main ContextProvider with a MockContextSupport.
     auto main_support = base::MakeUnique<MockContextSupport>();
     mock_main_context_support_ = main_support.get();
     auto test_main_context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(main_support));
 
     // Create the main ContextProvider with a MockContextSupport.
     auto worker_support = base::MakeUnique<MockContextSupport>();
     mock_worker_context_support_ = worker_support.get();
     auto test_worker_context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(worker_support));
     test_worker_context_provider->BindToCurrentThread();
 
     // At init, visibility is set to true, so SetAggressivelyFreeResources will
     // be disabled.
     EXPECT_CALL(*mock_main_context_support_,
                 SetAggressivelyFreeResources(false));
     EXPECT_CALL(*mock_worker_context_support_,
                 SetAggressivelyFreeResources(false));
 
-    return LayerTreeHostTest::CreateDelegatingOutputSurface(
+    return LayerTreeHostTest::CreateCompositorFrameSink(
         std::move(test_main_context_provider),
         std::move(test_worker_context_provider));
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void BeginTest() override {}
@@ skipping 112 matching lines @@
 
     // Ensure that our initialization expectations have completed.
     Mock::VerifyAndClearExpectations(mock_main_context_support_);
     Mock::VerifyAndClearExpectations(mock_worker_context_support_);
 
     // Output surface lost expectations.
     EXPECT_CALL(*mock_worker_context_support_,
                 SetAggressivelyFreeResources(true));
     EXPECT_CALL(*mock_main_context_support_,
                 SetAggressivelyFreeResources(true));
-    host_impl->DidLoseOutputSurface();
+    host_impl->DidLoseCompositorFrameSink();
     has_recreated_ = true;
   }
 
-  void DidInitializeOutputSurface() override {
+  void DidInitializeCompositorFrameSink() override {
     // This is run after we have recreated our OutputSurface.
     if (!has_recreated_)
       return;
 
     // Ensure that our initialization expectations have completed.
     Mock::VerifyAndClearExpectations(mock_main_context_support_);
     Mock::VerifyAndClearExpectations(mock_worker_context_support_);
 
     // Destruction exptectations.
     EXPECT_CALL(*mock_worker_context_support_,
@@ skipping 2104 matching lines @@
     EXPECT_EQ(commit_count_, 5);
     EXPECT_EQ(commit_abort_count_, 3);
     EXPECT_EQ(commit_complete_count_, 2);
   }
 
   int commit_count_;
   int commit_abort_count_;
   int commit_complete_count_;
 };
 
-class OnDrawOutputSurface : public TestDelegatingOutputSurface {
+class OnDrawCompositorFrameSink : public TestCompositorFrameSink {
  public:
-  explicit OnDrawOutputSurface(
+  explicit OnDrawCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider,
       std::unique_ptr<OutputSurface> display_output_surface,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       const RendererSettings& renderer_settings,
       base::SingleThreadTaskRunner* task_runner,
       bool synchronous_composite,
       bool force_disable_reclaim_resources,
       base::Closure invalidate_callback)
-      : TestDelegatingOutputSurface(std::move(compositor_context_provider),
-                                    std::move(worker_context_provider),
-                                    std::move(display_output_surface),
-                                    shared_bitmap_manager,
-                                    gpu_memory_buffer_manager,
-                                    renderer_settings,
-                                    task_runner,
-                                    synchronous_composite,
-                                    force_disable_reclaim_resources),
+      : TestCompositorFrameSink(std::move(compositor_context_provider),
+                                std::move(worker_context_provider),
+                                std::move(display_output_surface),
+                                shared_bitmap_manager,
+                                gpu_memory_buffer_manager,
+                                renderer_settings,
+                                task_runner,
+                                synchronous_composite,
+                                force_disable_reclaim_resources),
         invalidate_callback_(std::move(invalidate_callback)) {}
 
-  // TestDelegatingOutputSurface overrides.
+  // TestCompositorFrameSink overrides.
   void Invalidate() override { invalidate_callback_.Run(); }
 
   void OnDraw(bool resourceless_software_draw) {
     gfx::Transform identity;
     gfx::Rect empty_rect;
     client_->OnDraw(identity, empty_rect, resourceless_software_draw);
   }
 
  private:
   const base::Closure invalidate_callback_;
 };
 
 class LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor
     : public LayerTreeHostTestAbortedCommitDoesntStall {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
     settings->using_synchronous_renderer_compositor = true;
   }
 
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     auto on_draw_callback = base::Bind(
         &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
             CallOnDraw,
         base::Unretained(this));
-    auto output_surface = base::MakeUnique<OnDrawOutputSurface>(
+    auto output_surface = base::MakeUnique<OnDrawCompositorFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->GetSettings().renderer_settings,
         ImplThreadTaskRunner(), false /* synchronous_composite */,
         false /* force_disable_reclaim_resources */,
         std::move(on_draw_callback));
     output_surface_ = output_surface.get();
     return std::move(output_surface);
   }
 
   void CallOnDraw() {
     if (!TestEnded()) {
       // Synchronous compositor does not draw unless told to do so by the output
       // surface. But it needs to be done on a new stack frame.
       bool resourceless_software_draw = false;
       ImplThreadTaskRunner()->PostTask(
-          FROM_HERE, base::Bind(&OnDrawOutputSurface::OnDraw,
+          FROM_HERE, base::Bind(&OnDrawCompositorFrameSink::OnDraw,
                                 base::Unretained(output_surface_),
                                 resourceless_software_draw));
     }
   }
 
-  OnDrawOutputSurface* output_surface_ = nullptr;
+  OnDrawCompositorFrameSink* output_surface_ = nullptr;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor);
 
 class LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync
     : public LayerTreeHostTestAbortedCommitDoesntStall {
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
     settings->wait_for_beginframe_interval = false;
@@ skipping 98 matching lines @@
     child_layer_->SetBounds(gfx::Size(50, 50));
 
     root_layer_->AddChild(parent_layer_);
     parent_layer_->AddChild(child_layer_);
     layer_tree()->SetRootLayer(root_layer_);
 
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     auto on_draw_callback =
         base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
                    base::Unretained(this));
-    auto output_surface = base::MakeUnique<OnDrawOutputSurface>(
+    auto output_surface = base::MakeUnique<OnDrawCompositorFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->GetSettings().renderer_settings,
         ImplThreadTaskRunner(), false /* synchronous_composite */,
         false /* force_disable_reclaim_resources */,
         std::move(on_draw_callback));
     output_surface_ = output_surface.get();
     return std::move(output_surface);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CallOnDraw() {
     if (!TestEnded()) {
       // Synchronous compositor does not draw unless told to do so by the output
       // surface. But it needs to be done on a new stack frame.
       bool resourceless_software_draw = true;
       ImplThreadTaskRunner()->PostTask(
-          FROM_HERE, base::Bind(&OnDrawOutputSurface::OnDraw,
+          FROM_HERE, base::Bind(&OnDrawCompositorFrameSink::OnDraw,
                                 base::Unretained(output_surface_),
                                 resourceless_software_draw));
     }
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     if (host_impl->GetDrawMode() == DRAW_MODE_RESOURCELESS_SOFTWARE) {
       EXPECT_EQ(1u, frame_data->render_passes.size());
@@ skipping 21 matching lines @@
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void AfterTest() override {}
 
  private:
-  OnDrawOutputSurface* output_surface_ = nullptr;
+  OnDrawCompositorFrameSink* output_surface_ = nullptr;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<Layer> child_layer_;
   int draw_count_ = 0;
 };
 
 // Resourceless is not used for SingleThreadProxy, so it is unimplemented.
 MULTI_THREAD_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
 
@@ skipping 37 matching lines @@
         break;
       case 5:
         ClearResources();
         EndTest();
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     auto* context = static_cast<TestContextProvider*>(
-                        impl->output_surface()->context_provider())
+                        impl->compositor_frame_sink()->context_provider())
                         ->TestContext3d();
 
     int frame = impl->active_tree()->source_frame_number();
     switch (frame) {
       case 0:
         ASSERT_EQ(0u, context->NumTextures());
         break;
       case 1:
         // Created two textures.
         ASSERT_EQ(2u, context->NumTextures());
@@ skipping 2421 matching lines @@
 class LayerTreeHostTestSynchronousCompositeSwapPromise
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSynchronousCompositeSwapPromise() = default;
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
 
-  std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     bool synchronous_composite =
         !HasImplThread() &&
         !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
     // Relaiming resources is parameterized for this test.
     bool force_disable_reclaim_resources = !reclaim_resources_;
-    return base::MakeUnique<TestDelegatingOutputSurface>(
+    return base::MakeUnique<TestCompositorFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         CreateDisplayOutputSurface(compositor_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->GetSettings().renderer_settings,
         ImplThreadTaskRunner(), synchronous_composite,
         force_disable_reclaim_resources);
   }
 
   void BeginTest() override {
     // Successful composite.
@@ skipping 1435 matching lines @@
     client_.set_bounds(root->bounds());
   }
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     // Check that our large_image_size_ is greater than max texture size. We do
     // this here to ensure that our otuput surface exists.
 
     // Retrieve max texture size from Skia.
     ContextProvider* context_provider =
-        host_impl->output_surface()->context_provider();
+        host_impl->compositor_frame_sink()->context_provider();
     ASSERT_TRUE(context_provider);
     ContextProvider::ScopedContextLock context_lock(context_provider);
 
     GrContext* gr_context = context_provider->GrContext();
     ASSERT_TRUE(gr_context);
     const uint32_t max_texture_size = gr_context->caps()->maxTextureSize();
     ASSERT_GT(static_cast<uint32_t>(large_image_size_.width()),
               max_texture_size);
   }
 
@@ skipping 91 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
 }  // namespace
 }  // namespace cc