Rasterize at maximum scale for scale animations on CPU-rasterized layers

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 885 matching lines @@
     }
     next_scroll_compensation_matrix =
         inverse_surface_draw_transform * next_scroll_compensation_matrix *
         layer->render_surface()->draw_transform();
   }
 
   return next_scroll_compensation_matrix;
 }
 
 template <typename LayerType>
-static inline void CalculateContentsScale(LayerType* layer,
-                                          float contents_scale,
-                                          float device_scale_factor,
-                                          float page_scale_factor,
-                                          bool animating_transform_to_screen) {
+static inline void CalculateContentsScale(
+    LayerType* layer,
+    float contents_scale,
+    float device_scale_factor,
+    float page_scale_factor,
+    float maximum_animation_contents_scale,
+    bool animating_transform_to_screen) {
   layer->CalculateContentsScale(contents_scale,
                                 device_scale_factor,
                                 page_scale_factor,
+                                maximum_animation_contents_scale,
                                 animating_transform_to_screen,
                                 &layer->draw_properties().contents_scale_x,
                                 &layer->draw_properties().contents_scale_y,
                                 &layer->draw_properties().content_bounds);
 
   LayerType* mask_layer = layer->mask_layer();
   if (mask_layer) {
     mask_layer->CalculateContentsScale(
         contents_scale,
         device_scale_factor,
         page_scale_factor,
+        maximum_animation_contents_scale,
         animating_transform_to_screen,
         &mask_layer->draw_properties().contents_scale_x,
         &mask_layer->draw_properties().contents_scale_y,
         &mask_layer->draw_properties().content_bounds);
   }
 
   LayerType* replica_mask_layer =
       layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
   if (replica_mask_layer) {
     replica_mask_layer->CalculateContentsScale(
         contents_scale,
         device_scale_factor,
         page_scale_factor,
+        maximum_animation_contents_scale,
         animating_transform_to_screen,
         &replica_mask_layer->draw_properties().contents_scale_x,
         &replica_mask_layer->draw_properties().contents_scale_y,
         &replica_mask_layer->draw_properties().content_bounds);
   }
 }
 
 static inline void UpdateLayerContentsScale(
     LayerImpl* layer,
     bool can_adjust_raster_scale,
     float ideal_contents_scale,
     float device_scale_factor,
     float page_scale_factor,
+    float maximum_animation_contents_scale,
     bool animating_transform_to_screen) {
   CalculateContentsScale(layer,
                          ideal_contents_scale,
                          device_scale_factor,
                          page_scale_factor,
+                         maximum_animation_contents_scale,
                          animating_transform_to_screen);
 }
 
 static inline void UpdateLayerContentsScale(
     Layer* layer,
     bool can_adjust_raster_scale,
     float ideal_contents_scale,
     float device_scale_factor,
     float page_scale_factor,
+    float maximum_animation_contents_scale,
     bool animating_transform_to_screen) {
   if (can_adjust_raster_scale) {
     float ideal_raster_scale =
         ideal_contents_scale / (device_scale_factor * page_scale_factor);
 
     bool need_to_set_raster_scale = layer->raster_scale_is_unknown();
 
     // If we've previously saved a raster_scale but the ideal changes, things
     // are unpredictable and we should just use 1.
     if (!need_to_set_raster_scale && layer->raster_scale() != 1.f &&
@@ skipping 16 matching lines @@
 
   gfx::Size old_content_bounds = layer->content_bounds();
   float old_contents_scale_x = layer->contents_scale_x();
   float old_contents_scale_y = layer->contents_scale_y();
 
   float contents_scale = raster_scale * device_scale_factor * page_scale_factor;
   CalculateContentsScale(layer,
                          contents_scale,
                          device_scale_factor,
                          page_scale_factor,
+                         maximum_animation_contents_scale,
                          animating_transform_to_screen);
 
   if (layer->content_bounds() != old_content_bounds ||
       layer->contents_scale_x() != old_contents_scale_x ||
       layer->contents_scale_y() != old_contents_scale_y)
     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) {
+  *combined_is_animating_scale = false;
+  *combined_maximum_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) {
+  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_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_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_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_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());
+    return;
+  }
+
+  float layer_maximum_animated_scale = 0.f;
+  if (!layer->layer_animation_controller()->MaximumScale(
+          &layer_maximum_animated_scale)) {
+    *combined_maximum_animation_contents_scale = 0.f;
+    return;
+  }
+  gfx::Vector2dF ancestor_transform_scales =
+      MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
+  *combined_maximum_animation_contents_scale =
+      layer_maximum_animated_scale *
+      std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
+}
+
 static inline RenderSurface* CreateOrReuseRenderSurface(Layer* layer) {
   // The render surface should always be new on the main thread, as the
   // RenderSurfaceLayerList should be a new empty list when given to
   // CalculateDrawProperties.
   DCHECK(!layer->render_surface());
   layer->CreateRenderSurface();
   return layer->render_surface();
 }
 
 static inline RenderSurfaceImpl* CreateOrReuseRenderSurface(LayerImpl* layer) {
@@ skipping 139 matching lines @@
   // When the layer's children want to compute their visible content rect, they
   // want to know what their target surface's clip rect will be. BUT - they
   // want to know this clip rect represented in their own target space. This
   // requires inverse-projecting the surface's clip rect from the surface's
   // render target space down to the surface's own space. Instead of computing
   // this value redundantly for each child layer, it is computed only once
   // while dealing with the parent layer, and then this precomputed value is
   // passed down the recursion to the children that actually use it.
   gfx::Rect clip_rect_of_target_surface_in_target_space;
 
+  // The maximum amount by which this layer will be scaled during the lifetime
+  // of currently running animations.
+  float maximum_animation_contents_scale;
+
+  bool ancestor_is_animating_scale;
   bool ancestor_clips_subtree;
   typename LayerType::RenderSurfaceType*
       nearest_occlusion_immune_ancestor_surface;
   bool in_subtree_of_page_scale_application_layer;
   bool subtree_can_use_lcd_text;
   bool subtree_is_visible_from_ancestor;
 };
 
 template <typename LayerType>
 static LayerType* GetChildContainingLayer(const LayerType& parent,
@@ skipping 361 matching lines @@
     effective_scroll_delta -=
         gfx::ScaleVector2d(current_translation - previous_translation,
                            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;
+  if (globals.can_adjust_raster_scales) {
+    CalculateAnimationContentsScale(
+        layer,
+        data_from_ancestor.ancestor_is_animating_scale,
+        data_from_ancestor.maximum_animation_contents_scale,
+        data_from_ancestor.parent_matrix,
+        combined_transform,
+        &combined_is_animating_scale,
+        &combined_maximum_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;
   gfx::Vector2dF combined_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(
           combined_transform,
           layer_scale_factors);
 
   float ideal_contents_scale =
       globals.can_adjust_raster_scales
       ? std::max(combined_transform_scales.x(),
                  combined_transform_scales.y())
       : layer_scale_factors;
   UpdateLayerContentsScale(
       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,
+      data_from_ancestor.in_subtree_of_page_scale_application_layer
+          ? globals.page_scale_factor
+          : 1.f,
+      combined_maximum_animation_contents_scale,
       animating_transform_to_screen);
 
   // 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;
   // M[draw] = M[parent] * LT * S[layer2content]
   layer_draw_properties.target_space_transform.Scale(
       SK_MScalar1 / layer->contents_scale_x(),
       SK_MScalar1 / layer->contents_scale_y());
@@ skipping 567 matching lines @@
   globals.can_adjust_raster_scales = inputs->can_adjust_raster_scales;
 
   DataForRecursion<Layer> data_for_recursion;
   data_for_recursion.parent_matrix = scaled_device_transform;
   data_for_recursion.full_hierarchy_matrix = identity_matrix;
   data_for_recursion.scroll_compensation_matrix = identity_matrix;
   data_for_recursion.fixed_container = inputs->root_layer;
   data_for_recursion.clip_rect_in_target_space = device_viewport_rect;
   data_for_recursion.clip_rect_of_target_surface_in_target_space =
       device_viewport_rect;
+  data_for_recursion.maximum_animation_contents_scale = 1.f;
+  data_for_recursion.ancestor_is_animating_scale = false;
   data_for_recursion.ancestor_clips_subtree = true;
   data_for_recursion.nearest_occlusion_immune_ancestor_surface = NULL;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.subtree_can_use_lcd_text = inputs->can_use_lcd_text;
   data_for_recursion.subtree_is_visible_from_ancestor = true;
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer>(inputs->root_layer,
@@ skipping 38 matching lines @@
   globals.can_adjust_raster_scales = inputs->can_adjust_raster_scales;
 
   DataForRecursion<LayerImpl> data_for_recursion;
   data_for_recursion.parent_matrix = scaled_device_transform;
   data_for_recursion.full_hierarchy_matrix = identity_matrix;
   data_for_recursion.scroll_compensation_matrix = identity_matrix;
   data_for_recursion.fixed_container = inputs->root_layer;
   data_for_recursion.clip_rect_in_target_space = device_viewport_rect;
   data_for_recursion.clip_rect_of_target_surface_in_target_space =
       device_viewport_rect;
+  data_for_recursion.maximum_animation_contents_scale = 1.f;
+  data_for_recursion.ancestor_is_animating_scale = false;
   data_for_recursion.ancestor_clips_subtree = true;
   data_for_recursion.nearest_occlusion_immune_ancestor_surface = NULL;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.subtree_can_use_lcd_text = inputs->can_use_lcd_text;
   data_for_recursion.subtree_is_visible_from_ancestor = true;
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<LayerImpl> >
       accumulated_surface_state;
@@ skipping 180 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc