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 479 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 | 490 |
491 if (!tile_task_manager_) { | 491 if (!tile_task_manager_) { |
492 TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted", | 492 TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted", |
493 TRACE_EVENT_SCOPE_THREAD); | 493 TRACE_EVENT_SCOPE_THREAD); |
494 return false; | 494 return false; |
495 } | 495 } |
496 | 496 |
497 signals_.reset(); | 497 signals_.reset(); |
498 global_state_ = state; | 498 global_state_ = state; |
499 | 499 |
| 500 // Ensure that we don't schedule any decode work for checkered images until |
| 501 // the raster work for visible tiles is complete. This is done in |
| 502 // CheckAndIssueSignals when the ready to activate/draw signals are dispatched |
| 503 // to the client. |
| 504 checker_image_tracker_.SetNoDecodesAllowed(); |
| 505 |
500 // We need to call CheckForCompletedTasks() once in-between each call | 506 // We need to call CheckForCompletedTasks() once in-between each call |
501 // to ScheduleTasks() to prevent canceled tasks from being scheduled. | 507 // to ScheduleTasks() to prevent canceled tasks from being scheduled. |
502 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { | 508 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { |
503 tile_task_manager_->CheckForCompletedTasks(); | 509 tile_task_manager_->CheckForCompletedTasks(); |
504 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 510 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
505 } | 511 } |
506 | 512 |
507 PrioritizedWorkToSchedule prioritized_work = AssignGpuMemoryToTiles(); | 513 PrioritizedWorkToSchedule prioritized_work = AssignGpuMemoryToTiles(); |
508 | 514 |
509 // Inform the client that will likely require a draw if the highest priority | 515 // Inform the client that will likely require a draw if the highest priority |
510 // tile that will be rasterized is required for draw. | 516 // tile that will be rasterized is required for draw. |
511 client_->SetIsLikelyToRequireADraw( | 517 client_->SetIsLikelyToRequireADraw( |
512 !prioritized_work.tiles_to_raster.empty() && | 518 !prioritized_work.tiles_to_raster.empty() && |
513 prioritized_work.tiles_to_raster.front().tile()->required_for_draw()); | 519 prioritized_work.tiles_to_raster.front().tile()->required_for_draw()); |
514 | 520 |
515 // Schedule tile tasks. | 521 // Schedule tile tasks. |
516 ScheduleTasks(prioritized_work); | 522 ScheduleTasks(std::move(prioritized_work)); |
517 | 523 |
518 TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD, | 524 TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD, |
519 "state", BasicStateAsValue()); | 525 "state", BasicStateAsValue()); |
520 return true; | 526 return true; |
521 } | 527 } |
522 | 528 |
523 void TileManager::Flush() { | 529 void TileManager::Flush() { |
524 TRACE_EVENT0("cc", "TileManager::Flush"); | 530 TRACE_EVENT0("cc", "TileManager::Flush"); |
525 | 531 |
526 if (!tile_task_manager_) { | 532 if (!tile_task_manager_) { |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
702 // checker-images. If this tile does not need raster, process it only to | 708 // checker-images. If this tile does not need raster, process it only to |
703 // build the decode queue for checkered images. | 709 // build the decode queue for checkered images. |
704 // Note that performing this check after the solid color analysis is not | 710 // Note that performing this check after the solid color analysis is not |
705 // necessary for correctness. | 711 // necessary for correctness. |
706 if (!tile->draw_info().NeedsRaster()) { | 712 if (!tile->draw_info().NeedsRaster()) { |
707 DCHECK(tile->draw_info().is_checker_imaged()); | 713 DCHECK(tile->draw_info().is_checker_imaged()); |
708 DCHECK(prioritized_tile.should_decode_checkered_images_for_tile()); | 714 DCHECK(prioritized_tile.should_decode_checkered_images_for_tile()); |
709 | 715 |
710 AddCheckeredImagesToDecodeQueue( | 716 AddCheckeredImagesToDecodeQueue( |
711 prioritized_tile, raster_color_space, | 717 prioritized_tile, raster_color_space, |
| 718 CheckerImageTracker::DecodeType::kRaster, |
712 &work_to_schedule.checker_image_decode_queue); | 719 &work_to_schedule.checker_image_decode_queue); |
713 continue; | 720 continue; |
714 } | 721 } |
715 | 722 |
716 // We won't be able to schedule this tile, so break out early. | 723 // We won't be able to schedule this tile, so break out early. |
717 if (work_to_schedule.tiles_to_raster.size() >= | 724 if (work_to_schedule.tiles_to_raster.size() >= |
718 scheduled_raster_task_limit_) { | 725 scheduled_raster_task_limit_) { |
719 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; | 726 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; |
720 break; | 727 break; |
721 } | 728 } |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
760 | 767 |
761 // If the tile has a scheduled task that will rasterize a resource with | 768 // If the tile has a scheduled task that will rasterize a resource with |
762 // checker-imaged content, add those images to the decode queue. Note that | 769 // checker-imaged content, add those images to the decode queue. Note that |
763 // we add all images as we process the raster priority queue to ensure that | 770 // we add all images as we process the raster priority queue to ensure that |
764 // images are added to the decode queue in raster priority order. | 771 // images are added to the decode queue in raster priority order. |
765 if (tile->HasRasterTask()) { | 772 if (tile->HasRasterTask()) { |
766 if (tile->raster_task_scheduled_with_checker_images() && | 773 if (tile->raster_task_scheduled_with_checker_images() && |
767 prioritized_tile.should_decode_checkered_images_for_tile()) { | 774 prioritized_tile.should_decode_checkered_images_for_tile()) { |
768 AddCheckeredImagesToDecodeQueue( | 775 AddCheckeredImagesToDecodeQueue( |
769 prioritized_tile, raster_color_space, | 776 prioritized_tile, raster_color_space, |
| 777 CheckerImageTracker::DecodeType::kRaster, |
770 &work_to_schedule.checker_image_decode_queue); | 778 &work_to_schedule.checker_image_decode_queue); |
771 } | 779 } |
772 } else { | 780 } else { |
773 // Creating the raster task here will acquire resources, but | 781 // Creating the raster task here will acquire resources, but |
774 // this resource usage has already been accounted for above. | 782 // this resource usage has already been accounted for above. |
775 tile->raster_task_ = | 783 tile->raster_task_ = |
776 CreateRasterTask(prioritized_tile, client_->GetRasterColorSpace(), | 784 CreateRasterTask(prioritized_tile, client_->GetRasterColorSpace(), |
777 &work_to_schedule.checker_image_decode_queue); | 785 &work_to_schedule.checker_image_decode_queue); |
778 } | 786 } |
779 | 787 |
(...skipping 22 matching lines...) Expand all Loading... |
802 break; | 810 break; |
803 | 811 |
804 if (!prioritized_tile.should_decode_checkered_images_for_tile()) | 812 if (!prioritized_tile.should_decode_checkered_images_for_tile()) |
805 continue; | 813 continue; |
806 | 814 |
807 Tile* tile = prioritized_tile.tile(); | 815 Tile* tile = prioritized_tile.tile(); |
808 if (tile->draw_info().is_checker_imaged() || | 816 if (tile->draw_info().is_checker_imaged() || |
809 tile->raster_task_scheduled_with_checker_images()) { | 817 tile->raster_task_scheduled_with_checker_images()) { |
810 AddCheckeredImagesToDecodeQueue( | 818 AddCheckeredImagesToDecodeQueue( |
811 prioritized_tile, raster_color_space, | 819 prioritized_tile, raster_color_space, |
| 820 CheckerImageTracker::DecodeType::kRaster, |
812 &work_to_schedule.checker_image_decode_queue); | 821 &work_to_schedule.checker_image_decode_queue); |
813 } | 822 } |
814 } | 823 } |
815 } | 824 } |
816 | 825 |
817 UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", | 826 UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", |
818 !had_enough_memory_to_schedule_tiles_needed_now); | 827 !had_enough_memory_to_schedule_tiles_needed_now); |
819 did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now; | 828 did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now; |
820 | 829 |
821 memory_stats_from_last_assign_.total_budget_in_bytes = | 830 memory_stats_from_last_assign_.total_budget_in_bytes = |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
871 if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) | 880 if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) |
872 checkered_images->push_back(draw_image.paint_image()); | 881 checkered_images->push_back(draw_image.paint_image()); |
873 else | 882 else |
874 sync_decoded_images->push_back(draw_image); | 883 sync_decoded_images->push_back(draw_image); |
875 } | 884 } |
876 } | 885 } |
877 | 886 |
878 void TileManager::AddCheckeredImagesToDecodeQueue( | 887 void TileManager::AddCheckeredImagesToDecodeQueue( |
879 const PrioritizedTile& prioritized_tile, | 888 const PrioritizedTile& prioritized_tile, |
880 const gfx::ColorSpace& raster_color_space, | 889 const gfx::ColorSpace& raster_color_space, |
| 890 CheckerImageTracker::DecodeType decode_type, |
881 CheckerImageTracker::ImageDecodeQueue* image_decode_queue) { | 891 CheckerImageTracker::ImageDecodeQueue* image_decode_queue) { |
882 Tile* tile = prioritized_tile.tile(); | 892 Tile* tile = prioritized_tile.tile(); |
883 std::vector<DrawImage> images_in_tile; | 893 std::vector<DrawImage> images_in_tile; |
884 prioritized_tile.raster_source()->GetDiscardableImagesInRect( | 894 prioritized_tile.raster_source()->GetDiscardableImagesInRect( |
885 tile->enclosing_layer_rect(), tile->raster_transform().scale(), | 895 tile->enclosing_layer_rect(), tile->raster_transform().scale(), |
886 raster_color_space, &images_in_tile); | 896 raster_color_space, &images_in_tile); |
887 WhichTree tree = tile->tiling()->tree(); | 897 WhichTree tree = tile->tiling()->tree(); |
888 | 898 |
889 for (auto& draw_image : images_in_tile) { | 899 for (auto& draw_image : images_in_tile) { |
890 if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) | 900 if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) { |
891 image_decode_queue->push_back(draw_image.paint_image()); | 901 image_decode_queue->push_back(CheckerImageTracker::ImageDecodeRequest( |
| 902 draw_image.paint_image(), decode_type)); |
| 903 } |
892 } | 904 } |
893 } | 905 } |
894 | 906 |
895 void TileManager::ScheduleTasks( | 907 void TileManager::ScheduleTasks(PrioritizedWorkToSchedule work_to_schedule) { |
896 const PrioritizedWorkToSchedule& work_to_schedule) { | |
897 const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized = | 908 const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized = |
898 work_to_schedule.tiles_to_raster; | 909 work_to_schedule.tiles_to_raster; |
899 TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count", | 910 TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count", |
900 tiles_that_need_to_be_rasterized.size()); | 911 tiles_that_need_to_be_rasterized.size()); |
901 | 912 |
902 DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_); | 913 DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_); |
903 | 914 |
904 if (!has_scheduled_tile_tasks_) { | 915 if (!has_scheduled_tile_tasks_) { |
905 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); | 916 TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this); |
906 } | 917 } |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
966 tile->required_for_draw() || tile->required_for_activation() || | 977 tile->required_for_draw() || tile->required_for_activation() || |
967 prioritized_tile.priority().priority_bin == TilePriority::NOW; | 978 prioritized_tile.priority().priority_bin == TilePriority::NOW; |
968 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++, | 979 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++, |
969 use_foreground_category); | 980 use_foreground_category); |
970 } | 981 } |
971 | 982 |
972 const std::vector<PrioritizedTile>& tiles_to_process_for_images = | 983 const std::vector<PrioritizedTile>& tiles_to_process_for_images = |
973 work_to_schedule.tiles_to_process_for_images; | 984 work_to_schedule.tiles_to_process_for_images; |
974 std::vector<DrawImage> new_locked_images; | 985 std::vector<DrawImage> new_locked_images; |
975 for (const PrioritizedTile& prioritized_tile : tiles_to_process_for_images) { | 986 for (const PrioritizedTile& prioritized_tile : tiles_to_process_for_images) { |
976 Tile* tile = prioritized_tile.tile(); | 987 std::vector<DrawImage> sync_decoded_images; |
| 988 std::vector<PaintImage> checkered_images; |
| 989 PartitionImagesForCheckering(prioritized_tile, raster_color_space, |
| 990 &sync_decoded_images, &checkered_images); |
977 | 991 |
978 // TODO(khushalsagar): Send these images to the ImageDecodeService, through | 992 // Add the sync decoded images to |new_locked_images| so they can be added |
979 // the CheckerImageTracker as well. See crbug.com/691087. | 993 // to the task graph. |
980 std::vector<DrawImage> images; | 994 new_locked_images.insert(new_locked_images.end(), |
981 prioritized_tile.raster_source()->GetDiscardableImagesInRect( | 995 sync_decoded_images.begin(), |
982 tile->enclosing_layer_rect(), tile->raster_transform().scale(), | 996 sync_decoded_images.end()); |
983 raster_color_space, &images); | 997 |
984 new_locked_images.insert(new_locked_images.end(), images.begin(), | 998 // For checkered-images, send them to the decode service. |
985 images.end()); | 999 for (auto& image : checkered_images) { |
| 1000 work_to_schedule.checker_image_decode_queue.push_back( |
| 1001 CheckerImageTracker::ImageDecodeRequest( |
| 1002 std::move(image), CheckerImageTracker::DecodeType::kPreDecode)); |
| 1003 } |
986 } | 1004 } |
987 | 1005 |
988 // TODO(vmpstr): SOON is misleading here, but these images can come from | 1006 // TODO(vmpstr): SOON is misleading here, but these images can come from |
989 // several diffent tiles. Rethink what we actually want to trace here. Note | 1007 // several diffent tiles. Rethink what we actually want to trace here. Note |
990 // that I'm using SOON, since it can't be NOW (these are prepaint). | 1008 // that I'm using SOON, since it can't be NOW (these are prepaint). |
991 ImageDecodeCache::TracingInfo tracing_info( | 1009 ImageDecodeCache::TracingInfo tracing_info( |
992 prepare_tiles_count_, TilePriority::SOON, | 1010 prepare_tiles_count_, TilePriority::SOON, |
993 ImageDecodeCache::TaskType::kInRaster); | 1011 ImageDecodeCache::TaskType::kInRaster); |
994 std::vector<scoped_refptr<TileTask>> new_locked_image_tasks = | 1012 std::vector<scoped_refptr<TileTask>> new_locked_image_tasks = |
995 image_controller_.SetPredecodeImages(std::move(new_locked_images), | 1013 image_controller_.SetPredecodeImages(std::move(new_locked_images), |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1100 std::vector<PaintImage> checkered_images; | 1118 std::vector<PaintImage> checkered_images; |
1101 PartitionImagesForCheckering(prioritized_tile, color_space, | 1119 PartitionImagesForCheckering(prioritized_tile, color_space, |
1102 &sync_decoded_images, &checkered_images); | 1120 &sync_decoded_images, &checkered_images); |
1103 for (const auto& image : checkered_images) { | 1121 for (const auto& image : checkered_images) { |
1104 playback_settings.images_to_skip.insert(image.sk_image()->uniqueID()); | 1122 playback_settings.images_to_skip.insert(image.sk_image()->uniqueID()); |
1105 | 1123 |
1106 // This can be the case for tiles on the active tree that will be replaced | 1124 // This can be the case for tiles on the active tree that will be replaced |
1107 // or are occluded on the pending tree. While we still need to continue | 1125 // or are occluded on the pending tree. While we still need to continue |
1108 // skipping images for these tiles, we don't need to decode them since | 1126 // skipping images for these tiles, we don't need to decode them since |
1109 // they will not be required on the next active tree. | 1127 // they will not be required on the next active tree. |
1110 if (prioritized_tile.should_decode_checkered_images_for_tile()) | 1128 if (prioritized_tile.should_decode_checkered_images_for_tile()) { |
1111 checker_image_decode_queue->push_back(image); | 1129 checker_image_decode_queue->push_back( |
| 1130 CheckerImageTracker::ImageDecodeRequest( |
| 1131 image, CheckerImageTracker::DecodeType::kRaster)); |
| 1132 } |
1112 } | 1133 } |
1113 } | 1134 } |
1114 | 1135 |
1115 // We can skip the image hijack canvas if we have no images, or no images to | 1136 // We can skip the image hijack canvas if we have no images, or no images to |
1116 // skip during raster. | 1137 // skip during raster. |
1117 playback_settings.use_image_hijack_canvas = | 1138 playback_settings.use_image_hijack_canvas = |
1118 !sync_decoded_images.empty() || !playback_settings.images_to_skip.empty(); | 1139 !sync_decoded_images.empty() || !playback_settings.images_to_skip.empty(); |
1119 | 1140 |
1120 bool has_checker_images = !playback_settings.images_to_skip.empty(); | 1141 bool has_checker_images = !playback_settings.images_to_skip.empty(); |
1121 tile->set_raster_task_scheduled_with_checker_images(has_checker_images); | 1142 tile->set_raster_task_scheduled_with_checker_images(has_checker_images); |
(...skipping 178 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1300 !signals_.did_notify_all_tile_tasks_completed) { | 1321 !signals_.did_notify_all_tile_tasks_completed) { |
1301 signals_.all_tile_tasks_completed = false; | 1322 signals_.all_tile_tasks_completed = false; |
1302 if (!has_scheduled_tile_tasks_) { | 1323 if (!has_scheduled_tile_tasks_) { |
1303 TRACE_EVENT0( | 1324 TRACE_EVENT0( |
1304 TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 1325 TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
1305 "TileManager::CheckAndIssueSignals - all tile tasks completed"); | 1326 "TileManager::CheckAndIssueSignals - all tile tasks completed"); |
1306 signals_.did_notify_all_tile_tasks_completed = true; | 1327 signals_.did_notify_all_tile_tasks_completed = true; |
1307 client_->NotifyAllTileTasksCompleted(); | 1328 client_->NotifyAllTileTasksCompleted(); |
1308 } | 1329 } |
1309 } | 1330 } |
| 1331 |
| 1332 // Allow decodes for rasterized tiles if all required for draw/activate tiles |
| 1333 // are done. And pre-decode tiles once all tile tasks are done. |
| 1334 // Note that the order is important here, since all signals could have become |
| 1335 // true and in that case we want to allow the most decodes. |
| 1336 if (signals_.did_notify_all_tile_tasks_completed) { |
| 1337 checker_image_tracker_.SetMaxDecodePriorityAllowed( |
| 1338 CheckerImageTracker::DecodeType::kPreDecode); |
| 1339 } else if (signals_.did_notify_ready_to_activate && |
| 1340 signals_.did_notify_ready_to_draw) { |
| 1341 checker_image_tracker_.SetMaxDecodePriorityAllowed( |
| 1342 CheckerImageTracker::DecodeType::kRaster); |
| 1343 } |
1310 } | 1344 } |
1311 | 1345 |
1312 void TileManager::CheckIfMoreTilesNeedToBePrepared() { | 1346 void TileManager::CheckIfMoreTilesNeedToBePrepared() { |
1313 tile_task_manager_->CheckForCompletedTasks(); | 1347 tile_task_manager_->CheckForCompletedTasks(); |
1314 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 1348 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
1315 | 1349 |
1316 // When OOM, keep re-assigning memory until we reach a steady state | 1350 // When OOM, keep re-assigning memory until we reach a steady state |
1317 // where top-priority tiles are initialized. | 1351 // where top-priority tiles are initialized. |
1318 PrioritizedWorkToSchedule work_to_schedule = AssignGpuMemoryToTiles(); | 1352 PrioritizedWorkToSchedule work_to_schedule = AssignGpuMemoryToTiles(); |
1319 | 1353 |
1320 // Inform the client that will likely require a draw if the highest priority | 1354 // Inform the client that will likely require a draw if the highest priority |
1321 // tile that will be rasterized is required for draw. | 1355 // tile that will be rasterized is required for draw. |
1322 client_->SetIsLikelyToRequireADraw( | 1356 client_->SetIsLikelyToRequireADraw( |
1323 !work_to_schedule.tiles_to_raster.empty() && | 1357 !work_to_schedule.tiles_to_raster.empty() && |
1324 work_to_schedule.tiles_to_raster.front().tile()->required_for_draw()); | 1358 work_to_schedule.tiles_to_raster.front().tile()->required_for_draw()); |
1325 | 1359 |
1326 // |tiles_that_need_to_be_rasterized| will be empty when we reach a | 1360 // |tiles_that_need_to_be_rasterized| will be empty when we reach a |
1327 // steady memory state. Keep scheduling tasks until we reach this state. | 1361 // steady memory state. Keep scheduling tasks until we reach this state. |
1328 if (!work_to_schedule.tiles_to_raster.empty()) { | 1362 if (!work_to_schedule.tiles_to_raster.empty()) { |
1329 ScheduleTasks(work_to_schedule); | 1363 ScheduleTasks(std::move(work_to_schedule)); |
1330 return; | 1364 return; |
1331 } | 1365 } |
1332 | 1366 |
1333 // If we're not in SMOOTHNESS_TAKES_PRIORITY mode, we should unlock all | 1367 // If we're not in SMOOTHNESS_TAKES_PRIORITY mode, we should unlock all |
1334 // images since we're technically going idle here at least for this frame. | 1368 // images since we're technically going idle here at least for this frame. |
1335 if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) { | 1369 if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) { |
1336 image_controller_.SetPredecodeImages(std::vector<DrawImage>(), | 1370 image_controller_.SetPredecodeImages(std::vector<DrawImage>(), |
1337 ImageDecodeCache::TracingInfo()); | 1371 ImageDecodeCache::TracingInfo()); |
1338 locked_image_tasks_.clear(); | 1372 locked_image_tasks_.clear(); |
1339 } | 1373 } |
(...skipping 320 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1660 all_tile_tasks_completed = false; | 1694 all_tile_tasks_completed = false; |
1661 did_notify_all_tile_tasks_completed = false; | 1695 did_notify_all_tile_tasks_completed = false; |
1662 } | 1696 } |
1663 | 1697 |
1664 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default; | 1698 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default; |
1665 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule( | 1699 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule( |
1666 PrioritizedWorkToSchedule&& other) = default; | 1700 PrioritizedWorkToSchedule&& other) = default; |
1667 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default; | 1701 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default; |
1668 | 1702 |
1669 } // namespace cc | 1703 } // namespace cc |
OLD | NEW |