OLD | NEW |
---|---|
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 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 #ifndef CC_RESOURCES_TILE_MANAGER_H_ | 5 #ifndef CC_RESOURCES_TILE_MANAGER_H_ |
6 #define CC_RESOURCES_TILE_MANAGER_H_ | 6 #define CC_RESOURCES_TILE_MANAGER_H_ |
7 | 7 |
8 #include <deque> | 8 #include <deque> |
9 #include <queue> | 9 #include <queue> |
10 #include <set> | 10 #include <set> |
11 #include <utility> | 11 #include <utility> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "base/containers/hash_tables.h" | 14 #include "base/containers/hash_tables.h" |
15 #include "base/memory/scoped_ptr.h" | 15 #include "base/memory/scoped_ptr.h" |
16 #include "base/values.h" | 16 #include "base/values.h" |
17 #include "cc/base/ref_counted_managed.h" | 17 #include "cc/base/ref_counted_managed.h" |
18 #include "cc/base/unique_notifier.h" | 18 #include "cc/base/unique_notifier.h" |
19 #include "cc/debug/rendering_stats_instrumentation.h" | 19 #include "cc/debug/rendering_stats_instrumentation.h" |
20 #include "cc/layers/picture_layer_impl.h" | 20 #include "cc/layers/picture_layer_impl.h" |
21 #include "cc/resources/managed_tile_state.h" | 21 #include "cc/resources/managed_tile_state.h" |
22 #include "cc/resources/memory_history.h" | 22 #include "cc/resources/memory_history.h" |
23 #include "cc/resources/picture_pile_impl.h" | 23 #include "cc/resources/picture_pile_impl.h" |
24 #include "cc/resources/prioritized_tile_set.h" | |
25 #include "cc/resources/rasterizer.h" | 24 #include "cc/resources/rasterizer.h" |
26 #include "cc/resources/resource_pool.h" | 25 #include "cc/resources/resource_pool.h" |
27 #include "cc/resources/tile.h" | 26 #include "cc/resources/tile.h" |
28 | 27 |
29 namespace cc { | 28 namespace cc { |
30 class ResourceProvider; | 29 class ResourceProvider; |
31 | 30 |
32 class CC_EXPORT TileManagerClient { | 31 class CC_EXPORT TileManagerClient { |
33 public: | 32 public: |
34 // Returns the set of layers that the tile manager should consider for raster. | 33 // Returns the set of layers that the tile manager should consider for raster. |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
216 Tile* tile = tiles[i]; | 215 Tile* tile = tiles[i]; |
217 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 216 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
218 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); | 217 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); |
219 } | 218 } |
220 } | 219 } |
221 } | 220 } |
222 | 221 |
223 void SetGlobalStateForTesting( | 222 void SetGlobalStateForTesting( |
224 const GlobalStateThatImpactsTilePriority& state) { | 223 const GlobalStateThatImpactsTilePriority& state) { |
225 // Soft limit is used for resource pool such that | 224 // Soft limit is used for resource pool such that |
226 // memory returns to soft limit after going over. | 225 // memory returns to soft limit after going over. |
reveman
2014/06/14 14:53:25
not sure what this comment does here. doesn't make
vmpstr
2014/06/16 18:18:19
Yeah, I'm not sure what this comment means here. R
| |
227 if (state != global_state_) { | 226 global_state_ = state; |
228 global_state_ = state; | |
229 prioritized_tiles_dirty_ = true; | |
230 } | |
231 } | 227 } |
232 | 228 |
233 void SetRasterizerForTesting(Rasterizer* rasterizer); | 229 void SetRasterizerForTesting(Rasterizer* rasterizer); |
234 | 230 |
235 void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); } | 231 void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); } |
236 | 232 |
237 protected: | 233 protected: |
238 TileManager(TileManagerClient* client, | 234 TileManager(TileManagerClient* client, |
239 base::SequencedTaskRunner* task_runner, | 235 base::SequencedTaskRunner* task_runner, |
240 ResourcePool* resource_pool, | 236 ResourcePool* resource_pool, |
241 Rasterizer* rasterizer, | 237 Rasterizer* rasterizer, |
242 RenderingStatsInstrumentation* rendering_stats_instrumentation); | 238 RenderingStatsInstrumentation* rendering_stats_instrumentation); |
243 | 239 |
244 // Methods called by Tile | |
245 friend class Tile; | |
246 void DidChangeTilePriority(Tile* tile); | |
247 | |
248 void CleanUpReleasedTiles(); | 240 void CleanUpReleasedTiles(); |
249 | 241 |
250 // Overriden from RefCountedManager<Tile>: | 242 // Overriden from RefCountedManager<Tile>: |
243 friend class Tile; | |
251 virtual void Release(Tile* tile) OVERRIDE; | 244 virtual void Release(Tile* tile) OVERRIDE; |
252 | 245 |
253 // Overriden from RasterizerClient: | 246 // Overriden from RasterizerClient: |
254 virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE; | 247 virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE; |
255 virtual void DidFinishRunningTasks() OVERRIDE; | 248 virtual void DidFinishRunningTasks() OVERRIDE; |
256 virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE; | 249 virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE; |
257 | 250 |
258 typedef std::vector<Tile*> TileVector; | 251 typedef std::vector<Tile*> TileVector; |
259 typedef std::set<Tile*> TileSet; | 252 typedef std::set<Tile*> TileSet; |
260 | 253 |
261 // Virtual for test | 254 // Virtual for test |
262 virtual void ScheduleTasks( | 255 virtual void ScheduleTasks( |
263 const TileVector& tiles_that_need_to_be_rasterized); | 256 const TileVector& tiles_that_need_to_be_rasterized); |
264 | 257 |
265 void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles, | 258 void AssignGpuMemoryToTiles(TileVector* tiles_that_need_to_be_rasterized); |
266 TileVector* tiles_that_need_to_be_rasterized); | |
267 void GetTilesWithAssignedBins(PrioritizedTileSet* tiles); | |
268 | 259 |
269 private: | 260 private: |
261 struct MemoryBudget { | |
262 int64 soft_memory_bytes; | |
263 int64 hard_memory_bytes; | |
264 int resource_count; | |
265 | |
266 bool Exceeds(const MemoryBudget& other) const { | |
267 return soft_memory_bytes > other.soft_memory_bytes || | |
268 hard_memory_bytes > other.hard_memory_bytes || | |
269 resource_count > other.resource_count; | |
270 } | |
271 }; | |
272 | |
270 void OnImageDecodeTaskCompleted(int layer_id, | 273 void OnImageDecodeTaskCompleted(int layer_id, |
271 SkPixelRef* pixel_ref, | 274 SkPixelRef* pixel_ref, |
272 bool was_canceled); | 275 bool was_canceled); |
273 void OnRasterTaskCompleted(Tile::Id tile, | 276 void OnRasterTaskCompleted(Tile::Id tile, |
274 scoped_ptr<ScopedResource> resource, | 277 scoped_ptr<ScopedResource> resource, |
275 RasterMode raster_mode, | 278 RasterMode raster_mode, |
276 const PicturePileImpl::Analysis& analysis, | 279 const PicturePileImpl::Analysis& analysis, |
277 bool was_canceled); | 280 bool was_canceled); |
278 | 281 |
279 inline size_t BytesConsumedIfAllocated(const Tile* tile) const { | 282 inline size_t BytesConsumedIfAllocated(const Tile* tile) const { |
280 return Resource::MemorySizeBytes(tile->size(), | 283 return Resource::MemorySizeBytes(tile->size(), |
281 resource_pool_->resource_format()); | 284 resource_pool_->resource_format()); |
282 } | 285 } |
283 | 286 |
284 void FreeResourceForTile(Tile* tile, RasterMode mode); | 287 void FreeResourceForTile(Tile* tile, RasterMode mode); |
285 void FreeResourcesForTile(Tile* tile); | 288 void FreeResourcesForTile(Tile* tile); |
286 void FreeUnusedResourcesForTile(Tile* tile); | 289 void FreeUnusedResourcesForTile(Tile* tile); |
287 void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile); | 290 void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile); |
288 scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile, | 291 scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile, |
289 SkPixelRef* pixel_ref); | 292 SkPixelRef* pixel_ref); |
290 scoped_refptr<RasterTask> CreateRasterTask(Tile* tile); | 293 scoped_refptr<RasterTask> CreateRasterTask(Tile* tile); |
291 scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const; | 294 scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const; |
292 void UpdatePrioritizedTileSetIfNeeded(); | |
293 | 295 |
296 bool FreeTileResourcesUntilUsageIsWithinBudget( | |
297 EvictionTileIterator* eviction_iterator, | |
298 const MemoryBudget& required_budget, | |
299 MemoryBudget* current_budget, | |
300 const TilePriority& max_priority, | |
301 bool evict_unconditionally); | |
reveman
2014/06/14 14:53:25
The return value of this function seem to be unuse
vmpstr
2014/06/16 18:18:19
Done.
| |
302 bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority); | |
294 bool IsReadyToActivate() const; | 303 bool IsReadyToActivate() const; |
295 void CheckIfReadyToActivate(); | 304 void CheckIfReadyToActivate(); |
296 | 305 |
297 TileManagerClient* client_; | 306 TileManagerClient* client_; |
298 scoped_refptr<base::SequencedTaskRunner> task_runner_; | 307 scoped_refptr<base::SequencedTaskRunner> task_runner_; |
299 ResourcePool* resource_pool_; | 308 ResourcePool* resource_pool_; |
300 Rasterizer* rasterizer_; | 309 Rasterizer* rasterizer_; |
301 GlobalStateThatImpactsTilePriority global_state_; | 310 GlobalStateThatImpactsTilePriority global_state_; |
302 | 311 |
303 typedef base::hash_map<Tile::Id, Tile*> TileMap; | 312 typedef base::hash_map<Tile::Id, Tile*> TileMap; |
304 TileMap tiles_; | 313 TileMap tiles_; |
305 | 314 |
306 PrioritizedTileSet prioritized_tiles_; | |
307 bool prioritized_tiles_dirty_; | |
308 | |
309 bool all_tiles_that_need_to_be_rasterized_have_memory_; | 315 bool all_tiles_that_need_to_be_rasterized_have_memory_; |
310 bool all_tiles_required_for_activation_have_memory_; | 316 bool all_tiles_required_for_activation_have_memory_; |
311 | 317 |
312 size_t memory_required_bytes_; | |
313 size_t memory_nice_to_have_bytes_; | |
314 | |
315 size_t bytes_releasable_; | 318 size_t bytes_releasable_; |
316 size_t resources_releasable_; | 319 size_t resources_releasable_; |
320 size_t bytes_required_but_not_allocated_; | |
317 | 321 |
318 bool ever_exceeded_memory_budget_; | 322 bool ever_exceeded_memory_budget_; |
319 MemoryHistory::Entry memory_stats_from_last_assign_; | 323 MemoryHistory::Entry memory_stats_from_last_assign_; |
320 | 324 |
321 RenderingStatsInstrumentation* rendering_stats_instrumentation_; | 325 RenderingStatsInstrumentation* rendering_stats_instrumentation_; |
322 | 326 |
323 bool did_initialize_visible_tile_; | 327 bool did_initialize_visible_tile_; |
324 bool did_check_for_completed_tasks_since_last_schedule_tasks_; | 328 bool did_check_for_completed_tasks_since_last_schedule_tasks_; |
325 | 329 |
326 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> > | 330 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> > |
(...skipping 16 matching lines...) Expand all Loading... | |
343 std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_; | 347 std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_; |
344 | 348 |
345 UniqueNotifier ready_to_activate_check_notifier_; | 349 UniqueNotifier ready_to_activate_check_notifier_; |
346 | 350 |
347 DISALLOW_COPY_AND_ASSIGN(TileManager); | 351 DISALLOW_COPY_AND_ASSIGN(TileManager); |
348 }; | 352 }; |
349 | 353 |
350 } // namespace cc | 354 } // namespace cc |
351 | 355 |
352 #endif // CC_RESOURCES_TILE_MANAGER_H_ | 356 #endif // CC_RESOURCES_TILE_MANAGER_H_ |
OLD | NEW |