cc: Abstract the LayerTreeHost.

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 42 matching lines @@
   void DidCommit() override { WaitForCallback(); }
 
   void WaitForCallback() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::NextStep,
                    base::Unretained(this)));
   }
 
   void NextStep() {
-    int frame = layer_tree_host()->source_frame_number();
+    int frame = layer_tree_host()->SourceFrameNumber();
     switch (frame) {
       case 1:
         child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestTestMultipleRequests::
                            CopyOutputCallback,
                        base::Unretained(this), 0)));
         EXPECT_EQ(0u, callbacks_.size());
         break;
       case 2:
         // This commit is triggered by the copy request having been completed.
@@ skipping 38 matching lines @@
         // The |root| was copied to a bitmap and passed back also in Case 2.
         EXPECT_EQ(gfx::Size(20, 20).ToString(), callbacks_[2].ToString());
         // The |grand_child| was copied to a bitmap and passed back in Case 2.
         EXPECT_EQ(gfx::Size(5, 5).ToString(), callbacks_[3].ToString());
         EndTest();
         break;
     }
   }
 
   void CopyOutputCallback(size_t id, std::unique_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_TRUE(result->HasBitmap());
     std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
     EXPECT_EQ(result->size().ToString(),
               gfx::Size(bitmap->width(), bitmap->height()).ToString());
     callbacks_[id] = result->size();
   }
 
   void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
   std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
@@ skipping 74 matching lines @@
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    int frame = layer_tree_host()->source_frame_number();
+    int frame = layer_tree_host()->SourceFrameNumber();
     switch (frame) {
       case 1:
         layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&LayerTreeHostCopyRequestCompletionCausesCommit::
                            CopyOutputCallback)));
         break;
       case 2:
         // This commit is triggered by the copy request.
         break;
       case 3:
@@ skipping 35 matching lines @@
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    int frame = layer_tree_host()->source_frame_number();
+    int frame = layer_tree_host()->SourceFrameNumber();
     switch (frame) {
       case 1:
         main_destroyed_->RequestCopyOfOutput(
             CopyOutputRequest::CreateBitmapRequest(base::Bind(
                 &LayerTreeHostCopyRequestTestLayerDestroyed::CopyOutputCallback,
                 base::Unretained(this))));
         impl_destroyed_->RequestCopyOfOutput(
             CopyOutputRequest::CreateBitmapRequest(base::Bind(
                 &LayerTreeHostCopyRequestTestLayerDestroyed::CopyOutputCallback,
                 base::Unretained(this))));
@@ skipping 30 matching lines @@
         break;
       case 5:
         // We should get another callback with a NULL bitmap.
         EXPECT_EQ(2, callback_count_);
         EndTest();
         break;
     }
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_TRUE(result->IsEmpty());
     ++callback_count_;
   }
 
   void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> main_destroyed_;
@@ skipping 37 matching lines @@
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
 
     AddCopyRequest(copy_layer_.get());
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     ++callback_count_;
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString())
         << callback_count_;
     switch (callback_count_) {
       case 1:
         // Hide the copy request layer.
         grand_parent_layer_->SetHideLayerAndSubtree(false);
         parent_layer_->SetHideLayerAndSubtree(false);
         copy_layer_->SetHideLayerAndSubtree(true);
         AddCopyRequest(copy_layer_.get());
         break;
@@ skipping 84 matching lines @@
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest::
                  CopyOutputCallback,
             base::Unretained(this))));
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
     EndTest();
   }
 
   void DisplayWillDrawAndSwapOnThread(
       bool will_draw_and_swap,
       const RenderPassList& render_passes) override {
     EXPECT_TRUE(will_draw_and_swap) << did_swap_;
     if (did_swap_) {
       // TODO(crbug.com/564832): Ignore the extra frame that occurs due to copy
@@ skipping 73 matching lines @@
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&LayerTreeHostCopyRequestTestClippedOut::CopyOutputCallback,
                    base::Unretained(this))));
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     // We should still get the content even if the copy requested layer was
     // completely clipped away.
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> parent_layer_;
   scoped_refptr<FakePictureLayer> copy_layer_;
@@ skipping 88 matching lines @@
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     if (impl->active_tree()->source_frame_number() == 0) {
       EXPECT_TRUE(impl->active_tree()->LayerById(copy_layer_->id()));
       saw_copy_request_ = true;
     }
   }
 
   void DidCommit() override {
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       // Allow drawing.
       layer_tree()->SetViewportSize(gfx::Size(root_->bounds()));
 
       AddCopyRequest(copy_layer_.get());
     }
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
 
     // The first frame can't be drawn.
     switch (callback_count_) {
       case 0:
         EXPECT_TRUE(result->IsEmpty());
         EXPECT_EQ(gfx::Size(), result->size());
         break;
       case 1:
         EXPECT_FALSE(result->IsEmpty());
         EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
@@ skipping 37 matching lines @@
 
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void ReceiveCopyRequestOutputAndCommit(
       std::unique_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EXPECT_TRUE(result->HasTexture());
 
     // Save the result for later.
     EXPECT_FALSE(result_);
     result_ = std::move(result);
 
     // Post a commit to lose the output surface.
     layer_tree_host()->SetNeedsCommit();
   }
@@ skipping 113 matching lines @@
   }
 
   void BeginTest() override {
     waited_sync_token_after_readback_.Clear();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void RequestCopy(Layer* layer) = 0;
 
   void DidCommit() override {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // The layers have been pushed to the impl side and drawn. Any textures
         // that are created in that process will have been allocated.
         RequestCopy(copy_layer_.get());
         break;
     }
   }
 
   void DisplayDidDrawAndSwapOnThread() override {
     switch (num_swaps_++) {
@@ skipping 151 matching lines @@
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestDestroyBeforeCopy::DidActivate,
                    base::Unretained(this)));
   }
 
   void DidActivate() {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1: {
         EXPECT_EQ(0, callback_count_);
         // Put a copy request on the layer, but then don't allow any
         // drawing to take place.
         std::unique_ptr<CopyOutputRequest> request =
             CopyOutputRequest::CreateRequest(
                 base::Bind(&LayerTreeHostCopyRequestTestDestroyBeforeCopy::
                                CopyOutputCallback,
                            base::Unretained(this)));
         copy_layer_->RequestCopyOfOutput(std::move(request));
@@ skipping 55 matching lines @@
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::DidActivate,
                    base::Unretained(this)));
   }
 
   void DidActivate() {
-    switch (layer_tree_host()->source_frame_number()) {
+    switch (layer_tree_host()->SourceFrameNumber()) {
       case 1: {
         EXPECT_EQ(0, callback_count_);
         // Put a copy request on the layer, but then don't allow any
         // drawing to take place.
         std::unique_ptr<CopyOutputRequest> request =
             CopyOutputRequest::CreateRequest(
                 base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::
                                CopyOutputCallback,
                            base::Unretained(this)));
         copy_layer_->RequestCopyOfOutput(std::move(request));
@@ skipping 42 matching lines @@
 
   void BeginTest() override {
     num_draws_ = 0;
     copy_happened_ = false;
     draw_happened_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     // Send a copy request after the first commit.
-    if (layer_tree_host()->source_frame_number() == 1) {
+    if (layer_tree_host()->SourceFrameNumber() == 1) {
       child_->RequestCopyOfOutput(
           CopyOutputRequest::CreateBitmapRequest(base::Bind(
               &LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest::
                   CopyOutputCallback,
               base::Unretained(this))));
     }
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
@@ skipping 71 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc