cc: Give TilingData a Rect instead of a Size

cc/resources/picture_pile_base.cc

 // Copyright 2013 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/resources/picture_pile_base.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 74 matching lines @@
   for (PictureMap::const_iterator it = other->picture_map_.begin();
        it != other->picture_map_.end();
        ++it) {
     picture_map_[it->first] = it->second.CloneForThread(thread_index);
   }
 }
 
 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.
-  std::vector<PictureMapKey> to_erase;
-  int min_toss_x = tiling_.FirstBorderTileXIndexFromSrcCoord(
-      std::min(old_size.width(), new_size.width()));
-  int min_toss_y = tiling_.FirstBorderTileYIndexFromSrcCoord(
-      std::min(old_size.height(), new_size.height()));
-  for (PictureMap::const_iterator it = picture_map_.begin();
-       it != picture_map_.end();
-       ++it) {
-    const PictureMapKey& key = it->first;
-    if (key.first < min_toss_x && key.second < min_toss_y) {
-      has_any_recordings_ |= !!it->second.GetPicture();
-      continue;
+  if (new_tiling_rect.x() == old_tiling_rect.x() &&

[enne (OOO), 2014/04/11 20:19:51]

This could be said more simply as new_tiling_rect.origin() ==
old_tiling_rect.origin()

[ernstm, 2014/04/11 23:43:51]

Done.

+      new_tiling_rect.y() == old_tiling_rect.y()) {
+    // 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_tiling_rect.width(), new_tiling_rect.width()));

[enne (OOO), 2014/04/11 20:19:51]

correctness: I think width/height should be right/bottom, in case origin() !=
gfx::Point()?

[ernstm, 2014/04/11 23:43:51]

Done.

+    int min_toss_y = tiling_.FirstBorderTileYIndexFromSrcCoord(
+        std::min(old_tiling_rect.height(), new_tiling_rect.height()));
+    for (PictureMap::const_iterator it = picture_map_.begin();
+         it != picture_map_.end();
+         ++it) {
+      const PictureMapKey& key = it->first;
+      if (key.first < min_toss_x && key.second < min_toss_y) {
+        has_any_recordings_ |= !!it->second.GetPicture();
+        continue;
+      }
+      to_erase.push_back(key);
     }
-    to_erase.push_back(key);
+
+    for (size_t i = 0; i < to_erase.size(); ++i)
+      picture_map_.erase(to_erase[i]);
+  } else {
+    picture_map_.clear();

[enne (OOO), 2014/04/11 20:19:51]

style nit: this else clause is far away from its if.  Could you just have a:

    if (offsets have changed)
       clear map
       early-out return

...and then that block above doesn't need to be indented? and this all is easier
to read?

[ernstm, 2014/04/11 23:43:51]

Done. I had to move the recorded_viewport_ = gfx::Rect() up, in front of the if
(offsets have changed) block.

   }
 
-  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) {
   DCHECK(min_contents_scale);
   if (min_contents_scale_ == min_contents_scale)
     return;
 
   // Picture contents are played back scaled. When the final contents scale is
@@ skipping 47 matching lines @@
 
 bool PicturePileBase::HasRecordingAt(int x, int y) {
   PictureMap::const_iterator found = picture_map_.find(PictureMapKey(x, y));
   if (found == picture_map_.end())
     return false;
   return !!found->second.GetPicture();
 }
 
 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)) {
     // Sanity check that there are no false positives in recorded_viewport_.
     DCHECK(CanRasterSlowTileCheck(layer_rect));
     return true;
   }
 
   return CanRasterSlowTileCheck(layer_rect);
 }
@@ skipping 20 matching lines @@
 
 gfx::Rect PicturePileBase::PadRect(const gfx::Rect& rect) {
   gfx::Rect padded_rect = rect;
   padded_rect.Inset(
       -buffer_pixels(), -buffer_pixels(), -buffer_pixels(), -buffer_pixels());
   return padded_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());
     if (map_iter == picture_map_.end())
       continue;
 
     Picture* picture = map_iter->second.GetPicture();
     if (picture && (appended_pictures.count(picture) == 0)) {
       appended_pictures.insert(picture);
       pictures->Append(TracedValue::CreateIDRef(picture).release());
@@ skipping 53 matching lines @@
     info.picture_ = picture_->GetCloneForDrawingOnThread(thread_index);
   return info;
 }
 
 float PicturePileBase::PictureInfo::GetInvalidationFrequency() const {
   return invalidation_history_.count() /
          static_cast<float>(INVALIDATION_FRAMES_TRACKED);
 }
 
 }  // namespace cc