1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CC_RESOURCES_TILE_PRIORITY_H_ 6 #define CC_RESOURCES_TILE_PRIORITY_H_ 7 8 #include <algorithm> 9 #include <limits> 10 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "cc/resources/picture_pile.h" 14 #include "ui/gfx/quad_f.h" 15 #include "ui/gfx/rect.h" 16 #include "ui/gfx/size.h" 17 18 namespace base { 19 class Value; 20 } 21 22 namespace cc { 23 24 enum WhichTree { 25 // Note: these must be 0 and 1 because we index with them in various places, 26 // e.g. in Tile::priority_. 27 ACTIVE_TREE = 0, 28 PENDING_TREE = 1, 29 NUM_TREES = 2 30 // Be sure to update WhichTreeAsValue when adding new fields. 31 }; 32 scoped_ptr<base::Value> WhichTreeAsValue( 33 WhichTree tree); 34 35 enum TileResolution { 36 LOW_RESOLUTION = 0 , 37 HIGH_RESOLUTION = 1, 38 NON_IDEAL_RESOLUTION = 2, 39 }; 40 scoped_ptr<base::Value> TileResolutionAsValue( 41 TileResolution resolution); 42 43 struct CC_EXPORT TilePriority { TilePriorityTilePriority44 TilePriority() 45 : resolution(NON_IDEAL_RESOLUTION), 46 required_for_activation(false), 47 time_to_visible_in_seconds(std::numeric_limits<float>::infinity()), 48 distance_to_visible_in_pixels(std::numeric_limits<float>::infinity()) {} 49 TilePriorityTilePriority50 TilePriority(TileResolution resolution, 51 float time_to_visible_in_seconds, 52 float distance_to_visible_in_pixels) 53 : resolution(resolution), 54 required_for_activation(false), 55 time_to_visible_in_seconds(time_to_visible_in_seconds), 56 distance_to_visible_in_pixels(distance_to_visible_in_pixels) {} 57 TilePriorityTilePriority58 TilePriority(const TilePriority& active, const TilePriority& pending) { 59 if (active.resolution == HIGH_RESOLUTION || 60 pending.resolution == HIGH_RESOLUTION) 61 resolution = HIGH_RESOLUTION; 62 else if (active.resolution == LOW_RESOLUTION || 63 pending.resolution == LOW_RESOLUTION) 64 resolution = LOW_RESOLUTION; 65 else 66 resolution = NON_IDEAL_RESOLUTION; 67 68 required_for_activation = 69 active.required_for_activation || pending.required_for_activation; 70 71 time_to_visible_in_seconds = 72 std::min(active.time_to_visible_in_seconds, 73 pending.time_to_visible_in_seconds); 74 distance_to_visible_in_pixels = 75 std::min(active.distance_to_visible_in_pixels, 76 pending.distance_to_visible_in_pixels); 77 } 78 79 scoped_ptr<base::Value> AsValue() const; 80 81 // Calculate the time for the |current_bounds| to intersect with the 82 // |target_bounds| given its previous location and time delta. 83 // This function should work for both scaling and scrolling case. 84 static float TimeForBoundsToIntersect(const gfx::RectF& previous_bounds, 85 const gfx::RectF& current_bounds, 86 float time_delta, 87 const gfx::RectF& target_bounds); 88 89 bool operator ==(const TilePriority& other) const { 90 return resolution == other.resolution && 91 time_to_visible_in_seconds == other.time_to_visible_in_seconds && 92 distance_to_visible_in_pixels == other.distance_to_visible_in_pixels && 93 required_for_activation == other.required_for_activation; 94 } 95 96 bool operator !=(const TilePriority& other) const { 97 return !(*this == other); 98 } 99 100 TileResolution resolution; 101 bool required_for_activation; 102 float time_to_visible_in_seconds; 103 float distance_to_visible_in_pixels; 104 }; 105 106 enum TileMemoryLimitPolicy { 107 // Nothing. 108 ALLOW_NOTHING = 0, 109 110 // You might be made visible, but you're not being interacted with. 111 ALLOW_ABSOLUTE_MINIMUM = 1, // Tall. 112 113 // You're being interacted with, but we're low on memory. 114 ALLOW_PREPAINT_ONLY = 2, // Grande. 115 116 // You're the only thing in town. Go crazy. 117 ALLOW_ANYTHING = 3, // Venti. 118 119 NUM_TILE_MEMORY_LIMIT_POLICIES = 4, 120 121 // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding 122 // or reordering fields. 123 }; 124 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue( 125 TileMemoryLimitPolicy policy); 126 127 enum TreePriority { 128 SAME_PRIORITY_FOR_BOTH_TREES, 129 SMOOTHNESS_TAKES_PRIORITY, 130 NEW_CONTENT_TAKES_PRIORITY 131 132 // Be sure to update TreePriorityAsValue when adding new fields. 133 }; 134 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio); 135 136 class GlobalStateThatImpactsTilePriority { 137 public: GlobalStateThatImpactsTilePriority()138 GlobalStateThatImpactsTilePriority() 139 : memory_limit_policy(ALLOW_NOTHING), 140 memory_limit_in_bytes(0), 141 unused_memory_limit_in_bytes(0), 142 num_resources_limit(0), 143 tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {} 144 145 TileMemoryLimitPolicy memory_limit_policy; 146 147 size_t memory_limit_in_bytes; 148 size_t unused_memory_limit_in_bytes; 149 size_t num_resources_limit; 150 151 TreePriority tree_priority; 152 153 bool operator==(const GlobalStateThatImpactsTilePriority& other) const { 154 return memory_limit_policy == other.memory_limit_policy 155 && memory_limit_in_bytes == other.memory_limit_in_bytes 156 && unused_memory_limit_in_bytes == other.unused_memory_limit_in_bytes 157 && num_resources_limit == other.num_resources_limit 158 && tree_priority == other.tree_priority; 159 } 160 bool operator!=(const GlobalStateThatImpactsTilePriority& other) const { 161 return !(*this == other); 162 } 163 164 scoped_ptr<base::Value> AsValue() const; 165 }; 166 167 } // namespace cc 168 169 #endif // CC_RESOURCES_TILE_PRIORITY_H_ 170