cc: Separate tiling set functionality into explicit separate functions.

cc/resources/picture_layer_tiling_set_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_set.h"
 
 #include <map>
 #include <vector>
 
 #include "cc/resources/resource_provider.h"
@@ skipping 319 matching lines @@
 
   // The tiles should get the correct size.
   std::vector<Tile*> pending_tiles =
       pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
   for (const auto& tile : pending_tiles)
     EXPECT_EQ(tile_size1, tile->content_rect().size());
 
   // Update to a new source frame with a new tile size.
   pending_client.SetTileSize(tile_size2);
-  pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
-                                                  1.f, 1.f);
+  pending_set->UpdateTilingsToCurrentRasterSourceForCommit(pile.get(),
+                                                           Region());
   // The tiling should get the correct tile size.
   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 2.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 
   // Tiles should have the new correct size.
   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
   for (const auto& tile : pending_tiles)
     EXPECT_EQ(tile_size2, tile->content_rect().size());
 
   // Clone from the pending to the active tree.
   active_client.SetTileSize(tile_size2);
-  active_set->UpdateTilingsToCurrentRasterSource(pile.get(), pending_set.get(),
-                                                 Region(), 1.f, 1.f);
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      pile.get(), pending_set.get(), Region());
   // The active tiling should get the right tile size.
   EXPECT_EQ(tile_size2, active_set->tiling_at(0)->tile_size());
 
   // Cloned tiles should have the right size.
   std::vector<Tile*> active_tiles =
       active_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(active_tiles.size(), 0u);
   for (const auto& tile : active_tiles)
     EXPECT_EQ(tile_size2, tile->content_rect().size());
 
   // A new source frame with a new tile size.
   pending_client.SetTileSize(tile_size3);
-  pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
-                                                  1.f, 1.f);
+  pending_set->UpdateTilingsToCurrentRasterSourceForCommit(pile.get(),
+                                                           Region());
   // The tiling gets the new size correctly.
   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 3.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 
   // Tiles are resized for the new size.
   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
   for (const auto& tile : pending_tiles)
     EXPECT_EQ(tile_size3, tile->content_rect().size());
 
   // Now we activate with a different tile size for the active tiling.
   active_client.SetTileSize(tile_size3);
-  active_set->UpdateTilingsToCurrentRasterSource(pile.get(), pending_set.get(),
-                                                 Region(), 1.f, 1.f);
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      pile.get(), pending_set.get(), Region());
   // The active tiling changes its tile size.
   EXPECT_EQ(tile_size3, active_set->tiling_at(0)->tile_size());
 
   // And its tiles are resized.
   active_tiles = active_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(active_tiles.size(), 0u);
   for (const auto& tile : active_tiles)
     EXPECT_EQ(tile_size3, tile->content_rect().size());
 }
 
@@ skipping 14 matching lines @@
   pending_set->AddTiling(2.f, pile);
   pending_set->AddTiling(3.f, pile);
 
   // Set some expected things for the tiling set to function.
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   // Update to a new source frame with a max content scale that is larger than
   // everything.
   float max_content_scale = 3.f;
-  pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
-                                                  1.f, max_content_scale);
+  pending_set->UpdateTilingsToCurrentRasterSourceForCommit(pile.get(),
+                                                           Region());
+
   // All the tilings are there still.
   EXPECT_EQ(3u, pending_set->num_tilings());
 
   // Clone from the pending to the active tree with the same max content size.
-  active_set->UpdateTilingsToCurrentRasterSource(
-      pile.get(), pending_set.get(), Region(), 1.f, max_content_scale);
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      pile.get(), pending_set.get(), Region());
   // All the tilings are on the active tree.
   EXPECT_EQ(3u, active_set->num_tilings());
 
   // Update to a new source frame with a max content scale that will drop one

[enne (OOO), 2015/03/31 19:53:02]

This test no longer really makes any sense, since the test itself is removing
the tilings and then verifying that it's removed.  Maybe the suggestion I made
elsewhere would make this better.

[vmpstr, 2015/04/01 23:53:41]

Changed it back with RemoveTilings being a part of UpdateTilings.

   // tiling.
   max_content_scale = 2.9f;
-  pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
-                                                  1.f, max_content_scale);
+  pending_set->RemoveTilingsBelowScale(1.f);
+  pending_set->RemoveTilingsAboveScale(max_content_scale);
+  pending_set->UpdateTilingsToCurrentRasterSourceForCommit(pile.get(),
+                                                           Region());
   // All the tilings are there still.
   EXPECT_EQ(2u, pending_set->num_tilings());
 
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
 
   // Clone from the pending to the active tree with the same max content size.
-  active_set->UpdateTilingsToCurrentRasterSource(
-      pile.get(), pending_set.get(), Region(), 1.f, max_content_scale);
+  active_set->RemoveTilingsBelowScale(1.f);
+  active_set->RemoveTilingsAboveScale(max_content_scale);
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      pile.get(), pending_set.get(), Region());
   // All the tilings are on the active tree.
   EXPECT_EQ(2u, active_set->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc