Animation start scale should be considered for the raster scale

cc/trees/layer_tree_host_common.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 <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 895 matching lines @@
   }
 
   return next_scroll_compensation_matrix;
 }
 
 template <typename LayerType>
 static inline void UpdateLayerScaleDrawProperties(
     LayerType* layer,
     float ideal_contents_scale,
     float maximum_animation_contents_scale,
+    float starting_animation_contents_scale,
     float page_scale_factor,
     float device_scale_factor) {
   layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
   layer->draw_properties().maximum_animation_contents_scale =
       maximum_animation_contents_scale;
+  layer->draw_properties().starting_animation_contents_scale =
+      starting_animation_contents_scale;
   layer->draw_properties().page_scale_factor = page_scale_factor;
   layer->draw_properties().device_scale_factor = device_scale_factor;
 }
 
 static inline void CalculateContentsScale(LayerImpl* layer,
                                           float contents_scale) {
   // LayerImpl has all of its content scales and bounds pushed from the Main
   // thread during commit and just uses those values as-is.
 }
 
@@ skipping 79 matching lines @@
     layer->SetNeedsPushProperties();
 }
 
 static inline void CalculateAnimationContentsScale(
     Layer* layer,
     bool ancestor_is_animating_scale,
     float ancestor_maximum_animation_contents_scale,
     const gfx::Transform& parent_transform,
     const gfx::Transform& combined_transform,
     bool* combined_is_animating_scale,
-    float* combined_maximum_animation_contents_scale) {
+    float* combined_maximum_animation_contents_scale,
+    float* combined_starting_animation_contents_scale) {
   *combined_is_animating_scale = false;
   *combined_maximum_animation_contents_scale = 0.f;
+  *combined_starting_animation_contents_scale = 0.f;
 }
 
 static inline void CalculateAnimationContentsScale(
     LayerImpl* layer,
     bool ancestor_is_animating_scale,
     float ancestor_maximum_animation_contents_scale,
     const gfx::Transform& ancestor_transform,
     const gfx::Transform& combined_transform,
     bool* combined_is_animating_scale,
-    float* combined_maximum_animation_contents_scale) {
+    float* combined_maximum_animation_contents_scale,
+    float* combined_starting_animation_contents_scale) {
   if (ancestor_is_animating_scale &&
       ancestor_maximum_animation_contents_scale == 0.f) {
     // We've already failed to compute a maximum animated scale at an
     // ancestor, so we'll continue to fail.
     *combined_maximum_animation_contents_scale = 0.f;
+    *combined_starting_animation_contents_scale = 0.f;
     *combined_is_animating_scale = true;
     return;
   }
 
   if (!combined_transform.IsScaleOrTranslation()) {
     // Computing maximum animated scale in the presence of
     // non-scale/translation transforms isn't supported.
     *combined_maximum_animation_contents_scale = 0.f;
+    *combined_starting_animation_contents_scale = 0.f;
     *combined_is_animating_scale = true;
     return;
   }
 
   // We currently only support computing maximum scale for combinations of
   // scales and translations. We treat all non-translations as potentially
   // affecting scale. Animations that include non-translation/scale components
   // will cause the computation of MaximumScale below to fail.
   bool layer_is_animating_scale =
       !layer->layer_animation_controller()->HasOnlyTranslationTransforms();
 
   if (!layer_is_animating_scale && !ancestor_is_animating_scale) {
     *combined_maximum_animation_contents_scale = 0.f;
+    *combined_starting_animation_contents_scale = 0.f;
     *combined_is_animating_scale = false;
     return;
   }
 
   // We don't attempt to accumulate animation scale from multiple nodes,
   // because of the risk of significant overestimation. For example, one node
   // may be increasing scale from 1 to 10 at the same time as a descendant is
   // decreasing scale from 10 to 1. Naively combining these scales would produce
   // a scale of 100.
   if (layer_is_animating_scale && ancestor_is_animating_scale) {
     *combined_maximum_animation_contents_scale = 0.f;
+    *combined_starting_animation_contents_scale = 0.f;
     *combined_is_animating_scale = true;
     return;
   }
 
   // At this point, we know either the layer or an ancestor, but not both,
   // is animating scale.
   *combined_is_animating_scale = true;
   if (!layer_is_animating_scale) {
     gfx::Vector2dF layer_transform_scales =
         MathUtil::ComputeTransform2dScaleComponents(layer->transform(), 0.f);
     *combined_maximum_animation_contents_scale =
         ancestor_maximum_animation_contents_scale *
         std::max(layer_transform_scales.x(), layer_transform_scales.y());
+    *combined_starting_animation_contents_scale =
+        *combined_maximum_animation_contents_scale;
     return;
   }
 
   float layer_maximum_animated_scale = 0.f;
+  float layer_start_animated_scale = 0.f;
   if (!layer->layer_animation_controller()->MaximumTargetScale(
           &layer_maximum_animated_scale)) {
     *combined_maximum_animation_contents_scale = 0.f;
     return;
   }
+  if (!layer->layer_animation_controller()->AnimationStartScale(
+          &layer_start_animated_scale)) {
+    *combined_starting_animation_contents_scale = 0.f;
+    return;
+  }
+
   gfx::Vector2dF ancestor_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
+  float max_scale_xy =
+      std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
   *combined_maximum_animation_contents_scale =
-      layer_maximum_animated_scale *
-      std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
+      layer_maximum_animated_scale * max_scale_xy;
+  *combined_starting_animation_contents_scale =
+      layer_start_animated_scale * max_scale_xy;
 }
 
 template <typename LayerTypePtr>
 static inline void MarkLayerWithRenderSurfaceLayerListId(
     LayerTypePtr layer,
     int current_render_surface_layer_list_id) {
   layer->draw_properties().last_drawn_render_surface_layer_list_id =
       current_render_surface_layer_list_id;
   layer->draw_properties().layer_or_descendant_is_drawn =
       !!current_render_surface_layer_list_id;
@@ skipping 589 matching lines @@
                            1.f / parent_scales.x(),
                            1.f / parent_scales.y());
   }
 
   // Apply adjustment from position constraints.
   ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container,
       data_from_ancestor.scroll_compensation_matrix, &combined_transform);
 
   bool combined_is_animating_scale = false;
   float combined_maximum_animation_contents_scale = 0.f;
