cc: Change max_tiles_for_interest_rect to be screen pixels padding.

cc/tiles/picture_layer_tiling_unittest.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 <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 31 matching lines @@
   using PictureLayerTiling::TileAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       WhichTree tree,
       float contents_scale,
       scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       const LayerTreeSettings& settings) {
     return make_scoped_ptr(new TestablePictureLayerTiling(
         tree, contents_scale, raster_source, client,
-        settings.max_tiles_for_interest_area,
+        settings.tiling_interest_area_padding,
         settings.skewport_target_time_in_seconds,
         settings.skewport_extrapolation_limit_in_content_pixels));
   }
 
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
 
   using PictureLayerTiling::ComputeSkewport;
   using PictureLayerTiling::RemoveTileAt;
 
  protected:
   TestablePictureLayerTiling(WhichTree tree,
                              float contents_scale,
                              scoped_refptr<RasterSource> raster_source,
                              PictureLayerTilingClient* client,
-                             size_t max_tiles_for_interest_area,
+                             size_t tiling_interest_area_padding,
                              float skewport_target_time,
                              int skewport_extrapolation_limit)
       : PictureLayerTiling(tree,
                            contents_scale,
                            raster_source,
                            client,
-                           max_tiles_for_interest_area,
+                           tiling_interest_area_padding,
                            skewport_target_time,
                            skewport_extrapolation_limit) {}
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   ~PictureLayerTilingIteratorTest() override {}
 
   void Initialize(const gfx::Size& tile_size,
@@ skipping 458 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, SkewportLimits) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 10000;

[weiliangc, 2015/07/15 19:56:09]

Why can we rm this here? Does it have no effects in the first place?

[vmpstr, 2015/07/16 00:31:03]

It's a similar reason as the previous comment. Before, we didn't have enough to
get all of the times for the interest rect. Now, the padding is large enough to
get the tiles, so this isn't required (ie the default value is good enough).

   settings.skewport_extrapolation_limit_in_content_pixels = 75;
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
                                          settings);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
