cc: Make the invalidation frequency buffer bigger.

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_picture_pile.h"
@@ skipping 269 matching lines @@
       EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting())
           << "i " << i << " j " << j;
     }
   }
 
   // Update once more with a small viewport.
   Region invalidation(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), viewport);
   EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
 
+  bool had_tiles_with_no_pictures = false;
   for (int i = 0; i < pile_.tiling().num_tiles_x(); ++i) {
     for (int j = 0; j < pile_.tiling().num_tiles_y(); ++j) {
       FakePicturePile::PictureInfo& picture_info =
           pile_.picture_map()
               .find(FakePicturePile::PictureMapKey(i, j))
               ->second;
       EXPECT_FLOAT_EQ(1.0f, picture_info.GetInvalidationFrequencyForTesting());
 
       // If the y far enough away we expect to find no picture (no re-recording
       // happened). For close y, the picture should change.
-      if (j >= 2)
+      if (j >= 3) {
         EXPECT_FALSE(picture_info.GetPicture()) << "i " << i << " j " << j;
-      else
+        had_tiles_with_no_pictures = true;
+      } else {
         EXPECT_TRUE(picture_info.GetPicture()) << "i " << i << " j " << j;
+      }
     }
   }
 
+  EXPECT_TRUE(had_tiles_with_no_pictures);
+
   // Update a partial tile that doesn't get recorded. We should expand the
   // invalidation to the entire tiles that overlap it.
   Region small_invalidation =
       gfx::Rect(pile_.tiling().TileBounds(3, 4).x(),
                 pile_.tiling().TileBounds(3, 4).y() + 10,
                 1,
                 1);
   UpdateAndExpandInvalidation(&small_invalidation, tiling_size(), viewport);
   EXPECT_TRUE(small_invalidation.Contains(gfx::UnionRects(
       pile_.tiling().TileBounds(2, 4), pile_.tiling().TileBounds(3, 4))))
@@ skipping 36 matching lines @@
 
 TEST_F(PicturePileTest, FrequentInvalidationCanRaster) {
   // This test makes sure that if part of the page is frequently invalidated
   // and doesn't get re-recorded, then CanRaster is not true for any
   // tiles touching it, but is true for adjacent tiles, even if it
   // overlaps on borders (edge case).
   gfx::Size new_tiling_size =
       gfx::ToCeiledSize(gfx::ScaleSize(tiling_size(), 4.f));
   SetTilingSize(new_tiling_size);
 
-  gfx::Rect tile01_borders = pile_.tiling().TileBoundsWithBorder(0, 1);
   gfx::Rect tile02_borders = pile_.tiling().TileBoundsWithBorder(0, 2);
-  gfx::Rect tile01_noborders = pile_.tiling().TileBounds(0, 1);
+  gfx::Rect tile03_borders = pile_.tiling().TileBoundsWithBorder(0, 3);
   gfx::Rect tile02_noborders = pile_.tiling().TileBounds(0, 2);
+  gfx::Rect tile03_noborders = pile_.tiling().TileBounds(0, 3);
 
   // Sanity check these two tiles are overlapping with borders, since this is
   // what the test is trying to repro.
-  EXPECT_TRUE(tile01_borders.Intersects(tile02_borders));
-  EXPECT_FALSE(tile01_noborders.Intersects(tile02_noborders));
+  EXPECT_TRUE(tile02_borders.Intersects(tile03_borders));
+  EXPECT_FALSE(tile02_noborders.Intersects(tile03_noborders));
   UpdateWholePile();
-  EXPECT_TRUE(pile_.CanRasterLayerRect(tile01_noborders));
-  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile01_noborders));
   EXPECT_TRUE(pile_.CanRasterLayerRect(tile02_noborders));
   EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(tile03_noborders));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile03_noborders));
   // Sanity check that an initial paint goes down the fast path of having
   // a valid recorded viewport.
   EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
 
   // Update the whole layer until the invalidation frequency is high.
   for (int frame = 0; frame < 33; ++frame) {
     UpdateWholePile();
   }
 
   // Update once more with a small viewport.
   gfx::Rect viewport(tiling_size().width(), 1);
   Region invalidation(tiling_rect());
   UpdateAndExpandInvalidation(&invalidation, tiling_size(), viewport);
   EXPECT_EQ(tiling_rect().ToString(), invalidation.ToString());
 
   // Sanity check some pictures exist and others don't.
   EXPECT_TRUE(pile_.picture_map()
-                  .find(FakePicturePile::PictureMapKey(0, 1))
+                  .find(FakePicturePile::PictureMapKey(0, 2))
                   ->second.GetPicture());
   EXPECT_FALSE(pile_.picture_map()
-                   .find(FakePicturePile::PictureMapKey(0, 2))
+                   .find(FakePicturePile::PictureMapKey(0, 3))
                    ->second.GetPicture());
 
-  EXPECT_TRUE(pile_.CanRasterLayerRect(tile01_noborders));
-  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile01_noborders));
-  EXPECT_FALSE(pile_.CanRasterLayerRect(tile02_noborders));
-  EXPECT_FALSE(pile_.CanRasterSlowTileCheck(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterLayerRect(tile02_noborders));
+  EXPECT_TRUE(pile_.CanRasterSlowTileCheck(tile02_noborders));
+  EXPECT_FALSE(pile_.CanRasterLayerRect(tile03_noborders));
+  EXPECT_FALSE(pile_.CanRasterSlowTileCheck(tile03_noborders));
 }
 
 TEST_F(PicturePileTest, NoInvalidationValidViewport) {
   // This test validates that the recorded_viewport cache of full tiles
   // is still valid for some use cases.  If it's not, it's a performance
   // issue because CanRaster checks will go down the slow path.
   EXPECT_TRUE(!pile_.recorded_viewport().IsEmpty());
 
   // No invalidation, same viewport.
   Region invalidation;
@@ skipping 1124 matching lines @@
   EXPECT_TRUE(pile_.HasRecordings());
   pile_.SetEmptyBounds();
   EXPECT_FALSE(pile_.is_solid_color());
   EXPECT_TRUE(pile_.GetSize().IsEmpty());
   EXPECT_TRUE(pile_.picture_map().empty());
   EXPECT_FALSE(pile_.HasRecordings());
 }
 
 }  // namespace
 }  // namespace cc