cc: Decouple LayerTreeTests from FakeOutputSurface expectations.

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 53 matching lines @@
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtLeast;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
-class LayerTreeHostTest : public LayerTreeTest {};
+class LayerTreeHostTest : public LayerTreeTest {
+ protected:
+  // These tests are not pixel tests, and they use a fake output surface,
+  // while storing pointers to the test-types for tests to poke at.
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+    auto context = TestContextProvider::Create();
+    context_provider_ = context.get();
+    auto ret = delegating_renderer()
+                   ? FakeOutputSurface::CreateDelegating3d(std::move(context))
+                   : FakeOutputSurface::Create3d(std::move(context));
+    output_surface_ = ret.get();
+    return std::move(ret);
+  }
+
+  FakeOutputSurface* fake_output_surface() { return output_surface_; }
+  TestContextProvider* test_context_provider() { return context_provider_; }
+
+ private:
+  FakeOutputSurface* output_surface_ = nullptr;
+  TestContextProvider* context_provider_ = nullptr;
+};
 
 class LayerTreeHostTestHasImplThreadTest : public LayerTreeHostTest {
  public:
   LayerTreeHostTestHasImplThreadTest() : threaded_(false) {}
 
   void RunTest(CompositorMode mode, bool delegating_renderer) override {
     threaded_ = mode == CompositorMode::THREADED;
     LayerTreeHostTest::RunTest(mode, delegating_renderer);
   }
 
@@ skipping 333 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 LayerTreeHostFreeWorkerContextResourcesTest : public LayerTreeHostTest {
  public:
-  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     auto output_surface = base::WrapUnique(
         new testing::StrictMock<
             MockSetWorkerContextShouldAggressivelyFreeResourcesOutputSurface>(
             delegating_renderer()));
 
     // At init, we expect one call to set visibility to true.
     testing::Expectation visibility_true =
         EXPECT_CALL(*output_surface,
                     SetWorkerContextShouldAggressivelyFreeResources(false))
             .Times(1);
@@ skipping 2177 matching lines @@
                 CallOnDraw,
             base::Unretained(this)));
   }
 
   void CallOnDraw() {
     // Synchronous compositor does not draw unless told to do so by the output
     // surface.
     gfx::Transform identity;
     gfx::Rect empty_rect;
     bool resourceless_software_draw = false;
-    output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
-                                       resourceless_software_draw);
+    fake_output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
+                                            resourceless_software_draw);
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor);
 
 class LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync
     : public LayerTreeHostTestAbortedCommitDoesntStall {
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
@@ skipping 99 matching lines @@
     child_layer_->SetBounds(gfx::Size(50, 50));
 
     root_layer_->AddChild(parent_layer_);
     parent_layer_->AddChild(child_layer_);
     layer_tree_host()->SetRootLayer(root_layer_);
 
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
-  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
-    if (delegating_renderer()) {
-      return FakeOutputSurface::CreateDelegatingSoftware(
-          base::WrapUnique(new SoftwareOutputDevice));
-    } else {
-      return FakeOutputSurface::CreateSoftware(
-          base::WrapUnique(new SoftwareOutputDevice));
-    }
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+    auto output_surface = delegating_renderer()
+                              ? FakeOutputSurface::CreateDelegatingSoftware(
+                                    base::WrapUnique(new SoftwareOutputDevice))
+                              : FakeOutputSurface::CreateSoftware(
+                                    base::WrapUnique(new SoftwareOutputDevice));
+    software_output_surface_ = output_surface.get();
+    return std::move(output_surface);
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     swap_count_ = 0;
   }
 
   void ScheduledActionInvalidateOutputSurface() override {
     if (TestEnded())
       return;
 
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
                    base::Unretained(this)));
   }
 
   void CallOnDraw() {
     gfx::Transform identity;
     gfx::Rect empty_rect;
     bool resourceless_software_draw = true;
-    output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
-                                       resourceless_software_draw);
+    software_output_surface_->client()->OnDraw(identity, empty_rect, empty_rect,
+                                               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());
       // Has at least 3 quads for each layer.
       RenderPass* render_pass = frame_data->render_passes[0].get();
       EXPECT_GE(render_pass->quad_list.size(), 3u);
@@ skipping 18 matching lines @@
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void AfterTest() override {}
 
  private:
+  FakeOutputSurface* software_output_surface_ = nullptr;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<Layer> child_layer_;
   int swap_count_;
 };
 
 // Resourceless is not used for SingleThreadProxy, so it is unimplemented.
 MULTI_THREAD_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
 
