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 #include "cc/tiles/tile_manager.h" | 5 #include "cc/tiles/tile_manager.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
(...skipping 329 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
340 void TileManager::FinishTasksAndCleanUp() { | 340 void TileManager::FinishTasksAndCleanUp() { |
341 if (!tile_task_manager_) | 341 if (!tile_task_manager_) |
342 return; | 342 return; |
343 | 343 |
344 global_state_ = GlobalStateThatImpactsTilePriority(); | 344 global_state_ = GlobalStateThatImpactsTilePriority(); |
345 | 345 |
346 // This cancels tasks if possible, finishes pending tasks, and release any | 346 // This cancels tasks if possible, finishes pending tasks, and release any |
347 // uninitialized resources. | 347 // uninitialized resources. |
348 tile_task_manager_->Shutdown(); | 348 tile_task_manager_->Shutdown(); |
349 | 349 |
350 raster_buffer_provider_->Shutdown(); | 350 // Now that all tasks have been finished, we can clear any |
351 | 351 // |orphan_tasks_|. |
352 // Now that all tasks have been finished, we can clear any |orphan_tasks_|. | |
353 orphan_tasks_.clear(); | 352 orphan_tasks_.clear(); |
354 | 353 |
355 tile_task_manager_->CheckForCompletedTasks(); | 354 tile_task_manager_->CheckForCompletedTasks(); |
356 | 355 |
357 FreeResourcesForReleasedTiles(); | 356 FreeResourcesForReleasedTiles(); |
358 CleanUpReleasedTiles(); | 357 CleanUpReleasedTiles(); |
359 | 358 |
360 tile_task_manager_ = nullptr; | 359 tile_task_manager_ = nullptr; |
361 resource_pool_ = nullptr; | 360 resource_pool_ = nullptr; |
362 more_tiles_need_prepare_check_notifier_.Cancel(); | 361 more_tiles_need_prepare_check_notifier_.Cancel(); |
363 signals_check_notifier_.Cancel(); | 362 signals_check_notifier_.Cancel(); |
364 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | 363 task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); |
365 | 364 |
366 for (auto& draw_image_pair : locked_images_) | 365 for (auto& draw_image_pair : locked_images_) |
367 image_decode_controller_->UnrefImage(draw_image_pair.first); | 366 image_decode_controller_->UnrefImage(draw_image_pair.first); |
368 locked_images_.clear(); | 367 locked_images_.clear(); |
369 } | 368 } |
370 | 369 |
371 void TileManager::SetResources(ResourcePool* resource_pool, | 370 void TileManager::SetResources(ResourcePool* resource_pool, |
372 ImageDecodeController* image_decode_controller, | 371 ImageDecodeController* image_decode_controller, |
373 TileTaskManager* tile_task_manager, | 372 TileTaskManager* tile_task_manager, |
374 RasterBufferProvider* raster_buffer_provider, | |
375 size_t scheduled_raster_task_limit, | 373 size_t scheduled_raster_task_limit, |
376 bool use_gpu_rasterization) { | 374 bool use_gpu_rasterization) { |
377 DCHECK(!tile_task_manager_); | 375 DCHECK(!tile_task_manager_); |
378 DCHECK(tile_task_manager); | 376 DCHECK(tile_task_manager); |
379 | 377 |
380 use_gpu_rasterization_ = use_gpu_rasterization; | 378 use_gpu_rasterization_ = use_gpu_rasterization; |
381 scheduled_raster_task_limit_ = scheduled_raster_task_limit; | 379 scheduled_raster_task_limit_ = scheduled_raster_task_limit; |
382 resource_pool_ = resource_pool; | 380 resource_pool_ = resource_pool; |
383 image_decode_controller_ = image_decode_controller; | 381 image_decode_controller_ = image_decode_controller; |
384 tile_task_manager_ = tile_task_manager; | 382 tile_task_manager_ = tile_task_manager; |
385 raster_buffer_provider_ = raster_buffer_provider; | |
386 } | 383 } |
387 | 384 |
388 void TileManager::Release(Tile* tile) { | 385 void TileManager::Release(Tile* tile) { |
389 released_tiles_.push_back(tile); | 386 released_tiles_.push_back(tile); |
390 } | 387 } |
391 | 388 |
392 void TileManager::FreeResourcesForReleasedTiles() { | 389 void TileManager::FreeResourcesForReleasedTiles() { |
393 for (auto* tile : released_tiles_) | 390 for (auto* tile : released_tiles_) |
394 FreeResourcesForTile(tile); | 391 FreeResourcesForTile(tile); |
395 } | 392 } |
(...skipping 478 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
874 graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get())); | 871 graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get())); |
875 } | 872 } |
876 } | 873 } |
877 | 874 |
878 for (auto& draw_image_pair : locked_images_) | 875 for (auto& draw_image_pair : locked_images_) |
879 image_decode_controller_->UnrefImage(draw_image_pair.first); | 876 image_decode_controller_->UnrefImage(draw_image_pair.first); |
880 // The old locked images have to stay around until past the ScheduleTasks call | 877 // The old locked images have to stay around until past the ScheduleTasks call |
881 // below, so we do a swap instead of a move. | 878 // below, so we do a swap instead of a move. |
882 locked_images_.swap(new_locked_images); | 879 locked_images_.swap(new_locked_images); |
883 | 880 |
884 // We must reduce the amount of unused resources before calling | |
885 // ScheduleTasks to prevent usage from rising above limits. | |
886 resource_pool_->ReduceResourceUsage(); | |
887 image_decode_controller_->ReduceCacheUsage(); | |
888 | |
889 // Insert nodes for our task completion tasks. We enqueue these using | 881 // Insert nodes for our task completion tasks. We enqueue these using |
890 // NONCONCURRENT_FOREGROUND category this is the highest prioirty category and | 882 // NONCONCURRENT_FOREGROUND category this is the highest prioirty category and |
891 // we'd like to run these tasks as soon as possible. | 883 // we'd like to run these tasks as soon as possible. |
892 InsertNodeForTask(&graph_, required_for_activation_done_task.get(), | 884 InsertNodeForTask(&graph_, required_for_activation_done_task.get(), |
893 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, | 885 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, |
894 kRequiredForActivationDoneTaskPriority, | 886 kRequiredForActivationDoneTaskPriority, |
895 required_for_activate_count); | 887 required_for_activate_count); |
896 InsertNodeForTask(&graph_, required_for_draw_done_task.get(), | 888 InsertNodeForTask(&graph_, required_for_draw_done_task.get(), |
897 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, | 889 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, |
898 kRequiredForDrawDoneTaskPriority, required_for_draw_count); | 890 kRequiredForDrawDoneTaskPriority, required_for_draw_count); |
899 InsertNodeForTask(&graph_, all_done_task.get(), | 891 InsertNodeForTask(&graph_, all_done_task.get(), |
900 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, | 892 TASK_CATEGORY_NONCONCURRENT_FOREGROUND, |
901 kAllDoneTaskPriority, all_count); | 893 kAllDoneTaskPriority, all_count); |
902 | 894 |
903 // Synchronize worker with compositor. | 895 // We must reduce the amount of unused resoruces before calling |
904 raster_buffer_provider_->OrderingBarrier(); | 896 // ScheduleTasks to prevent usage from rising above limits. |
| 897 resource_pool_->ReduceResourceUsage(); |
| 898 image_decode_controller_->ReduceCacheUsage(); |
905 | 899 |
906 // Schedule running of |raster_queue_|. This replaces any previously | 900 // Schedule running of |raster_queue_|. This replaces any previously |
907 // scheduled tasks and effectively cancels all tasks not present | 901 // scheduled tasks and effectively cancels all tasks not present |
908 // in |raster_queue_|. | 902 // in |raster_queue_|. |
909 tile_task_manager_->ScheduleTasks(&graph_); | 903 tile_task_manager_->ScheduleTasks(&graph_); |
910 | 904 |
911 // It's now safe to clean up orphan tasks as raster worker pool is not | 905 // It's now safe to clean up orphan tasks as raster worker pool is not |
912 // allowed to keep around unreferenced raster tasks after ScheduleTasks() has | 906 // allowed to keep around unreferenced raster tasks after ScheduleTasks() has |
913 // been called. | 907 // been called. |
914 orphan_tasks_.clear(); | 908 orphan_tasks_.clear(); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
973 decode_tasks.push_back(task); | 967 decode_tasks.push_back(task); |
974 | 968 |
975 if (need_to_unref_when_finished) | 969 if (need_to_unref_when_finished) |
976 ++it; | 970 ++it; |
977 else | 971 else |
978 it = images.erase(it); | 972 it = images.erase(it); |
979 } | 973 } |
980 | 974 |
981 bool supports_concurrent_execution = !use_gpu_rasterization_; | 975 bool supports_concurrent_execution = !use_gpu_rasterization_; |
982 std::unique_ptr<RasterBuffer> raster_buffer = | 976 std::unique_ptr<RasterBuffer> raster_buffer = |
983 raster_buffer_provider_->AcquireBufferForRaster( | 977 tile_task_manager_->GetRasterBufferProvider()->AcquireBufferForRaster( |
984 resource, resource_content_id, tile->invalidated_id()); | 978 resource, resource_content_id, tile->invalidated_id()); |
985 return make_scoped_refptr(new RasterTaskImpl( | 979 return make_scoped_refptr(new RasterTaskImpl( |
986 this, tile, resource, prioritized_tile.raster_source(), playback_settings, | 980 this, tile, resource, prioritized_tile.raster_source(), playback_settings, |
987 prioritized_tile.priority().resolution, prepare_tiles_count_, | 981 prioritized_tile.priority().resolution, prepare_tiles_count_, |
988 std::move(raster_buffer), &decode_tasks, supports_concurrent_execution)); | 982 std::move(raster_buffer), &decode_tasks, supports_concurrent_execution)); |
989 } | 983 } |
990 | 984 |
991 void TileManager::OnRasterTaskCompleted( | 985 void TileManager::OnRasterTaskCompleted( |
992 std::unique_ptr<RasterBuffer> raster_buffer, | 986 std::unique_ptr<RasterBuffer> raster_buffer, |
993 Tile* tile, | 987 Tile* tile, |
994 Resource* resource, | 988 Resource* resource, |
995 bool was_canceled) { | 989 bool was_canceled) { |
996 DCHECK(tile); | 990 DCHECK(tile); |
997 DCHECK(tiles_.find(tile->id()) != tiles_.end()); | 991 DCHECK(tiles_.find(tile->id()) != tiles_.end()); |
998 raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer)); | 992 tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster( |
| 993 std::move(raster_buffer)); |
999 | 994 |
1000 TileDrawInfo& draw_info = tile->draw_info(); | 995 TileDrawInfo& draw_info = tile->draw_info(); |
1001 DCHECK(tile->raster_task_.get()); | 996 DCHECK(tile->raster_task_.get()); |
1002 orphan_tasks_.push_back(tile->raster_task_); | 997 orphan_tasks_.push_back(tile->raster_task_); |
1003 tile->raster_task_ = nullptr; | 998 tile->raster_task_ = nullptr; |
1004 | 999 |
1005 // Unref all the images. | 1000 // Unref all the images. |
1006 auto images_it = scheduled_draw_images_.find(tile->id()); | 1001 auto images_it = scheduled_draw_images_.find(tile->id()); |
1007 const std::vector<DrawImage>& images = images_it->second; | 1002 const std::vector<DrawImage>& images = images_it->second; |
1008 for (const auto& image : images) | 1003 for (const auto& image : images) |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1044 | 1039 |
1045 tiles_[tile->id()] = tile.get(); | 1040 tiles_[tile->id()] = tile.get(); |
1046 return tile; | 1041 return tile; |
1047 } | 1042 } |
1048 | 1043 |
1049 void TileManager::SetTileTaskManagerForTesting( | 1044 void TileManager::SetTileTaskManagerForTesting( |
1050 TileTaskManager* tile_task_manager) { | 1045 TileTaskManager* tile_task_manager) { |
1051 tile_task_manager_ = tile_task_manager; | 1046 tile_task_manager_ = tile_task_manager; |
1052 } | 1047 } |
1053 | 1048 |
1054 void TileManager::SetRasterBufferProviderForTesting( | |
1055 RasterBufferProvider* raster_buffer_provider) { | |
1056 raster_buffer_provider_ = raster_buffer_provider; | |
1057 } | |
1058 | |
1059 bool TileManager::AreRequiredTilesReadyToDraw( | 1049 bool TileManager::AreRequiredTilesReadyToDraw( |
1060 RasterTilePriorityQueue::Type type) const { | 1050 RasterTilePriorityQueue::Type type) const { |
1061 std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue( | 1051 std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue( |
1062 client_->BuildRasterQueue(global_state_.tree_priority, type)); | 1052 client_->BuildRasterQueue(global_state_.tree_priority, type)); |
1063 // It is insufficient to check whether the raster queue we constructed is | 1053 // It is insufficient to check whether the raster queue we constructed is |
1064 // empty. The reason for this is that there are situations (rasterize on | 1054 // empty. The reason for this is that there are situations (rasterize on |
1065 // demand) when the tile both needs raster and it's ready to draw. Hence, we | 1055 // demand) when the tile both needs raster and it's ready to draw. Hence, we |
1066 // have to iterate the queue to check whether the required tiles are ready to | 1056 // have to iterate the queue to check whether the required tiles are ready to |
1067 // draw. | 1057 // draw. |
1068 for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) { | 1058 for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) { |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1218 Tile* tile = queue->Top().tile(); | 1208 Tile* tile = queue->Top().tile(); |
1219 if (tile->draw_info().IsReadyToDraw()) | 1209 if (tile->draw_info().IsReadyToDraw()) |
1220 continue; | 1210 continue; |
1221 tile->draw_info().set_oom(); | 1211 tile->draw_info().set_oom(); |
1222 client_->NotifyTileStateChanged(tile); | 1212 client_->NotifyTileStateChanged(tile); |
1223 } | 1213 } |
1224 return true; | 1214 return true; |
1225 } | 1215 } |
1226 | 1216 |
1227 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const { | 1217 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const { |
1228 return raster_buffer_provider_->GetResourceFormat(!tile->is_opaque()); | 1218 return tile_task_manager_->GetRasterBufferProvider()->GetResourceFormat( |
| 1219 !tile->is_opaque()); |
1229 } | 1220 } |
1230 | 1221 |
1231 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const { | 1222 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const { |
1232 return raster_buffer_provider_->GetResourceRequiresSwizzle( | 1223 return tile_task_manager_->GetRasterBufferProvider() |
1233 !tile->is_opaque()); | 1224 ->GetResourceRequiresSwizzle(!tile->is_opaque()); |
1234 } | 1225 } |
1235 | 1226 |
1236 std::unique_ptr<base::trace_event::ConvertableToTraceFormat> | 1227 std::unique_ptr<base::trace_event::ConvertableToTraceFormat> |
1237 TileManager::ScheduledTasksStateAsValue() const { | 1228 TileManager::ScheduledTasksStateAsValue() const { |
1238 std::unique_ptr<base::trace_event::TracedValue> state( | 1229 std::unique_ptr<base::trace_event::TracedValue> state( |
1239 new base::trace_event::TracedValue()); | 1230 new base::trace_event::TracedValue()); |
1240 state->BeginDictionary("tasks_pending"); | 1231 state->BeginDictionary("tasks_pending"); |
1241 state->SetBoolean("ready_to_activate", signals_.ready_to_activate); | 1232 state->SetBoolean("ready_to_activate", signals_.ready_to_activate); |
1242 state->SetBoolean("ready_to_draw", signals_.ready_to_draw); | 1233 state->SetBoolean("ready_to_draw", signals_.ready_to_draw); |
1243 state->SetBoolean("all_tile_tasks_completed", | 1234 state->SetBoolean("all_tile_tasks_completed", |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1330 all_tile_tasks_completed = false; | 1321 all_tile_tasks_completed = false; |
1331 did_notify_all_tile_tasks_completed = false; | 1322 did_notify_all_tile_tasks_completed = false; |
1332 } | 1323 } |
1333 | 1324 |
1334 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default; | 1325 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default; |
1335 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule( | 1326 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule( |
1336 PrioritizedWorkToSchedule&& other) = default; | 1327 PrioritizedWorkToSchedule&& other) = default; |
1337 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default; | 1328 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default; |
1338 | 1329 |
1339 } // namespace cc | 1330 } // namespace cc |
OLD | NEW |