@@ skipping 222 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 10000;
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
   // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
   // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
   // tiling.
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.25f, pile, &client,
@@ skipping 174 matching lines @@
   priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
   EXPECT_FLOAT_EQ(55.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
   EXPECT_FLOAT_EQ(35.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
   EXPECT_FLOAT_EQ(30.f, priority.distance_to_visible);
 }
 
-TEST(PictureLayerTilingTest, ExpandRectEqual) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 10000, 10000);
-  int64 target_area = 100 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(in.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectSmaller) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 10000, 10000);
-  int64 target_area = 100 * 100;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
-  EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
-  EXPECT_EQ(out.width() - in.width(), out.height() - in.height());
-
-  // |in| represents the visible rect, and |out| represents the eventually rect.
-  // If the eventually rect doesn't contain the visible rect, we will start
-  // losing tiles.
-  EXPECT_TRUE(out.Contains(in));
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectUnbounded) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 10000, 10000);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
-  EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
-  EXPECT_EQ(out.width() - in.width(), out.height() - in.height());
-  EXPECT_NEAR(200 * 200, out.width() * out.height(), 100);
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedSmaller) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(50, 60, 40, 30);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedEqual) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds = in;
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchVertical) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(45, 0, 90, 300);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchVertical) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(40, 0, 100, 300);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchHorizontal) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(0, 55, 180, 190);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchHorizontal) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(0, 50, 180, 200);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedLeft) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(20, -1000, 10000, 10000);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
-  EXPECT_EQ(out.bottom() - in.bottom(), out.right() - in.right());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() - out.height() * 2);
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedRight) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 1000+120, 10000);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
-  EXPECT_EQ(out.bottom() - in.bottom(), in.x() - out.x());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() - out.height() * 2);
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedTop) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, 30, 10000, 10000);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
-  EXPECT_EQ(out.right() - in.right(), out.bottom() - in.bottom());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() * 2 - out.height());
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectBoundedBottom) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 10000, 1000 + 220);
-  int64 target_area = 200 * 200;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
-  EXPECT_EQ(out.right() - in.right(), in.y() - out.y());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() * 2 - out.height());
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectSquishedHorizontally) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(0, -4000, 100+40+20, 100000);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(20, out.right() - in.right());
-  EXPECT_EQ(40, in.x() - out.x());
-  EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() * 2);
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectSquishedVertically) {
-  gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-4000, 0, 100000, 200+50+30);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(30, out.bottom() - in.bottom());
-  EXPECT_EQ(50, in.y() - out.y());
-  EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.height() * 2);
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsFarAway) {
-  gfx::Rect in(400, 500, 100, 200);
-  gfx::Rect bounds(0, 0, 10, 10);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_TRUE(out.IsEmpty());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedFullyCover) {
-  gfx::Rect in(40, 50, 100, 100);
-  gfx::Rect bounds(0, 0, 10, 10);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.ToString(), out.ToString());
-}
-
-TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedPartlyCover) {
-  gfx::Rect in(600, 600, 100, 100);
-  gfx::Rect bounds(0, 0, 500, 500);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_EQ(bounds.right(), out.right());
-  EXPECT_EQ(bounds.bottom(), out.bottom());
-  EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() - out.height());
-  EXPECT_TRUE(bounds.Contains(out));
-}
-
-TEST(PictureLayerTilingTest, EmptyStartingRect) {
-  // If a layer has a non-invertible transform, then the starting rect
-  // for the layer would be empty.
-  gfx::Rect in(40, 40, 0, 0);
-  gfx::Rect bounds(0, 0, 10, 10);
-  int64 target_area = 400 * 400;
-  gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-      in, target_area, bounds, NULL);
-  EXPECT_TRUE(out.IsEmpty());
-}
-
 static void TileExists(bool exists, Tile* tile,
                        const gfx::Rect& geometry_rect) {
   EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
@@ skipping 63 matching lines @@
   EXPECT_EQ(expected_exists, tile != NULL)
       << "Rects intersecting " << rect.ToString() << " should exist. "
       << "Current tile rect is " << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   client_.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 1;
+  settings.tiling_interest_area_padding = 1;
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
   tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, 1.f, pile,
                                                &client_, settings);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
@@ skipping 436 matching lines @@
 
   // Offscreen layer is coming closer to viewport at 1000 pixels per second.
   current_screen_transform.Translate(1800, 0);
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 10000;
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
           current_layer_bounds);
   scoped_ptr<TestablePictureLayerTiling> tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
                                          settings);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
@@ skipping 109 matching lines @@
   // - Viewport moves somewhere far away and active tiling clears tiles.
   // - Viewport moves back and a new active tiling tile is created.
   // Result:
   // - Recycle tiling does _not_ have the tile in the same location (thus it
   //   will be shared next time a pending tiling is created).
 
   FakePictureLayerTilingClient active_client;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 10;
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
           gfx::Size(10000, 10000));
   scoped_ptr<TestablePictureLayerTiling> active_tiling =
       TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile,
                                          &active_client, settings);
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
@@ skipping 47 matching lines @@
                                          &active_client, LayerTreeSettings());
   // Create all tiles on this tiling.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
                                           Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
   LayerTreeSettings settings;
-  settings.max_tiles_for_interest_area = 10;
 
   pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
       gfx::Size(100, 100));
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
       TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, pile,
                                          &recycle_client, settings);
 
   // Create all tiles on the recycle tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
@@ skipping 32 matching lines @@
   tiling_->SetRasterSourceAndResize(pile);
 
   // Tile size in the tiling should be resized to 250x200.
   EXPECT_EQ(250, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(200, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(0u, tiling_->AllTilesForTesting().size());
 }
 
 }  // namespace
 }  // namespace cc