cc : Compute visible rects dynamically (2)

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 156 matching lines @@
   template <class LayerType>
   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) {
+  void ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(Layer* root_layer) {
     DCHECK(root_layer->GetLayerTree());
     PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
 
     bool can_render_to_separate_surface = true;
 
     const Layer* page_scale_layer =
         root_layer->GetLayerTree()->page_scale_layer();
     Layer* inner_viewport_scroll_layer =
         root_layer->GetLayerTree()->inner_viewport_scroll_layer();
     Layer* outer_viewport_scroll_layer =
@@ skipping 15 matching lines @@
         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->transform_tree,
         property_trees->effect_tree, &update_layer_list_);
   }
 
-  void ExecuteCalculateDrawPropertiesWithPropertyTrees(LayerImpl* root_layer) {
+  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;
 
     LayerImpl* page_scale_layer = nullptr;
     LayerImpl* inner_viewport_scroll_layer =
         root_layer->layer_tree_impl()->InnerViewportScrollLayer();
     LayerImpl* outer_viewport_scroll_layer =
         root_layer->layer_tree_impl()->OuterViewportScrollLayer();
     LayerImpl* overscroll_elasticity_layer =
         root_layer->layer_tree_impl()->OverscrollElasticityLayer();
     gfx::Vector2dF elastic_overscroll =
         root_layer->layer_tree_impl()->elastic_overscroll()->Current(
             root_layer->layer_tree_impl()->IsActiveTree());
     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);
     update_layer_list_impl_.reset(new LayerImplList);
     root_layer->layer_tree_impl()->BuildLayerListForTesting();
-    bool verify_visible_rect_calculations = true;
+    PropertyTrees* property_trees =
+        root_layer->layer_tree_impl()->property_trees();
     draw_property_utils::BuildPropertyTreesAndComputeVisibleRects(
         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(),
-        can_render_to_separate_surface, verify_visible_rect_calculations,
-        root_layer->layer_tree_impl()->property_trees(),
+        can_render_to_separate_surface, property_trees,
         update_layer_list_impl_.get());
+    draw_property_utils::VerifyClipTreeCalculations(*update_layer_list_impl_,
+                                                    property_trees);
+    if (!skip_verify_visible_rect_calculations)
+      draw_property_utils::VerifyVisibleRectsCalculations(
+          *update_layer_list_impl_, property_trees);
   }
 
   void ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(
       LayerImpl* root_layer) {
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width(), root_layer->bounds().height());
     render_surface_layer_list_impl_.reset(new LayerImplList);
 
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
@@ skipping 927 matching lines @@
   gfx::Transform grand_child_transform;
   grand_child_transform.RotateAboutYAxis(90.0);
 
   root->SetBounds(gfx::Size(200, 200));
   child->test_properties()->transform = child_transform;
   child->SetBounds(gfx::Size(10, 10));
   grand_child->test_properties()->transform = grand_child_transform;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->test_properties()->should_flatten_transform = false;
   grand_child->SetDrawsContent(true);
