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.
+        tile_invalidation.Inset(-buffer_pixels(), -buffer_pixels());
+        tile_invalidation.Intersect(tile);
+
+        // Make sure that the invalidation is at least large enough to cover a
+        // single rastered pixel when scaled down by any scale no smaller than
+        // the minimum contents scale. This means ensuring the resulting rect
+        // is at least (2 * buffer_pixels() + 1) large in each dimension.
+        //
+        // Because we already inflated by buffer_pixels() in each direction,
+        // and the |tile| is larger than our required minimum size, the
+        // intersection will only drop at most buffer_pixels() from the
+        // invalidation rect in each dimension. Inflating and intersecting once
+        // more will give us the minimum size required.
+        if (tile_invalidation.width() < buffer_pixels() * 2 + 1)

[enne (OOO), 2013/05/05 01:26:47]

Sorry, but no?

It's not about total width.  It's about maintaining a kernel of buffer pixels
around each invalidated pixel.

I think the right thing to do here is to intersect the invalidation against the
tile without border and then to inflate equally in all directions.

[danakj, 2013/05/06 14:40:06]

Hm, I am not sure if I agree, so let's make some pictures and sort this out.

+          tile_invalidation.Inset(-buffer_pixels(), 0);
+        if (tile_invalidation.height() < buffer_pixels() * 2 + 1)
+          tile_invalidation.Inset(0, -buffer_pixels());
+        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