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

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 399 matching lines @@
   if (tilings_)
     RemoveAllTilings();
 
   ResetRasterScale();
 }
 
 void PictureLayerImpl::CalculateContentsScale(
     float ideal_contents_scale,
     float device_scale_factor,
     float page_scale_factor,
+    float maximum_animation_contents_scale,
     bool animating_transform_to_screen,
     float* contents_scale_x,
     float* contents_scale_y,
     gfx::Size* content_bounds) {
   DoPostCommitInitializationIfNeeded();
 
   // This function sets valid raster scales and manages tilings, so tile
   // priorities can now be updated.
   should_update_tile_priorities_ = true;
 
@@ skipping 22 matching lines @@
   float ideal_page_scale = page_scale_factor;
   float ideal_device_scale = device_scale_factor;
   float ideal_source_scale =
       ideal_contents_scale / ideal_page_scale / ideal_device_scale;
 
   ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale);
   ideal_page_scale_ = ideal_page_scale;
   ideal_device_scale_ = ideal_device_scale;
   ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
 
-  ManageTilings(animating_transform_to_screen);
+  ManageTilings(animating_transform_to_screen,
+                maximum_animation_contents_scale);
 
   // The content scale and bounds for a PictureLayerImpl is somewhat fictitious.
   // There are (usually) several tilings at different scales.  However, the
   // content bounds is the (integer!) space in which quads are generated.
   // In order to guarantee that we can fill this integer space with any set of
   // tilings (and then map back to floating point texture coordinates), the
   // contents scale must be at least as large as the largest of the tilings.
   float max_contents_scale = min_contents_scale;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings_->tiling_at(i);
@@ skipping 434 matching lines @@
 namespace {
 
 inline float PositiveRatio(float float1, float float2) {
   DCHECK_GT(float1, 0);
   DCHECK_GT(float2, 0);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 }  // namespace
 
-void PictureLayerImpl::ManageTilings(bool animating_transform_to_screen) {
+void PictureLayerImpl::ManageTilings(bool animating_transform_to_screen,
+                                     float maximum_animation_contents_scale) {
   DCHECK(ideal_contents_scale_);
   DCHECK(ideal_page_scale_);
   DCHECK(ideal_device_scale_);
   DCHECK(ideal_source_scale_);
   DCHECK(CanHaveTilings());
   DCHECK(!needs_post_commit_initialization_);
 
   bool change_target_tiling =
       raster_page_scale_ == 0.f ||
       raster_device_scale_ == 0.f ||
       raster_source_scale_ == 0.f ||
       raster_contents_scale_ == 0.f ||
       low_res_raster_contents_scale_ == 0.f ||
       ShouldAdjustRasterScale(animating_transform_to_screen);
 
   if (tilings_->num_tilings() == 0) {
     DCHECK(change_target_tiling)
         << "A layer with no tilings shouldn't have valid raster scales";
   }
 
   // Store the value for the next time ShouldAdjustRasterScale is called.
   raster_source_scale_was_animating_ = animating_transform_to_screen;
 
   if (!change_target_tiling)
     return;
 
   if (!layer_tree_impl()->device_viewport_valid_for_tile_management())
     return;
 
-  RecalculateRasterScales(animating_transform_to_screen);
+  RecalculateRasterScales(animating_transform_to_screen,
+                          maximum_animation_contents_scale);
 
   PictureLayerTiling* high_res = NULL;
   PictureLayerTiling* low_res = NULL;
 
   PictureLayerTiling* previous_low_res = NULL;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == raster_contents_scale_)
       high_res = tiling;
     if (tiling->contents_scale() == low_res_raster_contents_scale_)
@@ skipping 32 matching lines @@
   SanityCheckTilingState();
 }
 
 bool PictureLayerImpl::ShouldAdjustRasterScale(
     bool animating_transform_to_screen) const {
   // TODO(danakj): Adjust raster source scale closer to ideal source scale at
   // a throttled rate. Possibly make use of invalidation_.IsEmpty() on pending
   // tree. This will allow CSS scale changes to get re-rastered at an
   // appropriate rate.
 
-  if (raster_source_scale_was_animating_ && !animating_transform_to_screen)
+  if (raster_source_scale_was_animating_ != animating_transform_to_screen)
     return true;
 
   if (animating_transform_to_screen &&
       raster_contents_scale_ != ideal_contents_scale_ &&
       ShouldUseGpuRasterization())
     return true;
 
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && raster_page_scale_) {
     // We change our raster scale when it is:
@@ skipping 27 matching lines @@
     float ratio = PositiveRatio(tiling_contents_scale, scale);
     if (ratio < snapped_ratio) {
       snapped_contents_scale = tiling_contents_scale;
       snapped_ratio = ratio;
     }
   }
   return snapped_contents_scale;
 }
 
 void PictureLayerImpl::RecalculateRasterScales(
-    bool animating_transform_to_screen) {
+    bool animating_transform_to_screen,
+    float maximum_animation_contents_scale) {
   raster_device_scale_ = ideal_device_scale_;
   raster_source_scale_ = ideal_source_scale_;
 
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (!is_pinching || raster_contents_scale_ == 0.f) {
     // When not pinching or when we have no previous scale, we use ideal scale:
     raster_page_scale_ = ideal_page_scale_;
     raster_contents_scale_ = ideal_contents_scale_;
   } else {
     // See ShouldAdjustRasterScale:
     // - When zooming out, preemptively create new tiling at lower resolution.
     // - When zooming in, approximate ideal using multiple of kMaxScaleRatio.
     bool zooming_out = raster_page_scale_ > ideal_page_scale_;
     float desired_contents_scale =
         zooming_out ? raster_contents_scale_ / kMaxScaleRatioDuringPinch
                     : raster_contents_scale_ * kMaxScaleRatioDuringPinch;
     raster_contents_scale_ = SnappedContentsScale(desired_contents_scale);
     raster_page_scale_ = raster_contents_scale_ / raster_device_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
-  // Don't allow animating CSS scales to drop below 1 if we're not
-  // re-rasterizing during the animation.
+  // If we're not re-rasterizing during animation, rasterize at the maximum
+  // scale that will occur during the animation, if the maximum scale is
+  // known.
   if (animating_transform_to_screen && !ShouldUseGpuRasterization()) {
-    raster_contents_scale_ = std::max(
-        raster_contents_scale_, 1.f * ideal_page_scale_ * ideal_device_scale_);
+    if (maximum_animation_contents_scale > 0.f) {
+      raster_contents_scale_ =
+          std::max(raster_contents_scale_, maximum_animation_contents_scale);
+    } else {
+      raster_contents_scale_ =
+          std::max(raster_contents_scale_,
+                   1.f * ideal_page_scale_ * ideal_device_scale_);
+    }
   }
 
   // If this layer would only create one tile at this content scale,
   // don't create a low res tiling.
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(bounds(), raster_contents_scale_));
   gfx::Size tile_size = CalculateTileSize(content_bounds);
   if (tile_size.width() >= content_bounds.width() &&
       tile_size.height() >= content_bounds.height()) {
     low_res_raster_contents_scale_ = raster_contents_scale_;
@@ skipping 401 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc