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 a75feb0c0bdeac8e72bcf16f55ff782156e2fd9b..bdfa21506a06e6fef91d34902de611d02de705da 100644 |
--- a/cc/layers/picture_layer_impl_unittest.cc |
+++ b/cc/layers/picture_layer_impl_unittest.cc |
@@ -2951,8 +2951,7 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) { |
EXPECT_FALSE(it); |
// Tiles don't have resources yet. |
- it = PictureLayerImpl::LayerEvictionTileIterator( |
- pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES); |
+ it = PictureLayerImpl::LayerEvictionTileIterator(pending_layer_); |
EXPECT_FALSE(it); |
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles); |
@@ -2962,9 +2961,9 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) { |
size_t scale_index = 0; |
bool reached_visible = false; |
Tile* last_tile = nullptr; |
- for (it = PictureLayerImpl::LayerEvictionTileIterator( |
- pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES); |
- it; |
+ int distance_decreasing = 0; |
+ int distance_increasing = 0; |
+ for (it = PictureLayerImpl::LayerEvictionTileIterator(pending_layer_); it; |
++it) { |
Tile* tile = *it; |
if (!last_tile) |
@@ -2991,21 +2990,26 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) { |
EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]); |
unique_tiles.insert(tile); |
- // If the tile is the same rough bin as last tile (same activation, bin, and |
- // scale), then distance should be decreasing. |
if (tile->required_for_activation() == |
last_tile->required_for_activation() && |
priority.priority_bin == |
last_tile->priority(PENDING_TREE).priority_bin && |
std::abs(tile->contents_scale() - last_tile->contents_scale()) < |
std::numeric_limits<float>::epsilon()) { |
- EXPECT_LE(priority.distance_to_visible, |
- last_tile->priority(PENDING_TREE).distance_to_visible); |
+ if (priority.distance_to_visible <= |
+ last_tile->priority(PENDING_TREE).distance_to_visible) { |
+ ++distance_decreasing; |
+ } else { |
+ ++distance_increasing; |
+ } |
} |
last_tile = tile; |
} |
+ EXPECT_EQ(7, distance_increasing); |
+ EXPECT_EQ(55, distance_decreasing); |
+ |
EXPECT_TRUE(reached_visible); |
EXPECT_EQ(65u, unique_tiles.size()); |
@@ -3814,52 +3818,41 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest { |
OcclusionTrackingPictureLayerImplTest() |
: PictureLayerImplTest(OcclusionTrackingSettings()) {} |
- void VerifyEvictionConsidersOcclusion( |
- PictureLayerImpl* layer, |
- size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) { |
- for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES; |
- ++priority_count) { |
- TreePriority tree_priority = static_cast<TreePriority>(priority_count); |
- size_t occluded_tile_count = 0u; |
- Tile* last_tile = nullptr; |
- |
- for (PictureLayerImpl::LayerEvictionTileIterator it = |
- PictureLayerImpl::LayerEvictionTileIterator(layer, |
- tree_priority); |
- it; |
- ++it) { |
- Tile* tile = *it; |
- if (!last_tile) |
- last_tile = tile; |
- |
- // The only way we will encounter an occluded tile after an unoccluded |
- // tile is if the priorty bin decreased, the tile is required for |
- // activation, or the scale changed. |
- bool tile_is_occluded = |
- tile->is_occluded_for_tree_priority(tree_priority); |
- if (tile_is_occluded) { |
- occluded_tile_count++; |
- |
- bool last_tile_is_occluded = |
- last_tile->is_occluded_for_tree_priority(tree_priority); |
- if (!last_tile_is_occluded) { |
- TilePriority::PriorityBin tile_priority_bin = |
- tile->priority_for_tree_priority(tree_priority).priority_bin; |
- TilePriority::PriorityBin last_tile_priority_bin = |
- last_tile->priority_for_tree_priority(tree_priority) |
- .priority_bin; |
- |
- EXPECT_TRUE( |
- (tile_priority_bin < last_tile_priority_bin) || |
- tile->required_for_activation() || |
- (tile->contents_scale() != last_tile->contents_scale())); |
- } |
- } |
+ void VerifyEvictionConsidersOcclusion(PictureLayerImpl* layer, |
+ WhichTree tree, |
+ size_t expected_occluded_tile_count) { |
+ size_t occluded_tile_count = 0u; |
+ Tile* last_tile = nullptr; |
+ |
+ for (PictureLayerImpl::LayerEvictionTileIterator it = |
+ PictureLayerImpl::LayerEvictionTileIterator(layer); |
+ it; ++it) { |
+ Tile* tile = *it; |
+ if (!last_tile) |
last_tile = tile; |
+ |
+ // The only way we will encounter an occluded tile after an unoccluded |
+ // tile is if the priorty bin decreased, the tile is required for |
+ // activation, or the scale changed. |
+ bool tile_is_occluded = tile->is_occluded(tree); |
+ if (tile_is_occluded) { |
+ occluded_tile_count++; |
+ |
+ bool last_tile_is_occluded = last_tile->is_occluded(tree); |
+ if (!last_tile_is_occluded) { |
+ TilePriority::PriorityBin tile_priority_bin = |
+ tile->priority(tree).priority_bin; |
+ TilePriority::PriorityBin last_tile_priority_bin = |
+ last_tile->priority(tree).priority_bin; |
+ |
+ EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) || |
+ tile->required_for_activation() || |
+ (tile->contents_scale() != last_tile->contents_scale())); |
+ } |
} |
- EXPECT_EQ(expected_occluded_tile_count[priority_count], |
- occluded_tile_count); |
+ last_tile = tile; |
} |
+ EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count); |
} |
}; |
@@ -4332,11 +4325,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, |
size_t expected_occluded_tile_count_on_active[] = {30u, 5u, 4u, 2u, 2u}; |
size_t expected_occluded_tile_count_on_pending[] = {30u, 5u, 4u, 2u, 2u}; |
- // The total expected number of occluded tiles on all tilings for each of the |
- // 3 tree priorities. |
- size_t total_expected_occluded_tile_count[] = {13u, 43u, 43u}; |
- |
- ASSERT_EQ(arraysize(total_expected_occluded_tile_count), NUM_TREE_PRIORITIES); |
+ size_t total_expected_occluded_count_on_trees[] = {43u, 43u}; |
// Verify number of occluded tiles on the pending layer for each tiling. |
for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) { |
@@ -4419,10 +4408,12 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, |
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles); |
- VerifyEvictionConsidersOcclusion(pending_layer_, |
- total_expected_occluded_tile_count); |
- VerifyEvictionConsidersOcclusion(active_layer_, |
- total_expected_occluded_tile_count); |
+ VerifyEvictionConsidersOcclusion( |
+ pending_layer_, PENDING_TREE, |
+ total_expected_occluded_count_on_trees[PENDING_TREE]); |
+ VerifyEvictionConsidersOcclusion( |
+ active_layer_, ACTIVE_TREE, |
+ total_expected_occluded_count_on_trees[ACTIVE_TREE]); |
} |
TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) { |