cc: Merge LayerTree into the 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 170 matching lines @@
     LayerType* inner_viewport_scroll_layer = nullptr;
     LayerType* outer_viewport_scroll_layer = nullptr;
     ExecuteCalculateDrawProperties(
         root_layer, device_scale_factor, 1.f, page_scale_application_layer,
         inner_viewport_scroll_layer, outer_viewport_scroll_layer);
   }
 
   const LayerList* GetUpdateLayerList() { return &update_layer_list_; }
 
   void ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(Layer* root_layer) {
-    DCHECK(root_layer->GetLayerTree());
+    DCHECK(root_layer->layer_tree_host());
     PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
 
     bool can_render_to_separate_surface = true;
 
     const Layer* page_scale_layer =
-        root_layer->GetLayerTree()->page_scale_layer();
+        root_layer->layer_tree_host()->page_scale_layer();
     Layer* inner_viewport_scroll_layer =
-        root_layer->GetLayerTree()->inner_viewport_scroll_layer();
+        root_layer->layer_tree_host()->inner_viewport_scroll_layer();
     Layer* outer_viewport_scroll_layer =
-        root_layer->GetLayerTree()->outer_viewport_scroll_layer();
+        root_layer->layer_tree_host()->outer_viewport_scroll_layer();
     const Layer* overscroll_elasticity_layer =
-        root_layer->GetLayerTree()->overscroll_elasticity_layer();
+        root_layer->layer_tree_host()->overscroll_elasticity_layer();
     gfx::Vector2dF elastic_overscroll =
-        root_layer->GetLayerTree()->elastic_overscroll();
+        root_layer->layer_tree_host()->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->GetLayerTree()->property_trees();
+        root_layer->layer_tree_host()->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->GetLayerTree(), property_trees, &update_layer_list_);
+        root_layer->layer_tree_host(), property_trees, &update_layer_list_);
   }
 
   void ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(
       LayerImpl* root_layer,
       bool skip_verify_visible_rect_calculations = false) {
     DCHECK(root_layer->layer_tree_impl());
     PropertyTreeBuilder::PreCalculateMetaInformationForTesting(root_layer);
 
     bool can_render_to_separate_surface = true;
 
@@ skipping 4769 matching lines @@
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<Layer> mask_layer = Layer::Create();
 
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
   root->AddChild(child.get());
 
   host()->SetRootLayer(root);
 
   int nonexistent_id = -1;
-  LayerTree* layer_tree = host()->GetLayerTree();
-  EXPECT_EQ(root.get(), layer_tree->LayerById(root->id()));
-  EXPECT_EQ(child.get(), layer_tree->LayerById(child->id()));
-  EXPECT_EQ(grand_child.get(), layer_tree->LayerById(grand_child->id()));
-  EXPECT_EQ(mask_layer.get(), layer_tree->LayerById(mask_layer->id()));
-  EXPECT_FALSE(layer_tree->LayerById(nonexistent_id));
+  EXPECT_EQ(root.get(), host()->LayerById(root->id()));
+  EXPECT_EQ(child.get(), host()->LayerById(child->id()));
+  EXPECT_EQ(grand_child.get(), host()->LayerById(grand_child->id()));
+  EXPECT_EQ(mask_layer.get(), host()->LayerById(mask_layer->id()));
+  EXPECT_FALSE(host()->LayerById(nonexistent_id));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(10, 10));
   child->test_properties()->opacity = 0.5f;
@@ skipping 2288 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, StickyPositionBottomInnerViewportDelta) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> scroller = Layer::Create();
   scoped_refptr<Layer> sticky_pos = Layer::Create();
   root->AddChild(scroller);
   scroller->AddChild(sticky_pos);
   host()->SetRootLayer(root);
   scroller->SetScrollClipLayerId(root->id());
-  host()->GetLayerTree()->RegisterViewportLayers(nullptr, root, scroller,
-                                                 nullptr);
+  host()->RegisterViewportLayers(nullptr, root, scroller, nullptr);
 
   LayerStickyPositionConstraint sticky_position;
   sticky_position.is_sticky = true;
   sticky_position.is_anchored_bottom = true;
   sticky_position.bottom_offset = 10.0f;
   sticky_position.parent_relative_sticky_box_offset = gfx::Point(0, 70);
   sticky_position.scroll_container_relative_sticky_box_rect =
       gfx::Rect(0, 70, 10, 10);
   sticky_position.scroll_container_relative_containing_block_rect =
       gfx::Rect(0, 60, 100, 100);
@@ skipping 52 matching lines @@
   scoped_refptr<Layer> outer_clip = Layer::Create();
   scoped_refptr<Layer> outer_viewport = Layer::Create();
   scoped_refptr<Layer> sticky_pos = Layer::Create();
   root->AddChild(scroller);
   scroller->AddChild(outer_clip);
   outer_clip->AddChild(outer_viewport);
   outer_viewport->AddChild(sticky_pos);
   host()->SetRootLayer(root);
   scroller->SetScrollClipLayerId(root->id());
   outer_viewport->SetScrollClipLayerId(outer_clip->id());
-  host()->GetLayerTree()->RegisterViewportLayers(nullptr, root, scroller,
-                                                 outer_viewport);
+  host()->RegisterViewportLayers(nullptr, root, scroller, outer_viewport);
 
   LayerStickyPositionConstraint sticky_position;
   sticky_position.is_sticky = true;
   sticky_position.is_anchored_bottom = true;
   sticky_position.bottom_offset = 10.0f;
   sticky_position.parent_relative_sticky_box_offset = gfx::Point(0, 70);
   sticky_position.scroll_container_relative_sticky_box_rect =
       gfx::Rect(0, 70, 10, 10);
   sticky_position.scroll_container_relative_containing_block_rect =
       gfx::Rect(0, 60, 100, 100);
@@ skipping 524 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->GetLayerTree()->property_trees()->transform_tree;
+  TransformTree& tree =
+      root->layer_tree_host()->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 883 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()->GetLayerTree()->RegisterViewportLayers(
-      nullptr, root, inner_viewport_scroll_layer, outer_viewport_scroll_layer);
+  host()->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 463 matching lines @@
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(10, 10));
   grandchild->SetBounds(gfx::Size(10, 10));
   greatgrandchild->SetBounds(gfx::Size(10, 10));
 
   root->AddChild(child);
   child->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
   host()->SetRootLayer(root);
-  host()->GetLayerTree()->SetElementIdsForTesting();
+  host()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   const LayerList* update_list = GetUpdateLayerList();
   EXPECT_TRUE(VerifyLayerInList(grandchild, update_list));
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
@@ skipping 1117 matching lines @@
   EXPECT_EQ(property_trees->layer_id_to_effect_node_index.find(child->id()),
             property_trees->layer_id_to_effect_node_index.end());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimationsTrackingTest) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
   host()->SetRootLayer(root);
-  host()->GetLayerTree()->SetElementIdsForTesting();
+  host()->SetElementIdsForTesting();
 
   root->SetBounds(gfx::Size(100, 100));
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetBounds(gfx::Size(20, 20));
   animated->SetOpacity(0.f);
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
 
   player->AttachElement(animated->element_id());
 
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       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));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
-  EffectTree& tree = root->GetLayerTree()->property_trees()->effect_tree;
+  EffectTree& tree = root->layer_tree_host()->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));
   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);
 
   player->AbortAnimations(TargetProperty::OPACITY, false /*needs_completion*/);
   node = tree.Node(animated->effect_tree_index());
   EXPECT_FALSE(node->is_currently_animating_opacity);
   EXPECT_FALSE(node->has_potential_opacity_animation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationsTrackingTest) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
   host()->SetRootLayer(root);
-  host()->GetLayerTree()->SetElementIdsForTesting();
+  host()->SetElementIdsForTesting();
 
   root->SetBounds(gfx::Size(100, 100));
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetBounds(gfx::Size(20, 20));
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
   player->AttachElement(animated->element_id());
 
@@ skipping 12 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));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
-  TransformTree& tree = root->GetLayerTree()->property_trees()->transform_tree;
+  TransformTree& tree =
+      root->layer_tree_host()->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));
   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 79 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()->GetLayerTree()->RegisterViewportLayers(nullptr, page_scale_layer,
-                                                 parent2, nullptr);
+  host()->RegisterViewportLayers(nullptr, page_scale_layer, parent2, nullptr);
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root1.get());
 
   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;
   ScrollTree& expected_scroll_tree = property_trees.scroll_tree;
@@ skipping 91 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