Revert of cc: Move data to LayerTree from 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 25 matching lines @@
     root->SetBounds(gfx::Size(20, 20));
 
     child = FakePictureLayer::Create(&client_);
     child->SetBounds(gfx::Size(10, 10));
     root->AddChild(child);
 
     grand_child = FakePictureLayer::Create(&client_);
     grand_child->SetBounds(gfx::Size(5, 5));
     child->AddChild(grand_child);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override { WaitForCallback(); }
 
   void WaitForCallback() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 140 matching lines @@
     : public LayerTreeHostCopyRequestTest {
  protected:
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(15, 15));
     root_->AddChild(layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     int frame = layer_tree_host()->source_frame_number();
@@ skipping 34 matching lines @@
     root_->SetBounds(gfx::Size(20, 20));
 
     main_destroyed_ = FakePictureLayer::Create(&client_);
     main_destroyed_->SetBounds(gfx::Size(15, 15));
     root_->AddChild(main_destroyed_);
 
     impl_destroyed_ = FakePictureLayer::Create(&client_);
     impl_destroyed_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(impl_destroyed_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
@@ skipping 11 matching lines @@
         EXPECT_EQ(0, callback_count_);
 
         // Destroy the main thread layer right away.
         main_destroyed_->RemoveFromParent();
         main_destroyed_ = NULL;
 
         // Should callback with a NULL bitmap.
         EXPECT_EQ(1, callback_count_);
 
         // Prevent drawing so we can't make a copy of the impl_destroyed layer.
-        layer_tree()->SetViewportSize(gfx::Size());
+        layer_tree_host()->SetViewportSize(gfx::Size());
         break;
       case 2:
         // Flush the message loops and make sure the callbacks run.
         layer_tree_host()->SetNeedsCommit();
         break;
       case 3:
         // No drawing means no readback yet.
         EXPECT_EQ(1, callback_count_);
 
         // Destroy the impl thread layer.
@@ skipping 46 matching lines @@
     // parent_layer_ owns a render surface.
     parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetForceRenderSurfaceForTesting(true);
     grand_parent_layer_->AddChild(parent_layer_);
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void AddCopyRequest(Layer* layer) {
     layer->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostCopyRequestTestInHiddenSubtree::CopyOutputCallback,
             base::Unretained(this))));
   }
@@ skipping 79 matching lines @@
     // parent_layer_ owns a render surface.
     parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetForceRenderSurfaceForTesting(true);
     grand_parent_layer_->AddChild(parent_layer_);
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   std::unique_ptr<TestDelegatingOutputSurface> CreateDelegatingOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     auto surface = LayerTreeHostCopyRequestTest::CreateDelegatingOutputSurface(
         std::move(compositor_context_provider),
         std::move(worker_context_provider));
@@ skipping 83 matching lines @@
     parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetMasksToBounds(true);
     root_->AddChild(parent_layer_);
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetPosition(gfx::PointF(15.f, 15.f));
     copy_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&LayerTreeHostCopyRequestTestClippedOut::CopyOutputCallback,
                    base::Unretained(this))));
@@ skipping 29 matching lines @@
 
     copy_layer_ = Layer::Create();
     copy_layer_->SetBounds(gfx::Size(10, 10));
     copy_layer_->SetTransform(scale);
     root_->AddChild(copy_layer_);
 
     child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(10, 10));
     copy_layer_->AddChild(child_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
     std::unique_ptr<CopyOutputRequest> request =
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostCopyRequestTestScaledLayer::CopyOutputCallback,
@@ skipping 23 matching lines @@
     : public LayerTreeHostCopyRequestTest {
  protected:
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void AddCopyRequest(Layer* layer) {
     layer->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostTestAsyncTwoReadbacksWithoutDraw::CopyOutputCallback,
             base::Unretained(this))));
   }
 
   void BeginTest() override {
     saw_copy_request_ = false;
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
 
     // Prevent drawing.
-    layer_tree()->SetViewportSize(gfx::Size(0, 0));
+    layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
 
     AddCopyRequest(copy_layer_.get());
   }
 
   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) {
       // Allow drawing.
-      layer_tree()->SetViewportSize(gfx::Size(root_->bounds()));
+      layer_tree_host()->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());
 
     // The first frame can't be drawn.
     switch (callback_count_) {
@@ skipping 35 matching lines @@
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->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_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
@@ skipping 110 matching lines @@
 
     copy_layer_ = FakePictureLayer::Create(&copy_client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     copy_client_.set_bounds(copy_layer_->bounds());
     // Doing a copy makes the layer have a render surface which can cause
     // texture allocations. So get those allocations out of the way in the
     // first frame by forcing it to have a render surface.
     copy_layer_->SetForceRenderSurfaceForTesting(true);
     root_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
   void BeginTest() override {
     waited_sync_token_after_readback_.Clear();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void RequestCopy(Layer* layer) = 0;
 
@@ skipping 140 matching lines @@
     : public LayerTreeHostCopyRequestTest {
  protected:
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
@@ skipping 14 matching lines @@
         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));
 
-        layer_tree()->SetViewportSize(gfx::Size());
+        layer_tree_host()->SetViewportSize(gfx::Size());
         break;
       }
       case 2:
         EXPECT_EQ(0, callback_count_);
         // Remove the copy layer before we were able to draw.
         copy_layer_->RemoveFromParent();
         break;
       case 3:
         EXPECT_EQ(1, callback_count_);
         // Allow us to draw now.
-        layer_tree()->SetViewportSize(layer_tree()->root_layer()->bounds());
+        layer_tree_host()->SetViewportSize(
+            layer_tree_host()->root_layer()->bounds());
         break;
       case 4:
         EXPECT_EQ(1, callback_count_);
         // We should not have crashed.
         EndTest();
     }
   }
 
   void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCopyRequestTestDestroyBeforeCopy);
 
 class LayerTreeHostCopyRequestTestShutdownBeforeCopy
     : public LayerTreeHostCopyRequestTest {
  protected:
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
-    layer_tree()->SetRootLayer(root_);
+    layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
@@ skipping 14 matching lines @@
         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));
 
-        layer_tree()->SetViewportSize(gfx::Size());
+        layer_tree_host()->SetViewportSize(gfx::Size());
         break;
       }
       case 2:
         DestroyLayerTreeHost();
         // End the test after the copy result has had a chance to get back to
         // the main thread.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::EndTest,
                        base::Unretained(this)));
@@ skipping 16 matching lines @@
  protected:
   void SetupTree() override {
     scoped_refptr<FakePictureLayer> root = FakePictureLayer::Create(&client_);
     root->SetBounds(gfx::Size(20, 20));
 
     child_ = FakePictureLayer::Create(&client_);
     child_->SetBounds(gfx::Size(10, 10));
     root->AddChild(child_);
     child_->SetHideLayerAndSubtree(true);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
   void BeginTest() override {
     num_draws_ = 0;
     copy_happened_ = false;
     draw_happened_ = false;
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 85 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc