Update from https://crrev.com/304121

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_->UpdateTilesToCurrentPile(invalidation, gfx::Size(200, 200));
+  tiling_->UpdateTilesToCurrentRasterSource(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_->UpdateTilesToCurrentPile(invalidation,
-                                    gfx::Size(right + 1, bottom + 1));
+  tiling_->UpdateTilesToCurrentRasterSource(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_->UpdateTilesToCurrentPile(invalidation,
-                                    gfx::Size(right + 2, bottom + 2));
+  tiling_->UpdateTilesToCurrentRasterSource(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_->UpdateTilesToCurrentPile(invalidation, gfx::Size(200, 200));
+  tiling_->UpdateTilesToCurrentRasterSource(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 1736 matching lines @@
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
   EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
+TEST_F(PictureLayerTilingIteratorTest, ResizeTilesAndUpdateToCurrent) {
+  // The tiling has four rows and three columns.
+  Initialize(gfx::Size(150, 100), 1, gfx::Size(250, 150));
+  tiling_->CreateAllTilesForTesting();
+  EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
+  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(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