cc: Clean up LayerTreeTest and TestHooks.

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 32 matching lines @@
 #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/skia_common.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"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ skipping 77 matching lines @@
   enum MainOrder : int {
     MAIN_START = 1,
     MAIN_LAYOUT,
     MAIN_COMMIT_COMPLETE,
     MAIN_DID_BEGIN_FRAME,
     MAIN_END,
   };
 
   enum ImplOrder : int {
     IMPL_START = 1,
+    IMPL_READY_TO_COMMIT,
     IMPL_COMMIT,
     IMPL_COMMIT_COMPLETE,
     IMPL_ACTIVATE,
     IMPL_DRAW,
     IMPL_END,
   };
 
   template <typename T>
   bool CheckStep(T next, T* var) {
     int expected = next - 1;
@@ skipping 10 matching lines @@
   }
 
   void DidCommit() override {
     EXPECT_TRUE(CheckStep(MAIN_COMMIT_COMPLETE, &main_));
   }
 
   void DidBeginMainFrame() override {
     EXPECT_TRUE(CheckStep(MAIN_DID_BEGIN_FRAME, &main_));
   }
 
+  void ReadyToCommitOnThread(LayerTreeHostImpl* impl) override {
+    EXPECT_TRUE(CheckStep(IMPL_READY_TO_COMMIT, &impl_));
+  }
+
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_COMMIT, &impl_));
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_COMMIT_COMPLETE, &impl_));
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_TRUE(CheckStep(IMPL_ACTIVATE, &impl_));
@@ skipping 2132 matching lines @@
       case 5:
         PostSetDeferCommitsToMainThread(false);
         break;
       default:
         // Sometimes |num_will_begin_impl_frame_| will be greater than 5 if the
         // main thread is slow to respond.
         break;
     }
   }
 
-  void ScheduledActionSendBeginMainFrame() override {
+  void WillBeginMainFrame() override {
     num_send_begin_main_frame_++;
     switch (num_send_begin_main_frame_) {
       case 1:
-        PostSetDeferCommitsToMainThread(true);
+        layer_tree_host()->SetDeferCommits(true);
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
@@ skipping 263 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 OutputSurface {
+ public:
+  explicit OnDrawOutputSurface(base::Closure invalidate_callback)
+      : OutputSurface(TestContextProvider::Create(),
+                      TestContextProvider::CreateWorker(),
+                      nullptr),
+        invalidate_callback_(std::move(invalidate_callback)) {
+    capabilities_.delegated_rendering = true;
+  }
+
+  // OutputSurface implementation.
+  void SwapBuffers(CompositorFrame frame) override { did_swap_ = true; }
+  uint32_t GetFramebufferCopyTextureFormat() override { return 0; }
+  void Invalidate() override { invalidate_callback_.Run(); }
+
+  void OnDraw(bool resourceless_software_draw) {
+    gfx::Transform identity;
+    gfx::Rect empty_rect;
+    // SwapBuffers happens inside of OnDraw.
+    client_->OnDraw(identity, empty_rect, empty_rect,
+                    resourceless_software_draw);
+    if (did_swap_) {
+      did_swap_ = false;
+      client_->DidSwapBuffersComplete();
+    }
+  }
+
+ private:
+  bool did_swap_ = false;
+  base::Closure invalidate_callback_;
+};
+
 class LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor
     : public LayerTreeHostTestAbortedCommitDoesntStall {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
     settings->using_synchronous_renderer_compositor = true;
   }
 
-  void ScheduledActionInvalidateOutputSurface() override {
-    // Do not call ImplThreadTaskRunner after the test ended because of the
-    // possibility of use-after-free due to a race.
-    if (TestEnded())
-      return;
-    ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
-                CallOnDraw,
-            base::Unretained(this)));
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+    auto output_surface = base::MakeUnique<OnDrawOutputSurface>(base::Bind(
+        &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
+            CallOnDraw,
+        base::Unretained(this)));
+    output_surface_ = output_surface.get();
+    return std::move(output_surface);
   }
 
   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;
-    fake_output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
-                                            resourceless_software_draw);
+    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,
+                                base::Unretained(output_surface_),
+                                resourceless_software_draw));
+    }
   }
+
+  OnDrawOutputSurface* 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 71 matching lines @@
 
   void AfterTest() override {}
 
  protected:
   int frame_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNumFramesPending);
 
 class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
- public:
+ protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->using_synchronous_renderer_compositor = true;
   }
 
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
 
     parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetIsDrawable(true);
     parent_layer_->SetBounds(gfx::Size(50, 50));
     parent_layer_->SetForceRenderSurfaceForTesting(true);
 
     child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetIsDrawable(true);
     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<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();
