cc: Correct expansion of invalidation for tiles outside of interest rect

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 131 matching lines @@
   }
 
   *record_rects = vertical_clustering;
   return vertical_density;
 }
 
 }  // namespace
 
 namespace cc {
 
-PicturePile::PicturePile() : is_suitable_for_gpu_rasterization_(true) {
+PicturePile::PicturePile()
+    : is_suitable_for_gpu_rasterization_(true),
+      pixel_record_distance_(kPixelDistanceToRecord) {
 }
 
 PicturePile::~PicturePile() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     SkColor background_color,
     bool contents_opaque,
@@ skipping 10 matching lines @@
   bool updated = false;
 
   Region resize_invalidation;
   gfx::Size old_tiling_size = tiling_size();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
     updated = true;
   }
 
   gfx::Rect interest_rect = visible_layer_rect;
-  interest_rect.Inset(
-      -kPixelDistanceToRecord,
-      -kPixelDistanceToRecord,
-      -kPixelDistanceToRecord,
-      -kPixelDistanceToRecord);
+  interest_rect.Inset(-pixel_record_distance_, -pixel_record_distance_);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(gfx::Rect(tiling_size()));
 
   gfx::Rect interest_rect_over_tiles =
       tiling_.ExpandRectToTileBounds(interest_rect);
 
   if (old_tiling_size != layer_size) {
     has_any_recordings_ = false;
 
     // Drop recordings that are outside the new layer bounds or that changed
@@ skipping 180 matching lines @@
     }
   }
 
   // Detect cases where the full pile is invalidated, in this situation we
   // can just drop/invalidate everything.
   if (invalidation->Contains(gfx::Rect(old_tiling_size)) ||
       invalidation->Contains(gfx::Rect(tiling_size()))) {
     for (auto& it : picture_map_)
       updated = it.second.Invalidate(frame_number) || updated;
   } else {
-    // Expand invalidation that is outside tiles that intersect the interest
-    // rect. These tiles are no longer valid and should be considerered fully
-    // invalid, so we can know to not keep around raster tiles that intersect
-    // with these recording tiles.
+    // Expand invalidation that is on tiles that aren't in the interest rect and
+    // will not be re-recorded below. These tiles are no longer valid and should
+    // be considerered fully invalid, so we can know to not keep around raster
+    // tiles that intersect with these recording tiles.
     Region invalidation_expanded_to_full_tiles;
 
     for (Region::Iterator i(*invalidation); i.has_rect(); i.next()) {
       gfx::Rect invalid_rect = i.rect();
 
-      gfx::Rect invalid_rect_outside_interest_rect_tiles = invalid_rect;
+      // This rect covers the bounds (excluding borders) of all tiles that touch

[vmpstr, 2014/10/15 19:00:20]

Can you rephrase this as:

This rect cover the bounds (excluding borders) of all the tiles whose bounds
(including borders) intersect the |interest_rect|

or something like that? My initial read through I though it's the interest rect
that has the borders, which I don't think is the case.

[danakj, 2014/10/15 19:06:27]

Right, done.

+      // the |interest_rect| (including borders). This matches the iteration of
+      // the |invalid_rect| below which includes borders when calling
+      // Invalidate() on pictures.
+      gfx::Rect invalid_rect_outside_interest_rect_tiles =
+          tiling_.ExpandRectToTileBounds(invalid_rect);
+      // We subtract the |interest_rect_over_tiles| which represents the bounds
+      // of tiles that will be re-recorded below. This matches the iteration of
+      // |interest_rect| below which includes borders.
       // TODO(danakj): We should have a Rect-subtract-Rect-to-2-rects operator
       // instead of using Rect::Subtract which gives you the bounding box of the
       // subtraction.
       invalid_rect_outside_interest_rect_tiles.Subtract(
           interest_rect_over_tiles);
-      invalidation_expanded_to_full_tiles.Union(tiling_.ExpandRectToTileBounds(
-          invalid_rect_outside_interest_rect_tiles));
+      invalidation_expanded_to_full_tiles.Union(
+          invalid_rect_outside_interest_rect_tiles);
 
       // 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_, invalid_rect, include_borders);
            iter;
            ++iter) {
         const PictureMapKey& key = iter.index();
 
         PictureMap::iterator picture_it = picture_map_.find(key);
@@ skipping 149 matching lines @@
     if (it->second.GetPicture() != picture)
       return;
   }
   skia::AnalysisCanvas canvas(recorded_viewport_.width(),
                               recorded_viewport_.height());
   picture->Raster(&canvas, NULL, Region(), 1.0f);
   is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
 }
 
 }  // namespace cc