cc: Change directly composited image raster source scale occasionally.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 856 matching lines @@
   if (layer_tree_impl()->IsPendingTree()) {
     // On the pending tree, drop any tilings that are non-ideal since we don't
     // need them to activate anyway.
     tilings_->RemoveNonIdealTilings();
   }
 
   SanityCheckTilingState();
 }
 
 bool PictureLayerImpl::ShouldAdjustRasterScale() const {
-  // TODO(vmpstr): We might want to adjust the raster scale once in a while.
-  if (is_directly_composited_image_)
+  if (is_directly_composited_image_) {
+    float max_scale = std::max(1.f, MinimumContentsScale());
+    if (raster_source_scale_ < std::min(ideal_source_scale_, max_scale))
+      return true;
+    if (raster_source_scale_ > 4 * ideal_source_scale_)
+      return true;
     return false;
+  }
 
   if (was_screen_space_transform_animating_ !=
       draw_properties().screen_space_transform_is_animating)
     return true;
 
   if (draw_properties().screen_space_transform_is_animating &&
       raster_contents_scale_ != ideal_contents_scale_ &&
       ShouldAdjustRasterScaleDuringScaleAnimations())
     return true;
 
@@ skipping 59 matching lines @@
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   bool is_animating = draw_properties().screen_space_transform_is_animating;
   if (!is_pinching && !is_animating) {
     if (!low_res)
       low_res = AddTiling(low_res_raster_contents_scale_);
     low_res->set_resolution(LOW_RESOLUTION);
   }
 }
 
 void PictureLayerImpl::RecalculateRasterScales() {
-  // TODO(vmpstr): We might want to adjust these once in a while.
   if (is_directly_composited_image_) {
+    if (!raster_source_scale_)
+      raster_source_scale_ = 1.f;
+
+    float min_scale = MinimumContentsScale();
+    float max_scale = std::max(1.f, MinimumContentsScale());
+    float clamped_ideal_source_scale_ =
+        std::max(min_scale, std::min(ideal_source_scale_, max_scale));
+
+    while (raster_source_scale_ < clamped_ideal_source_scale_)
+      raster_source_scale_ *= 2.f;
+    while (raster_source_scale_ > 4 * clamped_ideal_source_scale_)
+      raster_source_scale_ /= 2.f;
+
+    raster_source_scale_ =
+        std::max(min_scale, std::min(raster_source_scale_, max_scale));
+
     raster_page_scale_ = 1.f;
     raster_device_scale_ = 1.f;
-    raster_source_scale_ = std::max(1.f, MinimumContentsScale());
     raster_contents_scale_ = raster_source_scale_;
     low_res_raster_contents_scale_ = raster_contents_scale_;
     return;
   }
 
   float old_raster_contents_scale = raster_contents_scale_;
   float old_raster_page_scale = raster_page_scale_;
 
   raster_device_scale_ = ideal_device_scale_;
   raster_page_scale_ = ideal_page_scale_;
@@ skipping 214 matching lines @@
   const LayerTreeSettings& settings = layer_tree_impl()->settings();
   return PictureLayerTilingSet::Create(
       GetTree(), this, settings.tiling_interest_area_padding,
       layer_tree_impl()->use_gpu_rasterization()
           ? settings.gpu_rasterization_skewport_target_time_in_seconds
           : settings.skewport_target_time_in_seconds,
       settings.skewport_extrapolation_limit_in_screen_pixels);
 }
 
 void PictureLayerImpl::UpdateIdealScales() {
-  // TODO(vmpstr): We might want to adjust these once in a while.
-  if (is_directly_composited_image_) {
-    ideal_contents_scale_ = 1.f;
-    ideal_page_scale_ = 1.f;
-    ideal_device_scale_ = 1.f;
-    ideal_source_scale_ = 1.f;
-    return;
-  }
-
   DCHECK(CanHaveTilings());
 
   float min_contents_scale = MinimumContentsScale();
   DCHECK_GT(min_contents_scale, 0.f);
 
   ideal_page_scale_ = IsAffectedByPageScale()
                           ? layer_tree_impl()->current_page_scale_factor()
                           : 1.f;
   ideal_device_scale_ = layer_tree_impl()->device_scale_factor();
   ideal_contents_scale_ = std::max(GetIdealContentsScale(), min_contents_scale);
@@ skipping 74 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc