cc: Send notification of tasks completion directly without scheduling.

cc/tiles/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 309 matching lines @@
     : client_(client),
       task_runner_(std::move(task_runner)),
       resource_pool_(nullptr),
       tile_task_manager_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       use_partial_raster_(use_partial_raster),
       use_gpu_rasterization_(false),
       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),
       task_set_finished_weak_ptr_factory_(this) {}
 
 TileManager::~TileManager() {
   FinishTasksAndCleanUp();
 }
 
 void TileManager::FinishTasksAndCleanUp() {
@@ skipping 10 matching lines @@
   // |orphan_tasks_|.
   orphan_tasks_.clear();
 
   tile_task_manager_->CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
   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();
 }
 
 void TileManager::SetResources(ResourcePool* resource_pool,
                                ImageDecodeController* image_decode_controller,
                                TileTaskManager* tile_task_manager,
                                size_t scheduled_raster_task_limit,
                                bool use_gpu_rasterization) {
   DCHECK(!tile_task_manager_);
   DCHECK(tile_task_manager);
@@ skipping 24 matching lines @@
 
     DCHECK(!tile->draw_info().has_resource());
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
     delete tile;
   }
   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(
     const GlobalStateThatImpactsTilePriority& state) {
   ++prepare_tiles_count_;
 
   TRACE_EVENT1("cc", "TileManager::PrepareTiles", "prepare_tiles_id",
                prepare_tiles_count_);
 
   if (!tile_task_manager_) {
     TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  signals_.reset();
   global_state_ = state;
 
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
     tile_task_manager_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
   FreeResourcesForReleasedTiles();
@@ skipping 173 matching lines @@
         tile->draw_info().set_solid_color(color);
         tile->draw_info().set_was_ever_ready_to_draw();
         if (!tile_is_needed_now)
           tile->draw_info().set_was_a_prepaint_tile();
         client_->NotifyTileStateChanged(tile);
         continue;
       }
     }
 
     // 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 and scheduled_raster_task_limit
= 1, it makes all_tiles_that_need_to_be_rasterized_are_scheduled_ false which
causes another iteration of scheduling.

         scheduled_raster_task_limit) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     tile->scheduled_priority_ = schedule_priority++;
 
     DCHECK(tile->draw_info().mode() == TileDrawInfo::OOM_MODE ||
            !tile->draw_info().IsReadyToDraw());
 
@@ skipping 202 matching lines @@
   // been called.
   orphan_tasks_.clear();
 
   // It's also now safe to replace our *_done_task_ tasks.
   required_for_activation_done_task_ =
       std::move(required_for_activation_done_task);
   required_for_draw_done_task_ = std::move(required_for_draw_done_task);
   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(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
   // Get the resource.
   uint64_t resource_content_id = 0;
   Resource* resource = nullptr;
   if (use_partial_raster_ && tile->invalidated_id()) {
@@ skipping 147 matching lines @@
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 }
 
 bool TileManager::IsReadyToDraw() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToDraw");
   return AreRequiredTilesReadyToDraw(
       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;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   PrioritizedTileVector tiles_that_need_to_be_rasterized;
   std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
@@ skipping 11 matching lines @@
   if (!tiles_that_need_to_be_rasterized.empty()) {
     ScheduleTasks(tiles_that_need_to_be_rasterized);
     return;
   }
 
   FreeResourcesForReleasedTiles();
 
   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.
   // Likewise if we don't allow any tiles (as is the case when we're
   // invisible), if we have tiles that aren't ready, then we shouldn't
   // activate as activation can cause checkerboards.
   bool wait_for_all_required_tiles =
       global_state_.tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
       global_state_.memory_limit_policy == ALLOW_NOTHING;
 
   // If we have tiles left to raster for activation, and we don't allow
   // activating without them, then skip activation and return early.
   if (wait_for_all_required_tiles)
     return;
 
   // Mark any required tiles that have not been been assigned memory after
   // reaching a steady memory state as OOM. This ensures that we activate/draw
   // even when OOM. Note that we can't reuse the queue we used for
   // AssignGpuMemoryToTiles, since the AssignGpuMemoryToTiles call could have
   // evicted some tiles that would not be picked up by the old raster queue.
   bool need_to_signal_activate = MarkTilesOutOfMemory(client_->BuildRasterQueue(
       global_state_.tree_priority,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
   bool need_to_signal_draw = MarkTilesOutOfMemory(client_->BuildRasterQueue(
       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 function to be called once.

+
+  if (need_to_signal_draw)
+    CheckAndNotifyReadyToDraw();
+
+  CheckAndNotifyAllTileTasksCompleted();
 }
 
 bool TileManager::MarkTilesOutOfMemory(
     std::unique_ptr<RasterTilePriorityQueue> queue) const {
   // Mark required tiles as OOM so that we can activate/draw without them.
   if (queue->IsEmpty())
     return false;
 
   for (; !queue->IsEmpty(); queue->Pop()) {
     Tile* tile = queue->Top().tile();
     if (tile->draw_info().IsReadyToDraw())
       continue;
     tile->draw_info().set_oom();
     client_->NotifyTileStateChanged(tile);
   }
   return true;
 }
 
 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
   return tile_task_manager_->GetRasterBufferProvider()->GetResourceFormat(
       !tile->is_opaque());
 }
 
 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
   return tile_task_manager_->GetRasterBufferProvider()
       ->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()
     : memory_bytes_(0), resource_count_(0) {}
 
 TileManager::MemoryUsage::MemoryUsage(size_t memory_bytes,
                                       size_t resource_count)
     : memory_bytes_(static_cast<int64_t>(memory_bytes)),
       resource_count_(static_cast<int>(resource_count)) {
   // MemoryUsage is constructed using size_ts, since it deals with memory and
@@ skipping 45 matching lines @@
   MemoryUsage result = *this;
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          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