+  float combined_starting_animation_contents_scale = 0.f;
   if (globals.can_adjust_raster_scales) {
     CalculateAnimationContentsScale(
-        layer,
-        data_from_ancestor.ancestor_is_animating_scale,
+        layer, data_from_ancestor.ancestor_is_animating_scale,
         data_from_ancestor.maximum_animation_contents_scale,
-        data_from_ancestor.parent_matrix,
-        combined_transform,
+        data_from_ancestor.parent_matrix, combined_transform,
         &combined_is_animating_scale,
-        &combined_maximum_animation_contents_scale);
+        &combined_maximum_animation_contents_scale,
+        &combined_starting_animation_contents_scale);
   }
   data_for_children.ancestor_is_animating_scale = combined_is_animating_scale;
   data_for_children.maximum_animation_contents_scale =
       combined_maximum_animation_contents_scale;
 
   // Compute the 2d scale components of the transform hierarchy up to the target
   // surface. From there, we can decide on a contents scale for the layer.
   float layer_scale_factors = globals.device_scale_factor;
   if (data_from_ancestor.in_subtree_of_page_scale_application_layer)
     layer_scale_factors *= globals.page_scale_factor;
@@ skipping 11 matching lines @@
       layer,
       globals.can_adjust_raster_scales,
       ideal_contents_scale,
       globals.device_scale_factor,
       data_from_ancestor.in_subtree_of_page_scale_application_layer
           ? globals.page_scale_factor
           : 1.f,
       animating_transform_to_screen);
 
   UpdateLayerScaleDrawProperties(
-      layer,
-      ideal_contents_scale,
-      combined_maximum_animation_contents_scale,
+      layer, ideal_contents_scale, combined_maximum_animation_contents_scale,
+      combined_starting_animation_contents_scale,
       data_from_ancestor.in_subtree_of_page_scale_application_layer
           ? globals.page_scale_factor
           : 1.f,
       globals.device_scale_factor);
 
   LayerType* mask_layer = layer->mask_layer();
   if (mask_layer) {
     UpdateLayerScaleDrawProperties(
-        mask_layer,
-        ideal_contents_scale,
+        mask_layer, ideal_contents_scale,
         combined_maximum_animation_contents_scale,
+        combined_starting_animation_contents_scale,
         data_from_ancestor.in_subtree_of_page_scale_application_layer
             ? globals.page_scale_factor
             : 1.f,
         globals.device_scale_factor);
   }
 
   LayerType* replica_mask_layer =
       layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
   if (replica_mask_layer) {
     UpdateLayerScaleDrawProperties(
-        replica_mask_layer,
-        ideal_contents_scale,
+        replica_mask_layer, ideal_contents_scale,
         combined_maximum_animation_contents_scale,
+        combined_starting_animation_contents_scale,
         data_from_ancestor.in_subtree_of_page_scale_application_layer
             ? globals.page_scale_factor
             : 1.f,
         globals.device_scale_factor);
   }
 
   // The draw_transform that gets computed below is effectively the layer's
   // draw_transform, unless the layer itself creates a render_surface. In that
   // case, the render_surface re-parents the transforms.
   layer_draw_properties.target_space_transform = combined_transform;
@@ skipping 865 matching lines @@
                                 PropertyTrees* trees_from_inputs) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer,
                                 PropertyTrees* trees_from_inputs) {
   return trees_from_inputs;
 }
 
 }  // namespace cc