cc: Inflate invalidation in each picture list

cc/resources/picture_pile.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/resources/picture_pile.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/base/region.h"
@@ skipping 28 matching lines @@
     RenderingStats* stats) {
   background_color_ = background_color;
 
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -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());
       if (!tile.Intersects(interest_rect)) {
         // This invalidation touches a tile outside the interest rect, so
         // just remove the entire picture list.
         picture_list_map_.erase(iter.index());
         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());
       if (find == picture_list_map_.end())
         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);
+      }
     }
   }
 
   // Walk through all pictures in the rect of interest and record.
   for (TilingData::Iterator iter(&tiling_, interest_rect); iter; ++iter) {
     // Create a picture in this list if it doesn't exist.
     PictureList& pic_list = picture_list_map_[iter.index()];
     if (pic_list.empty()) {
       // Inflate the base picture with a margin, similar to invalidations, so
       // that when scaled down to at least min_contents_scale, the enclosed
@@ skipping 59 matching lines @@
 
   FullyContainedPredicate pred(picture_rect);
   picture_list.erase(std::remove_if(picture_list.begin(),
                                     picture_list.end(),
                                     pred),
                      picture_list.end());
   picture_list.push_back(Picture::Create(picture_rect));
 }
 
 }  // namespace cc