Let AreVisibleResourcesReady return correct value for PictureImageLayerImpl

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 "base/time.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 19 matching lines @@
       pile_(PicturePileImpl::Create(true)),
       last_content_scale_(0),
       ideal_contents_scale_(0),
       is_mask_(false),
       ideal_page_scale_(0.f),
       ideal_device_scale_(0.f),
       ideal_source_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
+      raster_contents_scale_(0.f),
+      low_res_raster_contents_scale_(0.f),
       raster_source_scale_was_animating_(false),
       is_using_lcd_text_(true) {
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "PictureLayer";
 }
@@ skipping 23 matching lines @@
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
 
   layer_impl->SetIsMask(is_mask_);
   layer_impl->TransferTilingSet(tilings_.Pass());
   layer_impl->pile_ = pile_;
   pile_ = PicturePileImpl::Create(is_using_lcd_text_);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
+  layer_impl->raster_contents_scale_ = raster_contents_scale_;
+  layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
   layer_impl->is_using_lcd_text_ = is_using_lcd_text_;
 }
 
 
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   const gfx::Rect& rect = visible_content_rect();
   gfx::Rect content_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
@@ skipping 297 matching lines @@
   return default_tile_size;
 }
 
 void PictureLayerImpl::SyncFromActiveLayer() {
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!DrawsContent()) {
     raster_page_scale_ = 0;
     raster_device_scale_ = 0;
     raster_source_scale_ = 0;
+    raster_contents_scale_ = 0;
+    low_res_raster_contents_scale_ = 0;
     return;
   }
 
   // If there is an active tree version of this layer, get a copy of its
   // tiles.  This needs to be done last, after setting invalidation and the
   // pile.
   if (PictureLayerImpl* active_twin = ActiveTwin())
     SyncFromActiveLayer(active_twin);
 }
 
 void PictureLayerImpl::SyncFromActiveLayer(const PictureLayerImpl* other) {
   raster_page_scale_ = other->raster_page_scale_;
   raster_device_scale_ = other->raster_device_scale_;
   raster_source_scale_ = other->raster_source_scale_;
+  raster_contents_scale_ = other->raster_contents_scale_;
+  low_res_raster_contents_scale_ = other->low_res_raster_contents_scale_;
   is_using_lcd_text_ = other->is_using_lcd_text_;
 
   // Add synthetic invalidations for any recordings that were dropped.  As
   // tiles are updated to point to this new pile, this will force the dropping
   // of tiles that can no longer be rastered.  This is not ideal, but is a
   // trade-off for memory (use the same pile as much as possible, by switching
   // during DidBecomeActive) and for time (don't bother checking every tile
   // during activation to see if the new pile can still raster it).
   //
   // TODO(enne): Clean up this double loop.
@@ skipping 63 matching lines @@
   }
   return 0;
 }
 
 bool PictureLayerImpl::AreVisibleResourcesReady() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(ideal_contents_scale_);
 
   const gfx::Rect& rect = visible_content_rect();
 
-  float raster_contents_scale =
-      raster_page_scale_ *
-      raster_device_scale_ *
-      raster_source_scale_;
-
   float min_acceptable_scale =
-      std::min(raster_contents_scale, ideal_contents_scale_);
+      std::min(raster_contents_scale_, ideal_contents_scale_);
 
   TreePriority tree_priority =
       layer_tree_impl()->tile_manager()->GlobalState().tree_priority;
   bool should_force_uploads =
       tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
       layer_tree_impl()->animationRegistrar()->
           active_animation_controllers().empty();
 
   if (PictureLayerImpl* twin = ActiveTwin()) {
-    float twin_raster_contents_scale =
-        twin->raster_page_scale_ *
-        twin->raster_device_scale_ *
-        twin->raster_source_scale_;
-
     min_acceptable_scale = std::min(
         min_acceptable_scale,
-        std::min(twin->ideal_contents_scale_, twin_raster_contents_scale));
+        std::min(twin->ideal_contents_scale_, twin->raster_contents_scale_));
   }
 
   Region missing_region = rect;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
     for (PictureLayerTiling::Iterator iter(tiling, contents_scale_x(), rect);
@@ skipping 66 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;
 
-  bool is_active_layer = layer_tree_impl()->IsActiveTree();
-  bool is_pinching = layer_tree_impl()->PinchGestureActive();
+  bool change_target_tiling =
+      !raster_page_scale_ || !raster_device_scale_ || !raster_source_scale_ ||
+      ShouldAdjustRasterScale(animating_transform_to_screen);
 
-  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
-  // tree. This will allow CSS scale changes to get re-rastered at an
-  // appropriate rate.
-
-  if (is_active_layer) {
-    if (raster_source_scale_was_animating_ && !animating_transform_to_screen)
-      change_target_tiling = true;
+  if (layer_tree_impl()->IsActiveTree())
     raster_source_scale_was_animating_ = animating_transform_to_screen;

[danakj, 2013/03/25 20:13:03]

Can you add a comment saying that this is setting the value for the next time
ManageTilings is called, since this is used in ShouldAdjustRasterScale()?

Since the place it's used is so far away now, this is less clear.

[Xianzhu, 2013/03/25 20:42:23]

Done.

-  }
-
-  if (is_active_layer && is_pinching && raster_page_scale_) {
-    // If the page scale diverges too far during pinch, change raster target to
-    // the current page scale.
-    float ratio = PositiveRatio(ideal_page_scale_, raster_page_scale_);
-    if (ratio >= kMaxScaleRatioDuringPinch)
-      change_target_tiling = true;
-  }
-
-  if (!is_pinching) {
-    // When not pinching, match the ideal page scale factor.
-    if (raster_page_scale_ != ideal_page_scale_)
-      change_target_tiling = true;
-  }
-
-  // Always match the ideal device scale factor.
-  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;
-  float low_res_raster_contents_scale;
   CalculateRasterContentsScale(animating_transform_to_screen,
-                               &raster_contents_scale,
-                               &low_res_raster_contents_scale);
+                               &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)
+    if (tiling->contents_scale() == raster_contents_scale_)
       high_res = tiling;
