Index: cc/tiles/tile_manager.cc |
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc |
index 73098a6fe881a35f91133340b29c9de9a1da1a46..78acf303a79522b4368515339f28b7e1a3a990a3 100644 |
--- a/cc/tiles/tile_manager.cc |
+++ b/cc/tiles/tile_manager.cc |
@@ -327,13 +327,6 @@ TileManager::TileManager(TileManagerClient* client, |
all_tiles_that_need_to_be_rasterized_are_scheduled_(true), |
did_check_for_completed_tasks_since_last_schedule_tasks_(true), |
did_oom_on_last_assign_(false), |
- more_tiles_need_prepare_check_notifier_( |
- task_runner_.get(), |
- base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared, |
- base::Unretained(this))), |
- signals_check_notifier_(task_runner_.get(), |
- base::Bind(&TileManager::CheckAndIssueSignals, |
- base::Unretained(this))), |
has_scheduled_tile_tasks_(false), |
prepare_tiles_count_(0u), |
next_tile_id_(0u), |
@@ -364,8 +357,6 @@ void TileManager::FinishTasksAndCleanUp() { |
tile_task_manager_ = nullptr; |
resource_pool_ = nullptr; |
- more_tiles_need_prepare_check_notifier_.Cancel(); |
- signals_check_notifier_.Cancel(); |
task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs(); |
} |
@@ -410,45 +401,51 @@ void TileManager::CleanUpReleasedTiles() { |
released_tiles_.swap(tiles_to_retain); |
} |
-void TileManager::DidFinishRunningTileTasksRequiredForActivation() { |
+void TileManager::DidFinishRunningTileTasksRequiredForActivation( |
+ uint64_t source_prepare_tiles_id) { |
TRACE_EVENT0("cc", |
"TileManager::DidFinishRunningTileTasksRequiredForActivation"); |
- TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", |
- ScheduledTasksStateAsValue()); |
- signals_.ready_to_activate = true; |
- signals_check_notifier_.Schedule(); |
+ |
+ // Check if there is another request to PrepareTiles(). |
+ if (prepare_tiles_count_ != source_prepare_tiles_id) |
+ return; |
+ |
+ CheckAndNotifyReadyToActivate(); |
} |
-void TileManager::DidFinishRunningTileTasksRequiredForDraw() { |
+void TileManager::DidFinishRunningTileTasksRequiredForDraw( |
+ uint64_t source_prepare_tiles_id) { |
TRACE_EVENT0("cc", "TileManager::DidFinishRunningTileTasksRequiredForDraw"); |
- TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", |
- ScheduledTasksStateAsValue()); |
- signals_.ready_to_draw = true; |
- signals_check_notifier_.Schedule(); |
+ |
+ // Check if there is another request to PrepareTiles(). |
+ if (prepare_tiles_count_ != source_prepare_tiles_id) |
+ return; |
+ |
+ CheckAndNotifyReadyToDraw(); |
} |
-void TileManager::DidFinishRunningAllTileTasks() { |
+void TileManager::DidFinishRunningAllTileTasks( |
+ uint64_t source_prepare_tiles_id) { |
TRACE_EVENT0("cc", "TileManager::DidFinishRunningAllTileTasks"); |
- TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this); |
- DCHECK(resource_pool_); |
- DCHECK(tile_task_manager_); |
+ |
+ // Check if there is another request to PrepareTiles(). |
+ if (prepare_tiles_count_ != source_prepare_tiles_id) |
+ return; |
has_scheduled_tile_tasks_ = false; |
+ DCHECK(resource_pool_); |
+ |
bool memory_usage_above_limit = resource_pool_->memory_usage_bytes() > |
global_state_.soft_memory_limit_in_bytes; |
if (all_tiles_that_need_to_be_rasterized_are_scheduled_ && |
!memory_usage_above_limit) { |
- // TODO(ericrk): We should find a better way to safely handle re-entrant |
- // notifications than always having to schedule a new task. |
- // http://crbug.com/498439 |
- signals_.all_tile_tasks_completed = true; |
- signals_check_notifier_.Schedule(); |
+ CheckAndNotifyAllTileTasksCompleted(); |
return; |
} |
- more_tiles_need_prepare_check_notifier_.Schedule(); |
+ CheckIfMoreTilesNeedToBePrepared(); |
} |
bool TileManager::PrepareTiles( |
@@ -464,7 +461,6 @@ bool TileManager::PrepareTiles( |
return false; |
} |
- signals_.reset(); |
global_state_ = state; |
// We need to call CheckForCompletedTasks() once in-between each call |
@@ -658,7 +654,7 @@ void TileManager::AssignGpuMemoryToTiles( |
} |
// We won't be able to schedule this tile, so break out early. |
- if (tiles_that_need_to_be_rasterized->size() >= |
+ if (tiles_that_need_to_be_rasterized->size() > |
prashant.n
2016/05/27 14:29:22
If size of tiles_that_need_to_be_rasterized = 1 an
|
scheduled_raster_task_limit) { |
all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; |
break; |
@@ -881,9 +877,6 @@ void TileManager::ScheduleTasks( |
all_done_task_ = std::move(all_done_task); |
did_check_for_completed_tasks_since_last_schedule_tasks_ = false; |
- |
- TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", |
- ScheduledTasksStateAsValue()); |
} |
scoped_refptr<TileTask> TileManager::CreateRasterTask( |
@@ -1051,48 +1044,56 @@ bool TileManager::IsReadyToDraw() const { |
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW); |
} |
-void TileManager::CheckAndIssueSignals() { |
- TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals"); |
+void TileManager::CheckAndNotifyReadyToActivate() { |
+ TRACE_EVENT0("cc", "TileManager::CheckAndNotifyReadyToActivate"); |
+ DCHECK(tile_task_manager_); |
+ |
tile_task_manager_->CheckForCompletedTasks(); |
did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
// Ready to activate. |
- if (signals_.ready_to_activate && !signals_.did_notify_ready_to_activate) { |
- signals_.ready_to_activate = false; |
- if (IsReadyToActivate()) { |
- TRACE_EVENT0("disabled-by-default-cc.debug", |
- "TileManager::CheckAndIssueSignals - ready to activate"); |
- signals_.did_notify_ready_to_activate = true; |
- client_->NotifyReadyToActivate(); |
- } |
+ if (IsReadyToActivate()) { |
+ TRACE_EVENT0( |
+ "disabled-by-default-cc.debug", |
+ "TileManager::CheckAndNotifyReadyToActivate - ready to activate"); |
+ client_->NotifyReadyToActivate(); |
} |
+} |
+void TileManager::CheckAndNotifyReadyToDraw() { |
+ TRACE_EVENT0("cc", "TileManager::CheckAndNotifyReadyToDraw"); |
+ |
+ DCHECK(tile_task_manager_); |
+ |
+ tile_task_manager_->CheckForCompletedTasks(); |
+ did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
// Ready to draw. |
- if (signals_.ready_to_draw && !signals_.did_notify_ready_to_draw) { |
- signals_.ready_to_draw = false; |
- if (IsReadyToDraw()) { |
- TRACE_EVENT0("disabled-by-default-cc.debug", |
- "TileManager::CheckAndIssueSignals - ready to draw"); |
- signals_.did_notify_ready_to_draw = true; |
- client_->NotifyReadyToDraw(); |
- } |
+ if (IsReadyToDraw()) { |
+ TRACE_EVENT0("disabled-by-default-cc.debug", |
+ "TileManager::CheckAndNotifyReadyToDraw - ready to draw"); |
+ client_->NotifyReadyToDraw(); |
} |
+} |
+ |
+void TileManager::CheckAndNotifyAllTileTasksCompleted() { |
+ TRACE_EVENT0("cc", "TileManager::CheckAndNotifyAllTileTasksCompleted"); |
+ |
+ DCHECK(tile_task_manager_); |
+ tile_task_manager_->CheckForCompletedTasks(); |
+ did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
// All tile tasks completed. |
- if (signals_.all_tile_tasks_completed && |
- !signals_.did_notify_all_tile_tasks_completed) { |
- signals_.all_tile_tasks_completed = false; |
- if (!has_scheduled_tile_tasks_) { |
- TRACE_EVENT0( |
- "disabled-by-default-cc.debug", |
- "TileManager::CheckAndIssueSignals - all tile tasks completed"); |
- signals_.did_notify_all_tile_tasks_completed = true; |
- client_->NotifyAllTileTasksCompleted(); |
- } |
+ if (!has_scheduled_tile_tasks_) { |
+ TRACE_EVENT0("disabled-by-default-cc.debug", |
+ "TileManager::CheckAndNotifyAllTileTasksCompleted - all tile " |
+ "tasks completed"); |
+ client_->NotifyAllTileTasksCompleted(); |
} |
} |
void TileManager::CheckIfMoreTilesNeedToBePrepared() { |
+ DCHECK(tile_task_manager_); |
+ |
tile_task_manager_->CheckForCompletedTasks(); |
did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
@@ -1124,9 +1125,6 @@ void TileManager::CheckIfMoreTilesNeedToBePrepared() { |
resource_pool_->ReduceResourceUsage(); |
image_decode_controller_->ReduceCacheUsage(); |
- signals_.all_tile_tasks_completed = true; |
- signals_check_notifier_.Schedule(); |
- |
// We don't reserve memory for required-for-activation tiles during |
// accelerated gestures, so we just postpone activation when we don't |
// have these tiles, and activate after the accelerated gesture. |
@@ -1154,13 +1152,13 @@ void TileManager::CheckIfMoreTilesNeedToBePrepared() { |
global_state_.tree_priority, |
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW)); |
- DCHECK(IsReadyToActivate()); |
- DCHECK(IsReadyToDraw()); |
- signals_.ready_to_activate = need_to_signal_activate; |
- signals_.ready_to_draw = need_to_signal_draw; |
- // TODO(ericrk): Investigate why we need to schedule this (not just call it |
- // inline). http://crbug.com/498439 |
- signals_check_notifier_.Schedule(); |
+ if (need_to_signal_activate) |
+ CheckAndNotifyReadyToActivate(); |
prashant.n
2016/05/27 14:29:22
I'll remove checking of completed tasks to common
|
+ |
+ if (need_to_signal_draw) |
+ CheckAndNotifyReadyToDraw(); |
+ |
+ CheckAndNotifyAllTileTasksCompleted(); |
} |
bool TileManager::MarkTilesOutOfMemory( |
@@ -1189,26 +1187,14 @@ bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const { |
->GetResourceRequiresSwizzle(!tile->is_opaque()); |
} |
-std::unique_ptr<base::trace_event::ConvertableToTraceFormat> |
-TileManager::ScheduledTasksStateAsValue() const { |
- std::unique_ptr<base::trace_event::TracedValue> state( |
- new base::trace_event::TracedValue()); |
- state->BeginDictionary("tasks_pending"); |
- state->SetBoolean("ready_to_activate", signals_.ready_to_activate); |
- state->SetBoolean("ready_to_draw", signals_.ready_to_draw); |
- state->SetBoolean("all_tile_tasks_completed", |
- signals_.all_tile_tasks_completed); |
- state->EndDictionary(); |
- return std::move(state); |
-} |
- |
// Utility function that can be used to create a "Task set finished" task that |
// posts |callback| to |task_runner| when run. |
scoped_refptr<TileTask> TileManager::CreateTaskSetFinishedTask( |
- void (TileManager::*callback)()) { |
+ void (TileManager::*callback)(uint64_t source_prepare_tiles_id)) { |
return make_scoped_refptr(new TaskSetFinishedTaskImpl( |
task_runner_.get(), |
- base::Bind(callback, task_set_finished_weak_ptr_factory_.GetWeakPtr()))); |
+ base::Bind(callback, task_set_finished_weak_ptr_factory_.GetWeakPtr(), |
+ prepare_tiles_count_))); |
} |
TileManager::MemoryUsage::MemoryUsage() |
@@ -1274,17 +1260,4 @@ bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const { |
resource_count_ > limit.resource_count_; |
} |
-TileManager::Signals::Signals() { |
- reset(); |
-} |
- |
-void TileManager::Signals::reset() { |
- ready_to_activate = false; |
- did_notify_ready_to_activate = false; |
- ready_to_draw = false; |
- did_notify_ready_to_draw = false; |
- all_tile_tasks_completed = false; |
- did_notify_all_tile_tasks_completed = false; |
-} |
- |
} // namespace cc |