cc: Give TilingData a Rect instead of a Size

This patch changes the assumption that the tiling covers the entire layer. It
can now cover an arbitray sub-rect, called the tiling_rect. This will be used
to implement viewport tiling in a separate patch.

R=enne@chromium.org
BUG=362668

Review URL: https://codereview.chromium.org/235753002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@264083 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 108 insertions, 115 deletions

diff --git a/cc/resources/layer_tiling_data.cc b/cc/resources/layer_tiling_data.cc
index ccbb6d0..b8d80bc 100644
--- a/cc/resources/layer_tiling_data.cc
+++ b/cc/resources/layer_tiling_data.cc
@@ -17,7 +17,7 @@ scoped_ptr<LayerTilingData> LayerTilingData::Create(const gfx::Size& tile_size,
 
 LayerTilingData::LayerTilingData(const gfx::Size& tile_size,
                                  BorderTexelOption border)
-    : tiling_data_(tile_size, gfx::Size(), border == HAS_BORDER_TEXELS) {
+    : tiling_data_(tile_size, gfx::Rect(), border == HAS_BORDER_TEXELS) {
   SetTileSize(tile_size);
 }
 
@@ -112,9 +112,9 @@ Region LayerTilingData::OpaqueRegionInContentRect(
   return opaque_region;
 }
 
-void LayerTilingData::SetBounds(const gfx::Size& size) {
-  tiling_data_.SetTotalSize(size);
-  if (size.IsEmpty()) {
+void LayerTilingData::SetTilingRect(const gfx::Rect& tiling_rect) {
+  tiling_data_.SetTilingRect(tiling_rect);
+  if (tiling_rect.IsEmpty()) {
     tiles_.clear();
     return;
   }
@@ -122,8 +122,7 @@ void LayerTilingData::SetBounds(const gfx::Size& size) {
   // Any tiles completely outside our new bounds are invalid and should be
   // dropped.
   int left, top, right, bottom;
-  ContentRectToTileIndices(
-      gfx::Rect(size), &left, &top, &right, &bottom);
+  ContentRectToTileIndices(tiling_rect, &left, &top, &right, &bottom);
   std::vector<TileMapKey> invalid_tile_keys;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     if (it->first.first > right || it->first.second > bottom)
diff --git a/cc/resources/layer_tiling_data.h b/cc/resources/layer_tiling_data.h
index 94644d0..b145e38 100644
--- a/cc/resources/layer_tiling_data.h
+++ b/cc/resources/layer_tiling_data.h
@@ -81,8 +81,8 @@ class CC_EXPORT LayerTilingData {
   Tile* TileAt(int i, int j) const;
   const TileMap& tiles() const { return tiles_; }
 
-  void SetBounds(const gfx::Size& size);
-  gfx::Size bounds() const { return tiling_data_.total_size(); }
+  void SetTilingRect(const gfx::Rect& tiling_rect);
+  gfx::Rect tiling_rect() const { return tiling_data_.tiling_rect(); }
 
   void ContentRectToTileIndices(const gfx::Rect& rect,
                                 int* left,
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 26e27da..2a4ad2e 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -60,7 +60,7 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       client_(client),
-      tiling_data_(gfx::Size(), gfx::Size(), true),
+      tiling_data_(gfx::Size(), gfx::Rect(), true),
       last_impl_frame_time_in_seconds_(0.0),
       eviction_tiles_cache_valid_(false),
       eviction_cache_tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES) {
@@ -74,7 +74,7 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
       " Layer bounds: " << layer_bounds.ToString() <<
       " Contents scale: " << contents_scale;
 
-  tiling_data_.SetTotalSize(content_bounds);
+  tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
@@ -85,12 +85,8 @@ void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
 }
 
-gfx::Rect PictureLayerTiling::ContentRect() const {
-  return gfx::Rect(tiling_data_.total_size());
-}
-
-gfx::SizeF PictureLayerTiling::ContentSizeF() const {
-  return gfx::ScaleSize(layer_bounds_, contents_scale_);
+gfx::Rect PictureLayerTiling::TilingRect() const {
+  return tiling_data_.tiling_rect();
 }
 
 Tile* PictureLayerTiling::CreateTile(int i,
@@ -159,13 +155,12 @@ void PictureLayerTiling::SetLayerBounds(const gfx::Size& layer_bounds) {
 
   gfx::Size old_layer_bounds = layer_bounds_;
   layer_bounds_ = layer_bounds;
-  gfx::Size old_content_bounds = tiling_data_.total_size();
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds_, contents_scale_));
 
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
   if (tile_size != tiling_data_.max_texture_size()) {
-    tiling_data_.SetTotalSize(content_bounds);
+    tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
     tiling_data_.SetMaxTextureSize(tile_size);
     Reset();
     return;
@@ -175,7 +170,7 @@ void PictureLayerTiling::SetLayerBounds(const gfx::Size& layer_bounds) {
   gfx::Rect bounded_live_tiles_rect(live_tiles_rect_);
   bounded_live_tiles_rect.Intersect(gfx::Rect(content_bounds));
   SetLiveTilesRect(bounded_live_tiles_rect);
-  tiling_data_.SetTotalSize(content_bounds);
+  tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
 
   // Create tiles for newly exposed areas.
   Region layer_region((gfx::Rect(layer_bounds_)));
@@ -253,11 +248,6 @@ PictureLayerTiling::CoverageIterator::CoverageIterator(
     return;
 
   dest_to_content_scale_ = tiling_->contents_scale_ / dest_scale;
-  // This is the maximum size that the dest rect can be, given the content size.
-  gfx::Size dest_content_size = gfx::ToCeiledSize(gfx::ScaleSize(
-      tiling_->ContentRect().size(),
-      1 / dest_to_content_scale_,
-      1 / dest_to_content_scale_));
 
   gfx::Rect content_rect =
       gfx::ScaleToEnclosingRect(dest_rect_,
@@ -265,7 +255,7 @@ PictureLayerTiling::CoverageIterator::CoverageIterator(
                                 dest_to_content_scale_);
   // IndexFromSrcCoord clamps to valid tile ranges, so it's necessary to
   // check for non-intersection first.
-  content_rect.Intersect(gfx::Rect(tiling_->tiling_data_.total_size()));
+  content_rect.Intersect(tiling_->TilingRect());
   if (content_rect.IsEmpty())
     return;
 
@@ -367,7 +357,7 @@ gfx::RectF PictureLayerTiling::CoverageIterator::texture_rect() const {
   texture_rect.Scale(dest_to_content_scale_,
                      dest_to_content_scale_);
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
-  texture_rect.Intersect(tiling_->ContentRect());
+  texture_rect.Intersect(tiling_->TilingRect());
 
   return texture_rect;
 }
@@ -443,7 +433,7 @@ void PictureLayerTiling::UpdateTilePriorities(
   gfx::Rect visible_rect_in_content_space =
       gfx::ScaleToEnclosingRect(visible_layer_rect, contents_scale_);
 
-  if (ContentRect().IsEmpty()) {
+  if (TilingRect().IsEmpty()) {
     last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
     last_visible_rect_in_content_space_ = visible_rect_in_content_space;
     return;
@@ -462,10 +452,10 @@ void PictureLayerTiling::UpdateTilePriorities(
   gfx::Rect eventually_rect =
       ExpandRectEquallyToAreaBoundedBy(visible_rect_in_content_space,
                                        eventually_rect_area,
-                                       ContentRect(),
+                                       TilingRect(),
                                        &expansion_cache_);
 
-  DCHECK(eventually_rect.IsEmpty() || ContentRect().Contains(eventually_rect));
+  DCHECK(eventually_rect.IsEmpty() || TilingRect().Contains(eventually_rect));
 
   SetLiveTilesRect(eventually_rect);
 
@@ -541,7 +531,7 @@ void PictureLayerTiling::UpdateTilePriorities(
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
-         ContentRect().Contains(new_live_tiles_rect));
+         TilingRect().Contains(new_live_tiles_rect));
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
@@ -609,8 +599,7 @@ scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
-  state->Set("content_bounds",
-             MathUtil::AsValue(ContentRect().size()).release());
+  state->Set("tiling_rect", MathUtil::AsValue(TilingRect()).release());
   return state.PassAs<base::Value>();
 }
 
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index bd442de..92c2879 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -135,8 +135,7 @@ class CC_EXPORT PictureLayerTiling {
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
 
-  gfx::Rect ContentRect() const;
-  gfx::SizeF ContentSizeF() const;
+  gfx::Rect TilingRect() const;
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
   float contents_scale() const { return contents_scale_; }
@@ -147,7 +146,7 @@ class CC_EXPORT PictureLayerTiling {
   }
 
   void CreateAllTilesForTesting() {
-    SetLiveTilesRect(gfx::Rect(tiling_data_.total_size()));
+    SetLiveTilesRect(tiling_data_.tiling_rect());
   }
 
   std::vector<Tile*> AllTilesForTesting() const {
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index a3610c6..47d393f 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -77,7 +77,7 @@ void PictureLayerTilingSet::SyncTilings(
       this_tiling->CreateMissingTilesInLiveTilesRect();
 
       DCHECK(this_tiling->tile_size() ==
-             client_->CalculateTileSize(this_tiling->ContentRect().size()));
+             client_->CalculateTileSize(this_tiling->TilingRect().size()));
       continue;
     }
     scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
diff --git a/cc/resources/picture_layer_tiling_set_unittest.cc b/cc/resources/picture_layer_tiling_set_unittest.cc
index 4263357..32a64eb 100644
--- a/cc/resources/picture_layer_tiling_set_unittest.cc
+++ b/cc/resources/picture_layer_tiling_set_unittest.cc
@@ -219,10 +219,10 @@ class PictureLayerTilingSetSyncTest : public testing::Test {
 
   void ValidateTiling(const PictureLayerTiling* tiling,
                       const PicturePileImpl* pile) const {
-    if (tiling->ContentRect().IsEmpty())
+    if (tiling->TilingRect().IsEmpty())
       EXPECT_TRUE(tiling->live_tiles_rect().IsEmpty());
     else if (!tiling->live_tiles_rect().IsEmpty())
-      EXPECT_TRUE(tiling->ContentRect().Contains(tiling->live_tiles_rect()));
+      EXPECT_TRUE(tiling->TilingRect().Contains(tiling->live_tiles_rect()));
 
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i) {
diff --git a/cc/resources/picture_layer_tiling_unittest.cc b/cc/resources/picture_layer_tiling_unittest.cc
index 16b68c1..976ed6b 100644
--- a/cc/resources/picture_layer_tiling_unittest.cc
+++ b/cc/resources/picture_layer_tiling_unittest.cc
@@ -156,7 +156,7 @@ class PictureLayerTilingIteratorTest : public testing::Test {
                                         const gfx::Rect& dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
-        tiling_->ContentRect(), 1.f / dest_to_contents_scale);
+        tiling_->TilingRect(), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index 8a15ea6..6637e4d 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -165,7 +165,7 @@ bool PicturePile::Update(ContentLayerClient* painter,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord);
   recorded_viewport_ = interest_rect;
-  recorded_viewport_.Intersect(gfx::Rect(size()));
+  recorded_viewport_.Intersect(tiling_rect());
 
   bool invalidated = false;
   for (Region::Iterator i(invalidation); i.has_rect(); i.next()) {
diff --git a/cc/resources/picture_pile_base.cc b/cc/resources/picture_pile_base.cc
index 2fb6ef5..aa00876f7 100644
--- a/cc/resources/picture_pile_base.cc
+++ b/cc/resources/picture_pile_base.cc
@@ -92,21 +92,29 @@ PicturePileBase::PicturePileBase(const PicturePileBase* other,
 PicturePileBase::~PicturePileBase() {
 }
 
-void PicturePileBase::Resize(const gfx::Size& new_size) {
-  if (size() == new_size)
+void PicturePileBase::SetTilingRect(const gfx::Rect& new_tiling_rect) {
+  if (tiling_rect() == new_tiling_rect)
     return;
 
-  gfx::Size old_size = size();
-  tiling_.SetTotalSize(new_size);
+  gfx::Rect old_tiling_rect = tiling_rect();
+  tiling_.SetTilingRect(new_tiling_rect);
 
   has_any_recordings_ = false;
 
-  // Find all tiles that contain any pixels outside the new size.
+  // Don't waste time in Resize figuring out what these hints should be.
+  recorded_viewport_ = gfx::Rect();
+
+  if (new_tiling_rect.origin() != old_tiling_rect.origin()) {
+    picture_map_.clear();
+    return;
+  }
+
+  // Find all tiles that contain any pixels outside the new rect.
   std::vector<PictureMapKey> to_erase;
   int min_toss_x = tiling_.FirstBorderTileXIndexFromSrcCoord(
-      std::min(old_size.width(), new_size.width()));
+      std::min(old_tiling_rect.right(), new_tiling_rect.right()));
   int min_toss_y = tiling_.FirstBorderTileYIndexFromSrcCoord(
-      std::min(old_size.height(), new_size.height()));
+      std::min(old_tiling_rect.bottom(), new_tiling_rect.bottom()));
   for (PictureMap::const_iterator it = picture_map_.begin();
        it != picture_map_.end();
        ++it) {
@@ -120,9 +128,6 @@ void PicturePileBase::Resize(const gfx::Size& new_size) {
 
   for (size_t i = 0; i < to_erase.size(); ++i)
     picture_map_.erase(to_erase[i]);
-
-  // Don't waste time in Resize figuring out what these hints should be.
-  recorded_viewport_ = gfx::Rect();
 }
 
 void PicturePileBase::SetMinContentsScale(float min_contents_scale) {
@@ -188,11 +193,11 @@ bool PicturePileBase::HasRecordingAt(int x, int y) {
 
 bool PicturePileBase::CanRaster(float contents_scale,
                                 const gfx::Rect& content_rect) {
-  if (tiling_.total_size().IsEmpty())
+  if (tiling_.tiling_rect().IsEmpty())
     return false;
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.f / contents_scale);
-  layer_rect.Intersect(gfx::Rect(tiling_.total_size()));
+  layer_rect.Intersect(tiling_.tiling_rect());
 
   // Common case inside of viewport to avoid the slower map lookups.
   if (recorded_viewport_.Contains(layer_rect)) {
@@ -233,10 +238,10 @@ gfx::Rect PicturePileBase::PadRect(const gfx::Rect& rect) {
 
 scoped_ptr<base::Value> PicturePileBase::AsValue() const {
   scoped_ptr<base::ListValue> pictures(new base::ListValue());
-  gfx::Rect layer_rect(tiling_.total_size());
+  gfx::Rect tiling_rect(tiling_.tiling_rect());
   std::set<void*> appended_pictures;
   bool include_borders = true;
-  for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
+  for (TilingData::Iterator tile_iter(&tiling_, tiling_rect, include_borders);
        tile_iter;
        ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
diff --git a/cc/resources/picture_pile_base.h b/cc/resources/picture_pile_base.h
index be9955e..eff7887 100644
--- a/cc/resources/picture_pile_base.h
+++ b/cc/resources/picture_pile_base.h
@@ -29,8 +29,8 @@ class CC_EXPORT PicturePileBase : public base::RefCounted<PicturePileBase> {
   explicit PicturePileBase(const PicturePileBase* other);
   PicturePileBase(const PicturePileBase* other, unsigned thread_index);
 
-  void Resize(const gfx::Size& size);
-  gfx::Size size() const { return tiling_.total_size(); }
+  void SetTilingRect(const gfx::Rect& tiling_rect);
+  gfx::Rect tiling_rect() const { return tiling_.tiling_rect(); }
   void SetMinContentsScale(float min_contents_scale);
 
   int num_tiles_x() const { return tiling_.num_tiles_x(); }
diff --git a/cc/resources/picture_pile_impl.cc b/cc/resources/picture_pile_impl.cc
index 3f8e167..e2d8674 100644
--- a/cc/resources/picture_pile_impl.cc
+++ b/cc/resources/picture_pile_impl.cc
@@ -110,25 +110,24 @@ void PicturePileImpl::RasterToBitmap(
     // layer, we also need to raster the background color underneath the last
     // texel (since the recording won't cover it) and outside the last texel
     // (due to linear filtering when using this texture).
-    gfx::SizeF total_content_size =
-        gfx::ScaleSize(tiling_.total_size(), contents_scale);
-    gfx::Rect content_rect(gfx::ToCeiledSize(total_content_size));
+    gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
+        gfx::ScaleRect(tiling_.tiling_rect(), contents_scale));
 
     // The final texel of content may only be partially covered by a
     // rasterization; this rect represents the content rect that is fully
     // covered by content.
-    gfx::Rect deflated_content_rect = content_rect;
-    deflated_content_rect.Inset(0, 0, 1, 1);
-    if (!deflated_content_rect.Contains(canvas_rect)) {
+    gfx::Rect deflated_content_tiling_rect = content_tiling_rect;
+    deflated_content_tiling_rect.Inset(0, 0, 1, 1);
+    if (!deflated_content_tiling_rect.Contains(canvas_rect)) {
       // Drawing at most 2 x 2 x (canvas width + canvas height) texels is 2-3X
       // faster than clearing, so special case this.
       canvas->save();
       canvas->translate(-canvas_rect.x(), -canvas_rect.y());
-      gfx::Rect inflated_content_rect = content_rect;
-      inflated_content_rect.Inset(0, 0, -1, -1);
-      canvas->clipRect(gfx::RectToSkRect(inflated_content_rect),
+      gfx::Rect inflated_content_tiling_rect = content_tiling_rect;
+      inflated_content_tiling_rect.Inset(0, 0, -1, -1);
+      canvas->clipRect(gfx::RectToSkRect(inflated_content_tiling_rect),
                        SkRegion::kReplace_Op);
-      canvas->clipRect(gfx::RectToSkRect(deflated_content_rect),
+      canvas->clipRect(gfx::RectToSkRect(deflated_content_tiling_rect),
                        SkRegion::kDifference_Op);
       canvas->drawColor(background_color_, SkXfermode::kSrc_Mode);
       canvas->restore();
@@ -253,18 +252,16 @@ void PicturePileImpl::RasterCommon(
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
-  gfx::SizeF total_content_size = gfx::ScaleSize(tiling_.total_size(),
-                                                 contents_scale);
-  gfx::Rect total_content_rect(gfx::ToCeiledSize(total_content_size));
-  gfx::Rect content_rect = total_content_rect;
-  content_rect.Intersect(canvas_rect);
+  gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
+      gfx::ScaleRect(tiling_.tiling_rect(), contents_scale));
+  content_tiling_rect.Intersect(canvas_rect);
 
-  canvas->clipRect(gfx::RectToSkRect(content_rect),
+  canvas->clipRect(gfx::RectToSkRect(content_tiling_rect),
                    SkRegion::kIntersect_Op);
 
   PictureRegionMap picture_region_map;
   CoalesceRasters(
-      canvas_rect, content_rect, contents_scale, &picture_region_map);
+      canvas_rect, content_tiling_rect, contents_scale, &picture_region_map);
 
 #ifndef NDEBUG
   Region total_clip;
@@ -279,7 +276,7 @@ void PicturePileImpl::RasterCommon(
     Region negated_clip_region = it->second;
 
 #ifndef NDEBUG
-    Region positive_clip = content_rect;
+    Region positive_clip = content_tiling_rect;
     positive_clip.Subtract(negated_clip_region);
     // Make sure we never rasterize the same region twice.
     DCHECK(!total_clip.Intersects(positive_clip));
@@ -332,17 +329,17 @@ void PicturePileImpl::RasterCommon(
 skia::RefPtr<SkPicture> PicturePileImpl::GetFlattenedPicture() {
   TRACE_EVENT0("cc", "PicturePileImpl::GetFlattenedPicture");
 
-  gfx::Rect layer_rect(tiling_.total_size());
+  gfx::Rect tiling_rect(tiling_.tiling_rect());
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(new SkPicture);
-  if (layer_rect.IsEmpty())
+  if (tiling_rect.IsEmpty())
     return picture;
 
-  SkCanvas* canvas = picture->beginRecording(
-      layer_rect.width(),
-      layer_rect.height(),
-      SkPicture::kUsePathBoundsForClip_RecordingFlag);
+  SkCanvas* canvas =
+      picture->beginRecording(tiling_rect.width(),
+                              tiling_rect.height(),
+                              SkPicture::kUsePathBoundsForClip_RecordingFlag);
 
-  RasterToBitmap(canvas, layer_rect, 1.0, NULL);
+  RasterToBitmap(canvas, tiling_rect, 1.0, NULL);
   picture->endRecording();
 
   return picture;
@@ -366,7 +363,7 @@ void PicturePileImpl::AnalyzeInRect(
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.0f / contents_scale);
 
-  layer_rect.Intersect(gfx::Rect(tiling_.total_size()));
+  layer_rect.Intersect(tiling_.tiling_rect());
 
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
 
@@ -436,7 +433,6 @@ void PicturePileImpl::PixelRefIterator::AdvanceToTilePictureWithPixelRefs() {
 }
 
 void PicturePileImpl::DidBeginTracing() {
-  gfx::Rect layer_rect(tiling_.total_size());
   std::set<void*> processed_pictures;
   for (PictureMap::iterator it = picture_map_.begin();
        it != picture_map_.end();
diff --git a/cc/resources/picture_pile_unittest.cc b/cc/resources/picture_pile_unittest.cc
index c64d420..04b4c33 100644
--- a/cc/resources/picture_pile_unittest.cc
+++ b/cc/resources/picture_pile_unittest.cc
@@ -44,12 +44,12 @@ class PicturePileTest : public testing::Test {
         min_scale_(0.125),
         frame_number_(0),
         contents_opaque_(false) {
-    pile_->Resize(pile_->tiling().max_texture_size());
+    pile_->SetTilingRect(gfx::Rect(pile_->tiling().max_texture_size()));
     pile_->SetTileGridSize(gfx::Size(1000, 1000));
     pile_->SetMinContentsScale(min_scale_);
   }
 
-  gfx::Rect layer_rect() const { return gfx::Rect(pile_->size()); }
+  gfx::Rect tiling_rect() const { return pile_->tiling_rect(); }
 
   bool Update(const Region& invalidation, const gfx::Rect& visible_layer_rect) {
     frame_number_++;
@@ -63,7 +63,7 @@ class PicturePileTest : public testing::Test {
                          &stats_instrumentation_);
   }
 
-  bool UpdateWholeLayer() { return Update(layer_rect(), layer_rect()); }
+  bool UpdateWholePile() { return Update(tiling_rect(), tiling_rect()); }
 
   FakeContentLayerClient client_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
@@ -75,11 +75,11 @@ class PicturePileTest : public testing::Test {
 };
 
 TEST_F(PicturePileTest, SmallInvalidateInflated) {
-  UpdateWholeLayer();
+  UpdateWholePile();
 
   // Invalidate something inside a tile.
   gfx::Rect invalidate_rect(50, 50, 1, 1);
-  Update(invalidate_rect, layer_rect());
+  Update(invalidate_rect, tiling_rect());
 
   EXPECT_EQ(1, pile_->tiling().num_tiles_x());
   EXPECT_EQ(1, pile_->tiling().num_tiles_y());
@@ -98,11 +98,11 @@ TEST_F(PicturePileTest, SmallInvalidateInflated) {
 }
 
 TEST_F(PicturePileTest, LargeInvalidateInflated) {
-  UpdateWholeLayer();
+  UpdateWholePile();
 
   // Invalidate something inside a tile.
   gfx::Rect invalidate_rect(50, 50, 100, 100);
-  Update(invalidate_rect, layer_rect());
+  Update(invalidate_rect, tiling_rect());
 
   EXPECT_EQ(1, pile_->tiling().num_tiles_x());
   EXPECT_EQ(1, pile_->tiling().num_tiles_y());
@@ -114,15 +114,16 @@ TEST_F(PicturePileTest, LargeInvalidateInflated) {
   int expected_inflation = pile_->buffer_pixels();
 
   Picture* base_picture = picture_info.GetPicture();
-  gfx::Rect base_picture_rect(pile_->size());
+  gfx::Rect base_picture_rect = pile_->tiling_rect();
   base_picture_rect.Inset(-expected_inflation, -expected_inflation);
   EXPECT_EQ(base_picture_rect.ToString(),
             base_picture->LayerRect().ToString());
 }
 
 TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
-  gfx::Size layer_size = gfx::ToFlooredSize(gfx::ScaleSize(pile_->size(), 2.f));
-  pile_->Resize(layer_size);
+  gfx::Rect new_tiling_rect =
+      gfx::ToEnclosedRect(gfx::ScaleRect(pile_->tiling_rect(), 2.f));
+  pile_->SetTilingRect(new_tiling_rect);
 
   // Due to border pixels, we should have 3 tiles.
   EXPECT_EQ(3, pile_->tiling().num_tiles_x());
@@ -133,11 +134,11 @@ TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
   EXPECT_EQ(7, pile_->tiling().border_texels());
 
   // Update the whole layer to create initial pictures.
-  UpdateWholeLayer();
+  UpdateWholePile();
 
   // Invalidate everything again to have a non zero invalidation
   // frequency.
-  UpdateWholeLayer();
+  UpdateWholePile();
 
   // Invalidate something just over a tile boundary by a single pixel.
   // This will invalidate the tile (1, 1), as well as 1 row of pixels in (1, 0).
@@ -146,7 +147,7 @@ TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
       pile_->tiling().TileBoundsWithBorder(0, 0).bottom() - 1,
       50,
       50);
-  Update(invalidate_rect, layer_rect());
+  Update(invalidate_rect, tiling_rect());
 
   for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
     for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
@@ -171,14 +172,16 @@ TEST_F(PicturePileTest, InvalidateOnTileBoundaryInflated) {
 }
 
 TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
-  gfx::Size layer_size = gfx::ToFlooredSize(gfx::ScaleSize(pile_->size(), 4.f));
-  pile_->Resize(layer_size);
+  gfx::Rect new_tiling_rect =
+      gfx::ToEnclosedRect(gfx::ScaleRect(pile_->tiling_rect(), 4.f));
+  pile_->SetTilingRect(new_tiling_rect);
 
-  gfx::Rect viewport(0, 0, layer_size.width(), 1);
+  gfx::Rect viewport(
+      tiling_rect().x(), tiling_rect().y(), tiling_rect().width(), 1);
 
-  // Update the whole layer until the invalidation frequency is high.
+  // Update the whole pile until the invalidation frequency is high.
   for (int frame = 0; frame < 33; ++frame) {
-    UpdateWholeLayer();
+    UpdateWholePile();
   }
 
   // Make sure we have a high invalidation frequency.
@@ -193,8 +196,9 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
     }
   }
 
-  // Update once more with a small viewport 0,0 layer_width by 1
-  Update(layer_rect(), viewport);
+  // Update once more with a small viewport tiilng_rect.x(), tiilng_rect.y(),
+  // tiling_rect.width() by 1
+  Update(tiling_rect(), viewport);
 
   for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
     for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
@@ -214,7 +218,7 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
   }
 
   // Now update with no invalidation and full viewport
-  Update(gfx::Rect(), layer_rect());
+  Update(gfx::Rect(), tiling_rect());
 
   for (int i = 0; i < pile_->tiling().num_tiles_x(); ++i) {
     for (int j = 0; j < pile_->tiling().num_tiles_y(); ++j) {
@@ -238,7 +242,7 @@ TEST_F(PicturePileTest, StopRecordingOffscreenInvalidations) {
 }
 
 TEST_F(PicturePileTest, ClearingInvalidatesRecordedRect) {
-  UpdateWholeLayer();
+  UpdateWholePile();
 
   gfx::Rect rect(0, 0, 5, 5);
   EXPECT_TRUE(pile_->CanRasterLayerRect(rect));
@@ -257,8 +261,9 @@ TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
   // and doesn't get re-recorded, then CanRaster is not true for any
   // tiles touching it, but is true for adjacent tiles, even if it
   // overlaps on borders (edge case).
-  gfx::Size layer_size = gfx::ToFlooredSize(gfx::ScaleSize(pile_->size(), 4.f));
-  pile_->Resize(layer_size);
+  gfx::Rect new_tiling_rect =
+      gfx::ToEnclosedRect(gfx::ScaleRect(pile_->tiling_rect(), 4.f));
+  pile_->SetTilingRect(new_tiling_rect);
 
   gfx::Rect tile01_borders = pile_->tiling().TileBoundsWithBorder(0, 1);
   gfx::Rect tile02_borders = pile_->tiling().TileBoundsWithBorder(0, 2);
@@ -269,7 +274,7 @@ TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
   // what the test is trying to repro.
   EXPECT_TRUE(tile01_borders.Intersects(tile02_borders));
   EXPECT_FALSE(tile01_noborders.Intersects(tile02_noborders));
-  UpdateWholeLayer();
+  UpdateWholePile();
   EXPECT_TRUE(pile_->CanRasterLayerRect(tile01_noborders));
   EXPECT_TRUE(pile_->CanRasterSlowTileCheck(tile01_noborders));
   EXPECT_TRUE(pile_->CanRasterLayerRect(tile02_noborders));
@@ -280,12 +285,12 @@ TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
 
   // Update the whole layer until the invalidation frequency is high.
   for (int frame = 0; frame < 33; ++frame) {
-    UpdateWholeLayer();
+    UpdateWholePile();
   }
 
   // Update once more with a small viewport.
-  gfx::Rect viewport(0, 0, layer_size.width(), 1);
-  Update(layer_rect(), viewport);
+  gfx::Rect viewport(0, 0, tiling_rect().width(), 1);
+  Update(tiling_rect(), viewport);
 
   // Sanity check some pictures exist and others don't.
   EXPECT_TRUE(pile_->picture_map()
@@ -305,15 +310,15 @@ TEST_F(PicturePileTest, NoInvalidationValidViewport) {
   // This test validates that the recorded_viewport cache of full tiles
   // is still valid for some use cases.  If it's not, it's a performance
   // issue because CanRaster checks will go down the slow path.
-  UpdateWholeLayer();
+  UpdateWholePile();
   EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
 
   // No invalidation, same viewport.
-  Update(gfx::Rect(), layer_rect());
+  Update(gfx::Rect(), tiling_rect());
   EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
 
   // Partial invalidation, same viewport.
-  Update(gfx::Rect(gfx::Rect(0, 0, 1, 1)), layer_rect());
+  Update(gfx::Rect(gfx::Rect(0, 0, 1, 1)), tiling_rect());
   EXPECT_TRUE(!pile_->recorded_viewport().IsEmpty());
 
   // No invalidation, changing viewport.
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 963808e..026fb8d 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -1138,7 +1138,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   // Note that this last optimization is a heuristic that ensures that we don't
   // spend too much time analyzing tiles on a multitude of small layers, as it
   // is likely that these layers have some non-solid content.
-  gfx::Size pile_size = tile->picture_pile()->size();
+  gfx::Size pile_size = tile->picture_pile()->tiling_rect().size();
   bool analyze_picture = !tile->use_gpu_rasterization() &&
                          std::min(pile_size.width(), pile_size.height()) >=
                              kMinDimensionsForAnalysis;