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 { 44 enum PriorityBin { NOW, SOON, EVENTUALLY }; 45 TilePriorityTilePriority46 TilePriority() 47 : resolution(NON_IDEAL_RESOLUTION), 48 required_for_activation(false), 49 priority_bin(EVENTUALLY), 50 distance_to_visible(std::numeric_limits<float>::infinity()) {} 51 TilePriorityTilePriority52 TilePriority(TileResolution resolution, 53 PriorityBin bin, 54 float distance_to_visible) 55 : resolution(resolution), 56 required_for_activation(false), 57 priority_bin(bin), 58 distance_to_visible(distance_to_visible) {} 59 TilePriorityTilePriority60 TilePriority(const TilePriority& active, const TilePriority& pending) { 61 if (active.resolution == HIGH_RESOLUTION || 62 pending.resolution == HIGH_RESOLUTION) 63 resolution = HIGH_RESOLUTION; 64 else if (active.resolution == LOW_RESOLUTION || 65 pending.resolution == LOW_RESOLUTION) 66 resolution = LOW_RESOLUTION; 67 else 68 resolution = NON_IDEAL_RESOLUTION; 69 70 required_for_activation = 71 active.required_for_activation || pending.required_for_activation; 72 73 if (active.priority_bin < pending.priority_bin) { 74 priority_bin = active.priority_bin; 75 distance_to_visible = active.distance_to_visible; 76 } else if (active.priority_bin > pending.priority_bin) { 77 priority_bin = pending.priority_bin; 78 distance_to_visible = pending.distance_to_visible; 79 } else { 80 priority_bin = active.priority_bin; 81 distance_to_visible = 82 std::min(active.distance_to_visible, pending.distance_to_visible); 83 } 84 } 85 86 scoped_ptr<base::Value> AsValue() const; 87 88 bool operator ==(const TilePriority& other) const { 89 return resolution == other.resolution && 90 priority_bin == other.priority_bin && 91 distance_to_visible == other.distance_to_visible && 92 required_for_activation == other.required_for_activation; 93 } 94 95 bool operator !=(const TilePriority& other) const { 96 return !(*this == other); 97 } 98 IsHigherPriorityThanTilePriority99 bool IsHigherPriorityThan(const TilePriority& other) const { 100 return priority_bin < other.priority_bin || 101 (priority_bin == other.priority_bin && 102 distance_to_visible < other.distance_to_visible); 103 } 104 105 TileResolution resolution; 106 bool required_for_activation; 107 PriorityBin priority_bin; 108 float distance_to_visible; 109 }; 110 111 scoped_ptr<base::Value> TilePriorityBinAsValue(TilePriority::PriorityBin bin); 112 113 enum TileMemoryLimitPolicy { 114 // Nothing. 115 ALLOW_NOTHING = 0, 116 117 // You might be made visible, but you're not being interacted with. 118 ALLOW_ABSOLUTE_MINIMUM = 1, // Tall. 119 120 // You're being interacted with, but we're low on memory. 121 ALLOW_PREPAINT_ONLY = 2, // Grande. 122 123 // You're the only thing in town. Go crazy. 124 ALLOW_ANYTHING = 3, // Venti. 125 126 NUM_TILE_MEMORY_LIMIT_POLICIES = 4, 127 128 // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding 129 // or reordering fields. 130 }; 131 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue( 132 TileMemoryLimitPolicy policy); 133 134 enum TreePriority { 135 SAME_PRIORITY_FOR_BOTH_TREES, 136 SMOOTHNESS_TAKES_PRIORITY, 137 NEW_CONTENT_TAKES_PRIORITY 138 139 // Be sure to update TreePriorityAsValue when adding new fields. 140 }; 141 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio); 142 143 class GlobalStateThatImpactsTilePriority { 144 public: GlobalStateThatImpactsTilePriority()145 GlobalStateThatImpactsTilePriority() 146 : memory_limit_policy(ALLOW_NOTHING), 147 soft_memory_limit_in_bytes(0), 148 hard_memory_limit_in_bytes(0), 149 num_resources_limit(0), 150 tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {} 151 152 TileMemoryLimitPolicy memory_limit_policy; 153 154 size_t soft_memory_limit_in_bytes; 155 size_t hard_memory_limit_in_bytes; 156 size_t num_resources_limit; 157 158 TreePriority tree_priority; 159 160 bool operator==(const GlobalStateThatImpactsTilePriority& other) const { 161 return memory_limit_policy == other.memory_limit_policy && 162 soft_memory_limit_in_bytes == other.soft_memory_limit_in_bytes && 163 hard_memory_limit_in_bytes == other.hard_memory_limit_in_bytes && 164 num_resources_limit == other.num_resources_limit && 165 tree_priority == other.tree_priority; 166 } 167 bool operator!=(const GlobalStateThatImpactsTilePriority& other) const { 168 return !(*this == other); 169 } 170 171 scoped_ptr<base::Value> AsValue() const; 172 }; 173 174 } // namespace cc 175 176 #endif // CC_RESOURCES_TILE_PRIORITY_H_ 177