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_H_ 6 #define CC_RESOURCES_TILE_H_ 7 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/memory/scoped_vector.h" 11 #include "cc/base/ref_counted_managed.h" 12 #include "cc/resources/managed_tile_state.h" 13 #include "cc/resources/picture_pile_impl.h" 14 #include "cc/resources/raster_mode.h" 15 #include "cc/resources/tile_priority.h" 16 #include "ui/gfx/rect.h" 17 #include "ui/gfx/size.h" 18 19 namespace cc { 20 21 class CC_EXPORT Tile : public RefCountedManaged<Tile> { 22 public: 23 enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 }; 24 25 typedef uint64 Id; 26 27 Id id() const { 28 return id_; 29 } 30 31 PicturePileImpl* picture_pile() { 32 return picture_pile_.get(); 33 } 34 35 const PicturePileImpl* picture_pile() const { 36 return picture_pile_.get(); 37 } 38 39 const TilePriority& priority(WhichTree tree) const { 40 return priority_[tree]; 41 } 42 43 TilePriority priority_for_tree_priority(TreePriority tree_priority) const { 44 switch (tree_priority) { 45 case SMOOTHNESS_TAKES_PRIORITY: 46 return priority_[ACTIVE_TREE]; 47 case NEW_CONTENT_TAKES_PRIORITY: 48 return priority_[PENDING_TREE]; 49 case SAME_PRIORITY_FOR_BOTH_TREES: 50 return combined_priority(); 51 default: 52 NOTREACHED(); 53 return TilePriority(); 54 } 55 } 56 57 TilePriority combined_priority() const { 58 return TilePriority(priority_[ACTIVE_TREE], 59 priority_[PENDING_TREE]); 60 } 61 62 void SetPriority(WhichTree tree, const TilePriority& priority); 63 64 void set_is_occluded(WhichTree tree, bool is_occluded) { 65 is_occluded_[tree] = is_occluded; 66 } 67 68 bool is_occluded(WhichTree tree) const { return is_occluded_[tree]; } 69 70 void set_shared(bool is_shared) { is_shared_ = is_shared; } 71 bool is_shared() const { return is_shared_; } 72 73 bool is_occluded_for_tree_priority(TreePriority tree_priority) const { 74 switch (tree_priority) { 75 case SMOOTHNESS_TAKES_PRIORITY: 76 return is_occluded_[ACTIVE_TREE]; 77 case NEW_CONTENT_TAKES_PRIORITY: 78 return is_occluded_[PENDING_TREE]; 79 case SAME_PRIORITY_FOR_BOTH_TREES: 80 return is_occluded_[ACTIVE_TREE] && is_occluded_[PENDING_TREE]; 81 default: 82 NOTREACHED(); 83 return false; 84 } 85 } 86 87 void MarkRequiredForActivation(); 88 89 bool required_for_activation() const { 90 return priority_[PENDING_TREE].required_for_activation; 91 } 92 93 bool use_picture_analysis() const { 94 return !!(flags_ & USE_PICTURE_ANALYSIS); 95 } 96 97 bool NeedsRasterForMode(RasterMode mode) const { 98 return !managed_state_.tile_versions[mode].IsReadyToDraw(); 99 } 100 101 bool HasResources() const { 102 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 103 if (managed_state_.tile_versions[mode].has_resource()) 104 return true; 105 } 106 return false; 107 } 108 109 void AsValueInto(base::debug::TracedValue* dict) const; 110 111 inline bool IsReadyToDraw() const { 112 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 113 if (managed_state_.tile_versions[mode].IsReadyToDraw()) 114 return true; 115 } 116 return false; 117 } 118 119 const ManagedTileState::TileVersion& GetTileVersionForDrawing() const { 120 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 121 if (managed_state_.tile_versions[mode].IsReadyToDraw()) 122 return managed_state_.tile_versions[mode]; 123 } 124 return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE]; 125 } 126 127 float contents_scale() const { return contents_scale_; } 128 gfx::Rect content_rect() const { return content_rect_; } 129 130 int layer_id() const { return layer_id_; } 131 132 int source_frame_number() const { return source_frame_number_; } 133 134 void set_picture_pile(scoped_refptr<PicturePileImpl> pile) { 135 DCHECK(pile->CanRaster(contents_scale_, content_rect_)) 136 << "Recording rect: " 137 << gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_) 138 .ToString(); 139 picture_pile_ = pile; 140 } 141 142 size_t GPUMemoryUsageInBytes() const; 143 144 gfx::Size size() const { return size_; } 145 146 RasterMode DetermineRasterModeForTree(WhichTree tree) const; 147 RasterMode DetermineOverallRasterMode() const; 148 149 // Functionality used in tests. 150 RasterMode GetRasterModeForTesting() const { 151 return managed_state().raster_mode; 152 } 153 ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) { 154 return managed_state_.tile_versions[mode]; 155 } 156 157 private: 158 friend class TileManager; 159 friend class PrioritizedTileSet; 160 friend class FakeTileManager; 161 friend class BinComparator; 162 friend class FakePictureLayerImpl; 163 164 // Methods called by by tile manager. 165 Tile(TileManager* tile_manager, 166 PicturePileImpl* picture_pile, 167 const gfx::Size& tile_size, 168 const gfx::Rect& content_rect, 169 float contents_scale, 170 int layer_id, 171 int source_frame_number, 172 int flags); 173 ~Tile(); 174 175 ManagedTileState& managed_state() { return managed_state_; } 176 const ManagedTileState& managed_state() const { return managed_state_; } 177 RasterMode DetermineRasterModeForResolution(TileResolution resolution) const; 178 179 bool HasRasterTask() const; 180 181 TileManager* tile_manager_; 182 scoped_refptr<PicturePileImpl> picture_pile_; 183 gfx::Size size_; 184 gfx::Rect content_rect_; 185 float contents_scale_; 186 bool is_occluded_[NUM_TREES]; 187 188 TilePriority priority_[NUM_TREES]; 189 ManagedTileState managed_state_; 190 int layer_id_; 191 int source_frame_number_; 192 int flags_; 193 bool is_shared_; 194 195 Id id_; 196 static Id s_next_id_; 197 198 DISALLOW_COPY_AND_ASSIGN(Tile); 199 }; 200 201 } // namespace cc 202 203 #endif // CC_RESOURCES_TILE_H_ 204
