Efficiently handle image layer scaling

cc/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/picture_layer_impl.h"
 
 #include "base/time.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
@@ skipping 561 matching lines @@
 
 void PictureLayerImpl::ManageTilings(bool animating_transform_to_screen) {
   DCHECK(ideal_contents_scale_);
   DCHECK(ideal_page_scale_);
   DCHECK(ideal_device_scale_);
   DCHECK(ideal_source_scale_);
 
   if (pile_->recorded_region().IsEmpty())
     return;
 
-  float low_res_factor = layerTreeImpl()->settings().lowResContentsScaleFactor;
-
   bool is_active_layer = layerTreeImpl()->IsActiveTree();
   bool is_pinching = layerTreeImpl()->PinchGestureActive();
 
   bool change_target_tiling = false;
 
   if (!raster_page_scale_ || !raster_device_scale_ || !raster_source_scale_)
     change_target_tiling = true;
 
   // TODO(danakj): Adjust raster_source_scale_ closer to ideal_source_scale_ at
   // a throttled rate. Possibly make use of invalidation_.IsEmpty() on pending
@@ skipping 24 matching lines @@
   if (raster_device_scale_ != ideal_device_scale_)
     change_target_tiling = true;
 
   if (!change_target_tiling)
     return;
 
   raster_page_scale_ = ideal_page_scale_;
   raster_device_scale_ = ideal_device_scale_;
   raster_source_scale_ = ideal_source_scale_;
 
-  float raster_contents_scale = ideal_contents_scale_;
-
-  // Don't allow animating CSS scales to drop below 1.
-  if (animating_transform_to_screen) {
-    raster_contents_scale = std::max(
-        raster_contents_scale, 1.f * ideal_page_scale_ * ideal_device_scale_);
-  }
-
-  float low_res_raster_contents_scale = std::max(
-      raster_contents_scale * low_res_factor,
-      layerTreeImpl()->settings().minimumContentsScale);
+  float raster_contents_scale;
+  float low_res_raster_contents_scale;
+  CalculateRasterContentsScale(animating_transform_to_screen,
+                               &raster_contents_scale,
+                               &low_res_raster_contents_scale);
 
   PictureLayerTiling* high_res = NULL;
   PictureLayerTiling* 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)
       low_res = tiling;
 
     // Reset all tilings to non-ideal until the end of this function.
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
   }
 
-  if (!high_res)
+  if (!high_res) {
     high_res = AddTiling(raster_contents_scale);
+    if (raster_contents_scale == low_res_raster_contents_scale)
+      low_res = high_res;
+  }
   if (!low_res && low_res != high_res)
     low_res = AddTiling(low_res_raster_contents_scale);
 
   if (high_res)
     high_res->set_resolution(HIGH_RESOLUTION);
   if (low_res && low_res != high_res)
     low_res->set_resolution(LOW_RESOLUTION);
 }
 
+void PictureLayerImpl::CalculateRasterContentsScale(
+    bool animating_transform_to_screen,
+    float* raster_contents_scale,
+    float* low_res_raster_contents_scale) {
+  *raster_contents_scale = ideal_contents_scale_;
+
+  // Don't allow animating CSS scales to drop below 1.
+  if (animating_transform_to_screen) {
+    *raster_contents_scale = std::max(
+        *raster_contents_scale, 1.f * ideal_page_scale_ * ideal_device_scale_);
+  }
+
+  float low_res_factor = layerTreeImpl()->settings().lowResContentsScaleFactor;
+  *low_res_raster_contents_scale = std::max(
+      *raster_contents_scale * low_res_factor,
+      layerTreeImpl()->settings().minimumContentsScale);
+}
+
 void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
     std::vector<PictureLayerTiling*> used_tilings) {
   DCHECK(layerTreeImpl()->IsActiveTree());
 
   float raster_contents_scale =
       raster_page_scale_ * raster_device_scale_ * raster_source_scale_;
 
   float min_acceptable_high_res_scale = std::min(
       raster_contents_scale, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
@@ skipping 77 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc