Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(122)

Side by Side Diff: cc/resources/tile_manager.cc

Issue 820743002: cc: GPU rasterize tiles synchronously in PrepareToDraw. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: why wasn't that picked up by presubmit? Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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/resources/tile_manager.h" 5 #include "cc/resources/tile_manager.h"
6 6
7 #include <algorithm> 7 #include <algorithm>
8 #include <limits> 8 #include <limits>
9 #include <string> 9 #include <string>
10 10
11 #include "base/bind.h" 11 #include "base/bind.h"
12 #include "base/debug/trace_event_argument.h" 12 #include "base/debug/trace_event_argument.h"
13 #include "base/json/json_writer.h" 13 #include "base/json/json_writer.h"
14 #include "base/logging.h" 14 #include "base/logging.h"
15 #include "base/metrics/histogram.h" 15 #include "base/metrics/histogram.h"
16 #include "cc/debug/devtools_instrumentation.h" 16 #include "cc/debug/devtools_instrumentation.h"
17 #include "cc/debug/frame_viewer_instrumentation.h" 17 #include "cc/debug/frame_viewer_instrumentation.h"
18 #include "cc/debug/traced_value.h" 18 #include "cc/debug/traced_value.h"
19 #include "cc/layers/picture_layer_impl.h" 19 #include "cc/layers/picture_layer_impl.h"
20 #include "cc/resources/raster_buffer.h" 20 #include "cc/resources/raster_buffer.h"
21 #include "cc/resources/rasterizer.h"
21 #include "cc/resources/tile.h" 22 #include "cc/resources/tile.h"
22 #include "cc/resources/tile_task_runner.h" 23 #include "cc/resources/tile_task_runner.h"
23 #include "ui/gfx/geometry/rect_conversions.h" 24 #include "ui/gfx/geometry/rect_conversions.h"
24 25
25 namespace cc { 26 namespace cc {
26 namespace { 27 namespace {
27 28
28 // Flag to indicate whether we should try and detect that 29 // Flag to indicate whether we should try and detect that
29 // a tile is of solid color. 30 // a tile is of solid color.
30 const bool kUseColorEstimator = true; 31 const bool kUseColorEstimator = true;
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after
194 state->SetInteger("canceled_count", stats.canceled_count); 195 state->SetInteger("canceled_count", stats.canceled_count);
195 return state; 196 return state;
196 } 197 }
197 198
198 // static 199 // static
199 scoped_ptr<TileManager> TileManager::Create( 200 scoped_ptr<TileManager> TileManager::Create(
200 TileManagerClient* client, 201 TileManagerClient* client,
201 base::SequencedTaskRunner* task_runner, 202 base::SequencedTaskRunner* task_runner,
202 ResourcePool* resource_pool, 203 ResourcePool* resource_pool,
203 TileTaskRunner* tile_task_runner, 204 TileTaskRunner* tile_task_runner,
205 Rasterizer* rasterizer,
204 size_t scheduled_raster_task_limit) { 206 size_t scheduled_raster_task_limit) {
205 return make_scoped_ptr(new TileManager(client, task_runner, resource_pool, 207 return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
206 tile_task_runner, 208 tile_task_runner, rasterizer,
207 scheduled_raster_task_limit)); 209 scheduled_raster_task_limit));
208 } 210 }
209 211
210 TileManager::TileManager( 212 TileManager::TileManager(
211 TileManagerClient* client, 213 TileManagerClient* client,
212 const scoped_refptr<base::SequencedTaskRunner>& task_runner, 214 const scoped_refptr<base::SequencedTaskRunner>& task_runner,
213 ResourcePool* resource_pool, 215 ResourcePool* resource_pool,
214 TileTaskRunner* tile_task_runner, 216 TileTaskRunner* tile_task_runner,
217 Rasterizer* rasterizer,
215 size_t scheduled_raster_task_limit) 218 size_t scheduled_raster_task_limit)
216 : client_(client), 219 : client_(client),
217 task_runner_(task_runner), 220 task_runner_(task_runner),
218 resource_pool_(resource_pool), 221 resource_pool_(resource_pool),
219 tile_task_runner_(tile_task_runner), 222 tile_task_runner_(tile_task_runner),
223 rasterizer_(rasterizer),
220 scheduled_raster_task_limit_(scheduled_raster_task_limit), 224 scheduled_raster_task_limit_(scheduled_raster_task_limit),
221 all_tiles_that_need_to_be_rasterized_are_scheduled_(true), 225 all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
222 did_check_for_completed_tasks_since_last_schedule_tasks_(true), 226 did_check_for_completed_tasks_since_last_schedule_tasks_(true),
223 did_oom_on_last_assign_(false), 227 did_oom_on_last_assign_(false),
228 ready_to_activate_notifier_(
229 task_runner_.get(),
230 base::Bind(&TileManager::NotifyReadyToActivate,
231 base::Unretained(this))),
232 ready_to_draw_notifier_(
233 task_runner_.get(),
234 base::Bind(&TileManager::NotifyReadyToDraw, base::Unretained(this))),
224 ready_to_activate_check_notifier_( 235 ready_to_activate_check_notifier_(
225 task_runner_.get(), 236 task_runner_.get(),
226 base::Bind(&TileManager::CheckIfReadyToActivate, 237 base::Bind(&TileManager::CheckIfReadyToActivate,
227 base::Unretained(this))), 238 base::Unretained(this))),
228 ready_to_draw_check_notifier_( 239 ready_to_draw_check_notifier_(
229 task_runner_.get(), 240 task_runner_.get(),
230 base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))), 241 base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
231 more_tiles_need_prepare_check_notifier_( 242 more_tiles_need_prepare_check_notifier_(
232 task_runner_.get(), 243 task_runner_.get(),
233 base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared, 244 base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after
329 340
330 NOTREACHED(); 341 NOTREACHED();
331 } 342 }
332 343
333 void TileManager::PrepareTiles( 344 void TileManager::PrepareTiles(
334 const GlobalStateThatImpactsTilePriority& state) { 345 const GlobalStateThatImpactsTilePriority& state) {
335 TRACE_EVENT0("cc", "TileManager::PrepareTiles"); 346 TRACE_EVENT0("cc", "TileManager::PrepareTiles");
336 347
337 global_state_ = state; 348 global_state_ = state;
338 349
339 // We need to call CheckForCompletedTasks() once in-between each call 350 PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
340 // to ScheduleTasks() to prevent canceled tasks from being scheduled. 351
341 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { 352 if (prepare_tiles_mode != PrepareTilesMode::PREPARE_NONE) {
342 tile_task_runner_->CheckForCompletedTasks(); 353 // We need to call CheckForCompletedTasks() once in-between each call
343 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 354 // to ScheduleTasks() to prevent canceled tasks from being scheduled.
355 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
356 tile_task_runner_->CheckForCompletedTasks();
357 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
358 }
359
360 FreeResourcesForReleasedTiles();
361 CleanUpReleasedTiles();
362
363 client_->BuildRasterQueue(&raster_priority_queue_,
364 global_state_.tree_priority);
365 TileVector tiles_that_need_to_be_rasterized;
366
367 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
368 scheduled_raster_task_limit_);
369
370 raster_priority_queue_.Reset();
371
372 // Schedule tile tasks.
373 ScheduleTasks(tiles_that_need_to_be_rasterized);
374
375 did_notify_ready_to_activate_ = false;
376 did_notify_ready_to_draw_ = false;
377 } else {
378 did_notify_ready_to_activate_ = false;
379 did_notify_ready_to_draw_ = false;
380 ready_to_activate_notifier_.Schedule();
381 ready_to_draw_notifier_.Schedule();
344 } 382 }
345 383
384 TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
385 "state", BasicStateAsValue());
386
387 TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
388 resource_pool_->total_memory_usage_bytes() -
389 resource_pool_->acquired_memory_usage_bytes());
390 }
391
392 void TileManager::SynchronouslyRasterizeTiles(
393 const GlobalStateThatImpactsTilePriority& state) {
394 TRACE_EVENT0("cc", "TileManager::SynchronouslyRasterizeTiles");
395
396 DCHECK(rasterizer_->GetPrepareTilesMode() !=
397 PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES);
398
399 global_state_ = state;
400
346 FreeResourcesForReleasedTiles(); 401 FreeResourcesForReleasedTiles();
347 CleanUpReleasedTiles(); 402 CleanUpReleasedTiles();
348 403
404 client_->BuildRasterQueue(&raster_priority_queue_,
405 global_state_.tree_priority);
349 TileVector tiles_that_need_to_be_rasterized; 406 TileVector tiles_that_need_to_be_rasterized;
350 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); 407 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
408 std::numeric_limits<size_t>::max());
351 409
352 // Schedule tile tasks. 410 // We must reduce the amount of unused resoruces before calling
353 ScheduleTasks(tiles_that_need_to_be_rasterized); 411 // RunTasks to prevent usage from rising above limits.
412 resource_pool_->ReduceResourceUsage();
354 413
355 did_notify_ready_to_activate_ = false; 414 // Run and complete all raster task synchronously.
356 did_notify_ready_to_draw_ = false; 415 rasterizer_->RasterizeTiles(
416 tiles_that_need_to_be_rasterized, resource_pool_,
417 base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this)));
357 418
358 TRACE_EVENT_INSTANT1("cc", "DidPrepare", TRACE_EVENT_SCOPE_THREAD, "state", 419 // Use on-demand raster for any required-for-activation tiles that have not
420 // been been assigned memory after reaching a steady memory state. This
421 // ensures that we activate even when OOM. Note that we have to rebuilt the
422 // queue in case the last AssignGpuMemoryToTiles evicted some tiles that would
423 // otherwise not be picked up by the old raster queue.
424 raster_priority_queue_.Reset();
425 client_->BuildRasterQueue(&raster_priority_queue_,
426 global_state_.tree_priority);
427
428 // Use on-demand raster for any tiles that have not been been assigned
429 // memory. This ensures that we draw even when OOM.
430 while (!raster_priority_queue_.IsEmpty()) {
431 Tile* tile = raster_priority_queue_.Top();
432 TileDrawInfo& draw_info = tile->draw_info();
433
434 if (tile->required_for_draw() && !draw_info.IsReadyToDraw()) {
435 draw_info.set_rasterize_on_demand();
436 client_->NotifyTileStateChanged(tile);
437 }
438 raster_priority_queue_.Pop();
439 }
440 raster_priority_queue_.Reset();
441
442 TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
359 BasicStateAsValue()); 443 BasicStateAsValue());
360 444
361 TRACE_COUNTER_ID1("cc", 445 TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
362 "unused_memory_bytes",
363 this,
364 resource_pool_->total_memory_usage_bytes() - 446 resource_pool_->total_memory_usage_bytes() -
365 resource_pool_->acquired_memory_usage_bytes()); 447 resource_pool_->acquired_memory_usage_bytes());
366 } 448 }
367 449
368 void TileManager::UpdateVisibleTiles() { 450 void TileManager::UpdateVisibleTiles(
451 const GlobalStateThatImpactsTilePriority& state) {
369 TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles"); 452 TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
370 453
371 tile_task_runner_->CheckForCompletedTasks(); 454 tile_task_runner_->CheckForCompletedTasks();
455
456 DCHECK(rasterizer_);
457 PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
458 if (prepare_tiles_mode != PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES)
459 SynchronouslyRasterizeTiles(state);
460
372 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 461 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
373 462
374 TRACE_EVENT_INSTANT1( 463 TRACE_EVENT_INSTANT1(
375 "cc", 464 "cc",
376 "DidUpdateVisibleTiles", 465 "DidUpdateVisibleTiles",
377 TRACE_EVENT_SCOPE_THREAD, 466 TRACE_EVENT_SCOPE_THREAD,
378 "stats", 467 "stats",
379 RasterTaskCompletionStatsAsValue(update_visible_tiles_stats_)); 468 RasterTaskCompletionStatsAsValue(update_visible_tiles_stats_));
380 update_visible_tiles_stats_ = RasterTaskCompletionStats(); 469 update_visible_tiles_stats_ = RasterTaskCompletionStats();
381 } 470 }
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
457 return priority.priority_bin > TilePriority::SOON; 546 return priority.priority_bin > TilePriority::SOON;
458 case ALLOW_ANYTHING: 547 case ALLOW_ANYTHING:
459 return priority.distance_to_visible == 548 return priority.distance_to_visible ==
460 std::numeric_limits<float>::infinity(); 549 std::numeric_limits<float>::infinity();
461 } 550 }
462 NOTREACHED(); 551 NOTREACHED();
463 return true; 552 return true;
464 } 553 }
465 554
466 void TileManager::AssignGpuMemoryToTiles( 555 void TileManager::AssignGpuMemoryToTiles(
467 TileVector* tiles_that_need_to_be_rasterized) { 556 TileVector* tiles_that_need_to_be_rasterized,
557 size_t scheduled_raster_task_limit) {
468 TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles"); 558 TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
469 559
470 // Maintain the list of released resources that can potentially be re-used 560 // Maintain the list of released resources that can potentially be re-used
471 // or deleted. 561 // or deleted.
472 // If this operation becomes expensive too, only do this after some 562 // If this operation becomes expensive too, only do this after some
473 // resource(s) was returned. Note that in that case, one also need to 563 // resource(s) was returned. Note that in that case, one also need to
474 // invalidate when releasing some resource from the pool. 564 // invalidate when releasing some resource from the pool.
475 resource_pool_->CheckBusyResources(false); 565 resource_pool_->CheckBusyResources(false);
476 566
477 // Now give memory out to the tiles until we're out, and build 567 // Now give memory out to the tiles until we're out, and build
478 // the needs-to-be-rasterized queue. 568 // the needs-to-be-rasterized queue.
479 unsigned schedule_priority = 1u; 569 unsigned schedule_priority = 1u;
480 all_tiles_that_need_to_be_rasterized_are_scheduled_ = true; 570 all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
481 bool had_enough_memory_to_schedule_tiles_needed_now = true; 571 bool had_enough_memory_to_schedule_tiles_needed_now = true;
482 572
483 MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes, 573 MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
484 global_state_.num_resources_limit); 574 global_state_.num_resources_limit);
485 MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes, 575 MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
486 global_state_.num_resources_limit); 576 global_state_.num_resources_limit);
487 MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(), 577 MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
488 resource_pool_->acquired_resource_count()); 578 resource_pool_->acquired_resource_count());
489 579
490 eviction_priority_queue_is_up_to_date_ = false; 580 eviction_priority_queue_is_up_to_date_ = false;
491 client_->BuildRasterQueue(&raster_priority_queue_,
492 global_state_.tree_priority);
493 581
494 while (!raster_priority_queue_.IsEmpty()) { 582 while (!raster_priority_queue_.IsEmpty()) {
495 Tile* tile = raster_priority_queue_.Top(); 583 Tile* tile = raster_priority_queue_.Top();
496 TilePriority priority = tile->combined_priority(); 584 TilePriority priority = tile->combined_priority();
497 585
498 if (TilePriorityViolatesMemoryPolicy(priority)) { 586 if (TilePriorityViolatesMemoryPolicy(priority)) {
499 TRACE_EVENT_INSTANT0( 587 TRACE_EVENT_INSTANT0(
500 "cc", 588 "cc", "TileManager::AssignGpuMemory tile violates memory policy",
501 "TileManager::AssignGpuMemory tile violates memory policy",
502 TRACE_EVENT_SCOPE_THREAD); 589 TRACE_EVENT_SCOPE_THREAD);
503 break; 590 break;
504 } 591 }
505 592
506 // We won't be able to schedule this tile, so break out early. 593 // We won't be able to schedule this tile, so break out early.
507 if (tiles_that_need_to_be_rasterized->size() >= 594 if (tiles_that_need_to_be_rasterized->size() >=
508 scheduled_raster_task_limit_) { 595 scheduled_raster_task_limit) {
509 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; 596 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
510 break; 597 break;
511 } 598 }
512 599
513 TileDrawInfo& draw_info = tile->draw_info(); 600 TileDrawInfo& draw_info = tile->draw_info();
514 tile->scheduled_priority_ = schedule_priority++; 601 tile->scheduled_priority_ = schedule_priority++;
515 602
516 DCHECK(draw_info.mode() == TileDrawInfo::PICTURE_PILE_MODE || 603 DCHECK(draw_info.mode() == TileDrawInfo::PICTURE_PILE_MODE ||
517 !draw_info.IsReadyToDraw()); 604 !draw_info.IsReadyToDraw());
518 605
(...skipping 10 matching lines...) Expand all
529 616
530 // This is the memory limit that will be used by this tile. Depending on 617 // This is the memory limit that will be used by this tile. Depending on
531 // the tile priority, it will be one of hard_memory_limit or 618 // the tile priority, it will be one of hard_memory_limit or
532 // soft_memory_limit. 619 // soft_memory_limit.
533 MemoryUsage& tile_memory_limit = 620 MemoryUsage& tile_memory_limit =
534 tile_is_needed_now ? hard_memory_limit : soft_memory_limit; 621 tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
535 622
536 bool memory_usage_is_within_limit = 623 bool memory_usage_is_within_limit =
537 FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit( 624 FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
538 tile_memory_limit - memory_required_by_tile_to_be_scheduled, 625 tile_memory_limit - memory_required_by_tile_to_be_scheduled,
539 priority, 626 priority, &memory_usage);
540 &memory_usage);
541 627
542 // If we couldn't fit the tile into our current memory limit, then we're 628 // If we couldn't fit the tile into our current memory limit, then we're
543 // done. 629 // done.
544 if (!memory_usage_is_within_limit) { 630 if (!memory_usage_is_within_limit) {
545 if (tile_is_needed_now) 631 if (tile_is_needed_now)
546 had_enough_memory_to_schedule_tiles_needed_now = false; 632 had_enough_memory_to_schedule_tiles_needed_now = false;
547 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; 633 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
548 break; 634 break;
549 } 635 }
550 636
(...skipping 10 matching lines...) Expand all
561 UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", 647 UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
562 !had_enough_memory_to_schedule_tiles_needed_now); 648 !had_enough_memory_to_schedule_tiles_needed_now);
563 did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now; 649 did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now;
564 650
565 memory_stats_from_last_assign_.total_budget_in_bytes = 651 memory_stats_from_last_assign_.total_budget_in_bytes =
566 global_state_.hard_memory_limit_in_bytes; 652 global_state_.hard_memory_limit_in_bytes;
567 memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes(); 653 memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes();
568 memory_stats_from_last_assign_.had_enough_memory = 654 memory_stats_from_last_assign_.had_enough_memory =
569 had_enough_memory_to_schedule_tiles_needed_now; 655 had_enough_memory_to_schedule_tiles_needed_now;
570 656
571 raster_priority_queue_.Reset(); 657 TRACE_EVENT_END2("cc", "TileManager::AssignGpuMemoryToTiles",
572
573 TRACE_EVENT_END2("cc",
574 "TileManager::AssignGpuMemoryToTiles",
575 "all_tiles_that_need_to_be_rasterized_are_scheduled", 658 "all_tiles_that_need_to_be_rasterized_are_scheduled",
576 all_tiles_that_need_to_be_rasterized_are_scheduled_, 659 all_tiles_that_need_to_be_rasterized_are_scheduled_,
577 "had_enough_memory_to_schedule_tiles_needed_now", 660 "had_enough_memory_to_schedule_tiles_needed_now",
578 had_enough_memory_to_schedule_tiles_needed_now); 661 had_enough_memory_to_schedule_tiles_needed_now);
579 } 662 }
580 663
581 void TileManager::FreeResourcesForTile(Tile* tile) { 664 void TileManager::FreeResourcesForTile(Tile* tile) {
582 TileDrawInfo& draw_info = tile->draw_info(); 665 TileDrawInfo& draw_info = tile->draw_info();
583 if (draw_info.resource_) 666 if (draw_info.resource_)
584 resource_pool_->ReleaseResource(draw_info.resource_.Pass()); 667 resource_pool_->ReleaseResource(draw_info.resource_.Pass());
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after
716 799
717 void TileManager::OnRasterTaskCompleted( 800 void TileManager::OnRasterTaskCompleted(
718 Tile::Id tile_id, 801 Tile::Id tile_id,
719 scoped_ptr<ScopedResource> resource, 802 scoped_ptr<ScopedResource> resource,
720 const RasterSource::SolidColorAnalysis& analysis, 803 const RasterSource::SolidColorAnalysis& analysis,
721 bool was_canceled) { 804 bool was_canceled) {
722 DCHECK(tiles_.find(tile_id) != tiles_.end()); 805 DCHECK(tiles_.find(tile_id) != tiles_.end());
723 806
724 Tile* tile = tiles_[tile_id]; 807 Tile* tile = tiles_[tile_id];
725 TileDrawInfo& draw_info = tile->draw_info(); 808 TileDrawInfo& draw_info = tile->draw_info();
726 DCHECK(tile->raster_task_.get()); 809 if (tile->raster_task_.get()) {
727 orphan_raster_tasks_.push_back(tile->raster_task_); 810 orphan_raster_tasks_.push_back(tile->raster_task_);
728 tile->raster_task_ = NULL; 811 tile->raster_task_ = nullptr;
812 }
729 813
730 if (was_canceled) { 814 if (was_canceled) {
731 ++update_visible_tiles_stats_.canceled_count; 815 ++update_visible_tiles_stats_.canceled_count;
732 resource_pool_->ReleaseResource(resource.Pass()); 816 resource_pool_->ReleaseResource(resource.Pass());
733 return; 817 return;
734 } 818 }
735 819
736 ++update_visible_tiles_stats_.completed_count; 820 ++update_visible_tiles_stats_.completed_count;
737 821
738 if (analysis.is_solid_color) { 822 if (analysis.is_solid_color) {
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
790 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers(); 874 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
791 875
792 for (const auto& layer : layers) { 876 for (const auto& layer : layers) {
793 if (!layer->AllTilesRequiredForDrawAreReadyToDraw()) 877 if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
794 return false; 878 return false;
795 } 879 }
796 880
797 return true; 881 return true;
798 } 882 }
799 883
884 void TileManager::NotifyReadyToActivate() {
885 TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
886 if (did_notify_ready_to_activate_)
887 return;
888 client_->NotifyReadyToActivate();
889 did_notify_ready_to_activate_ = true;
890 }
891
892 void TileManager::NotifyReadyToDraw() {
893 TRACE_EVENT0("cc", "TileManager::NotifyReadyToDraw");
894 if (did_notify_ready_to_draw_)
895 return;
896 client_->NotifyReadyToDraw();
897 did_notify_ready_to_draw_ = true;
898 }
899
800 void TileManager::CheckIfReadyToActivate() { 900 void TileManager::CheckIfReadyToActivate() {
801 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); 901 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
802 902
803 tile_task_runner_->CheckForCompletedTasks(); 903 tile_task_runner_->CheckForCompletedTasks();
804 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 904 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
805 905
806 if (did_notify_ready_to_activate_) 906 if (did_notify_ready_to_activate_)
807 return; 907 return;
808 if (!IsReadyToActivate()) 908 if (!IsReadyToActivate())
809 return; 909 return;
810 910
811 client_->NotifyReadyToActivate(); 911 NotifyReadyToActivate();
812 did_notify_ready_to_activate_ = true;
813 } 912 }
814 913
815 void TileManager::CheckIfReadyToDraw() { 914 void TileManager::CheckIfReadyToDraw() {
816 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToDraw"); 915 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToDraw");
817 916
818 tile_task_runner_->CheckForCompletedTasks(); 917 tile_task_runner_->CheckForCompletedTasks();
819 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 918 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
820 919
821 if (did_notify_ready_to_draw_) 920 if (did_notify_ready_to_draw_)
822 return; 921 return;
823 if (!IsReadyToDraw()) 922 if (!IsReadyToDraw())
824 return; 923 return;
825 924
826 client_->NotifyReadyToDraw(); 925 NotifyReadyToDraw();
827 did_notify_ready_to_draw_ = true;
828 } 926 }
829 927
830 void TileManager::CheckIfMoreTilesNeedToBePrepared() { 928 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
831 tile_task_runner_->CheckForCompletedTasks(); 929 tile_task_runner_->CheckForCompletedTasks();
832 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 930 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
833 931
834 // When OOM, keep re-assigning memory until we reach a steady state 932 // When OOM, keep re-assigning memory until we reach a steady state
835 // where top-priority tiles are initialized. 933 // where top-priority tiles are initialized.
934 client_->BuildRasterQueue(&raster_priority_queue_,
935 global_state_.tree_priority);
836 TileVector tiles_that_need_to_be_rasterized; 936 TileVector tiles_that_need_to_be_rasterized;
837 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); 937 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
938 scheduled_raster_task_limit_);
939 raster_priority_queue_.Reset();
838 940
839 // |tiles_that_need_to_be_rasterized| will be empty when we reach a 941 // |tiles_that_need_to_be_rasterized| will be empty when we reach a
840 // steady memory state. Keep scheduling tasks until we reach this state. 942 // steady memory state. Keep scheduling tasks until we reach this state.
841 if (!tiles_that_need_to_be_rasterized.empty()) { 943 if (!tiles_that_need_to_be_rasterized.empty()) {
842 ScheduleTasks(tiles_that_need_to_be_rasterized); 944 ScheduleTasks(tiles_that_need_to_be_rasterized);
843 return; 945 return;
844 } 946 }
845 947
846 FreeResourcesForReleasedTiles(); 948 FreeResourcesForReleasedTiles();
847 949
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
932 result -= other; 1034 result -= other;
933 return result; 1035 return result;
934 } 1036 }
935 1037
936 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const { 1038 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
937 return memory_bytes_ > limit.memory_bytes_ || 1039 return memory_bytes_ > limit.memory_bytes_ ||
938 resource_count_ > limit.resource_count_; 1040 resource_count_ > limit.resource_count_;
939 } 1041 }
940 1042
941 } // namespace cc 1043 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698