cc: Don't swap PictureLayerTilingSet on activate.

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 190 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(client_.raster_source(),
-                                            invalidation, gfx::Size(200, 200));
+  tiling_->Resize(gfx::Size(200, 200));
+  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, 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 33 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.
-  Region invalidation;
-  tiling_->UpdateTilesToCurrentRasterSource(
-      client_.raster_source(), invalidation, gfx::Size(right + 1, bottom + 1));
+  tiling_->Resize(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(
-      client_.raster_source(), invalidation, gfx::Size(right + 2, bottom + 2));
+  tiling_->Resize(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(client_.raster_source(),
-                                            invalidation, gfx::Size(200, 200));
+  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));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
   Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801));
@@ skipping 928 matching lines @@
                           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_);
   Region invalidation;
-  pending_set->SyncTilings(*active_set, layer_bounds, invalidation, 0.f,
-                           client_.raster_source());
+  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
@@ skipping 659 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());
 
-  Region invalidation;
-  tiling_->UpdateTilesToCurrentRasterSource(client_.raster_source(),
-                                            invalidation, gfx::Size(250, 150));
+  tiling_->Resize(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