Update from https://crrev.com/309415

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"
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
+#include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
 static gfx::Rect ViewportInLayerSpace(
     const gfx::Transform& transform,
     const gfx::Size& device_viewport) {
 
   gfx::Transform inverse;
   if (!transform.GetInverse(&inverse))
     return gfx::Rect();
 
   gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect(
       inverse, gfx::RectF(gfx::Point(0, 0), device_viewport));
   return ToEnclosingRect(viewport_in_layer_space);
 }
 
-static void UpdateAllTilePriorities(PictureLayerTilingSet* set,
-                                    const gfx::Rect& visible_layer_rect,
-                                    float layer_contents_scale,
-                                    double current_frame_time_in_seconds) {
-  for (size_t i = 0; i < set->num_tilings(); ++i) {
-    set->tiling_at(i)
-        ->ComputeTilePriorityRects(visible_layer_rect, layer_contents_scale,
-                                   current_frame_time_in_seconds, Occlusion());
-  }
-}
-
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       float contents_scale,
-      const gfx::Size& layer_bounds,
+      scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       const LayerTreeSettings& settings) {
     return make_scoped_ptr(new TestablePictureLayerTiling(
-        contents_scale, layer_bounds, client,
+        contents_scale, raster_source, client,
         settings.max_tiles_for_interest_area,
         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(float contents_scale,
-                             const gfx::Size& layer_bounds,
+                             scoped_refptr<RasterSource> raster_source,
                              PictureLayerTilingClient* client,
                              size_t max_tiles_for_interest_area,
                              float skewport_target_time,
                              int skewport_extrapolation_limit)
       : PictureLayerTiling(contents_scale,
-                           layer_bounds,
+                           raster_source,
                            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());
+    scoped_refptr<FakePicturePileImpl> pile =
+        FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+    tiling_ = TestablePictureLayerTiling::Create(contents_scale, pile, &client_,
+                                                 LayerTreeSettings());
   }
 
   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 91 matching lines @@
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(10, 10);
   Initialize(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
-  client_.set_allow_create_tile(false);
+  gfx::Size new_layer_size(200, 200);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(new_layer_size);
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
-  tiling_->Resize(gfx::Size(200, 200));
+  tiling_->SetRasterSourceAndResize(pile);
   EXPECT_TRUE(tiling_->TileAt(0, 0));
   tiling_->Invalidate(invalidation);
   EXPECT_FALSE(tiling_->TileAt(0, 0));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, CreateMissingTilesStaysInsideLiveRect) {
   // The tiling has three rows and columns.
   Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 250));
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
@@ skipping 35 matching lines @@
   EXPECT_TRUE(tiling_->TileAt(2, 2));
   EXPECT_TRUE(tiling_->TileAt(2, 3));
   EXPECT_TRUE(tiling_->TileAt(1, 3));
   EXPECT_TRUE(tiling_->TileAt(0, 3));
 
   int right = tiling_->TilingDataForTesting().TileBounds(2, 2).x();
   int bottom = tiling_->TilingDataForTesting().TileBounds(2, 3).y();
 
   // Shrink the tiling so that the last tile row/column is entirely in the
   // border pixels of the interior tiles. That row/column is removed.
-  tiling_->Resize(gfx::Size(right + 1, bottom + 1));
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          gfx::Size(right + 1, bottom + 1));
+  tiling_->SetRasterSourceAndResize(pile);
   EXPECT_EQ(2, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
 
   // The live tiles rect was clamped to the pile size.
   EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
 
   // Since the row/column is gone, the tiles should be gone too.
   EXPECT_FALSE(tiling_->TileAt(2, 0));
   EXPECT_FALSE(tiling_->TileAt(2, 1));
   EXPECT_FALSE(tiling_->TileAt(2, 2));
   EXPECT_FALSE(tiling_->TileAt(2, 3));
   EXPECT_FALSE(tiling_->TileAt(1, 3));
   EXPECT_FALSE(tiling_->TileAt(0, 3));
 
   // Growing outside the current right/bottom tiles border pixels should create
   // the tiles again, even though the live rect has not changed size.
-  tiling_->Resize(gfx::Size(right + 2, bottom + 2));
+  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+      gfx::Size(right + 2, bottom + 2));
+  tiling_->SetRasterSourceAndResize(pile);
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
 
   // Not changed.
   EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
 
   // The last row/column tiles are inside the live tiles rect.
   EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
       tiling_->TilingDataForTesting().TileBounds(2, 0)));
   EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
@@ skipping 111 matching lines @@
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(99, 99);
   Initialize(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
-  client_.set_allow_create_tile(false);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(
+          gfx::Size(200, 200));
+  tiling_->SetRasterSourceAndResize(pile);
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
-  tiling_->Resize(gfx::Size(200, 200));
   EXPECT_TRUE(tiling_->TileAt(0, 0));
   tiling_->Invalidate(invalidation);
   EXPECT_FALSE(tiling_->TileAt(0, 0));
 
   // The original tile was the same size after resize, but it would include new
   // border pixels.
   EXPECT_EQ(gfx::Rect(original_layer_size),
             tiling_->TilingDataForTesting().TileBounds(0, 0));
 }
 
@@ skipping 94 matching lines @@
 
   // 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_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));
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10000;
   settings.skewport_extrapolation_limit_in_content_pixels = 75;
-  tiling =
-      TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client, settings);
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client, settings);
 
   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 38 matching lines @@
 
   EXPECT_EQ(-575, big_expand_skewport.x());
   EXPECT_EQ(-575, big_expand_skewport.y());
   EXPECT_EQ(1650, big_expand_skewport.width());
   EXPECT_EQ(1650, big_expand_skewport.height());
   EXPECT_TRUE(big_expand_skewport.Contains(gfx::Rect(-500, -500, 1500, 1500)));
 }
 
 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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 31 matching lines @@
       tiling->ComputeSkewport(1.2, gfx::Rect(-5, -5, 110, 110));
 
   EXPECT_EQ(-30, expanded_skewport.x());
   EXPECT_EQ(-30, expanded_skewport.y());
   EXPECT_EQ(160, expanded_skewport.width());
   EXPECT_EQ(160, expanded_skewport.height());
 }
 
 TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
   client.set_tree(ACTIVE_TREE);
   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.
-  tiling = TestablePictureLayerTiling::Create(0.25f, layer_bounds, &client,
-                                              settings);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(0.25f, pile, &client, settings);
   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::Create(0.2f, pile, &client,
                                               LayerTreeSettings());
   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);
 
@@ skipping 230 matching lines @@
   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());
 }
 
 TEST(PictureLayerTilingTest, TilingRasterTileIteratorStaticViewport) {
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   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);
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10000;
 
-  tiling =
-      TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client, settings);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client, settings);
   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 19 matching lines @@
     }
 
     EXPECT_TRUE(it);
     std::set<Tile*> unique_tiles;
     unique_tiles.insert(*it);
     Tile* last_tile = *it;
     have_tiles[last_tile->priority(ACTIVE_TREE).priority_bin] = true;
 
     // On the second iteration, mark everything as ready to draw (solid color).
     if (i == 1) {
-      ManagedTileState::DrawInfo& draw_info = last_tile->draw_info();
+      TileDrawInfo& draw_info = last_tile->draw_info();
       draw_info.SetSolidColorForTesting(SK_ColorRED);
     }
     ++it;
     int eventually_bin_order_correct_count = 0;
     int eventually_bin_order_incorrect_count = 0;
     while (it) {
       Tile* new_tile = *it;
       ++it;
       unique_tiles.insert(new_tile);
 
@@ skipping 15 matching lines @@
           EXPECT_EQ(TilePriority::SOON, new_priority.priority_bin);
         }
       }
       have_tiles[new_priority.priority_bin] = true;
 
       last_tile = new_tile;
 
       // On the second iteration, mark everything as ready to draw (solid
       // color).
       if (i == 1) {
-        ManagedTileState::DrawInfo& draw_info = last_tile->draw_info();
+        TileDrawInfo& draw_info = last_tile->draw_info();
         draw_info.SetSolidColorForTesting(SK_ColorRED);
       }
     }
 
     EXPECT_GT(eventually_bin_order_correct_count,
               eventually_bin_order_incorrect_count);
 
     // We should have now and eventually tiles, as well as soon tiles from
     // the border region.
     EXPECT_TRUE(have_tiles[TilePriority::NOW]);
     EXPECT_TRUE(have_tiles[TilePriority::SOON]);
     EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 
     EXPECT_EQ(unique_tiles.size(), all_tiles.size());
   }
 }
 
 TEST(PictureLayerTilingTest, TilingRasterTileIteratorMovingViewport) {
   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);
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10000;
 
-  tiling =
-      TestablePictureLayerTiling::Create(1.f, layer_bounds, &client, settings);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.f, pile, &client, settings);
   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 119 matching lines @@
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   client_.SetTileSize(gfx::Size(100, 100));
   client_.set_tree(PENDING_TREE);
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 1;
 
-  tiling_ =
-      TestablePictureLayerTiling::Create(1.f, layer_bounds, &client_, settings);
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
+  tiling_ = TestablePictureLayerTiling::Create(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);
 
   client_.set_tree(ACTIVE_TREE);
   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);
-
-  client_.SetTileSize(tile_size);
-  client_.set_tree(PENDING_TREE);
-
-  LayerTreeSettings defaults;
-  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_, 10000, defaults.skewport_target_time_in_seconds,
-      defaults.skewport_extrapolation_limit_in_content_pixels);
-  Region invalidation;
-  pending_set->SyncTilingsForTesting(*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.
-  UpdateAllTilePriorities(pending_set.get(),
-                          gfx::Rect(layer_bounds),  // visible content rect
-                          1.f,                      // current contents scale
-                          1.0);                     // current frame time
-
-  VerifyTiles(pending_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
-              base::Bind(&TileExists, true));
-}
-
 TEST(ComputeTilePriorityRectsTest, VisibleTiles) {
   // The TilePriority of visible tiles should have zero distance_to_visible
   // and time_to_visible.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 11 matching lines @@
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, OffscreenTiles) {
   // The TilePriority of offscreen tiles (without movement) should have nonzero
   // distance_to_visible and infinite time_to_visible.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 21 matching lines @@
   EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 
   left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 }
 
 TEST(ComputeTilePriorityRectsTest, PartiallyOffscreenLayer) {
   // Sanity check that a layer with some tiles visible and others offscreen has
   // correct TilePriorities for each tile.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 12 matching lines @@
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, PartiallyOffscreenRotatedLayer) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that ComputeTilePriorityRects correctly accounts for the transform between
   // layer space and screen space.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   // A diagonally rotated layer that is partially off the bottom of the screen.
   // 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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 20 matching lines @@
   TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(top_right.distance_to_visible, top_left.distance_to_visible);
 
   EXPECT_EQ(bottom_right.distance_to_visible, top_right.distance_to_visible);
 }
 
 TEST(ComputeTilePriorityRectsTest, PerspectiveLayer) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
@@ skipping 16 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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 25 matching lines @@
   TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
 
   EXPECT_GT(bottom_right.distance_to_visible, top_right.distance_to_visible);
 
   EXPECT_GT(bottom_left.distance_to_visible, top_left.distance_to_visible);
 }
 
 TEST(ComputeTilePriorityRectsTest, PerspectiveLayerClippedByW) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   // A 3d perspective layer rotated about its Y axis, translated to almost
@@ skipping 21 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,
-                                              LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client,
+                                         LayerTreeSettings());
 
   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 15 matching lines @@
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, BasicMotion) {
   // Test that time_to_visible is computed correctly when
   // there is some motion.
-
   FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double last_frame_time_in_seconds = 1.0;
   double current_frame_time_in_seconds = 2.0;
 
   // 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);
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10000;
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              current_layer_bounds, &client,
-                                              settings);
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &client, settings);
 
   // 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,
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          current_layer_bounds);
+  tiling = TestablePictureLayerTiling::Create(1.0f, pile, &client,
                                               LayerTreeSettings());
 
   // 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,
@@ skipping 23 matching lines @@
   // Setup:
   // - 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;
 
   active_client.SetTileSize(gfx::Size(100, 100));
   active_client.set_tree(ACTIVE_TREE);
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10;
-  active_tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                                     gfx::Size(10000, 10000),
-                                                     &active_client, settings);
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          gfx::Size(10000, 10000));
+  scoped_ptr<TestablePictureLayerTiling> active_tiling =
+      TestablePictureLayerTiling::Create(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());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_tree(PENDING_TREE);
   recycle_client.set_twin_tiling(active_tiling.get());
 
-  scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
-  recycle_tiling = TestablePictureLayerTiling::Create(
-      1.0f,  // contents_scale
-      gfx::Size(10000, 10000), &recycle_client, settings);
+  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+      gfx::Size(10000, 10000));
+  scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &recycle_client, settings);
 
   // 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 13 matching lines @@
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 3.0,
                                           Occlusion());
 
   // Ensure that we now have a tile here on both tilings again.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(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, LayerTreeSettings());
+
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          gfx::Size(100, 100));
+  scoped_ptr<TestablePictureLayerTiling> active_tiling =
+      TestablePictureLayerTiling::Create(1.0f, pile, &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_tree(PENDING_TREE);
   recycle_client.set_twin_tiling(active_tiling.get());
 
   LayerTreeSettings settings;
   settings.max_tiles_for_interest_area = 10;
-  scoped_ptr<TestablePictureLayerTiling> recycle_tiling;
-  recycle_tiling = TestablePictureLayerTiling::Create(
-      1.0f,  // contents_scale
-      gfx::Size(100, 100), &recycle_client, settings);
+
+  pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+      gfx::Size(100, 100));
+  scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
+      TestablePictureLayerTiling::Create(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());
 
   // 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 16 matching lines @@
   EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(4u, tiling_->AllRefTilesForTesting().size());
 
   client_.SetTileSize(gfx::Size(250, 200));
   client_.set_tree(PENDING_TREE);
 
   // Tile size in the tiling should still be 150x100.
   EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
 
-  tiling_->Resize(gfx::Size(250, 150));
+  // The layer's size isn't changed, but the tile size was.
+  scoped_refptr<FakePicturePileImpl> pile =
+      FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
+          gfx::Size(250, 150));
+  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_->AllRefTilesForTesting().size());
 }
 
 }  // namespace
 }  // namespace cc