@@ skipping 34 matching lines @@
         PostSetNeedsCommitToMainThread();
         break;
       case 5:
         ClearResources();
         EndTest();
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    TestWebGraphicsContext3D* context = TestContext();
+    auto* context = test_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());
         break;
@@ skipping 1066 matching lines @@
         EndTest();
         break;
     }
     return LayerTreeHostTest::PrepareToDrawOnThread(
         host_impl, frame_data, draw_result);
   }
 
   void AfterTest() override { EXPECT_EQ(3, num_commits_); }
 
   void SetCallback(bool enable) {
-    output_surface()->SetTreeActivationCallback(
+    fake_output_surface()->SetTreeActivationCallback(
         enable
             ? base::Bind(
                   &LayerTreeHostTestTreeActivationCallback::ActivationCallback,
                   base::Unretained(this))
             : base::Closure());
   }
 
   void ActivationCallback() { ++callback_count_; }
 
   int num_commits_;
@@ skipping 259 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestElasticOverscroll);
 
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface()
       : first_output_surface_memory_limit_(4321234),
         second_output_surface_memory_limit_(1234321) {}
 
-  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     if (!first_context_provider_.get()) {
       first_context_provider_ = TestContextProvider::Create();
     } else {
       EXPECT_FALSE(second_context_provider_.get());
       second_context_provider_ = TestContextProvider::Create();
     }
 
     scoped_refptr<TestContextProvider> provider(second_context_provider_.get()
                                                     ? second_context_provider_
                                                     : first_context_provider_);
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (delegating_renderer())
       output_surface = FakeOutputSurface::CreateDelegating3d(provider);
     else
       output_surface = FakeOutputSurface::Create3d(provider);
     output_surface->SetMemoryPolicyToSetAtBind(
         base::WrapUnique(new ManagedMemoryPolicy(
             second_context_provider_.get() ? second_output_surface_memory_limit_
                                            : first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
-    return output_surface;
+    return std::move(output_surface);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
@@ skipping 230 matching lines @@
     }
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
-class LayerTreeHostTestKeepSwapPromise : public LayerTreeTest {
+class LayerTreeHostTestKeepSwapPromise : public LayerTreeHostTest {
  public:
   LayerTreeHostTestKeepSwapPromise() {}
 
   void BeginTest() override {
     layer_ = SolidColorLayer::Create();
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->SetRootLayer(layer_);
     gfx::Size bounds(100, 100);
     layer_tree_host()->SetViewportSize(bounds);
@@ skipping 42 matching lines @@
     }
   }
 
   void ActivationCallback() {
     // DidActivate needs to happen before the tree activation callback.
     base::AutoLock lock(swap_promise_result_.lock);
     EXPECT_TRUE(swap_promise_result_.did_activate_called);
   }
 
   void SetCallback(bool enable) {
-    output_surface()->SetTreeActivationCallback(
+    fake_output_surface()->SetTreeActivationCallback(
         enable
             ? base::Bind(&LayerTreeHostTestKeepSwapPromise::ActivationCallback,
                          base::Unretained(this))
             : base::Closure());
   }
 
   void SwapBuffersCompleteOnThread() override {
     if (num_swaps_++ >= 1) {
       // The commit changes layers so it should cause a swap.
       base::AutoLock lock(swap_promise_result_.lock);
@@ skipping 1047 matching lines @@
   base::WaitableEvent playback_allowed_event_;
 };
 
 // This test does pinching on the impl side which is not supported in single
 // thread.
 MULTI_THREAD_TEST_F(LayerTreeHostTestCrispUpAfterPinchEnds);
 
 class LayerTreeHostTestCrispUpAfterPinchEndsWithOneCopy
     : public LayerTreeHostTestCrispUpAfterPinchEnds {
  protected:
-  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     std::unique_ptr<TestWebGraphicsContext3D> context3d =
         TestWebGraphicsContext3D::Create();
     context3d->set_support_image(true);
     context3d->set_support_sync_query(true);
 #if defined(OS_MACOSX)
     context3d->set_support_texture_rectangle(true);
 #endif
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(std::move(context3d));
@@ skipping 1110 matching lines @@
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_EQ(2.0f, host_impl->active_tree()->painted_device_scale_factor());
     EXPECT_EQ(1.0f, host_impl->active_tree()->device_scale_factor());
   }
 
   void SwapBuffersCompleteOnThread() override {
     EXPECT_EQ(
         2.0f,
-        output_surface()->last_sent_frame()->metadata.device_scale_factor);
+        fake_output_surface()->last_sent_frame()->metadata.device_scale_factor);
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc