OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/layers/picture_layer_impl.h" | 5 #include "cc/layers/picture_layer_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 #include <set> | 9 #include <set> |
10 #include <utility> | 10 #include <utility> |
(...skipping 2867 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2878 non_ideal_tile_count += priority.resolution == NON_IDEAL_RESOLUTION; | 2878 non_ideal_tile_count += priority.resolution == NON_IDEAL_RESOLUTION; |
2879 low_res_tile_count += priority.resolution == LOW_RESOLUTION; | 2879 low_res_tile_count += priority.resolution == LOW_RESOLUTION; |
2880 high_res_tile_count += priority.resolution == HIGH_RESOLUTION; | 2880 high_res_tile_count += priority.resolution == HIGH_RESOLUTION; |
2881 } | 2881 } |
2882 | 2882 |
2883 EXPECT_EQ(0u, non_ideal_tile_count); | 2883 EXPECT_EQ(0u, non_ideal_tile_count); |
2884 EXPECT_EQ(1u, low_res_tile_count); | 2884 EXPECT_EQ(1u, low_res_tile_count); |
2885 EXPECT_EQ(0u, high_res_tile_count); | 2885 EXPECT_EQ(0u, high_res_tile_count); |
2886 } | 2886 } |
2887 | 2887 |
2888 TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) { | 2888 TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) { |
2889 gfx::Size tile_size(100, 100); | 2889 gfx::Size tile_size(100, 100); |
2890 gfx::Size layer_bounds(1000, 1000); | 2890 gfx::Size layer_bounds(1000, 1000); |
2891 | 2891 |
2892 scoped_refptr<FakePicturePileImpl> pending_pile = | 2892 scoped_refptr<FakePicturePileImpl> pending_pile = |
2893 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); | 2893 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); |
2894 | 2894 |
2895 SetupPendingTree(pending_pile); | 2895 SetupPendingTree(pending_pile); |
2896 | 2896 |
2897 ASSERT_TRUE(pending_layer_->CanHaveTilings()); | 2897 ASSERT_TRUE(pending_layer_->CanHaveTilings()); |
2898 | 2898 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2939 mark_required = !mark_required; | 2939 mark_required = !mark_required; |
2940 } | 2940 } |
2941 } | 2941 } |
2942 | 2942 |
2943 // Sanity checks. | 2943 // Sanity checks. |
2944 EXPECT_EQ(91u, all_tiles.size()); | 2944 EXPECT_EQ(91u, all_tiles.size()); |
2945 EXPECT_EQ(91u, all_tiles_set.size()); | 2945 EXPECT_EQ(91u, all_tiles_set.size()); |
2946 EXPECT_GT(number_of_marked_tiles, 1u); | 2946 EXPECT_GT(number_of_marked_tiles, 1u); |
2947 EXPECT_GT(number_of_unmarked_tiles, 1u); | 2947 EXPECT_GT(number_of_unmarked_tiles, 1u); |
2948 | 2948 |
2949 // Empty iterator. | |
2950 PictureLayerImpl::LayerEvictionTileIterator it; | |
2951 EXPECT_FALSE(it); | |
2952 | |
2953 // Tiles don't have resources yet. | 2949 // Tiles don't have resources yet. |
2954 it = PictureLayerImpl::LayerEvictionTileIterator( | 2950 scoped_ptr<TilingSetEvictionQueue> queue = |
2955 pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES); | 2951 pending_layer_->CreateEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES); |
2956 EXPECT_FALSE(it); | 2952 EXPECT_TRUE(queue->IsEmpty()); |
2957 | 2953 |
2958 host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles); | 2954 host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles); |
2959 | 2955 |
2960 std::set<Tile*> unique_tiles; | 2956 std::set<Tile*> unique_tiles; |
2961 float expected_scales[] = {2.0f, 0.3f, 0.7f, low_res_factor, 1.0f}; | 2957 float expected_scales[] = {2.0f, 0.3f, 0.7f, low_res_factor, 1.0f}; |
2962 size_t scale_index = 0; | 2958 size_t scale_index = 0; |
2963 bool reached_visible = false; | 2959 bool reached_visible = false; |
2964 Tile* last_tile = nullptr; | 2960 Tile* last_tile = nullptr; |
2965 for (it = PictureLayerImpl::LayerEvictionTileIterator( | 2961 queue = pending_layer_->CreateEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES); |
2966 pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES); | 2962 while (!queue->IsEmpty()) { |
2967 it; | 2963 Tile* tile = queue->Top(); |
2968 ++it) { | |
2969 Tile* tile = *it; | |
2970 if (!last_tile) | 2964 if (!last_tile) |
2971 last_tile = tile; | 2965 last_tile = tile; |
2972 | 2966 |
2973 EXPECT_TRUE(tile); | 2967 EXPECT_TRUE(tile); |
2974 | 2968 |
2975 TilePriority priority = tile->priority(PENDING_TREE); | 2969 TilePriority priority = tile->priority(PENDING_TREE); |
2976 | 2970 |
2977 if (priority.priority_bin == TilePriority::NOW) { | 2971 if (priority.priority_bin == TilePriority::NOW) { |
2978 reached_visible = true; | 2972 reached_visible = true; |
2979 last_tile = tile; | 2973 last_tile = tile; |
(...skipping 17 matching lines...) Expand all Loading... |
2997 last_tile->required_for_activation() && | 2991 last_tile->required_for_activation() && |
2998 priority.priority_bin == | 2992 priority.priority_bin == |
2999 last_tile->priority(PENDING_TREE).priority_bin && | 2993 last_tile->priority(PENDING_TREE).priority_bin && |
3000 std::abs(tile->contents_scale() - last_tile->contents_scale()) < | 2994 std::abs(tile->contents_scale() - last_tile->contents_scale()) < |
3001 std::numeric_limits<float>::epsilon()) { | 2995 std::numeric_limits<float>::epsilon()) { |
3002 EXPECT_LE(priority.distance_to_visible, | 2996 EXPECT_LE(priority.distance_to_visible, |
3003 last_tile->priority(PENDING_TREE).distance_to_visible); | 2997 last_tile->priority(PENDING_TREE).distance_to_visible); |
3004 } | 2998 } |
3005 | 2999 |
3006 last_tile = tile; | 3000 last_tile = tile; |
| 3001 queue->Pop(); |
3007 } | 3002 } |
3008 | 3003 |
3009 EXPECT_TRUE(reached_visible); | 3004 EXPECT_TRUE(reached_visible); |
3010 EXPECT_EQ(65u, unique_tiles.size()); | 3005 EXPECT_EQ(65u, unique_tiles.size()); |
3011 | 3006 |
3012 scale_index = 0; | 3007 scale_index = 0; |
3013 bool reached_required = false; | 3008 bool reached_required = false; |
3014 for (; it; ++it) { | 3009 while (!queue->IsEmpty()) { |
3015 Tile* tile = *it; | 3010 Tile* tile = queue->Top(); |
3016 EXPECT_TRUE(tile); | 3011 EXPECT_TRUE(tile); |
3017 | 3012 |
3018 TilePriority priority = tile->priority(PENDING_TREE); | 3013 TilePriority priority = tile->priority(PENDING_TREE); |
3019 EXPECT_EQ(TilePriority::NOW, priority.priority_bin); | 3014 EXPECT_EQ(TilePriority::NOW, priority.priority_bin); |
3020 | 3015 |
3021 if (reached_required) { | 3016 if (reached_required) { |
3022 EXPECT_TRUE(tile->required_for_activation()); | 3017 EXPECT_TRUE(tile->required_for_activation()); |
3023 } else if (tile->required_for_activation()) { | 3018 } else if (tile->required_for_activation()) { |
3024 reached_required = true; | 3019 reached_required = true; |
3025 scale_index = 0; | 3020 scale_index = 0; |
3026 } | 3021 } |
3027 | 3022 |
3028 while (std::abs(tile->contents_scale() - expected_scales[scale_index]) > | 3023 while (std::abs(tile->contents_scale() - expected_scales[scale_index]) > |
3029 std::numeric_limits<float>::epsilon()) { | 3024 std::numeric_limits<float>::epsilon()) { |
3030 ++scale_index; | 3025 ++scale_index; |
3031 ASSERT_LT(scale_index, arraysize(expected_scales)); | 3026 ASSERT_LT(scale_index, arraysize(expected_scales)); |
3032 } | 3027 } |
3033 | 3028 |
3034 EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]); | 3029 EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]); |
3035 unique_tiles.insert(tile); | 3030 unique_tiles.insert(tile); |
| 3031 queue->Pop(); |
3036 } | 3032 } |
3037 | 3033 |
3038 EXPECT_TRUE(reached_required); | 3034 EXPECT_TRUE(reached_required); |
3039 EXPECT_EQ(all_tiles_set.size(), unique_tiles.size()); | 3035 EXPECT_EQ(all_tiles_set.size(), unique_tiles.size()); |
3040 } | 3036 } |
3041 | 3037 |
3042 TEST_F(PictureLayerImplTest, Occlusion) { | 3038 TEST_F(PictureLayerImplTest, Occlusion) { |
3043 gfx::Size tile_size(102, 102); | 3039 gfx::Size tile_size(102, 102); |
3044 gfx::Size layer_bounds(1000, 1000); | 3040 gfx::Size layer_bounds(1000, 1000); |
3045 gfx::Size viewport_size(1000, 1000); | 3041 gfx::Size viewport_size(1000, 1000); |
(...skipping 770 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3816 | 3812 |
3817 void VerifyEvictionConsidersOcclusion( | 3813 void VerifyEvictionConsidersOcclusion( |
3818 PictureLayerImpl* layer, | 3814 PictureLayerImpl* layer, |
3819 size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) { | 3815 size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) { |
3820 for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES; | 3816 for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES; |
3821 ++priority_count) { | 3817 ++priority_count) { |
3822 TreePriority tree_priority = static_cast<TreePriority>(priority_count); | 3818 TreePriority tree_priority = static_cast<TreePriority>(priority_count); |
3823 size_t occluded_tile_count = 0u; | 3819 size_t occluded_tile_count = 0u; |
3824 Tile* last_tile = nullptr; | 3820 Tile* last_tile = nullptr; |
3825 | 3821 |
3826 for (PictureLayerImpl::LayerEvictionTileIterator it = | 3822 scoped_ptr<TilingSetEvictionQueue> queue = |
3827 PictureLayerImpl::LayerEvictionTileIterator(layer, | 3823 layer->CreateEvictionQueue(tree_priority); |
3828 tree_priority); | 3824 while (!queue->IsEmpty()) { |
3829 it; | 3825 Tile* tile = queue->Top(); |
3830 ++it) { | |
3831 Tile* tile = *it; | |
3832 if (!last_tile) | 3826 if (!last_tile) |
3833 last_tile = tile; | 3827 last_tile = tile; |
3834 | 3828 |
3835 // The only way we will encounter an occluded tile after an unoccluded | 3829 // The only way we will encounter an occluded tile after an unoccluded |
3836 // tile is if the priorty bin decreased, the tile is required for | 3830 // tile is if the priorty bin decreased, the tile is required for |
3837 // activation, or the scale changed. | 3831 // activation, or the scale changed. |
3838 bool tile_is_occluded = | 3832 bool tile_is_occluded = |
3839 tile->is_occluded_for_tree_priority(tree_priority); | 3833 tile->is_occluded_for_tree_priority(tree_priority); |
3840 if (tile_is_occluded) { | 3834 if (tile_is_occluded) { |
3841 occluded_tile_count++; | 3835 occluded_tile_count++; |
3842 | 3836 |
3843 bool last_tile_is_occluded = | 3837 bool last_tile_is_occluded = |
3844 last_tile->is_occluded_for_tree_priority(tree_priority); | 3838 last_tile->is_occluded_for_tree_priority(tree_priority); |
3845 if (!last_tile_is_occluded) { | 3839 if (!last_tile_is_occluded) { |
3846 TilePriority::PriorityBin tile_priority_bin = | 3840 TilePriority::PriorityBin tile_priority_bin = |
3847 tile->priority_for_tree_priority(tree_priority).priority_bin; | 3841 tile->priority_for_tree_priority(tree_priority).priority_bin; |
3848 TilePriority::PriorityBin last_tile_priority_bin = | 3842 TilePriority::PriorityBin last_tile_priority_bin = |
3849 last_tile->priority_for_tree_priority(tree_priority) | 3843 last_tile->priority_for_tree_priority(tree_priority) |
3850 .priority_bin; | 3844 .priority_bin; |
3851 | 3845 |
3852 EXPECT_TRUE( | 3846 EXPECT_TRUE( |
3853 (tile_priority_bin < last_tile_priority_bin) || | 3847 (tile_priority_bin < last_tile_priority_bin) || |
3854 tile->required_for_activation() || | 3848 tile->required_for_activation() || |
3855 (tile->contents_scale() != last_tile->contents_scale())); | 3849 (tile->contents_scale() != last_tile->contents_scale())); |
3856 } | 3850 } |
3857 } | 3851 } |
3858 last_tile = tile; | 3852 last_tile = tile; |
| 3853 queue->Pop(); |
3859 } | 3854 } |
3860 EXPECT_EQ(expected_occluded_tile_count[priority_count], | 3855 EXPECT_EQ(expected_occluded_tile_count[priority_count], |
3861 occluded_tile_count); | 3856 occluded_tile_count); |
3862 } | 3857 } |
3863 } | 3858 } |
3864 }; | 3859 }; |
3865 | 3860 |
3866 TEST_F(OcclusionTrackingPictureLayerImplTest, | 3861 TEST_F(OcclusionTrackingPictureLayerImplTest, |
3867 OccludedTilesSkippedDuringRasterization) { | 3862 OccludedTilesSkippedDuringRasterization) { |
3868 base::TimeTicks time_ticks; | 3863 base::TimeTicks time_ticks; |
(...skipping 853 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4722 result = layer->CalculateTileSize(gfx::Size(447, 400)); | 4717 result = layer->CalculateTileSize(gfx::Size(447, 400)); |
4723 EXPECT_EQ(result.width(), 448); | 4718 EXPECT_EQ(result.width(), 448); |
4724 EXPECT_EQ(result.height(), 448); | 4719 EXPECT_EQ(result.height(), 448); |
4725 result = layer->CalculateTileSize(gfx::Size(500, 499)); | 4720 result = layer->CalculateTileSize(gfx::Size(500, 499)); |
4726 EXPECT_EQ(result.width(), 512); | 4721 EXPECT_EQ(result.width(), 512); |
4727 EXPECT_EQ(result.height(), 500 + 2); | 4722 EXPECT_EQ(result.height(), 500 + 2); |
4728 } | 4723 } |
4729 | 4724 |
4730 } // namespace | 4725 } // namespace |
4731 } // namespace cc | 4726 } // namespace cc |
OLD | NEW |