-    if (tiling->contents_scale() == low_res_raster_contents_scale)
+    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) {
-    high_res = AddTiling(raster_contents_scale);
-    if (raster_contents_scale == low_res_raster_contents_scale)
+    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);
+    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);
 }
 
+bool PictureLayerImpl::ShouldAdjustRasterScale(
+    bool animating_transform_to_screen) const {
+  // TODO(danakj): Adjust raster source scale closer to ideal source scale at
+  // a throttled rate. Possibly make use of invalidation_.IsEmpty() on pending
+  // tree. This will allow CSS scale changes to get re-rastered at an
+  // appropriate rate.
+
+  bool is_active_layer = layer_tree_impl()->IsActiveTree();
+  if (is_active_layer && raster_source_scale_was_animating_ &&
+      !animating_transform_to_screen)
+    return true;
+
+  bool is_pinching = layer_tree_impl()->PinchGestureActive();
+  if (is_active_layer && is_pinching && raster_page_scale_) {
+    // If the page scale diverges too far during pinch, change raster target to
+    // the current page scale.
+    float ratio = PositiveRatio(ideal_page_scale_, raster_page_scale_);
+    if (ratio >= kMaxScaleRatioDuringPinch)
+      return true;
+  }
+
+  if (!is_pinching) {
+    // When not pinching, match the ideal page scale factor.
+    if (raster_page_scale_ != ideal_page_scale_)
+      return true;
+  }
+
+  // Always match the ideal device scale factor.
+  if (raster_device_scale_ != ideal_device_scale_)
+    return true;
+
+  return false;
+}
+
 void PictureLayerImpl::CalculateRasterContentsScale(
     bool animating_transform_to_screen,
     float* raster_contents_scale,
-    float* low_res_raster_contents_scale) {
+    float* low_res_raster_contents_scale) const {
   *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 =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
   *low_res_raster_contents_scale = std::max(
       *raster_contents_scale * low_res_factor,
       MinimumContentsScale());
 }
 
 void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
     std::vector<PictureLayerTiling*> used_tilings) {
   DCHECK(layer_tree_impl()->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_);
+      raster_contents_scale_, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
-      raster_contents_scale, ideal_contents_scale_);
+      raster_contents_scale_, ideal_contents_scale_);
 
   PictureLayerImpl* twin = PendingTwin();
   if (twin) {
-    float twin_raster_contents_scale =
-        twin->raster_page_scale_ *
-        twin->raster_device_scale_ *
-        twin->raster_source_scale_;
-
     min_acceptable_high_res_scale = std::min(
         min_acceptable_high_res_scale,
-        std::min(twin_raster_contents_scale, twin->ideal_contents_scale_));
+        std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_));
     max_acceptable_high_res_scale = std::max(
         max_acceptable_high_res_scale,
-        std::max(twin_raster_contents_scale, twin->ideal_contents_scale_));
+        std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_));
   }
 
   float low_res_factor =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
 
   float min_acceptable_low_res_scale =
       low_res_factor * min_acceptable_high_res_scale;
   float max_acceptable_low_res_scale =
       low_res_factor * max_acceptable_high_res_scale;
 
@@ skipping 107 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