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;
   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