cc: Make PictureLayerImpl use a better choice for animated raster scale.

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 <set>
 
@@ skipping 1152 matching lines @@
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
   // 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. However, to avoid excessive memory use, don't rasterize at a scale
   // at which this layer would become larger than the viewport.
   if (draw_properties().screen_space_transform_is_animating &&
       !ShouldAdjustRasterScaleDuringScaleAnimations()) {
     bool can_raster_at_maximum_scale = false;
-    if (draw_properties().maximum_animation_contents_scale > 0.f) {
-      gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(gfx::ScaleSize(
-          bounds(), draw_properties().maximum_animation_contents_scale));
-      if (bounds_at_maximum_scale.GetArea() <=
-          layer_tree_impl()->device_viewport_size().GetArea())
+    float maximum_scale = draw_properties().maximum_animation_contents_scale;
+    if (maximum_scale) {
+      if (maximum_scale < raster_contents_scale_) {
         can_raster_at_maximum_scale = true;
+      } else {
+        gfx::Size bounds_at_maximum_scale =
+            gfx::ToCeiledSize(gfx::ScaleSize(bounds(), maximum_scale));
+        if (bounds_at_maximum_scale.GetArea() <=
+            layer_tree_impl()->device_viewport_size().GetArea())
+          can_raster_at_maximum_scale = true;
+      }
     }
-    if (can_raster_at_maximum_scale) {
-      raster_contents_scale_ =
-          std::max(raster_contents_scale_,
-                   draw_properties().maximum_animation_contents_scale);
-    } else {
-      raster_contents_scale_ =
-          std::max(raster_contents_scale_,
-                   1.f * ideal_page_scale_ * ideal_device_scale_);
-    }
+    // Use the computed scales for the raster scale directly, do not try to use
+    // the ideal scale here. The current ideal scale may be way too large in the
+    // case of an animation with scale, and will be constantly changing.
+    if (can_raster_at_maximum_scale)
+      raster_contents_scale_ = maximum_scale;

[vmpstr, 2014/10/10 00:50:49]

If I understand this correctly, maximum_scale is a maximum scale at keyframes
not including the intial one. Is that correct? In that case what happens if my
animation is from some large zoom (when layer is 1000x1000) in to a 5x5 pixels
square that kicks off after a couple of seconds? Would the result basically
rerasterize at the scale needed for 5x5 even when it's at 999x999? (This is
assuming there's only two keyframes: the current one and the final one).

[danakj, 2014/10/10 01:00:19]

We'd raster new content at the very small scale yes. That doesn't mean we'd
throw away the old tiles though, we'd consider those better for drawing purposes
and keep them around until we actually got (close?) to the 5x5 scale. That's
what my intention with this change is.

+    else
+      raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   // If this layer would create zero or one tiles 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);
   bool tile_covers_bounds = tile_size.width() >= content_bounds.width() &&
                             tile_size.height() >= content_bounds.height();
   if (tile_size.IsEmpty() || tile_covers_bounds) {
@@ skipping 584 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc