cc: Remove GetRasterSource from PictureLayerTilingClient.

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 193 matching lines @@
   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);
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
-  tiling_->UpdateTilesToCurrentRasterSource(invalidation, gfx::Size(200, 200));
+  tiling_->UpdateTilesToCurrentRasterSource(client_.raster_source(),
+                                            invalidation, gfx::Size(200, 200));
   EXPECT_FALSE(tiling_->TileAt(0, 0));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, CreateMissingTilesStaysInsideLiveRect) {
   // The tiling has three rows and columns.
   Initialize(gfx::Size(100, 100), 1, gfx::Size(250, 250));
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
   EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
 
   // The live tiles rect is at the very edge of the right-most and
@@ skipping 34 matching lines @@
   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.
   Region invalidation;
-  tiling_->UpdateTilesToCurrentRasterSource(invalidation,
-                                            gfx::Size(right + 1, bottom + 1));
+  tiling_->UpdateTilesToCurrentRasterSource(
+      client_.raster_source(), invalidation, gfx::Size(right + 1, bottom + 1));
   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_->UpdateTilesToCurrentRasterSource(invalidation,
-                                            gfx::Size(right + 2, bottom + 2));
+  tiling_->UpdateTilesToCurrentRasterSource(
+      client_.raster_source(), invalidation, gfx::Size(right + 2, bottom + 2));
   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 115 matching lines @@
   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);
 
   Region invalidation =
       SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
-  tiling_->UpdateTilesToCurrentRasterSource(invalidation, gfx::Size(200, 200));
+  tiling_->UpdateTilesToCurrentRasterSource(client_.raster_source(),
+                                            invalidation, gfx::Size(200, 200));
   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));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
   Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801));
@@ skipping 1022 matching lines @@
               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);
 
-  PictureLayerTilingSet active_set(&client_);
+  auto active_set = PictureLayerTilingSet::Create(&client_);
 
-  active_set.AddTiling(1.f, layer_bounds);
+  active_set->AddTiling(1.f, layer_bounds);
 
-  VerifyTiles(active_set.tiling_at(0),
-              1.f,
-              gfx::Rect(layer_bounds),
+  VerifyTiles(active_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
-  UpdateAllTilePriorities(&active_set,
-                          PENDING_TREE,
+  UpdateAllTilePriorities(active_set.get(),
+                          PENDING_TREE,             // WhichTree
                           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),
+  VerifyTiles(active_set->tiling_at(0), 1.f, gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 
   // Add the same tilings to the pending set.
-  PictureLayerTilingSet pending_set(&client_);
+  auto pending_set = PictureLayerTilingSet::Create(&client_);
   Region invalidation;
-  pending_set.SyncTilings(active_set, layer_bounds, invalidation, 0.f);
+  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),
+  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,
-                          PENDING_TREE,
+  UpdateAllTilePriorities(pending_set.get(),
+                          PENDING_TREE,             // WhichTree
                           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),
+  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;
 
@@ skipping 667 matching lines @@
   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());
 
   Region invalidation;
-  tiling_->UpdateTilesToCurrentRasterSource(invalidation, gfx::Size(250, 150));
+  tiling_->UpdateTilesToCurrentRasterSource(client_.raster_source(),
+                                            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