cc: Added tile bundles

cc/layers/picture_layer_impl_unittest.cc

Index: cc/layers/picture_layer_impl_unittest.cc
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 8d70bc7316b31f32dddeb5021e3d47923643aac6..be393ab2abe43f4f092afd556aa8a4ef5467c8cc 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -93,9 +93,9 @@ class PictureLayerImplTest : public testing::Test {
 
   void CreateHighLowResAndSetAllTilesVisible() {
     // Active layer must get updated first so pending layer can share from it.
-    active_layer_->CreateDefaultTilingsAndTiles();
+    active_layer_->CreateDefaultTilingsAndTiles(ACTIVE_TREE);
     active_layer_->SetAllTilesVisible();
-    pending_layer_->CreateDefaultTilingsAndTiles();
+    pending_layer_->CreateDefaultTilingsAndTiles(PENDING_TREE);
     pending_layer_->SetAllTilesVisible();
   }
 
@@ -104,10 +104,13 @@ class PictureLayerImplTest : public testing::Test {
     active_layer_->AddTiling(1.0f);
     active_layer_->AddTiling(0.5f);
     for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i)
-      active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
+      active_layer_->tilings()->tiling_at(i)->CreateAllActiveTilesForTesting();
     pending_layer_->set_invalidation(invalidation);
-    for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
-      pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
+    for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i) {
+      pending_layer_->tilings()
+          ->tiling_at(i)
+          ->CreateAllPendingTilesForTesting();
+    }
   }
 
   void SetupPendingTree(
@@ -168,15 +171,13 @@ class PictureLayerImplTest : public testing::Test {
     active_layer_->DidLoseOutputSurface();
   }
 
-  void AssertAllTilesRequired(PictureLayerTiling* tiling) {
-    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+  void AssertAllTilesRequired(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i)
       EXPECT_TRUE(tiles[i]->required_for_activation()) << "i: " << i;
     EXPECT_GT(tiles.size(), 0u);
   }
 
-  void AssertNoTilesRequired(PictureLayerTiling* tiling) {
-    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+  void AssertNoTilesRequired(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i)
       EXPECT_FALSE(tiles[i]->required_for_activation()) << "i: " << i;
     EXPECT_GT(tiles.size(), 0u);
@@ -1215,7 +1216,6 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
        ++iter) {
     if (!*iter)
       continue;
-    Tile* tile = *iter;
     TilePriority priority;
     priority.resolution = HIGH_RESOLUTION;
     if (++tile_count % 2) {
@@ -1225,7 +1225,7 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
       priority.time_to_visible_in_seconds = 1.f;
       priority.distance_to_visible_in_pixels = 1.f;
     }
-    tile->SetPriority(PENDING_TREE, priority);
+    iter.SetPriorityForTesting(priority);
   }
 
   pending_layer_->MarkVisibleResourcesAsRequired();
@@ -1242,7 +1242,7 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
     if (!*iter)
       continue;
     const Tile* tile = *iter;
-    if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels == 0.f) {
+    if (iter.priority().distance_to_visible_in_pixels == 0.f) {
       EXPECT_TRUE(tile->required_for_activation());
       num_visible++;
     } else {
@@ -1270,8 +1270,10 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
   // No shared tiles and all active tiles ready, so pending can only
   // activate with all high res tiles.
   pending_layer_->MarkVisibleResourcesAsRequired();
-  AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertAllTilesRequired(
+      pending_layer_->HighResTiling()->AllPendingTilesForTesting());
+  AssertNoTilesRequired(
+      pending_layer_->LowResTiling()->AllPendingTilesForTesting());
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
@@ -1288,8 +1290,10 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
   // All tiles shared (no invalidation), so even though the active tree's
   // tiles aren't ready, there is nothing required.
   pending_layer_->MarkVisibleResourcesAsRequired();
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertNoTilesRequired(
+      pending_layer_->HighResTiling()->AllPendingTilesForTesting());
+  AssertNoTilesRequired(
+      pending_layer_->LowResTiling()->AllPendingTilesForTesting());
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
@@ -1313,14 +1317,17 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
-  EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
+  EXPECT_EQ(active_layer_->HighResTiling()->AllActiveTilesForTesting().size(),
+            0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.  This is attempting to simulate
   // scrolling past the end of recorded content on the active layer.
   pending_layer_->MarkVisibleResourcesAsRequired();
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertNoTilesRequired(
+      pending_layer_->HighResTiling()->AllPendingTilesForTesting());
+  AssertNoTilesRequired(
+      pending_layer_->LowResTiling()->AllPendingTilesForTesting());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
@@ -1344,8 +1351,10 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   // This can happen if a layer exists for a while and switches from
   // not being able to have content to having content.
   pending_layer_->MarkVisibleResourcesAsRequired();
-  AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertAllTilesRequired(
+      pending_layer_->HighResTiling()->AllPendingTilesForTesting());
+  AssertNoTilesRequired(
+      pending_layer_->LowResTiling()->AllPendingTilesForTesting());
 }
 
 TEST_F(PictureLayerImplTest, LowResRequiredWhenMissingHighRes) {
@@ -1369,8 +1378,10 @@ TEST_F(PictureLayerImplTest, LowResRequiredWhenMissingHighRes) {
   // the pending needs to at least have its low res tiles ready in order
   // to activate in order to not flash content.
   pending_layer_->MarkVisibleResourcesAsRequired();
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertAllTilesRequired(pending_layer_->LowResTiling());
+  AssertNoTilesRequired(
+      pending_layer_->HighResTiling()->AllPendingTilesForTesting());
+  AssertAllTilesRequired(
+      pending_layer_->LowResTiling()->AllPendingTilesForTesting());
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {