Update from https://crrev.com/304121

cc/resources/tile_manager_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/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 91 matching lines @@
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
     // Steal from the recycled tree.
     scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
     DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
 
     scoped_ptr<FakePictureLayerImpl> pending_layer;
     if (old_pending_root) {
       pending_layer.reset(
           static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetPile(pile);
+      pending_layer->SetRasterSource(pile);
     } else {
       pending_layer =
-          FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
+          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_, pile);
       pending_layer->SetDrawsContent(true);
     }
     // The bounds() just mirror the pile size.
-    pending_layer->SetBounds(pending_layer->pile()->tiling_size());
+    pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
   void CreateHighLowResAndSetAllTilesVisible() {
     // Active layer must get updated first so pending layer can share from it.
     active_layer_->CreateDefaultTilingsAndTiles();
@@ skipping 56 matching lines @@
       smoothness_tiles.insert(tile);
     queue.Pop();
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
   EXPECT_TRUE(had_low_res);
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
   pending_layer_->set_invalidation(invalidation);
-  pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
+  pending_layer_->HighResTiling()->UpdateTilesToCurrentRasterSource(
       invalidation, gfx::Size(1000, 1000));
-  pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
+  pending_layer_->LowResTiling()->UpdateTilesToCurrentRasterSource(
       invalidation, gfx::Size(1000, 1000));
 
   active_layer_->ResetAllTilesPriorities();
   pending_layer_->ResetAllTilesPriorities();
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(
       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
   pending_layer_->LowResTiling()->ComputeTilePriorityRects(
@@ skipping 128 matching lines @@
   SetupDefaultTrees(gfx::Size(1000, 1000));
 
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   // Create a pending child layer.
   gfx::Size tile_size(256, 256);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
   scoped_ptr<FakePictureLayerImpl> pending_child =
-      FakePictureLayerImpl::CreateWithPile(
-          host_impl_.pending_tree(), id_ + 1, pending_pile);
+      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(),
+                                                   id_ + 1, pending_pile);
   pending_layer_->AddChild(pending_child.Pass());
   FakePictureLayerImpl* pending_child_raw = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_ + 1));
   ASSERT_TRUE(pending_child_raw);
 
   pending_child_raw->SetDrawsContent(true);
   pending_child_raw->DoPostCommitInitializationIfNeeded();
   pending_child_raw->CreateDefaultTilingsAndTiles();
   ASSERT_TRUE(pending_child_raw->HighResTiling());
 
@@ skipping 75 matching lines @@
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   tile_manager()->ReleaseTileResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
   Region invalidation(gfx::Rect(0, 0, 500, 500));
 
   // Invalidate the pending tree.
   pending_layer_->set_invalidation(invalidation);
-  pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
+  pending_layer_->HighResTiling()->UpdateTilesToCurrentRasterSource(
       invalidation, gfx::Size(1000, 1000));
-  pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
+  pending_layer_->LowResTiling()->UpdateTilesToCurrentRasterSource(
       invalidation, gfx::Size(1000, 1000));
 
   active_layer_->ResetAllTilesPriorities();
   pending_layer_->ResetAllTilesPriorities();
 
   // Renew all of the tile priorities.
   gfx::Rect viewport(50, 50, 100, 100);
   pending_layer_->HighResTiling()->ComputeTilePriorityRects(
       PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
   pending_layer_->LowResTiling()->ComputeTilePriorityRects(
@@ skipping 102 matching lines @@
        EvictionTilePriorityQueueWithOcclusion) {
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pending_pile);
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   scoped_ptr<FakePictureLayerImpl> pending_child =
-      FakePictureLayerImpl::CreateWithPile(
-          host_impl_.pending_tree(), 2, pending_pile);
+      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+                                                   pending_pile);
   pending_layer_->AddChild(pending_child.Pass());
 
   FakePictureLayerImpl* pending_child_layer =
       static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
   pending_child_layer->SetDrawsContent(true);
   pending_child_layer->DoPostCommitInitializationIfNeeded();
   pending_child_layer->CreateDefaultTilingsAndTiles();
 
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
@@ skipping 81 matching lines @@
       }
     }
     last_tile = tile;
     queue.Pop();
   }
   size_t expected_occluded_count =
       pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
+TEST_F(TileManagerTilePriorityQueueTest,
+       EvictionTilePriorityQueueWithTransparentLayer) {
+  gfx::Size tile_size(102, 102);
+  gfx::Size layer_bounds(1000, 1000);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupPendingTree(pending_pile);
+  pending_layer_->CreateDefaultTilingsAndTiles();
+
+  scoped_ptr<FakePictureLayerImpl> pending_child =
+      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+                                                   pending_pile);
+  pending_layer_->AddChild(pending_child.Pass());
+
+  // Create a fully transparent child layer so that its tile priorities are not
+  // considered to be valid.
+  FakePictureLayerImpl* pending_child_layer =
+      static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
+  pending_child_layer->SetDrawsContent(true);
+  pending_child_layer->CreateDefaultTilingsAndTiles();
+  pending_child_layer->SetOpacity(0.0);
+  pending_child_layer->layer_tree_impl()->UpdateDrawProperties();
+  pending_child_layer->DoPostCommitInitializationIfNeeded();
+
+  // Renew all of the tile priorities.
+  gfx::Rect viewport(layer_bounds);
+  pending_layer_->HighResTiling()->ComputeTilePriorityRects(
+      PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
+  pending_layer_->LowResTiling()->ComputeTilePriorityRects(
+      PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
+  pending_child_layer->HighResTiling()->ComputeTilePriorityRects(
+      PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
+  pending_child_layer->LowResTiling()->ComputeTilePriorityRects(
+      PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
+
+  // Populate all tiles directly from the tilings.
+  std::set<Tile*> all_pending_tiles;
+  std::vector<Tile*> pending_high_res_tiles =
+      pending_layer_->HighResTiling()->AllTilesForTesting();
+  all_pending_tiles.insert(pending_high_res_tiles.begin(),
+                           pending_high_res_tiles.end());
+  EXPECT_EQ(16u, pending_high_res_tiles.size());
+
+  std::vector<Tile*> pending_low_res_tiles =
+      pending_layer_->LowResTiling()->AllTilesForTesting();
+  all_pending_tiles.insert(pending_low_res_tiles.begin(),
+                           pending_low_res_tiles.end());
+  EXPECT_EQ(1u, pending_low_res_tiles.size());
+
+  std::set<Tile*> all_pending_child_tiles;
+  std::vector<Tile*> pending_child_high_res_tiles =
+      pending_child_layer->HighResTiling()->AllTilesForTesting();
+  all_pending_child_tiles.insert(pending_child_high_res_tiles.begin(),
+                                 pending_child_high_res_tiles.end());
+  EXPECT_EQ(16u, pending_child_high_res_tiles.size());
+
+  std::vector<Tile*> pending_child_low_res_tiles =
+      pending_child_layer->LowResTiling()->AllTilesForTesting();
+  all_pending_child_tiles.insert(pending_child_low_res_tiles.begin(),
+                                 pending_child_low_res_tiles.end());
+  EXPECT_EQ(1u, pending_child_low_res_tiles.size());
+
+  std::set<Tile*> all_tiles = all_pending_tiles;
+  all_tiles.insert(all_pending_child_tiles.begin(),
+                   all_pending_child_tiles.end());
+
+  tile_manager()->InitializeTilesWithResourcesForTesting(
+      std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
+
+  EXPECT_TRUE(pending_layer_->HasValidTilePriorities());
+  EXPECT_FALSE(pending_child_layer->HasValidTilePriorities());
+
+  // Verify that eviction queue returns tiles also from layers without valid
+  // tile priorities and that the tile priority bin of those tiles is (at most)
+  // EVENTUALLY.
+  TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
+  std::set<Tile*> new_content_tiles;
+  size_t tile_count = 0;
+  EvictionTilePriorityQueue queue;
+  host_impl_.BuildEvictionQueue(&queue, tree_priority);
+  while (!queue.IsEmpty()) {
+    Tile* tile = queue.Top();
+    const TilePriority& pending_priority = tile->priority(PENDING_TREE);
+    EXPECT_NE(std::numeric_limits<float>::infinity(),
+              pending_priority.distance_to_visible);
+    if (all_pending_child_tiles.find(tile) != all_pending_child_tiles.end())
+      EXPECT_EQ(TilePriority::EVENTUALLY, pending_priority.priority_bin);
+    else
+      EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
+    new_content_tiles.insert(tile);
+    ++tile_count;
+    queue.Pop();
+  }
+  EXPECT_EQ(tile_count, new_content_tiles.size());
+  EXPECT_EQ(all_tiles, new_content_tiles);
+}
+
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
   SetupDefaultTrees(gfx::Size(1000, 1000));
 
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   RasterTilePriorityQueue queue;
   host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
   EXPECT_FALSE(queue.IsEmpty());
 
@@ skipping 78 matching lines @@
     all_tiles.insert(queue.Top());
     ++tile_count;
     queue.Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 }
 
 }  // namespace
 }  // namespace cc