Animation start scale should be considered for the 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 <cmath>
 #include <limits>
 #include <set>
@@ skipping 954 matching lines @@
 
   // 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 we want to avoid excessive memory use. If the scale is
   // smaller than what we would choose otherwise, then it's always better off
   // for us memory-wise. But otherwise, we don't choose a scale at which this
   // layer's rastered content would become larger than the viewport.
   if (draw_properties().screen_space_transform_is_animating &&
       !ShouldAdjustRasterScaleDuringScaleAnimations()) {
     bool can_raster_at_maximum_scale = false;
-    // TODO(ajuma): If we need to deal with scale-down animations starting right
-    // as a layer gets promoted, then we'd want to have the
-    // |starting_animation_contents_scale| passed in here as a separate draw
-    // property so we could try use that when the max is too large.
-    // See crbug.com/422341.
+    bool should_raster_at_starting_scale = false;
     float maximum_scale = draw_properties().maximum_animation_contents_scale;
+    float starting_scale = draw_properties().starting_animation_contents_scale;
     if (maximum_scale) {
       gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(
           gfx::ScaleSize(raster_source_->GetSize(), maximum_scale));
       int64 maximum_area = static_cast<int64>(bounds_at_maximum_scale.width()) *
                            static_cast<int64>(bounds_at_maximum_scale.height());
       gfx::Size viewport = layer_tree_impl()->device_viewport_size();
       int64 viewport_area = static_cast<int64>(viewport.width()) *
                             static_cast<int64>(viewport.height());
       if (maximum_area <= viewport_area)
         can_raster_at_maximum_scale = true;
     }
+    if (starting_scale && starting_scale > maximum_scale) {
+      gfx::Size bounds_at_starting_scale = gfx::ToCeiledSize(
+          gfx::ScaleSize(raster_source_->GetSize(), starting_scale));
+      int64 start_area = static_cast<int64>(bounds_at_starting_scale.width()) *
+                         static_cast<int64>(bounds_at_starting_scale.height());
+      gfx::Size viewport = layer_tree_impl()->device_viewport_size();
+      int64 viewport_area = static_cast<int64>(viewport.width()) *
+                            static_cast<int64>(viewport.height());
+      if (start_area <= viewport_area)
+        should_raster_at_starting_scale = true;
+    }
     // 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)
+    if (should_raster_at_starting_scale)
+      raster_contents_scale_ = starting_scale;
+    else if (can_raster_at_maximum_scale)
       raster_contents_scale_ = maximum_scale;
     else
       raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
   raster_contents_scale_ =
       std::min(raster_contents_scale_, MaximumContentsScale());
   DCHECK_GE(raster_contents_scale_, MinimumContentsScale());
@@ skipping 246 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc