cc: Expand invalidation to full tile when recording is missing for the tile.

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 <limits>
 #include <vector>
 
@@ skipping 128 matching lines @@
 
 }  // namespace
 
 namespace cc {
 
 PicturePile::PicturePile() : is_suitable_for_gpu_rasterization_(true) {}
 
 PicturePile::~PicturePile() {
 }
 
-bool PicturePile::Update(ContentLayerClient* painter,
-                         SkColor background_color,
-                         bool contents_opaque,
-                         bool contents_fill_bounds_completely,
-                         const Region& invalidation,
-                         const gfx::Rect& visible_layer_rect,
-                         int frame_number,
-                         Picture::RecordingMode recording_mode,
-                         RenderingStatsInstrumentation* stats_instrumentation) {
+bool PicturePile::UpdateAndExpandInvalidation(
+    ContentLayerClient* painter,
+    Region* invalidation,
+    SkColor background_color,
+    bool contents_opaque,
+    bool contents_fill_bounds_completely,
+    const gfx::Rect& visible_layer_rect,
+    int frame_number,
+    Picture::RecordingMode recording_mode,
+    RenderingStatsInstrumentation* stats_instrumentation) {
   background_color_ = background_color;
   contents_opaque_ = contents_opaque;
   contents_fill_bounds_completely_ = contents_fill_bounds_completely;
 
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(tiling_rect());
 
+  // Anything outside the interest rect may no longer be valid, we don't care to
+  // know so consider it invalid.
+  Region invalidation_across_frames = tiling_.tiling_rect();
+  invalidation_across_frames.Subtract(interest_rect);

[enne (OOO), 2014/06/13 21:16:44]

The one bad part about this is that if you have a single long page that fits
into memory and has no invalidations then we'll have to reraster tiles we could
have kept around.  Do you actually need this outside invalidation here?  I think
the code below that invalidates tiles will do the same thing?

[danakj, 2014/06/13 21:19:18]

our goal is to invalidate all tiles on the pending layer that we don't have a
recording for. anything outside of this rect may not have a recording for it.

the code below does not do the same, it just invalidates things touched by the
invalidation rect which could be empty and then it would do nothing.

i think?

alternatively we need to know what we have recordings for outside the interest
rect, which we could compute but that's as expensive (and the same thing) as
what we were doing in PictureLayerImpl before, unless we save this data
somewhere?

[enne (OOO), 2014/06/13 21:23:20]

The only recordings that are dropped are ones that have been invalidated, so
ones that are external to recorded_viewport are still there.  recorded_viewport
is just an optimization to quickly early out of a few hash map lookups to see if
tiles exist.  There may still be valid tiles outside of it.

+
   bool invalidated = false;
-  for (Region::Iterator i(invalidation); i.has_rect(); i.next()) {
-    gfx::Rect invalidation = i.rect();
+  for (Region::Iterator i(*invalidation); i.has_rect(); i.next()) {
+    gfx::Rect invalid_rect = i.rect();
     // Split this inflated invalidation across tile boundaries and apply it
     // to all tiles that it touches.
     bool include_borders = true;
-    for (TilingData::Iterator iter(&tiling_, invalidation, include_borders);
+    for (TilingData::Iterator iter(&tiling_, invalid_rect, include_borders);
          iter;
          ++iter) {
       const PictureMapKey& key = iter.index();
 
       PictureMap::iterator picture_it = picture_map_.find(key);
       if (picture_it == picture_map_.end())
         continue;
 
       // Inform the grid cell that it has been invalidated in this frame.
       invalidated = picture_it->second.Invalidate(frame_number) || invalidated;
     }
+
+    int left_tile = tiling_.FirstBorderTileXIndexFromSrcCoord(invalid_rect.x());
+    int top_tile = tiling_.FirstBorderTileYIndexFromSrcCoord(invalid_rect.y());
+    int right_tile =
+        tiling_.LastBorderTileXIndexFromSrcCoord(invalid_rect.right() - 1);
+    int bottom_tile =
+        tiling_.LastBorderTileYIndexFromSrcCoord(invalid_rect.bottom() - 1);
+    gfx::Rect invalid_rect_filling_tiles =
+        gfx::UnionRects(tiling_.TileBoundsWithBorder(left_tile, top_tile),
+                        tiling_.TileBoundsWithBorder(right_tile, bottom_tile));
+    invalidation_across_frames.Union(invalid_rect_filling_tiles);
   }
 
+  // Return the expanded invalidation from this frame and previous frames.
+  invalidation_across_frames.Swap(invalidation);
+
   // Make a list of all invalid tiles; we will attempt to
   // cluster these into multiple invalidation regions.
   std::vector<gfx::Rect> invalid_tiles;
   bool include_borders = true;
   for (TilingData::Iterator it(&tiling_, interest_rect, include_borders); it;
        ++it) {
     const PictureMapKey& key = it.index();
     PictureInfo& info = picture_map_[key];
 
     gfx::Rect rect = PaddedRect(key);
@@ skipping 76 matching lines @@
     }
     DCHECK(found_tile_for_recorded_picture);
   }
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 }  // namespace cc