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 9716aa91030bf3cf3bfb5094b7c9b7808c9703cc..3de7bb2799512e16b83877e7098ce65d58048508 100644 |
--- a/cc/layers/picture_layer_impl_unittest.cc |
+++ b/cc/layers/picture_layer_impl_unittest.cc |
@@ -2816,6 +2816,8 @@ TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) { |
size_t scale_index = 0; |
bool reached_visible = false; |
Tile* last_tile = nullptr; |
+ int distance_decreasing = 0; |
+ int distance_increasing = 0; |
for (it = PictureLayerImpl::LayerEvictionTileIterator( |
pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES); |
it; |
@@ -2845,21 +2847,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); |
ajuma
2014/10/23 23:12:54
Is there an intuitive explanation for why we get t
vmpstr
2014/10/29 18:19:41
Well.. I'm not sure how intuitive it is, starting
ajuma
2014/10/29 19:42:39
Ok, I mostly wanted to find out if these specific
|
+ |
EXPECT_TRUE(reached_visible); |
EXPECT_EQ(65u, unique_tiles.size()); |
@@ -3667,9 +3674,9 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest { |
OcclusionTrackingPictureLayerImplTest() |
: PictureLayerImplTest(OcclusionTrackingSettings()) {} |
- void VerifyEvictionConsidersOcclusion( |
- PictureLayerImpl* layer, |
- size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) { |
+ void VerifyEvictionConsidersOcclusion(PictureLayerImpl* layer, |
+ WhichTree tree, |
+ size_t expected_occluded_tile_count) { |
for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES; |
++priority_count) { |
TreePriority tree_priority = static_cast<TreePriority>(priority_count); |
@@ -3688,19 +3695,16 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest { |
// 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); |
+ bool tile_is_occluded = tile->is_occluded(tree); |
if (tile_is_occluded) { |
occluded_tile_count++; |
- bool last_tile_is_occluded = |
- last_tile->is_occluded_for_tree_priority(tree_priority); |
+ bool last_tile_is_occluded = last_tile->is_occluded(tree); |
if (!last_tile_is_occluded) { |
TilePriority::PriorityBin tile_priority_bin = |
- tile->priority_for_tree_priority(tree_priority).priority_bin; |
+ tile->priority(tree).priority_bin; |
TilePriority::PriorityBin last_tile_priority_bin = |
- last_tile->priority_for_tree_priority(tree_priority) |
- .priority_bin; |
+ last_tile->priority(tree).priority_bin; |
EXPECT_TRUE( |
(tile_priority_bin < last_tile_priority_bin) || |
@@ -3710,8 +3714,7 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest { |
} |
last_tile = tile; |
} |
- EXPECT_EQ(expected_occluded_tile_count[priority_count], |
- occluded_tile_count); |
+ EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count); |
} |
} |
}; |
@@ -4185,11 +4188,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) { |
@@ -4272,10 +4271,14 @@ 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, RecycledTwinLayer) { |