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 15 matching lines @@
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
       pile_(PicturePileImpl::Create()),
       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) {
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "PictureLayer";
 }
 
@@ skipping 21 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();
 
   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_;
 }
 
 
 void PictureLayerImpl::AppendQuads(QuadSink* quadSink,
                                    AppendQuadsData* appendQuadsData) {
   const gfx::Rect& rect = visible_content_rect();
   gfx::Rect content_rect(content_bounds());
 
   SharedQuadState* sharedQuadState =
       quadSink->UseSharedQuadState(CreateSharedQuadState());
@@ skipping 183 matching lines @@
     float* contents_scale_y,
     gfx::Size* content_bounds) {
   if (!DrawsContent()) {
     DCHECK(!tilings_->num_tilings());
     return;
   }
 
   float min_contents_scale = MinimumContentsScale();
   float min_page_scale = layer_tree_impl()->min_page_scale_factor();
   float min_device_scale = 1.f;
-  float min_source_scale =
-      min_contents_scale / min_page_scale / min_device_scale;
 
   float ideal_page_scale = layer_tree_impl()->total_page_scale_factor();
   float ideal_device_scale = layer_tree_impl()->device_scale_factor();
-  float ideal_source_scale =
-      ideal_contents_scale / ideal_page_scale / ideal_device_scale;
 
   ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale);
   ideal_page_scale_ = ideal_page_scale;
   ideal_device_scale_ = ideal_device_scale;
-  ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
 
   ManageTilings(animating_transform_to_screen);
 
   // The content scale and bounds for a PictureLayerImpl is somewhat fictitious.
   // There are (usually) several tilings at different scales.  However, the
   // content bounds is the (integer!) space in which quads are generated.
   // In order to guarantee that we can fill this integer space with any set of
   // tilings (and then map back to floating point texture coordinates), the
   // contents scale must be at least as large as the largest of the tilings.
   float max_contents_scale = min_contents_scale;
@@ skipping 77 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;
     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_;
 
   // 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.
   for (int x = 0; x < pile_->num_tiles_x(); ++x) {
@@ skipping 62 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_);
 
-  float min_acceptable_scale =
-      std::min(raster_contents_scale, ideal_contents_scale_);
-
-  TreePriority tree_priority =
-      layer_tree_impl()->tile_manager()->GlobalState().tree_priority;
+  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 61 matching lines @@
   float ratio2 = PositiveRatio(layer2->contents_scale(), contents_scale);
   return ratio1 < ratio2;
 }
 
 }  // namespace
 
 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 = false;
 
-  if (!raster_page_scale_ || !raster_device_scale_ || !raster_source_scale_)
+  if (!raster_page_scale_ || !raster_device_scale_ || !raster_contents_scale_)

[enne (OOO), 2013/03/23 00:47:32]

I think this is wrong.  The previous check was if the raster source scale
changed which is not the same as raster contents scale.

[Xianzhu, 2013/03/25 16:05:07]

I'm confused. How did the previous check deal with changes of raster source
scale?

[danakj, 2013/03/25 16:44:44]

It seems like you're just getting rid of raster source (i.e. CSS) scale here?

The "contents scale" is meant to be the product of the source*page*device
scales.

     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 (ShouldAdjustRasterSourceScale())
+    change_target_tiling = true;
 
   if (is_active_layer) {
     if (raster_source_scale_was_animating_ && !animating_transform_to_screen)
       change_target_tiling = true;
     raster_source_scale_was_animating_ = animating_transform_to_screen;
   }
 
   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.
@@ skipping 10 matching lines @@
 
   // 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);
+  CalculateRasterContentsScale(animating_transform_to_screen);

[enne (OOO), 2013/03/23 00:47:32]

I like the previous version where rather you had a functional-style function
that computed values rather than a function with side effects.  The former makes
it much obvious here in the caller that raster_contents_scale and
low_res_raster_contents_scale are affected by this function. 

 
   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::ShouldAdjustRasterSourceScale() 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.
+  return false;
+}
+
 void PictureLayerImpl::CalculateRasterContentsScale(
-    bool animating_transform_to_screen,
-    float* raster_contents_scale,
-    float* low_res_raster_contents_scale) {
-  *raster_contents_scale = ideal_contents_scale_;
+    bool animating_transform_to_screen) {
+  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_);
+    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,
+  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 68 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