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