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 {};

[vmpstr, 2016/07/22 20:24:36]

Can the below classes directly derive from LayerTreeTest?

[danakj, 2016/07/22 20:34:57]

I've made it a pattern that each file has its own base class, so that when we
want to do something for all the classes in it, we don't have to change the
whole file. I'd like to preserve that here. (It made adding this method that I'm
now deleting easy for example.)

[vmpstr, 2016/07/22 20:56:34]

Makes sense!

 
 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