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_MANAGER_H_ 6 #define CC_RESOURCES_TILE_MANAGER_H_ 7 8 #include <deque> 9 #include <queue> 10 #include <set> 11 #include <utility> 12 #include <vector> 13 14 #include "base/containers/hash_tables.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/values.h" 17 #include "cc/base/ref_counted_managed.h" 18 #include "cc/base/unique_notifier.h" 19 #include "cc/debug/rendering_stats_instrumentation.h" 20 #include "cc/layers/picture_layer_impl.h" 21 #include "cc/resources/managed_tile_state.h" 22 #include "cc/resources/memory_history.h" 23 #include "cc/resources/picture_pile_impl.h" 24 #include "cc/resources/prioritized_tile_set.h" 25 #include "cc/resources/rasterizer.h" 26 #include "cc/resources/resource_pool.h" 27 #include "cc/resources/tile.h" 28 29 namespace cc { 30 class ResourceProvider; 31 32 class CC_EXPORT TileManagerClient { 33 public: 34 // Returns the set of layers that the tile manager should consider for raster. 35 virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() = 0; 36 37 // Called when all tiles marked as required for activation are ready to draw. 38 virtual void NotifyReadyToActivate() = 0; 39 40 // Called when the visible representation of a tile might have changed. Some 41 // examples are: 42 // - Tile version initialized. 43 // - Tile resources freed. 44 // - Tile marked for on-demand raster. 45 virtual void NotifyTileStateChanged(const Tile* tile) = 0; 46 47 protected: ~TileManagerClient()48 virtual ~TileManagerClient() {} 49 }; 50 51 struct RasterTaskCompletionStats { 52 RasterTaskCompletionStats(); 53 54 size_t completed_count; 55 size_t canceled_count; 56 }; 57 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue( 58 const RasterTaskCompletionStats& stats); 59 60 // This class manages tiles, deciding which should get rasterized and which 61 // should no longer have any memory assigned to them. Tile objects are "owned" 62 // by layers; they automatically register with the manager when they are 63 // created, and unregister from the manager when they are deleted. 64 class CC_EXPORT TileManager : public RasterizerClient, 65 public RefCountedManager<Tile> { 66 public: 67 struct CC_EXPORT PairedPictureLayer { 68 PairedPictureLayer(); 69 ~PairedPictureLayer(); 70 71 PictureLayerImpl* active_layer; 72 PictureLayerImpl* pending_layer; 73 }; 74 75 class CC_EXPORT RasterTileIterator { 76 public: 77 RasterTileIterator(TileManager* tile_manager, TreePriority tree_priority); 78 ~RasterTileIterator(); 79 80 RasterTileIterator& operator++(); 81 operator bool() const; 82 Tile* operator*(); 83 84 private: 85 struct PairedPictureLayerIterator { 86 PairedPictureLayerIterator(); 87 ~PairedPictureLayerIterator(); 88 89 Tile* PeekTile(TreePriority tree_priority); 90 void PopTile(TreePriority tree_priority); 91 92 std::pair<PictureLayerImpl::LayerRasterTileIterator*, WhichTree> 93 NextTileIterator(TreePriority tree_priority); 94 95 PictureLayerImpl::LayerRasterTileIterator active_iterator; 96 PictureLayerImpl::LayerRasterTileIterator pending_iterator; 97 98 std::vector<Tile*> returned_shared_tiles; 99 }; 100 101 class RasterOrderComparator { 102 public: 103 explicit RasterOrderComparator(TreePriority tree_priority); 104 105 bool operator()(PairedPictureLayerIterator* a, 106 PairedPictureLayerIterator* b) const; 107 108 private: 109 TreePriority tree_priority_; 110 }; 111 112 std::vector<PairedPictureLayerIterator> paired_iterators_; 113 std::vector<PairedPictureLayerIterator*> iterator_heap_; 114 TreePriority tree_priority_; 115 RasterOrderComparator comparator_; 116 117 DISALLOW_COPY_AND_ASSIGN(RasterTileIterator); 118 }; 119 120 struct CC_EXPORT EvictionTileIterator { 121 public: 122 EvictionTileIterator(); 123 EvictionTileIterator(TileManager* tile_manager, TreePriority tree_priority); 124 ~EvictionTileIterator(); 125 126 EvictionTileIterator& operator++(); 127 operator bool() const; 128 Tile* operator*(); 129 130 private: 131 struct PairedPictureLayerIterator { 132 PairedPictureLayerIterator(); 133 ~PairedPictureLayerIterator(); 134 135 Tile* PeekTile(TreePriority tree_priority); 136 void PopTile(TreePriority tree_priority); 137 138 PictureLayerImpl::LayerEvictionTileIterator* NextTileIterator( 139 TreePriority tree_priority); 140 141 PictureLayerImpl::LayerEvictionTileIterator active_iterator; 142 PictureLayerImpl::LayerEvictionTileIterator pending_iterator; 143 144 std::vector<Tile*> returned_shared_tiles; 145 }; 146 147 class EvictionOrderComparator { 148 public: 149 explicit EvictionOrderComparator(TreePriority tree_priority); 150 151 bool operator()(PairedPictureLayerIterator* a, 152 PairedPictureLayerIterator* b) const; 153 154 private: 155 TreePriority tree_priority_; 156 }; 157 158 std::vector<PairedPictureLayerIterator> paired_iterators_; 159 std::vector<PairedPictureLayerIterator*> iterator_heap_; 160 TreePriority tree_priority_; 161 EvictionOrderComparator comparator_; 162 163 DISALLOW_COPY_AND_ASSIGN(EvictionTileIterator); 164 }; 165 166 static scoped_ptr<TileManager> Create( 167 TileManagerClient* client, 168 base::SequencedTaskRunner* task_runner, 169 ResourcePool* resource_pool, 170 Rasterizer* rasterizer, 171 RenderingStatsInstrumentation* rendering_stats_instrumentation); 172 virtual ~TileManager(); 173 174 void ManageTiles(const GlobalStateThatImpactsTilePriority& state); 175 176 // Returns true when visible tiles have been initialized. 177 bool UpdateVisibleTiles(); 178 179 scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile, 180 const gfx::Size& tile_size, 181 const gfx::Rect& content_rect, 182 const gfx::Rect& opaque_rect, 183 float contents_scale, 184 int layer_id, 185 int source_frame_number, 186 int flags); 187 188 scoped_ptr<base::Value> BasicStateAsValue() const; memory_stats_from_last_assign()189 const MemoryHistory::Entry& memory_stats_from_last_assign() const { 190 return memory_stats_from_last_assign_; 191 } 192 193 void GetPairedPictureLayers(std::vector<PairedPictureLayer>* layers) const; 194 InitializeTilesWithResourcesForTesting(const std::vector<Tile * > & tiles)195 void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) { 196 for (size_t i = 0; i < tiles.size(); ++i) { 197 ManagedTileState& mts = tiles[i]->managed_state(); 198 ManagedTileState::TileVersion& tile_version = 199 mts.tile_versions[HIGH_QUALITY_RASTER_MODE]; 200 201 tile_version.resource_ = resource_pool_->AcquireResource(gfx::Size(1, 1)); 202 203 bytes_releasable_ += BytesConsumedIfAllocated(tiles[i]); 204 ++resources_releasable_; 205 } 206 } 207 ReleaseTileResourcesForTesting(const std::vector<Tile * > & tiles)208 void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) { 209 for (size_t i = 0; i < tiles.size(); ++i) { 210 Tile* tile = tiles[i]; 211 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 212 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); 213 } 214 } 215 } 216 SetGlobalStateForTesting(const GlobalStateThatImpactsTilePriority & state)217 void SetGlobalStateForTesting( 218 const GlobalStateThatImpactsTilePriority& state) { 219 // Soft limit is used for resource pool such that 220 // memory returns to soft limit after going over. 221 if (state != global_state_) { 222 global_state_ = state; 223 prioritized_tiles_dirty_ = true; 224 } 225 } 226 227 void SetRasterizerForTesting(Rasterizer* rasterizer); 228 CleanUpReleasedTilesForTesting()229 void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); } 230 231 protected: 232 TileManager(TileManagerClient* client, 233 base::SequencedTaskRunner* task_runner, 234 ResourcePool* resource_pool, 235 Rasterizer* rasterizer, 236 RenderingStatsInstrumentation* rendering_stats_instrumentation); 237 238 // Methods called by Tile 239 friend class Tile; 240 void DidChangeTilePriority(Tile* tile); 241 242 void CleanUpReleasedTiles(); 243 244 // Overriden from RefCountedManager<Tile>: 245 virtual void Release(Tile* tile) OVERRIDE; 246 247 // Overriden from RasterizerClient: 248 virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE; 249 virtual void DidFinishRunningTasks() OVERRIDE; 250 virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE; 251 252 typedef std::vector<Tile*> TileVector; 253 typedef std::set<Tile*> TileSet; 254 255 // Virtual for test 256 virtual void ScheduleTasks( 257 const TileVector& tiles_that_need_to_be_rasterized); 258 259 void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles, 260 TileVector* tiles_that_need_to_be_rasterized); 261 void GetTilesWithAssignedBins(PrioritizedTileSet* tiles); 262 263 private: 264 void OnImageDecodeTaskCompleted(int layer_id, 265 SkPixelRef* pixel_ref, 266 bool was_canceled); 267 void OnRasterTaskCompleted(Tile::Id tile, 268 scoped_ptr<ScopedResource> resource, 269 RasterMode raster_mode, 270 const PicturePileImpl::Analysis& analysis, 271 bool was_canceled); 272 BytesConsumedIfAllocated(const Tile * tile)273 inline size_t BytesConsumedIfAllocated(const Tile* tile) const { 274 return Resource::MemorySizeBytes(tile->size(), 275 resource_pool_->resource_format()); 276 } 277 278 void FreeResourceForTile(Tile* tile, RasterMode mode); 279 void FreeResourcesForTile(Tile* tile); 280 void FreeUnusedResourcesForTile(Tile* tile); 281 void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile); 282 scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile, 283 SkPixelRef* pixel_ref); 284 scoped_refptr<RasterTask> CreateRasterTask(Tile* tile); 285 void UpdatePrioritizedTileSetIfNeeded(); 286 287 bool IsReadyToActivate() const; 288 void CheckIfReadyToActivate(); 289 290 TileManagerClient* client_; 291 scoped_refptr<base::SequencedTaskRunner> task_runner_; 292 ResourcePool* resource_pool_; 293 Rasterizer* rasterizer_; 294 GlobalStateThatImpactsTilePriority global_state_; 295 296 typedef base::hash_map<Tile::Id, Tile*> TileMap; 297 TileMap tiles_; 298 299 PrioritizedTileSet prioritized_tiles_; 300 bool prioritized_tiles_dirty_; 301 302 bool all_tiles_that_need_to_be_rasterized_have_memory_; 303 bool all_tiles_required_for_activation_have_memory_; 304 305 size_t bytes_releasable_; 306 size_t resources_releasable_; 307 308 bool ever_exceeded_memory_budget_; 309 MemoryHistory::Entry memory_stats_from_last_assign_; 310 311 RenderingStatsInstrumentation* rendering_stats_instrumentation_; 312 313 bool did_initialize_visible_tile_; 314 bool did_check_for_completed_tasks_since_last_schedule_tasks_; 315 316 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> > 317 PixelRefTaskMap; 318 typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap; 319 LayerPixelRefTaskMap image_decode_tasks_; 320 321 typedef base::hash_map<int, int> LayerCountMap; 322 LayerCountMap used_layer_counts_; 323 324 RasterTaskCompletionStats update_visible_tiles_stats_; 325 326 std::vector<Tile*> released_tiles_; 327 328 ResourceFormat resource_format_; 329 330 // Queue used when scheduling raster tasks. 331 RasterTaskQueue raster_queue_; 332 333 std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_; 334 335 UniqueNotifier ready_to_activate_check_notifier_; 336 337 DISALLOW_COPY_AND_ASSIGN(TileManager); 338 }; 339 340 } // namespace cc 341 342 #endif // CC_RESOURCES_TILE_MANAGER_H_ 343