cc: Get rid of non-delegated rendering in most cc unit tests.

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 55 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 {
- 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 LayerTreeHostTest : public LayerTreeTest {};
 
 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 2865 matching lines @@
         PostSetNeedsCommitToMainThread();
         break;
       case 5:
         ClearResources();
         EndTest();
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    auto* context = test_context_provider()->TestContext3d();
+    auto* context = static_cast<TestContextProvider*>(
+                        impl->output_surface()->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 1040 matching lines @@
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
-        SetCallback(true);
+        SetCallback(host_impl, true);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(1, callback_count_);
         callback_count_ = 0;
-        SetCallback(false);
+        SetCallback(host_impl, false);
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         EndTest();
         break;
       default:
         ADD_FAILURE() << num_commits_;
         EndTest();
         break;
     }
     return LayerTreeHostTest::PrepareToDrawOnThread(
         host_impl, frame_data, draw_result);
   }
 
   void AfterTest() override { EXPECT_EQ(3, num_commits_); }
 
-  void SetCallback(bool enable) {
-    fake_output_surface()->SetTreeActivationCallback(
+  void SetCallback(LayerTreeHostImpl* host_impl, bool enable) {
+    host_impl->SetTreeActivationCallback(
         enable
             ? base::Bind(
                   &LayerTreeHostTestTreeActivationCallback::ActivationCallback,
                   base::Unretained(this))
             : base::Closure());
   }
 
   void ActivationCallback() { ++callback_count_; }
 
   int num_commits_;
@@ skipping 573 matching lines @@
         break;
     }
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->pending_tree()) {
       if (host_impl->pending_tree()->source_frame_number() == 1) {
         base::AutoLock lock(swap_promise_result_.lock);
         EXPECT_FALSE(swap_promise_result_.did_activate_called);
         EXPECT_FALSE(swap_promise_result_.did_swap_called);
-        SetCallback(true);
+        SetCallback(host_impl, true);
       } else {
-        SetCallback(false);
+        SetCallback(host_impl, false);
       }
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() == 1) {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_TRUE(swap_promise_result_.did_activate_called);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
     }
   }
 
   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) {
-    fake_output_surface()->SetTreeActivationCallback(
+  void SetCallback(LayerTreeHostImpl* host_impl, bool enable) {
+    host_impl->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 2101 matching lines @@
 
   void AfterTest() override {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDestroyWhileInitializingOutputSurface);
 
 // Makes sure that painted_device_scale_factor is propagated to the
 // frame's metadata.
 class LayerTreeHostTestPaintedDeviceScaleFactor : public LayerTreeHostTest {
  protected:
+  LayerTreeHostTestPaintedDeviceScaleFactor() = default;
+
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+    auto ret = FakeOutputSurface::CreateDelegating3d();
+    fake_output_surface_ = ret.get();
+    return std::move(ret);
+  }
+
   void BeginTest() override {
     layer_tree_host()->SetPaintedDeviceScaleFactor(2.0f);
     EXPECT_EQ(1.0f, layer_tree_host()->device_scale_factor());
     PostSetNeedsCommitToMainThread();
   }
 
   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,
-        fake_output_surface()->last_sent_frame()->metadata.device_scale_factor);
+        fake_output_surface_->last_sent_frame()->metadata.device_scale_factor);
     EndTest();
   }
 
   void AfterTest() override {}
+
+  FakeOutputSurface* fake_output_surface_ = nullptr;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 // The GPU image decode controller hands images off to Skia for rasterization.
 // When used with large images, the images in question could be deleted before
 // Skia was done with them, causing a crash. This test performs an end-to-end
 // check of large image rasterization to ensure we do not hit this crash.
 // Note that this code path won't always hit the crash, even when incorrect
 // behavior occurs, so this is more of a sanity check.
@@ skipping 64 matching lines @@
  private:
   FakeContentLayerClient client_;
   const gfx::Size viewport_size_;
   const gfx::Size large_image_size_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(GpuRasterizationSucceedsWithLargeImage);
 
 }  // namespace
 }  // namespace cc