-  ExecuteCalculateDrawProperties(root);
+  float device_scale_factor = 1.f;
+  float page_scale_factor = 1.f;
+  LayerImpl* page_scale_layer = nullptr;
+  // Visible rects computed by combining clips in target space and root space
+  // don't match because of rotation transforms. So, we skip
+  // verify_visible_rect_calculations.
+  bool skip_verify_visible_rect_calculations = true;
+  ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
+                                 page_scale_layer,
+                                 skip_verify_visible_rect_calculations);
 
   // Mapping grand_child's bounds to target space produces a non-empty rect
   // that is fully contained within the target's bounds, so grand_child should
   // be considered fully visible.
   EXPECT_EQ(gfx::Rect(grand_child->bounds()),
             grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
   // A layer that is empty in one axis, but not the other, was accidentally
@@ skipping 513 matching lines @@
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   root->SetBounds(gfx::Size(10, 10));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   {
-    ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+    ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(root->has_render_surface());
     EXPECT_TRUE(render_surface1->has_render_surface());
   }
 
   {
     render_surface1->test_properties()->force_render_surface = false;
     render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
-    ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+    ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
     EXPECT_TRUE(root->has_render_surface());
     EXPECT_FALSE(render_surface1->has_render_surface());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
@@ skipping 2448 matching lines @@
   back_facing_child->test_properties()->transform = backface_matrix;
   back_facing_surface->test_properties()->transform = backface_matrix;
   back_facing_child_of_front_facing_surface->test_properties()->transform =
       backface_matrix;
   back_facing_child_of_back_facing_surface->test_properties()->transform =
       backface_matrix;
 
   // Note: No layers preserve 3d. According to current W3C CSS gfx::Transforms
   // spec, these layers should blindly use their own local transforms to
   // determine back-face culling.
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(
       front_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());
@@ skipping 88 matching lines @@
   // and (b) the layer's transform style is preserve-3d.
   front_facing_surface->test_properties()->should_flatten_transform = false;
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->test_properties()->should_flatten_transform = false;
   back_facing_surface->Set3dSortingContextId(1);
   front_facing_child_of_front_facing_surface->Set3dSortingContextId(1);
   back_facing_child_of_front_facing_surface->Set3dSortingContextId(1);
   front_facing_child_of_back_facing_surface->Set3dSortingContextId(1);
   back_facing_child_of_back_facing_surface->Set3dSortingContextId(1);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
   // We expect that a has_render_surface was created but not used.
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(
       front_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());
@@ skipping 55 matching lines @@
   child->test_properties()->transform = backface_matrix;
   animating_surface->SetBounds(gfx::Size(100, 100));
   animating_surface->test_properties()->transform = backface_matrix;
   animating_surface->test_properties()->force_render_surface = true;
   child_of_animating_surface->SetBounds(gfx::Size(100, 100));
   child_of_animating_surface->test_properties()->transform = backface_matrix;
   animating_child->SetBounds(gfx::Size(100, 100));
   animating_child->test_properties()->transform = backface_matrix;
   child2->SetBounds(gfx::Size(100, 100));
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   EXPECT_FALSE(child->has_render_surface());
   EXPECT_TRUE(animating_surface->has_render_surface());
   EXPECT_FALSE(child_of_animating_surface->has_render_surface());
   EXPECT_FALSE(animating_child->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
 
   EXPECT_EQ(1u, update_layer_list_impl()->size());
 
   // The back facing layers are culled from the layer list, and have an empty
@@ skipping 38 matching lines @@
   front_facing_surface->test_properties()->force_render_surface = true;
   back_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_surface->test_properties()->transform = backface_matrix;
   back_facing_surface->test_properties()->force_render_surface = true;
   child1->SetBounds(gfx::Size(100, 100));
   child2->SetBounds(gfx::Size(100, 100));
 
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->Set3dSortingContextId(1);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created and used.
   EXPECT_TRUE(front_facing_surface->has_render_surface());
 
   // We expect the render surface to have been created, but remain unused.
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
 
   EXPECT_EQ(2u, update_layer_list_impl()->size());
@@ skipping 1501 matching lines @@
   child1->SetBounds(bounds);
   child1->SetDrawsContent(true);
   child1->Set3dSortingContextId(1);
   child1->test_properties()->should_flatten_transform = false;
   child2->SetBounds(bounds);
   child2->SetDrawsContent(true);
   child2->Set3dSortingContextId(1);
   child3->SetBounds(bounds);
   child3->SetDrawsContent(true);
   child3->Set3dSortingContextId(1);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(child1->has_render_surface());
   EXPECT_TRUE(child2->has_render_surface());
   EXPECT_FALSE(child3->has_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
@@ skipping 1901 matching lines @@
   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);
 
   fixed_to_inner->SetPositionConstraint(fixed_to_right);
   fixed_to_outer->SetPositionConstraint(fixed_to_right);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
   TransformTree& transform_tree = host()->property_trees()->transform_tree;
   EXPECT_TRUE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_TRUE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 
   LayerPositionConstraint fixed_to_left;
   fixed_to_left.set_is_fixed_position(true);
   fixed_to_inner->SetPositionConstraint(fixed_to_left);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_TRUE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 
   fixed_to_outer->SetPositionConstraint(fixed_to_left);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
   host_impl()->CreatePendingTree();
   std::unique_ptr<LayerImpl> pending_root =
       LayerImpl::Create(host_impl()->pending_tree(), 1);
   LayerImpl* root = pending_root.get();
   host_impl()->pending_tree()->SetRootLayerForTesting(std::move(pending_root));
   std::unique_ptr<LayerImpl> animated_ptr =
       LayerImpl::Create(host_impl()->pending_tree(), 2);
   LayerImpl* animated = animated_ptr.get();
   root->test_properties()->AddChild(std::move(animated_ptr));
 
   animated->SetDrawsContent(true);
   host_impl()->pending_tree()->SetElementIdsForTesting();
 
   root->SetBounds(gfx::Size(100, 100));
   root->SetMasksToBounds(true);
   root->test_properties()->force_render_surface = true;
   animated->test_properties()->opacity = 0.f;
   animated->SetBounds(gfx::Size(20, 20));
 
   AddOpacityTransitionToElementWithPlayer(
       animated->element_id(), timeline_impl(), 10.0, 0.f, 1.f, false);
   animated->test_properties()->opacity_can_animate = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   EXPECT_FALSE(animated->visible_layer_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* animated = AddChild<LayerImpl>(clip);
   LayerImpl* surface = AddChild<LayerImpl>(animated);
@@ skipping 17 matching lines @@
   surface->test_properties()->force_render_surface = true;
   descendant_of_animation->SetBounds(gfx::Size(200, 200));
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
   AddAnimatedTransformToElementWithPlayer(
       animated->element_id(), timeline_impl(), 10.0, start_transform_operations,
       end_transform_operations);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   // The animated layer has a singular transform and maps to a non-empty rect in
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(2, 2), descendant_of_animation->visible_layer_rect());
 
   gfx::Transform zero_matrix;
   zero_matrix.Scale3d(0.f, 0.f, 0.f);
   root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
       zero_matrix, animated->transform_tree_index(), root->layer_tree_impl());
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+  // While computing visible rects by combining clips in screen space, we set
+  // the entire layer as visible if the screen space transform is singular. This
+  // is not always true when we combine clips in target space because if the
+  // intersection of combined_clip in taret space with layer_rect projected to
+  // target space is empty, we set it to an empty rect.
+  bool skip_verify_visible_rect_calculations = true;
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(
+      root, skip_verify_visible_rect_calculations);
 
   // The animated layer maps to the empty rect in clipped target space, so is
   // treated as having an empty visible rect.
   EXPECT_EQ(gfx::Rect(), animated->visible_layer_rect());
 
+  // The animated layer will be treated as fully visible when we combine clips
+  // in screen space.
+  gfx::Rect visible_rect = draw_property_utils::ComputeLayerVisibleRectDynamic(
+      root->layer_tree_impl()->property_trees(), animated);
+  EXPECT_EQ(gfx::Rect(120, 120), visible_rect);
+
   // This time, flattening does not make |animated|'s transform invertible. This
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(), descendant_of_animation->visible_layer_rect());
 }
 
 // Verify that having animated opacity but current opacity 1 still creates
 // a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedOpacityCreatesRenderSurface) {
