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

cc/resources/picture_pile_unittest.cc

 // Copyright 2013 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 <map>
 #include <utility>
 
 #include "cc/resources/picture_pile.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_rendering_stats_instrumentation.h"
@@ skipping 81 matching lines @@
   float min_scale_;
   int frame_number_;
   bool contents_opaque_;
 };
 
 class PicturePileTest : public PicturePileTestBase, public testing::Test {
  public:
   virtual void SetUp() override { InitializeData(); }
 };
 
+TEST_F(PicturePileTest, InvalidationOnTileBorderOutsideInterestRect) {
+  // Don't expand the interest rect past what we invalidate.
+  pile_->SetPixelRecordDistanceForTesting(0);
+
+  gfx::Size tile_size(100, 100);
+  pile_->tiling().SetMaxTextureSize(tile_size);
+
+  gfx::Size pile_size(400, 400);
+  SetTilingSize(pile_size);
+
+  // We have multiple tiles.

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

Can you explain in the comment why 5 not 4?

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

Cuz borders :D I could just > 1 instead.. maybe that's better, then I don't have
to worry about 4 vs 5.

+  EXPECT_EQ(5, pile_->tiling().num_tiles_x());
+  EXPECT_EQ(5, pile_->tiling().num_tiles_y());
+
+  // Record everything.
+  Region invalidation(tiling_rect());
+  UpdateAndExpandInvalidation(&invalidation, tiling_size(), tiling_rect());
+
+  // The interest rect will be entirely inside 1,0 and not touch the border of
+  // 1,1.
+  gfx::Rect interest_rect(
+      pile_->tiling().TilePositionX(1) + pile_->tiling().border_texels(),
+      0,
+      10,
+      pile_->tiling().TileSizeY(0) - pile_->tiling().border_texels());
+
+  // Invalidate tile 1,0 only. This is a rect that avoids the borders of any
+  // other tiles.
+  gfx::Rect invalidate_tile = interest_rect;
+  // This should cause the tile 1,0 to be invalidated and re-recorded. The
+  // invalidation did not need to be expanded.
+  invalidation = invalidate_tile;
+  UpdateAndExpandInvalidation(&invalidation, tiling_size(), interest_rect);
+  EXPECT_EQ(invalidate_tile, invalidation);
+
+  // Invalidate tile 1,0 and 1,1 by invalidating something that only touches the
+  // border of 1,1 (and is inside the tile bounds of 1,0). This is a 10px wide
+  // strip from the top of the tiling onto the border pixels of tile 1,1 that
+  // avoids border pixels of any other tiles.
+  gfx::Rect invalidate_border(pile_->tiling().TilePositionX(1) + 10,
+                              0,
+                              10,
+                              pile_->tiling().TileSizeY(0));

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

Can you assert somewhere that pile_->tiling().border_texels() is 1? or
alternatively make this pile_->tiling().TileSizeY(0) -
pile_->tiling().border_texels() + 1? I just wanna make sure that we're just 1
pixel over the border.

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

It's not 1. The recording border pixels are more.
SG. How about:
invalidate_border = interest_rect;
invaliadte_border.Inset(0, 0, 0, -1);

+  // This should cause the tile 1,0 and 1,1 to be invalidated, and 1,1 will not

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

"and 1,1 will not be re-recorded" Can you elaborate to say because we're only
recording enough to cover the last tile? I made a comment saying "why not", then
went to the code, read that comment and it made it clear.

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

It's because the interest rect doesn't touch it. I'm not sure what you mean by
last tile there, but I'll say something about the interest rect here?

+  // be re-recorded. So the invalidation should be expanded to cover all of 1,1.
+  invalidation = invalidate_border;
+  UpdateAndExpandInvalidation(&invalidation, tiling_size(), interest_rect);
+  Region expected_invalidation = invalidate_border;
+  expected_invalidation.Union(pile_->tiling().TileBounds(1, 1));
+  EXPECT_EQ(expected_invalidation.ToString(), invalidation.ToString());
+}
+
 TEST_F(PicturePileTest, SmallInvalidateInflated) {
   // Invalidate something inside a tile.
   Region invalidate_rect(gfx::Rect(50, 50, 1, 1));
   UpdateAndExpandInvalidation(&invalidate_rect, tiling_size(), tiling_rect());
   EXPECT_EQ(gfx::Rect(50, 50, 1, 1).ToString(), invalidate_rect.ToString());
 
   EXPECT_EQ(1, pile_->tiling().num_tiles_x());
   EXPECT_EQ(1, pile_->tiling().num_tiles_y());
 
   TestPicturePile::PictureInfo& picture_info =
@@ skipping 1241 matching lines @@
   client_.add_draw_rect(tiling_rect(), paint);
   client_.add_draw_rect(tiling_rect(), paint);
   client_.add_draw_rect(tiling_rect(), paint);
   Region invalidation5(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation5, tiling_size(), tiling_rect());
   EXPECT_FALSE(pile_->is_solid_color());
 }
 
 }  // namespace
 }  // namespace cc