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_) {

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

Does the comment need updating above? Also, can you add a comment here for
what's the two cases. I'm not sure if it's just an optimization or something
else.

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

Yar.

         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;
+    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