@@ skipping 213 matching lines @@
 
   translate.Translate(10, 10);
   rotate.Rotate(45);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(800, 800));
   root->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(translate);
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(rotate);
   EXPECT_TRUE(host()->property_trees()->needs_rebuild);
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangeTransformOrigin) {
@@ skipping 69 matching lines @@
   root->AddChild(child2);
   child1->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
   host()->SetRootLayer(root);
 
   child1->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   greatgrandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   child2->SetOpacity(0.f);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
   EXPECT_EQ(root->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child1->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child2->num_copy_requests_in_target_subtree(), 0);
   EXPECT_EQ(grandchild->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(greatgrandchild->num_copy_requests_in_target_subtree(), 1);
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
   scoped_refptr<Layer> root = Layer::Create();
@@ skipping 11 matching lines @@
   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();
 
   // Check the non-skipped case.
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  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.
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
 
   child->SetTransform(singular);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_FALSE(VerifyLayerInList(grandchild, update_list));
   child->SetTransform(gfx::Transform());
 
   child->SetHideLayerAndSubtree(true);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_FALSE(VerifyLayerInList(grandchild, update_list));
   child->SetHideLayerAndSubtree(false);
 
   gfx::Transform zero_z_scale;
   zero_z_scale.Scale3d(1, 1, 0);
   child->SetTransform(zero_z_scale);
 
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)),
       animation_id, 1, TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   AddAnimationToElementWithPlayer(child->element_id(), timeline(),
                                   std::move(animation));
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_TRUE(VerifyLayerInList(grandchild, update_list));
 
   RemoveAnimationFromElementWithExistingPlayer(child->element_id(), timeline(),
                                                animation_id);
   child->SetTransform(gfx::Transform());
   child->SetOpacity(0.f);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_FALSE(VerifyLayerInList(grandchild, update_list));
 
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   grandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_TRUE(VerifyLayerInList(grandchild, update_list));
 
   // Add an opacity animation with a start delay.
   animation_id = 1;
   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));
   AddAnimationToElementWithExistingPlayer(child->element_id(), timeline(),
                                           std::move(animation));
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   update_list = GetUpdateLayerList();
   EXPECT_TRUE(VerifyLayerInList(grandchild, update_list));
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
@@ skipping 19 matching lines @@
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
-  // ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  // ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   // EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   // 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.
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
 
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
   // This line is used to make the results of skipping and not skipping layers
   // different.
   singular.matrix().set(0, 1, 1);
 
   gfx::Transform rotate;
   rotate.Rotate(90);
 
   gfx::Transform rotate_back_and_translate;
   rotate_back_and_translate.RotateAboutYAxis(180);
   rotate_back_and_translate.Translate(-10, 0);
 
   child_ptr->test_properties()->transform = singular;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->transform = gfx::Transform();
 
   child_ptr->test_properties()->hide_layer_and_subtree = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->hide_layer_and_subtree = false;
 
   child_ptr->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.f, child_ptr->effect_tree_index(), child_ptr->layer_tree_impl());
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->opacity = 1.f;
 
   root_ptr->test_properties()->transform = singular;
   // Force transform tree to have a node for child, so that ancestor's
   // invertible transform can be tested.
   child_ptr->test_properties()->transform = rotate;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   root_ptr->test_properties()->transform = gfx::Transform();
   child_ptr->test_properties()->transform = gfx::Transform();
 
   root_ptr->test_properties()->opacity = 0.f;
   child_ptr->test_properties()->opacity = 0.7f;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   root_ptr->test_properties()->opacity = 1.f;
 
   child_ptr->test_properties()->opacity = 0.f;
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   grandchild_ptr->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateEmptyRequest());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->property_trees()->effect_tree.ClearCopyRequests();
   child_ptr->test_properties()->opacity = 1.f;
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetHasRenderSurface(true);
   child_ptr->test_properties()->double_sided = true;
   child_ptr->test_properties()->transform = rotate_back_and_translate;
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->transform = gfx::Transform();
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_ptr<Animation> transform_animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl.active_tree()->animation_host()->RegisterPlayerForElement(
       root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
       ->GetElementAnimationsForElementId(root_ptr->element_id())
       ->AddAnimation(std::move(transform_animation));
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetScrollClipLayer(root_ptr->id());
   root_ptr->test_properties()->transform = singular;
   child_ptr->test_properties()->transform = singular;
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
@@ skipping 70 matching lines @@
   LayerImpl* root_ptr = root.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
 
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.pending_tree()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   std::unique_ptr<TimingFunction> func =
       CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE);
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta(), 0.9f, std::move(func)));
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 0.3f, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::OPACITY));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl.active_tree()->animation_host()->RegisterPlayerForElement(
       root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
       ->GetElementAnimationsForElementId(root_ptr->element_id())
       ->AddAnimation(std::move(animation));
   root_ptr->test_properties()->opacity = 0.f;
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
@@ skipping 45 matching lines @@
   child->SetBounds(gfx::Size(100, 100));
   child->SetClipParent(root.get());
 
   root->AddChild(parent);
   parent->AddChild(child);
   host()->SetRootLayer(root);
 
   child->RequestCopyOfOutput(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_EQ(parent->num_unclipped_descendants(), 1u);
 
   EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(800, 800));
 
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
   scoped_refptr<Layer> child = Layer::Create();
   child->SetTransform(translate_z);
   child->SetBounds(gfx::Size(100, 100));
 
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_NE(-1, child->transform_tree_index());
 
   child->RemoveFromParent();
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_EQ(-1, child->transform_tree_index());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceClipsSubtree) {
   // Ensure that a Clip Node is added when a render surface applies clip.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* significant_transform = AddChildToRoot<LayerImpl>();
   LayerImpl* layer_clips_subtree = AddChild<LayerImpl>(significant_transform);
   LayerImpl* render_surface = AddChild<LayerImpl>(layer_clips_subtree);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
@@ skipping 683 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, PropertyTreesRebuildWithOpacityChanges) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
   host()->SetRootLayer(root);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(20, 20));
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
   // Changing the opacity from 1 to non-1 value should trigger rebuild of
   // property trees as a new effect node will be created.
   child->SetOpacity(0.5f);
   PropertyTrees* property_trees = host()->property_trees();
   EXPECT_TRUE(property_trees->needs_rebuild);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_NE(property_trees->effect_id_to_index_map.find(child->id()),
             property_trees->effect_id_to_index_map.end());
 
   // child already has an effect node. Changing its opacity shouldn't trigger
   // a property trees rebuild.
   child->SetOpacity(0.8f);
   property_trees = host()->property_trees();
   EXPECT_FALSE(property_trees->needs_rebuild);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_NE(property_trees->effect_id_to_index_map.find(child->id()),
             property_trees->effect_id_to_index_map.end());
 
   // Changing the opacity from non-1 value to 1 should trigger a rebuild of
   // property trees as the effect node may no longer be needed.
   child->SetOpacity(1.f);
   property_trees = host()->property_trees();
   EXPECT_TRUE(property_trees->needs_rebuild);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_EQ(property_trees->effect_id_to_index_map.find(child->id()),
             property_trees->effect_id_to_index_map.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);
@@ skipping 13 matching lines @@
   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));
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
   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));
   host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->effect_tree_index());
@@ skipping 36 matching lines @@
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   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());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
   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));
   host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->transform_tree_index());
@@ skipping 120 matching lines @@
   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);
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(root1.get());
+  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(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;
   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