cc: Make consistent use of bounds() versus the pile's size.

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 <limits>
 #include <set>
 
@@ skipping 137 matching lines @@
 
   // We always need to push properties.
   // See http://crbug.com/303943
   needs_push_properties_ = true;
 }
 
 void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
                                    const Occlusion& occlusion_in_content_space,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
+  // The bounds and the pile size may differ if the pile wasn't updated (ie.
+  // PictureLayer::Update didn't happen). But that should never be the case if
+  // the layer is part of the visible frame, which is why we're appending quads
+  // in the first place
+  DCHECK_EQ(bounds().ToString(), pile_->tiling_size().ToString());
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
 
   if (pile_->is_solid_color()) {
     PopulateSharedQuadState(shared_quad_state);
 
     AppendDebugBorderQuad(
-        render_pass, content_bounds(), shared_quad_state, append_quads_data);
+        render_pass, bounds(), shared_quad_state, append_quads_data);
 
     SolidColorLayerImpl::AppendSolidQuads(render_pass,
                                           occlusion_in_content_space,
                                           shared_quad_state,
                                           visible_content_rect(),
                                           pile_->solid_color(),
                                           append_quads_data);
     return;
   }
 
   float max_contents_scale = MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
   gfx::Size scaled_content_bounds =
-      gfx::ToCeiledSize(gfx::ScaleSize(content_bounds(), max_contents_scale));
+      gfx::ToCeiledSize(gfx::ScaleSize(bounds(), max_contents_scale));
   gfx::Rect scaled_visible_content_rect =
       gfx::ScaleToEnclosingRect(visible_content_rect(), max_contents_scale);
   scaled_visible_content_rect.Intersect(gfx::Rect(scaled_content_bounds));
   Occlusion scaled_occlusion =
       occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
           scaled_draw_transform);
 
   shared_quad_state->SetAll(scaled_draw_transform,
                             scaled_content_bounds,
                             scaled_visible_content_rect,
@@ skipping 570 matching lines @@
   }
 
   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_;
 
   bool synced_high_res_tiling = false;
   if (CanHaveTilings()) {
-    synced_high_res_tiling = tilings_->SyncTilings(
-        *other->tilings_, bounds(), invalidation_, MinimumContentsScale());
+    synced_high_res_tiling = tilings_->SyncTilings(*other->tilings_,
+                                                   pile_->tiling_size(),
+                                                   invalidation_,
+                                                   MinimumContentsScale());
   } else {
     RemoveAllTilings();
   }
 
   // If our MinimumContentsScale has changed to prevent the twin's high res
   // tiling from being synced, we should reset the raster scale and let it be
   // recalculated (1) again. This can happen if our bounds shrink to the point
   // where min contents scale grows.
   // (1) - TODO(vmpstr) Instead of hoping that this will be recalculated, we
   // should refactor this code a little bit and actually recalculate this.
   // However, this is a larger undertaking, so this will work for now.
   if (!synced_high_res_tiling)
     ResetRasterScale();
   else
     SanityCheckTilingState();
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
   if (!CanHaveTilingWithScale(tiling->contents_scale()))
     return;
-  tilings_->AddTiling(tiling->contents_scale(), bounds());
+  tilings_->AddTiling(tiling->contents_scale(), pile_->tiling_size());
 
   // If this tree needs update draw properties, then the tiling will
   // get updated prior to drawing or activation.  If this tree does not
   // need update draw properties, then its transforms are up to date and
   // we can create tiles for this tiling immediately.
   if (!layer_tree_impl()->needs_update_draw_properties() &&
       should_update_tile_priorities_) {
     // TODO(danakj): Add a DCHECK() that we are not using occlusion tracking
     // when we stop using the pending tree in the browser compositor. If we want
     // to support occlusion tracking here, we need to dirty the draw properties
     // or save occlusion as a draw property.
     UpdateTilePriorities(Occlusion());
   }
 }
 
 void PictureLayerImpl::GetContentsResourceId(
     ResourceProvider::ResourceId* resource_id,
     gfx::Size* resource_size) const {
+  DCHECK_EQ(bounds().ToString(), pile_->tiling_size().ToString());
   gfx::Rect content_rect(bounds());
   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), 1.f, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
   if (!iter || !*iter) {
     *resource_id = 0;
     return;
   }
 
@@ skipping 32 matching lines @@
       SyncFromActiveLayer(twin_layer_);
   }
 
   needs_post_commit_initialization_ = false;
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
-  PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale, bounds());
+  PictureLayerTiling* tiling =
+      tilings_->AddTiling(contents_scale, pile_->tiling_size());
 
   DCHECK(pile_->HasRecordings());
 
   if (twin_layer_)
     twin_layer_->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
@@ skipping 182 matching lines @@
   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.
     float maximum_scale = draw_properties().maximum_animation_contents_scale;
     if (maximum_scale) {
-      gfx::Size bounds_at_maximum_scale =
-          gfx::ToCeiledSize(gfx::ScaleSize(bounds(), maximum_scale));
+      gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(
+          gfx::ScaleSize(pile_->tiling_size(), maximum_scale));
       if (bounds_at_maximum_scale.GetArea() <=
           layer_tree_impl()->device_viewport_size().GetArea())
         can_raster_at_maximum_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)
       raster_contents_scale_ = maximum_scale;
     else
       raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   // If this layer would create zero or one tiles at this content scale,
   // don't create a low res tiling.
-  gfx::Size content_bounds =
-      gfx::ToCeiledSize(gfx::ScaleSize(bounds(), raster_contents_scale_));
-  gfx::Size tile_size = CalculateTileSize(content_bounds);
-  bool tile_covers_bounds = tile_size.width() >= content_bounds.width() &&
-                            tile_size.height() >= content_bounds.height();
+  gfx::Size raster_bounds = gfx::ToCeiledSize(
+      gfx::ScaleSize(pile_->tiling_size(), raster_contents_scale_));
+  gfx::Size tile_size = CalculateTileSize(raster_bounds);
+  bool tile_covers_bounds = tile_size.width() >= raster_bounds.width() &&
+                            tile_size.height() >= raster_bounds.height();
   if (tile_size.IsEmpty() || tile_covers_bounds) {
     low_res_raster_contents_scale_ = raster_contents_scale_;
     return;
   }
 
   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());
@@ skipping 76 matching lines @@
   SanityCheckTilingState();
 }
 
 float PictureLayerImpl::MinimumContentsScale() const {
   float setting_min = layer_tree_impl()->settings().minimum_contents_scale;
 
   // If the contents scale is less than 1 / width (also for height),
   // then it will end up having less than one pixel of content in that
   // dimension.  Bump the minimum contents scale up in this case to prevent
   // this from happening.
-  int min_dimension = std::min(bounds().width(), bounds().height());
+  int min_dimension =
+      std::min(pile_->tiling_size().width(), pile_->tiling_size().height());
   if (!min_dimension)
     return setting_min;
 
   return std::max(1.f / min_dimension, setting_min);
 }
 
 void PictureLayerImpl::ResetRasterScale() {
   raster_page_scale_ = 0.f;
   raster_device_scale_ = 0.f;
   raster_source_scale_ = 0.f;
@@ skipping 112 matching lines @@
 
   state->BeginArray("pictures");
   pile_->AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("invalidation");
   invalidation_.AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("coverage_tiles");
-  for (PictureLayerTilingSet::CoverageIterator iter(tilings_.get(),
-                                                    1.f,
-                                                    gfx::Rect(content_bounds()),
-                                                    ideal_contents_scale_);
+  for (PictureLayerTilingSet::CoverageIterator iter(
+           tilings_.get(),
+           1.f,
+           gfx::Rect(pile_->tiling_size()),
+           ideal_contents_scale_);
        iter;
        ++iter) {
     state->BeginDictionary();
 
     state->BeginArray("geometry_rect");
     MathUtil::AddToTracedValue(iter.geometry_rect(), state);
     state->EndArray();
 
     if (*iter)
       TracedValue::SetIDRef(*iter, state, "tile");
@@ skipping 341 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc