Move occlusion info to TilePriority.

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/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 141 matching lines @@
   int max_tiles_;
   bool ready_to_activate_;
   std::vector<PictureLayerImpl*> picture_layers_;
 };
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
   // A few tiles of each type of priority, with enough memory for all tiles.
 
   Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
-      CreateTiles(3, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(3, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_now =
-      CreateTiles(3, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(3, TilePriority(), TilePriorityForUnoccludedNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // with the exception of never bin.
 
   Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
-      CreateTiles(3, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(3, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_now =
-      CreateTiles(3, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(3, TilePriority(), TilePriorityForUnoccludedNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 }
 
 TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
   // A few low-res tiles required for activation, with enough memory for all
   // tiles.
 
   Initialize(5, ALLOW_ABSOLUTE_MINIMUM, SAME_PRIORITY_FOR_BOTH_TREES);
   TileVector pending_low_res =
-      CreateTiles(5, TilePriority(), TilePriorityLowRes());
+      CreateTiles(5, TilePriority(), TilePriorityUnoccludedLowRes());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(pending_low_res));
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // with the exception of never and soon bins.
 
   Initialize(10, ALLOW_ABSOLUTE_MINIMUM, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
-      CreateTiles(3, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(3, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_now =
-      CreateTiles(3, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(3, TilePriority(), TilePriorityForUnoccludedNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_now));
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
   // A few tiles of each type of priority, with enough memory for all tiles,
   // but allow nothing should not assign any memory.
 
   Initialize(10, ALLOW_NOTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
-      CreateTiles(3, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(3, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_now =
-      CreateTiles(3, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(3, TilePriority(), TilePriorityForUnoccludedNowBin());
   TileVector active_pending_soon =
       CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
   TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(0, AssignedMemoryCount(active_now));
   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
   // required for activation, but only enough memory for 8 tiles. The result
   // is all pending tree tiles get memory, and 3 of the active tree tiles
   // get memory. None of these tiles is needed to avoid calimity (flickering or
   // raster-on-demand) so the soft memory limit is used.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
+  TileVector pending_tree_tiles = CreateTiles(
+      5, TilePriority(), TilePriorityUnoccludedRequiredForActivation());
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 
   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
   // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
   // but only enough memory for 8 tiles. The result is all active tree tiles
   // get memory, and 3 of the pending tree tiles get memory.
   // The pending tiles are not needed to avoid calimity (flickering or
   // raster-on-demand) and the active tiles fit, so the soft limit is used.
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
-      CreateTiles(5, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(5, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(5, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(5, TilePriority(), TilePriorityForUnoccludedNowBin());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
   // 10 tiles on active tree eventually bin, 10 tiles on pending tree that are
   // required for activation, but only enough tiles for 4 tiles. The result
   // is 4 pending tree tiles get memory, and none of the active tree tiles
   // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(10, TilePriorityForEventualBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
+  TileVector pending_tree_tiles = CreateTiles(
+      10, TilePriority(), TilePriorityUnoccludedRequiredForActivation());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 
   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Pending tiles are now required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
 }
 
 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
   // 10 tiles on active tree soon bin, 10 tiles on pending tree that are
   // required for activation, but only enough tiles for 4 tiles. The result
   // is 4 pending tree tiles get memory, and none of the active tree tiles
   // get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
       CreateTiles(10, TilePriorityForSoonBin(), TilePriority());
-  TileVector pending_tree_tiles =
-      CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
+  TileVector pending_tree_tiles = CreateTiles(
+      10, TilePriority(), TilePriorityUnoccludedRequiredForActivation());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 
   SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Pending tiles are now required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
   // 10 tiles on active tree eventually bin, 10 tiles on pending tree now bin,
   // but only enough memory for 4 tiles. The result is 4 active tree tiles
   // get memory, and none of the pending tree tiles get memory.
 
   Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
-      CreateTiles(10, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(10, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(10, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(10, TilePriority(), TilePriorityForUnoccludedNowBin());
 
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   if (UsingResourceLimit()) {
     EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
   } else {
     // Active tiles are required to avoid calimity (flickering or
     // raster-on-demand). Hard-limit is used and double the tiles fit.
     EXPECT_EQ(8, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
   }
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
   // 10 tiles on active tree now bin, 10 tiles on pending tree now bin,
   // but only enough memory for 8 tiles. Any tile missing would cause
   // a calamity (flickering or raster-on-demand). Depending on mode,
   // we should use varying amounts of the higher hard memory limit.
   if (UsingResourceLimit())
     return;
 
   Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_tree_tiles =
-      CreateTiles(10, TilePriorityForNowBin(), TilePriority());
+      CreateTiles(10, TilePriorityForUnoccludedNowBin(), TilePriority());
   TileVector pending_tree_tiles =
-      CreateTiles(10, TilePriority(), TilePriorityForNowBin());
+      CreateTiles(10, TilePriority(), TilePriorityForUnoccludedNowBin());
 
   // Active tiles are required to avoid calimity. The hard-limit is used and all
   // active-tiles fit. No pending tiles are needed to avoid calamity so only 10
   // tiles total are used.
   tile_manager()->AssignMemoryToTiles(global_state_);
   EXPECT_EQ(10, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
 
   // Even the hard-limit won't save us now. All tiles are required to avoid
   // a clamity but we only have 16. The tiles will be distribted randomly
@@ skipping 545 matching lines @@
 
     last_tile = tile;
     new_content_tiles.insert(tile);
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 }  // namespace
 }  // namespace cc