cc: Added tile bundles

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <utility>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
@@ skipping 75 matching lines @@
   void SetupTrees(
       scoped_refptr<PicturePileImpl> pending_pile,
       scoped_refptr<PicturePileImpl> active_pile) {
     SetupPendingTree(active_pile);
     ActivateTree();
     SetupPendingTree(pending_pile);
   }
 
   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();
   }
 
   void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
     active_layer_->AddTiling(2.3f);
     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(
       scoped_refptr<PicturePileImpl> pile) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
     pending_tree->DetachLayerTree();
 
     scoped_ptr<FakePictureLayerImpl> pending_layer =
@@ skipping 40 matching lines @@
         &result_scale_x,
         &result_scale_y,
         &result_bounds);
   }
 
   void ResetTilingsAndRasterScales() {
     pending_layer_->DidLoseOutputSurface();
     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);
   }
 
  protected:
   void TestTileGridAlignmentCommon() {
     // Layer to span 4 raster tiles in x and in y
     ImplSidePaintingSettings settings;
     gfx::Size layer_size(
@@ skipping 1018 matching lines @@
   // Fake set priorities.
   int tile_count = 0;
   for (PictureLayerTiling::CoverageIterator iter(
            tiling,
            pending_layer_->contents_scale_x(),
            gfx::Rect(pending_layer_->visible_content_rect()));
        iter;
        ++iter) {
     if (!*iter)
       continue;
-    Tile* tile = *iter;
     TilePriority priority;
     priority.resolution = HIGH_RESOLUTION;
     if (++tile_count % 2) {
       priority.time_to_visible_in_seconds = 0.f;
       priority.distance_to_visible_in_pixels = 0.f;
     } else {
       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();
 
   int num_visible = 0;
   int num_offscreen = 0;
 
   for (PictureLayerTiling::CoverageIterator iter(
            tiling,
            pending_layer_->contents_scale_x(),
            gfx::Rect(pending_layer_->visible_content_rect()));
        iter;
        ++iter) {
     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 {
       EXPECT_FALSE(tile->required_for_activation());
       num_offscreen++;
     }
   }
 
   EXPECT_GT(num_visible, 0);
   EXPECT_GT(num_offscreen, 0);
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   // No tiles shared.
   pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
 
   CreateHighLowResAndSetAllTilesVisible();
 
   active_layer_->SetAllTilesReady();
 
   // 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) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
   // 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) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   // An arbitrary bogus outside the layer recording.  Enough for the layer to
   // think it can create tiles, but not in bounds so all tiles are null.
   Region active_recorded_region;
   active_recorded_region.Union(gfx::Rect(1000, 1000, 1, 1));
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreatePileWithRecordedRegion(
           tile_size, layer_bounds, active_recorded_region);
   SetupTrees(pending_pile, active_pile);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // 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) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   SetupTrees(pending_pile, active_pile);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer can't have tiles.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
 
   // All high res tiles required.  This should be considered identical
   // to the case where there is no active layer, to avoid flashing content.
   // 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) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
   // No tiles shared.
   pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Only set the active low res tiles as being ready.
   active_layer_->SetAllTilesReadyInTiling(active_layer_->LowResTiling());
   // Verify high res not active.
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
   // Active layer's high res tiles aren't ready but low res ones are, so
   // 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) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
@@ skipping 103 matching lines @@
       TestContextProvider::Create(), NULL));
 
   // These will crash PictureLayerImpl if this is not true.
   ASSERT_TRUE(host_impl_.pending_tree()->needs_update_draw_properties());
   ASSERT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
   host_impl_.active_tree()->UpdateDrawProperties();
 }
 
 }  // namespace
 }  // namespace cc