cc: Merge LayerTree into the LayerTreeHost.

cc/trees/layer_tree_host_unittest_picture.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 "cc/trees/layer_tree_host.h"
 
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 namespace {
 
 // These tests deal with picture layers.
 class LayerTreeHostPictureTest : public LayerTreeTest {
  protected:
   void SetupTreeWithSinglePictureLayer(const gfx::Size& size) {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(size);
 
     root_picture_layer_ = FakePictureLayer::Create(&client_);
     root_picture_layer_->SetBounds(size);
     root->AddChild(root_picture_layer_);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     client_.set_bounds(size);
   }
 
   scoped_refptr<FakePictureLayer> root_picture_layer_;
   FakeContentLayerClient client_;
 };
 
 class LayerTreeHostPictureTestTwinLayer
     : public LayerTreeHostPictureTest {
   void SetupTree() override {
@@ skipping 17 matching lines @@
         // Drop the picture layer from the tree so the activate will have an
         // active layer without a pending twin.
         root_picture_layer_->RemoveFromParent();
         break;
       case 3: {
         // Add a new picture layer so the activate will have a pending layer
         // without an active twin.
         scoped_refptr<FakePictureLayer> picture =
             FakePictureLayer::Create(&client_);
         picture_id2_ = picture->id();
-        layer_tree()->root_layer()->AddChild(picture);
+        layer_tree_host()->root_layer()->AddChild(picture);
         break;
       }
       case 4:
         // Active while there are pending and active twins again.
         layer_tree_host()->SetNeedsCommit();
         break;
       case 5:
         EndTest();
         break;
     }
@@ skipping 75 matching lines @@
 
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(768, 960));
     client_.set_bounds(root->bounds());
     client_.set_fill_with_nonsolid_color(true);
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(768, 960));
     root->AddChild(picture_);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* child = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     gfx::Size tile_size =
@@ skipping 11 matching lines @@
         EXPECT_NE(gfx::Size(768, 256), tile_size);
     }
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         // Change the picture layer's size along with the viewport, so it will
         // consider picking a new tile size.
         picture_->SetBounds(gfx::Size(768, 1056));
-        layer_tree()->SetViewportSize(gfx::Size(768, 1056));
+        layer_tree_host()->SetViewportSize(gfx::Size(768, 1056));
         break;
       case 2:
         EndTest();
     }
   }
 
   void AfterTest() override {}
 
   gfx::Size tile_size_;
   FakeContentLayerClient client_;
@@ skipping 15 matching lines @@
     // layer.
     client_.set_fill_with_nonsolid_color(true);
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100000));
     root->AddChild(picture_);
 
     // picture_'s transform is going to be changing on the compositor thread, so
     // force it to have a transform node by making it scrollable.
     picture_->SetScrollClipLayerId(root->id());
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
     client_.set_bounds(picture_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* child = impl->active_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
@@ skipping 91 matching lines @@
 
     child_ = Layer::Create();
     root->AddChild(child_);
 
     // Don't be solid color so the layer has tilings/tiles.
     client_.set_fill_with_nonsolid_color(true);
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100));
     child_->AddChild(picture_);
 
-    layer_tree()->SetRootLayer(root);
+    layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* gchild = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     switch (impl->sync_tree()->source_frame_number()) {
@@ skipping 70 matching lines @@
     pinch_->SetIsContainerForFixedPositionLayers(true);
     page_scale_layer->AddChild(pinch_);
     root_clip->AddChild(page_scale_layer);
 
     // Don't be solid color so the layer has tilings/tiles.
     client_.set_fill_with_nonsolid_color(true);
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100));
     pinch_->AddChild(picture_);
 
-    layer_tree()->RegisterViewportLayers(NULL, page_scale_layer, pinch_,
-                                         nullptr);
-    layer_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
-    layer_tree()->SetRootLayer(root_clip);
+    layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch_,
+                                              nullptr);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
+    layer_tree_host()->SetRootLayer(root_clip);
     LayerTreeHostPictureTest::SetupTree();
     client_.set_bounds(picture_->bounds());
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void BeginTest() override {
     frame_ = 0;
@@ skipping 139 matching lines @@
 
     will_change_layer_ = FakePictureLayer::Create(&client_);
     will_change_layer_->SetHasWillChangeTransformHint(true);
     will_change_layer_->SetBounds(size);
     root->AddChild(will_change_layer_);
 
     normal_layer_ = FakePictureLayer::Create(&client_);
     normal_layer_->SetBounds(size);
     root->AddChild(normal_layer_);
 
-    layer_tree()->SetRootLayer(root);
-    layer_tree()->SetViewportSize(size);
+    layer_tree_host()->SetRootLayer(root);
+    layer_tree_host()->SetViewportSize(size);
 
     client_.set_fill_with_nonsolid_color(true);
     client_.set_bounds(size);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 44 matching lines @@
         ASSERT_EQ(1u, normal_layer->tilings()->num_tilings());
         EXPECT_EQ(4.f, normal_layer->tilings()->tiling_at(0)->contents_scale());
         EndTest();
         break;
     }
   }
 
   void ScaleRootUp() {
     gfx::Transform transform;
     transform.Scale(2, 2);
-    layer_tree_host()->GetLayerTree()->root_layer()->SetTransform(transform);
+    layer_tree_host()->root_layer()->SetTransform(transform);
   }
 
   void ScaleRootUpAndRecalculateScales() {
     gfx::Transform transform;
     transform.Scale(4, 4);
-    layer_tree_host()->GetLayerTree()->root_layer()->SetTransform(transform);
+    layer_tree_host()->root_layer()->SetTransform(transform);
     layer_tree_host()->SetNeedsRecalculateRasterScales();
   }
 
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> will_change_layer_;
   scoped_refptr<FakePictureLayer> normal_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostPictureTestForceRecalculateScales);
 
 }  // namespace
 }  // namespace cc