+    auto output_surface = base::MakeUnique<OnDrawOutputSurface>(
+        base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
+                   base::Unretained(this)));
+    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;
-    software_output_surface_->client()->OnDraw(identity, empty_rect, empty_rect,
-                                               resourceless_software_draw);
+    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,
+                                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());
       // 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);
     } else {
       EXPECT_EQ(2u, frame_data->render_passes.size());
 
       // At least root layer quad in root render pass.
       EXPECT_GE(frame_data->render_passes[0]->quad_list.size(), 1u);
       // At least parent and child layer quads in parent render pass.
       EXPECT_GE(frame_data->render_passes[1]->quad_list.size(), 2u);
     }
     return draw_result;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
-    swap_count_++;
-    switch (swap_count_) {
+    draw_count_++;
+    switch (draw_count_) {
       case 1:
         host_impl->SetNeedsRedraw();
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void AfterTest() override {}
 
  private:
-  FakeOutputSurface* software_output_surface_ = nullptr;
+  OnDrawOutputSurface* output_surface_ = nullptr;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<Layer> parent_layer_;
   scoped_refptr<Layer> child_layer_;
-  int swap_count_;
+  int draw_count_ = 0;
 };
 
 // Resourceless is not used for SingleThreadProxy, so it is unimplemented.
 MULTI_THREAD_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
 
 // Test for UI Resource management.
 class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
@@ skipping 1772 matching lines @@
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetVisibleFalseAndQueueSwapPromise() {
     layer_tree_host()->SetVisible(false);
     std::unique_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
   }
 
-  void ScheduledActionWillSendBeginMainFrame() override {
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
+                                  const BeginFrameArgs& args) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTestBreakSwapPromiseForVisibility
                        ::SetVisibleFalseAndQueueSwapPromise,
             base::Unretained(this)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     EndTest();
@@ skipping 23 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void LoseOutputSurfaceAndQueueSwapPromise() {
     layer_tree_host()->DidLoseOutputSurface();
     std::unique_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(std::move(swap_promise));
   }
 
-  void ScheduledActionWillSendBeginMainFrame() override {
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
+                                  const BeginFrameArgs& args) override {
     if (output_surface_lost_triggered_)
       return;
     output_surface_lost_triggered_ = true;
 
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostTestBreakSwapPromiseForContext
                        ::LoseOutputSurfaceAndQueueSwapPromise,
                    base::Unretained(this)));
   }
@@ skipping 507 matching lines @@
     did_finish_impl_frame_count_++;
     EXPECT_EQ(will_begin_impl_frame_count_, did_finish_impl_frame_count_);
 
     // Request a number of commits to cause multiple impl frames. We expect to
     // get one more impl frames than the number of commits requested because
     // after a commit it takes one frame to become idle.
     if (did_finish_impl_frame_count_ < kExpectedNumImplFrames - 1)
       PostSetNeedsCommitToMainThread();
   }
 
-  void SendBeginMainFrameNotExpectedSoon() override { EndTest(); }
+  void BeginMainFrameNotExpectedSoon() override { EndTest(); }
 
   void AfterTest() override {
     EXPECT_GT(will_begin_impl_frame_count_, 0);
     EXPECT_GT(did_finish_impl_frame_count_, 0);
     EXPECT_EQ(will_begin_impl_frame_count_, did_finish_impl_frame_count_);
 
     // TODO(mithro): Figure out why the multithread version of this test
     // sometimes has one more frame then expected. Possibly related to
     // http://crbug.com/443185
     if (!HasImplThread()) {
@@ skipping 52 matching lines @@
     if (will_begin_impl_frame_count_ < 10)
       PostSetNeedsCommitToMainThread();
   }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     ASSERT_GT(impl_frame_args_.size(), 0U)
         << "BeginMainFrame called before BeginImplFrame called!";
     EXPECT_PRED_FORMAT2(AssertFrameTimeContained, impl_frame_args_, args);
   }
 
-  void SendBeginMainFrameNotExpectedSoon() override { EndTest(); }
+  void BeginMainFrameNotExpectedSoon() override { EndTest(); }
 
   void AfterTest() override {
     EXPECT_GT(impl_frame_args_.size(), 0U);
     EXPECT_GE(will_begin_impl_frame_count_, 10);
   }
 
  private:
   std::vector<BeginFrameArgs> impl_frame_args_;
   int will_begin_impl_frame_count_;
 };
@@ skipping 684 matching lines @@
                                    bool success) override {
     ASSERT_TRUE(success);
     host_impl->tile_manager()->SetScheduledRasterTaskLimitForTesting(1);
   }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     ++notify_ready_to_activate_count_;
     EndTestAfterDelayMs(100);
   }
 
-  void ScheduledActionPrepareTiles() override {
+  void WillPrepareTilesOnThread(LayerTreeHostImpl* impl) override {
     ++scheduled_prepare_tiles_count_;
   }
 
   void AfterTest() override {
     // Expect at most a notification for each scheduled prepare tiles, plus one
     // for the initial commit (which doesn't go through scheduled actions).
     // The reason this is not an equality is because depending on timing, we
     // might get a prepare tiles but not yet get a notification that we're
     // ready to activate. The intent of a test is to ensure that we don't
     // get more than one notification per prepare tiles, so this is OK.
@@ skipping 34 matching lines @@
 
     // After activating, we either need to prepare tiles, or we've already
     // called a scheduled prepare tiles. This is done because activation might
     // cause us to have to memory available (old active tree is gone), so we
     // need to ensure we will get a PrepareTiles call.
     if (!impl->prepare_tiles_needed())
       EXPECT_GE(scheduled_prepare_tiles_count_, 1);
     EndTest();
   }
 
-  void ScheduledActionPrepareTiles() override {
+  void WillPrepareTilesOnThread(LayerTreeHostImpl* impl) override {
     ++scheduled_prepare_tiles_count_;
   }
 
   void AfterTest() override {}
 
  protected:
   FakeContentLayerClient client_;
   int scheduled_prepare_tiles_count_;
 };
 
@@ skipping 634 matching lines @@
   }
 
   void AfterTest() override {}
 
   std::vector<int> affected_by_page_scale_;
   std::vector<int> not_affected_by_page_scale_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestPageScaleFlags);
 
-class LayerTreeHostScrollingAndScalingUpdatesLayers : public LayerTreeHostTest {
- public:
-  LayerTreeHostScrollingAndScalingUpdatesLayers()
-      : requested_update_layers_(false), commit_count_(0) {}
-
-  void SetupTree() override {
-    LayerTreeHostTest::SetupTree();
-    Layer* root_layer = layer_tree_host()->root_layer();
-    scoped_refptr<Layer> scroll_layer = Layer::Create();
-    CreateVirtualViewportLayers(root_layer, scroll_layer, root_layer->bounds(),
-                                root_layer->bounds(), layer_tree_host());
-  }
-
-  void BeginTest() override {
-    LayerTreeHostCommon::ScrollUpdateInfo scroll;
-    scroll.layer_id = layer_tree_host()->root_layer()->id();
-    scroll.scroll_delta = gfx::Vector2d(0, 33);
-    scroll_info_.scrolls.push_back(scroll);
-
-    scale_info_.page_scale_delta = 2.71f;
-
-    PostSetNeedsCommitToMainThread();
-  }
-
-  void BeginMainFrame(const BeginFrameArgs& args) override {
-    switch (commit_count_) {
-      case 0:
-        requested_update_layers_ = false;
-        layer_tree_host()->ApplyScrollAndScale(&no_op_info_);
-        EXPECT_FALSE(requested_update_layers_);
-        break;
-      case 1:
-        requested_update_layers_ = false;
-        layer_tree_host()->ApplyScrollAndScale(&scale_info_);
-        EXPECT_TRUE(requested_update_layers_);
-        break;
-      case 2:
-        requested_update_layers_ = false;
-        layer_tree_host()->ApplyScrollAndScale(&scroll_info_);
-        EXPECT_TRUE(requested_update_layers_);
-        EndTest();
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-
-  void DidSetNeedsUpdateLayers() override { requested_update_layers_ = true; }
-
-  void DidCommit() override {
-    if (++commit_count_ < 3)
-      PostSetNeedsCommitToMainThread();
-  }
-
-  void AfterTest() override {}
-
-  ScrollAndScaleSet scroll_info_;
-  ScrollAndScaleSet scale_info_;
-  ScrollAndScaleSet no_op_info_;
-  bool requested_update_layers_;
-  int commit_count_;
-};
-
-MULTI_THREAD_TEST_F(LayerTreeHostScrollingAndScalingUpdatesLayers);
-
 class LayerTreeHostTestDestroyWhileInitializingOutputSurface
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
     // By ending the test immediately we start initialization of an output
     // surface but destroy the LTH before it completes. This test verifies
     // that this works correctly and the output surface is destroyed on
     // the correct thread.
     EndTest();
   }
@@ skipping 103 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