cc: Move data to LayerTree from LayerTreeHost.

cc/trees/layer_tree_host_common_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_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 154 matching lines @@
   void ExecuteCalculateDrawProperties(LayerType* root_layer,
                                       float device_scale_factor) {
     LayerType* page_scale_application_layer = nullptr;
     ExecuteCalculateDrawProperties(root_layer, device_scale_factor, 1.f,
                                    page_scale_application_layer);
   }
 
   const LayerList* GetUpdateLayerList() { return &update_layer_list_; }
 
   void ExecuteCalculateDrawPropertiesWithPropertyTrees(Layer* root_layer) {
-    DCHECK(root_layer->layer_tree_host());
+    DCHECK(root_layer->GetLayerTree());
     PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
 
     bool can_render_to_separate_surface = true;
 
     const Layer* page_scale_layer =
-        root_layer->layer_tree_host()->page_scale_layer();
+        root_layer->GetLayerTree()->page_scale_layer();
     Layer* inner_viewport_scroll_layer =
-        root_layer->layer_tree_host()->inner_viewport_scroll_layer();
+        root_layer->GetLayerTree()->inner_viewport_scroll_layer();
     Layer* outer_viewport_scroll_layer =
-        root_layer->layer_tree_host()->outer_viewport_scroll_layer();
+        root_layer->GetLayerTree()->outer_viewport_scroll_layer();
     const Layer* overscroll_elasticity_layer =
-        root_layer->layer_tree_host()->overscroll_elasticity_layer();
+        root_layer->GetLayerTree()->overscroll_elasticity_layer();
     gfx::Vector2dF elastic_overscroll =
-        root_layer->layer_tree_host()->elastic_overscroll();
+        root_layer->GetLayerTree()->elastic_overscroll();
     float page_scale_factor = 1.f;
     float device_scale_factor = 1.f;
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
     PropertyTrees* property_trees =
-        root_layer->layer_tree_host()->property_trees();
+        root_layer->GetLayerTree()->property_trees();
     update_layer_list_.clear();
     PropertyTreeBuilder::BuildPropertyTrees(
         root_layer, page_scale_layer, inner_viewport_scroll_layer,
         outer_viewport_scroll_layer, overscroll_elasticity_layer,
         elastic_overscroll, page_scale_factor, device_scale_factor,
         gfx::Rect(device_viewport_size), gfx::Transform(), property_trees);
     draw_property_utils::UpdatePropertyTrees(property_trees,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(
         root_layer->layer_tree_host(), property_trees->transform_tree,
@@ skipping 6715 matching lines @@
   root->SetBounds(gfx::Size(50, 50));
   container->SetBounds(gfx::Size(50, 50));
   scroller->SetBounds(gfx::Size(50, 50));
   fixed_pos->SetBounds(gfx::Size(50, 50));
 
   gfx::Transform rotate;
   rotate.RotateAboutXAxis(20);
   container->SetTransform(rotate);
 
   ExecuteCalculateDrawProperties(root.get());
-  TransformTree& tree =
-      root->layer_tree_host()->property_trees()->transform_tree;
+  TransformTree& tree = root->GetLayerTree()->property_trees()->transform_tree;
   gfx::Transform transform;
   tree.ComputeTranslation(fixed_pos->transform_tree_index(),
                           container->transform_tree_index(), &transform);
   EXPECT_TRUE(transform.IsIdentity());
 }
 
 TEST_F(LayerTreeHostCommonTest, ScrollSnappingWithFixedPosChild) {
   // This test verifies that a fixed pos child of a scrolling layer doesn't get
   // snapped to integer coordinates.
   //
@@ skipping 901 matching lines @@
 
   inner_viewport_scroll_layer->SetScrollClipLayerId(
       inner_viewport_container_layer->id());
   outer_viewport_scroll_layer->SetScrollClipLayerId(
       outer_viewport_container_layer->id());
 
   inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
   outer_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
-  host()->RegisterViewportLayers(nullptr, root, inner_viewport_scroll_layer,
-                                 outer_viewport_scroll_layer);
+  host()->GetLayerTree()->RegisterViewportLayers(
+      nullptr, root, inner_viewport_scroll_layer, outer_viewport_scroll_layer);
 
   scoped_refptr<Layer> fixed_to_inner = Layer::Create();
   scoped_refptr<Layer> fixed_to_outer = Layer::Create();
 
   inner_viewport_scroll_layer->AddChild(fixed_to_inner);
   outer_viewport_scroll_layer->AddChild(fixed_to_outer);
 
   LayerPositionConstraint fixed_to_right;
   fixed_to_right.set_is_fixed_position(true);
   fixed_to_right.set_is_fixed_to_right_edge(true);
@@ skipping 1585 matching lines @@
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
   AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
                                           std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
-  EffectTree& tree = root->layer_tree_host()->property_trees()->effect_tree;
+  EffectTree& tree = root->GetLayerTree()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(animated->effect_tree_index());
   EXPECT_FALSE(node->is_currently_animating_opacity);
   EXPECT_TRUE(node->has_potential_opacity_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
   root->layer_tree_host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->effect_tree_index());
   EXPECT_TRUE(node->is_currently_animating_opacity);
   EXPECT_TRUE(node->has_potential_opacity_animation);
@@ skipping 36 matching lines @@
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
   AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
                                           std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
-  TransformTree& tree =
-      root->layer_tree_host()->property_trees()->transform_tree;
+  TransformTree& tree = root->GetLayerTree()->property_trees()->transform_tree;
   TransformNode* node = tree.Node(animated->transform_tree_index());
   EXPECT_FALSE(node->is_currently_animating);
   EXPECT_TRUE(node->has_potential_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
   root->layer_tree_host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->transform_tree_index());
   EXPECT_TRUE(node->is_currently_animating);
   EXPECT_TRUE(node->has_potential_animation);
@@ skipping 116 matching lines @@
       MainThreadScrollingReason::kScrollbarScrolling);
 
   child7->SetScrollClipLayerId(parent3->id());
 
   child8->SetScrollParent(child7.get());
   grand_child11->SetScrollClipLayerId(parent3->id());
 
   parent5->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
   parent5->SetBounds(gfx::Size(10, 10));
 
-  host()->RegisterViewportLayers(nullptr, page_scale_layer, parent2, nullptr);
+  host()->GetLayerTree()->RegisterViewportLayers(nullptr, page_scale_layer,
+                                                 parent2, nullptr);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root1.get());
 
   const int kInvalidPropertyTreeNodeId = -1;
   const int kRootPropertyTreeNodeId = 0;
 
   // Property tree root
   ScrollTree& scroll_tree = host()->property_trees()->scroll_tree;
   PropertyTrees property_trees;
   property_trees.is_main_thread = true;
   property_trees.is_active = false;
@@ skipping 92 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc