cc: Remove max tiles and skewport constants from tiling client.

cc/resources/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 "cc/resources/picture_layer_tiling.h"
 
 #include <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 36 matching lines @@
 }
 
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
+      PictureLayerTilingClient* client,
+      size_t max_tiles_for_interest_area,
+      float skewport_target_time,
+      int skewport_extrapolation_limit) {
+    return make_scoped_ptr(new TestablePictureLayerTiling(
+        contents_scale, layer_bounds, client, max_tiles_for_interest_area,
+        skewport_target_time, skewport_extrapolation_limit));
+  }
+
+  static scoped_ptr<TestablePictureLayerTiling> CreateDefault(
+      float contents_scale,
+      const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client) {
-    return make_scoped_ptr(new TestablePictureLayerTiling(
-        contents_scale,
-        layer_bounds,
-        client));
+    LayerTreeSettings defaults;
+    return Create(contents_scale, layer_bounds, client, 10000,

[danakj, 2014/12/10 22:23:25]

did you mean to use 10000 here?

[vmpstr, 2014/12/11 00:14:17]

I changed this a bit. I removed CreateDefault, and added LayerTreeSettings as a
parameter to Create. Each of the tests that creates this now passes the settings
either unmodified from default, or modifies the settings and passes it. I think
that's the most sane approach.

+                  defaults.skewport_target_time_in_seconds,
+                  defaults.skewport_extrapolation_limit_in_content_pixels);
   }
 
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   bool eviction_tiles_cache_valid() const {
     return eviction_tiles_cache_valid_;
   }
 
   using PictureLayerTiling::ComputeSkewport;
   using PictureLayerTiling::RemoveTileAt;
 
  protected:
   TestablePictureLayerTiling(float contents_scale,
                              const gfx::Size& layer_bounds,
-                             PictureLayerTilingClient* client)
-      : PictureLayerTiling(contents_scale, layer_bounds, client) { }
+                             PictureLayerTilingClient* client,
+                             size_t max_tiles_for_interest_area,
+                             float skewport_target_time,
+                             int skewport_extrapolation_limit)
+      : PictureLayerTiling(contents_scale,
+                           layer_bounds,
+                           client,
+                           max_tiles_for_interest_area,
+                           skewport_target_time,
+                           skewport_extrapolation_limit) {}
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   virtual ~PictureLayerTilingIteratorTest() {}
 
   void Initialize(const gfx::Size& tile_size,
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
     client_.set_tree(PENDING_TREE);
-    tiling_ = TestablePictureLayerTiling::Create(contents_scale,
-                                                 layer_bounds,
-                                                 &client_);
+    LayerTreeSettings defaults;
+    tiling_ = TestablePictureLayerTiling::Create(

[danakj, 2014/12/10 22:23:25]

or else this can just call CreateDefault?

[vmpstr, 2014/12/11 00:14:17]

Done.

+        contents_scale, layer_bounds, &client_, 10000,
+        defaults.skewport_target_time_in_seconds,
+        defaults.skewport_extrapolation_limit_in_content_pixels);
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
       EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
@@ skipping 71 matching lines @@
 
   void VerifyTilesCoverNonContainedRect(float rect_scale,
                                         const gfx::Rect& dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
-  void set_max_tiles_for_interest_area(size_t area) {
-    client_.set_max_tiles_for_interest_area(area);
-  }
-
  protected:
   FakePictureLayerTilingClient client_;
   scoped_ptr<TestablePictureLayerTiling> tiling_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
 };
 
 TEST_F(PictureLayerTilingIteratorTest, ResizeDeletesTiles) {
   // Verifies that a resize with invalidation for newly exposed pixels will
@@ skipping 328 matching lines @@
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000));
 
   // Partially covering content, but too large
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
 }
 
 TEST(PictureLayerTilingTest, SkewportLimits) {
   FakePictureLayerTilingClient client;
-  client.set_skewport_extrapolation_limit_in_content_pixels(75);
+  LayerTreeSettings defaults;
   client.set_tree(ACTIVE_TREE);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
-  tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
+  tiling = TestablePictureLayerTiling::Create(
+      1.0f, layer_bounds, &client, 10000,
+      defaults.skewport_target_time_in_seconds, 75);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
   EXPECT_EQ(100, down_skewport.width());
@@ skipping 45 matching lines @@
 
 TEST(PictureLayerTilingTest, ComputeSkewport) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f, layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
   EXPECT_EQ(100, down_skewport.width());
@@ skipping 44 matching lines @@
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
   client.set_tree(ACTIVE_TREE);
 
   // 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.
-  tiling = TestablePictureLayerTiling::Create(0.25f, layer_bounds, &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(0.25f, layer_bounds, &client);
   gfx::Rect viewport_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
 
   tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   gfx::Rect soon_rect = viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
   gfx::Rect soon_rect_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(soon_rect, 0.25f));
@@ skipping 133 matching lines @@
   priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(136.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(56.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(8.f, priority.distance_to_visible);
 
   // Test additional scales.
-  tiling = TestablePictureLayerTiling::Create(0.2f, layer_bounds, &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(0.2f, layer_bounds, &client);
   tiling->ComputeTilePriorityRects(viewport, 1.0f, 4.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(110.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(70.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
@@ skipping 240 matching lines @@
 
   gfx::Rect viewport(50, 50, 100, 100);
   gfx::Size layer_bounds(800, 800);
 
   gfx::Rect soon_rect = viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
   client.SetTileSize(gfx::Size(30, 30));
   client.set_tree(ACTIVE_TREE);
 
-  tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f, layer_bounds, &client);
   tiling->ComputeTilePriorityRects(viewport, 1.0f, 1.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   PictureLayerTiling::TilingRasterTileIterator empty_iterator;
   EXPECT_FALSE(empty_iterator);
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
   // Sanity check.
   EXPECT_EQ(841u, all_tiles.size());
@@ skipping 84 matching lines @@
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 0, 100, 100);
   gfx::Rect moved_viewport(50, 0, 100, 500);
   gfx::Size layer_bounds(1000, 1000);
 
   client.SetTileSize(gfx::Size(30, 30));
   client.set_tree(ACTIVE_TREE);
 
-  tiling = TestablePictureLayerTiling::Create(1.f, layer_bounds, &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.f, layer_bounds, &client);
   tiling->ComputeTilePriorityRects(viewport, 1.0f, 1.0, Occlusion());
   tiling->ComputeTilePriorityRects(moved_viewport, 1.0f, 2.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
   // There are 3 bins in TilePriority.
   bool have_tiles[3] = {};
   Tile* last_tile = NULL;
@@ skipping 114 matching lines @@
   bool intersects = rect.Intersects(geometry_rect);
   bool expected_exists = intersect_exists ? intersects : !intersects;
   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);
-  Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
+  client_.SetTileSize(gfx::Size(100, 100));
+  client_.set_tree(PENDING_TREE);
+  LayerTreeSettings defaults;
+  tiling_ = TestablePictureLayerTiling::Create(
+      1.f, layer_bounds, &client_, 1, defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
   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);
 
   client_.set_tree(ACTIVE_TREE);
-  set_max_tiles_for_interest_area(1);
   tiling_->ComputeTilePriorityRects(visible_rect,  // visible content rect
                                     1.f,           // current contents scale
                                     1.0,           // current frame time
                                     Occlusion());
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TilesIntersectingRectExist, visible_rect, true));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
   gfx::Size layer_bounds(1099, 801);
   gfx::Size tile_size(100, 100);
+  LayerTreeSettings defaults;
 
   client_.SetTileSize(tile_size);
   client_.set_tree(PENDING_TREE);
 
-  auto active_set = PictureLayerTilingSet::Create(&client_);
+  auto active_set = PictureLayerTilingSet::Create(
+      &client_, 10000, defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
 
   active_set->AddTiling(1.f, layer_bounds);
 
   VerifyTiles(active_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
   UpdateAllTilePriorities(active_set.get(),
                           gfx::Rect(layer_bounds),  // visible content rect
                           1.f,                      // current contents scale
                           1.0);                     // current frame time
 
   // The active tiling has tiles now.
   VerifyTiles(active_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 
   // Add the same tilings to the pending set.
-  auto pending_set = PictureLayerTilingSet::Create(&client_);
+  auto pending_set = PictureLayerTilingSet::Create(
+      &client_, 10000, defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
   Region invalidation;
   pending_set->SyncTilings(*active_set, layer_bounds, invalidation, 0.f,
                            client_.raster_source());
 
   // The pending tiling starts with no tiles.
   VerifyTiles(pending_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
   // ComputeTilePriorityRects on the pending tiling at the same frame time. The
   // pending tiling should get tiles.
@@ skipping 18 matching lines @@
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 31 matching lines @@
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 41 matching lines @@
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 35 matching lines @@
   // In this configuration, only the top-left tile would be visible.
   current_screen_transform.Translate(600, 750);
   current_screen_transform.RotateAboutZAxis(45);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 59 matching lines @@
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(0, 0, 200, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 69 matching lines @@
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
@@ skipping 39 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));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    last_layer_contents_scale,
                                    last_frame_time_in_seconds, Occlusion());
 
   // current frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
@@ skipping 52 matching lines @@
   current_screen_transform.Translate(400, 550);
   current_screen_transform.RotateAboutZAxis(45);
 
   last_screen_transform.Translate(400, 550);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds,
-                                              &client);
+  tiling =
+      TestablePictureLayerTiling::CreateDefault(1.0f,  // contents_scale
+                                                current_layer_bounds, &client);
 
   // previous ("last") frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    last_layer_contents_scale,
                                    last_frame_time_in_seconds, Occlusion());
 
   // current frame
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
@@ skipping 23 matching lines @@
   // - Two tilings, one active one recycled with all tiles shared.
   // Procedure:
   // - 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;
   scoped_ptr<TestablePictureLayerTiling> active_tiling;
+  LayerTreeSettings defaults;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   active_client.set_tree(ACTIVE_TREE);
-  active_client.set_max_tiles_for_interest_area(10);
-  active_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                                     gfx::Size(10000, 10000),
-                                                     &active_client);
+  active_tiling = TestablePictureLayerTiling::Create(
+      1.0f,  // contents_scale
+      gfx::Size(10000, 10000), &active_client, 10,
+      defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
   // 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_tree(PENDING_TREE);
   recycle_client.set_twin_tiling(active_tiling.get());
-  recycle_client.set_max_tiles_for_interest_area(10);
 
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
-  recycle_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                                      gfx::Size(10000, 10000),
-                                                      &recycle_client);
+  recycle_tiling = TestablePictureLayerTiling::Create(
+      1.0f,  // contents_scale
+      gfx::Size(10000, 10000), &recycle_client, 10,
+      defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
 
   // Create all tiles on the second tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
   recycle_client.set_twin_tiling(NULL);
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
   FakePictureLayerTilingClient active_client;
   scoped_ptr<TestablePictureLayerTiling> active_tiling;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   active_client.set_tree(ACTIVE_TREE);
-  active_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                                     gfx::Size(100, 100),
-                                                     &active_client);
+  active_tiling = TestablePictureLayerTiling::CreateDefault(
+      1.0f,  // contents_scale
+      gfx::Size(100, 100), &active_client);
   // 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_tree(PENDING_TREE);
   recycle_client.set_twin_tiling(active_tiling.get());
-  recycle_client.set_max_tiles_for_interest_area(10);
 
+  LayerTreeSettings defaults;
   scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
-  recycle_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                                      gfx::Size(100, 100),
-                                                      &recycle_client);
+  recycle_tiling = TestablePictureLayerTiling::Create(
+      1.0f,  // contents_scale
+      gfx::Size(100, 100), &recycle_client, 10,
+      defaults.skewport_target_time_in_seconds,
+      defaults.skewport_extrapolation_limit_in_content_pixels);
 
   // 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());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
   recycle_client.set_twin_tiling(NULL);
 
@@ skipping 28 matching lines @@
                                             invalidation, gfx::Size(250, 150));
 
   // 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_->AllRefTilesForTesting().size());
 }
 
 }  // namespace
 }  // namespace cc