cc: Compute animation scale on demand

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 7318 matching lines @@
 
   SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // No layers have animations.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   TransformOperations translation;
   translation.AppendTranslate(1.f, 2.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline;
   timeline = AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
                                         TransformOperations(), translation);
 
   // No layers have scale-affecting animations.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   TransformOperations scale;
   scale.AppendScale(5.f, 4.f, 3.f);
 
   AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
                                         TransformOperations(), scale);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // Only |child| has a scale-affecting animation.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(5.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      5.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(5.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(1.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      1.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(1.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(1.f, GetStartingAnimationScale(grand_child_raw));
 
   AddAnimatedTransformToLayerWithPlayer(grand_parent_raw->id(), timeline, 1.0,
                                         TransformOperations(), scale);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |child| have scale-affecting animations.
-  EXPECT_EQ(
-      5.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(5.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(5.f, GetMaximumAnimationScale(parent_raw));
   // We don't support combining animated scales from two nodes; 0.f means
   // that the maximum scale could not be computed.
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      1.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(1.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(1.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(1.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
                                         TransformOperations(), scale);
   parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
-  EXPECT_EQ(
-      5.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      1.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(1.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   AbortAnimationsOnLayerWithPlayer(grand_parent_raw->id(), timeline,
                                    TargetProperty::TRANSFORM);
   AbortAnimationsOnLayerWithPlayer(parent_raw->id(), timeline,
                                    TargetProperty::TRANSFORM);
   AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
                                    TargetProperty::TRANSFORM);
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
   AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
                                         TransformOperations(), perspective);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a scale-affecting animation but computing the maximum of this
   // animation is not supported.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
                                    TargetProperty::TRANSFORM);
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent_raw->SetTransform(scale_matrix);
   parent_raw->SetTransform(scale_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
                                         TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(10.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(10.f,
-            child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      10.f,
-      grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(10.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(10.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(10.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(2.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(2.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      2.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(2.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(2.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(2.f, GetStartingAnimationScale(grand_child_raw));
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.f);
   child_raw->SetTransform(perspective_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a transform that's neither a translation nor a scale.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(10.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(10.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(2.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(2.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   parent_raw->SetTransform(perspective_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |parent| and |child| have transforms that are neither translations nor
   // scales.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   parent_raw->SetTransform(identity_matrix);
   child_raw->SetTransform(identity_matrix);
   grand_parent_raw->SetTransform(perspective_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
-  EXPECT_EQ(
-      0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
-  EXPECT_EQ(
-      0.f,
-      grand_parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            parent_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(0.f,
-            child_raw->draw_properties().starting_animation_contents_scale);
-  EXPECT_EQ(
-      0.f,
-      grand_child_raw->draw_properties().starting_animation_contents_scale);
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
+  EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 }
 
 static void GatherDrawnLayers(LayerImplList* rsll,
                               std::set<LayerImpl*>* drawn_layers) {
   for (LayerIterator it = LayerIterator::Begin(rsll),
                      end = LayerIterator::End(rsll);
        it != end; ++it) {
     LayerImpl* layer = *it;
     if (it.represents_itself())
       drawn_layers->insert(layer);
@@ skipping 331 matching lines @@
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(3.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       3.f,
       child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(5.f, child2_layer->GetIdealContentsScale());
 
-  EXPECT_FLOAT_EQ(
-      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      8.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
+  EXPECT_FLOAT_EQ(8.f, GetMaximumAnimationScale(child2_layer));
 
   // Changing page-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   float page_scale_factor = 3.f;
   float device_scale_factor = 1.0f;
   std::vector<LayerImpl*> render_surface_layer_list;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, device_viewport_size, &render_surface_layer_list);
 
   inputs.page_scale_factor = page_scale_factor;
   inputs.can_adjust_raster_scales = true;
   inputs.page_scale_layer = root_layer;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       9.f,
       child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->test_properties()
                            ->replica_layer->test_properties()
                            ->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(15.f, child2_layer->GetIdealContentsScale());
 
-  EXPECT_FLOAT_EQ(
-      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      24.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
+  EXPECT_FLOAT_EQ(24.f, GetMaximumAnimationScale(child2_layer));
 
   // Changing device-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   device_scale_factor = 4.0f;
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FLOAT_EQ(12.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(36.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       36.f,
       child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(36.f, child1_layer->test_properties()
                             ->replica_layer->test_properties()
                             ->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(60.f, child2_layer->GetIdealContentsScale());
 
-  EXPECT_FLOAT_EQ(
-      0.f, root_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(
-      96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
+  EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
+  EXPECT_FLOAT_EQ(96.f, GetMaximumAnimationScale(child2_layer));
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* content = AddChild<LayerImpl>(clip);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(768 / 2, 3000), true,
@@ skipping 2274 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