cc: Inflate invalidation in each picture list

cc/resources/picture_pile.cc

Index: cc/resources/picture_pile.cc
diff --git a/cc/resources/picture_pile.cc b/cc/resources/picture_pile.cc
index a45dd9e71b1fb1f5ff323805b3f0d094fe6e3f1c..ce254617faa3fb04b18d0a9d93436e80a0cfcaa9 100644
--- a/cc/resources/picture_pile.cc
+++ b/cc/resources/picture_pile.cc
@@ -46,18 +46,10 @@ void PicturePile::Update(
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord);
   for (Region::Iterator i(invalidation); i.has_rect(); i.next()) {
-    // Inflate all recordings from invalidations with a margin so that when
-    // scaled down to at least min_contents_scale, any final pixel touched by an
-    // invalidation can be fully rasterized by this picture.
-    gfx::Rect inflated_invalidation = i.rect();
-    inflated_invalidation.Inset(
-        -buffer_pixels(),
-        -buffer_pixels(),
-        -buffer_pixels(),
-        -buffer_pixels());
+    gfx::Rect invalidation = i.rect();
     // Split this inflated invalidation across tile boundaries and apply it
     // to all tiles that it touches.
-    for (TilingData::Iterator iter(&tiling_, inflated_invalidation);
+    for (TilingData::Iterator iter(&tiling_, invalidation);
          iter; ++iter) {
       gfx::Rect tile =
           tiling_.TileBoundsWithBorder(iter.index_x(), iter.index_y());
@@ -68,8 +60,7 @@ void PicturePile::Update(
         continue;
       }
 
-      gfx::Rect tile_invalidation =
-          gfx::IntersectRects(inflated_invalidation, tile);
+      gfx::Rect tile_invalidation = gfx::IntersectRects(invalidation, tile);
       if (tile_invalidation.IsEmpty())
         continue;
       PictureListMap::iterator find = picture_list_map_.find(iter.index());
@@ -77,8 +68,28 @@ void PicturePile::Update(
         continue;
       PictureList& pic_list = find->second;
       // Leave empty pic_lists empty in case there are multiple invalidations.
-      if (!pic_list.empty())
+      if (!pic_list.empty()) {
+        // Inflate all recordings from invalidations with a margin so that when
+        // scaled down to at least min_contents_scale, any final pixel touched
+        // by an invalidation can be fully rasterized by this picture.
+        for (int i = 0; i < 2; ++i) {

[enne (OOO), 2013/05/03 07:00:57]

This is not right.  It's not just for scaling down by min contents scale.  If
you scale down by 1/4x, then 4x4 recorded pixels equal one rastered pixel. 
Let's say your invalidation includes gfx::Rect(12, 12, 1, 1).  You will need
gfx::Rect(12, 12, 4, 4) in order to correctly raster that pixel because it will
sample from all 4x4 of those recorded pixels to generate it.

See
https://code.google.com/p/chromium/codesearch#chromium/src/cc/resources/pictu...
for the bit of code that requires this inflation during rasterization.

This is why it was inflated evenly in all directions by the buffer pixels, and I
think that logic needs to stay.  We do the same thing with the base picture too:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/resources/pictu....

[danakj, 2013/05/03 17:49:20]

Okay so let me see if I'm understanding correctly..

The picture list (tile) is inflated such that any texel we want to raster at any
scale will be sourcable by pixels entirely in a single picuture list (tile).

Then, if we invalidate on the edge of a picture list (tile), we'll actually be
over two picture lists due to border pixels.

Now, if we inflate the invalidation in all directions by the border pixels and
intersect with the tile, we may end up with a Picture of dimensions less than
1/scale-1, which caused the assert.

So we need each individual Picture in the PictureList to be big enough.

The other problem is that we need to inflate in all directions in order to get
the right pixels needed to raster the texel.

The tile_invalidation must be at least 1x1 px already when we get to this point.
When we finish it needs to be expanded by 2*borderpx, so it will be >=
2*borderpx+1 in each dimension if we did things right.

I think that you're saying we need to always inflate by the borderpx in all
directions, then inflate extra if required to meet our min size requirements?
I'll do that. 

+          int width_inflate = 0;
+          int height_inflate = 0;
+          if (tile_invalidation.width() < buffer_pixels() * 2 + 1)
+            width_inflate = buffer_pixels();
+          if (tile_invalidation.height() < buffer_pixels() * 2 + 1)
+            height_inflate = buffer_pixels();
+          if (!width_inflate && !height_inflate)
+            break;
+          tile_invalidation.Inset(-width_inflate, -height_inflate);
+          tile_invalidation.Intersect(tile);
+        }
+
+        DCHECK_GE(tile_invalidation.width(), buffer_pixels() * 2 + 1);
+        DCHECK_GE(tile_invalidation.height(), buffer_pixels() * 2 + 1);
+
         InvalidateRect(pic_list, tile_invalidation);
+      }
     }
   }