Delay activation/draw on GPU tile work completion

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 330 matching lines @@
                     base::saturated_cast<int>(stats.canceled_count));
   return std::move(state);
 }
 
 TileManager::TileManager(TileManagerClient* client,
                          base::SequencedTaskRunner* task_runner,
                          size_t scheduled_raster_task_limit,
                          bool use_partial_raster)
     : client_(client),
       task_runner_(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_,
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_,
                               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) {}
+      task_set_finished_weak_ptr_factory_(this),
+      weak_ptr_factory_(this) {}
 
 TileManager::~TileManager() {
   FinishTasksAndCleanUp();
 }
 
 void TileManager::FinishTasksAndCleanUp() {
   if (!tile_task_manager_)
     return;
 
   global_state_ = GlobalStateThatImpactsTilePriority();
@@ skipping 10 matching lines @@
   orphan_tasks_.clear();
 
   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();
+  weak_ptr_factory_.InvalidateWeakPtrs();
 
   image_manager_.SetImageDecodeController(nullptr);
   locked_image_tasks_.clear();
 }
 
 void TileManager::SetResources(ResourcePool* resource_pool,
                                ImageDecodeController* image_decode_controller,
                                TaskGraphRunner* task_graph_runner,
                                RasterBufferProvider* raster_buffer_provider,
                                size_t scheduled_raster_task_limit,
@@ skipping 33 matching lines @@
     delete tile;
   }
   released_tiles_.swap(tiles_to_retain);
 }
 
 void TileManager::DidFinishRunningTileTasksRequiredForActivation() {
   TRACE_EVENT0("cc",
                "TileManager::DidFinishRunningTileTasksRequiredForActivation");
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
+
+  // In SMOOTHNESS_TAKES_PRIORITY, we want to wait on all required for
+  // activation

[vmpstr, 2016/12/07 21:00:25]

nit: reformat plz

+  // resources being ready to draw (from the RasterBufferProvider's perspective)
+  // before activating. Depending on the RasterBufferProvider, this may involve
+  // waiting on a GL sync token for GPU work to complete.
+  if (global_state_.tree_priority == SMOOTHNESS_TAKES_PRIORITY) {
+    // Build a list of all resources required for activation.
+    ResourceProvider::ResourceIdArray array;

[vmpstr, 2016/12/07 21:00:25]

nit: resource_ids

+    auto raster_priority_queue(client_->BuildRasterQueue(

[vmpstr, 2016/12/07 21:00:25]

nit: I kinda prefer = instead of ()

+        global_state_.tree_priority,
+        RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
+    for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
+      const TileDrawInfo& draw_info =
+          raster_priority_queue->Top().tile()->draw_info();
+      if (!draw_info.has_resource()) {

[vmpstr, 2016/12/07 21:00:25]

Can you verify that OOM case is still handled. I think it should be in all tiles
finished that we mark tiles as oom, so it should be OK (also might be special
logic in smoothness mode). However, if OOM tiles block activation because of
this, it isn't good :)

+        // If we encounter any required for activation tile with a missing
+        // resource, more raster tasks need to be scheduled to activate, so
+        // there's no reason to wait on a callback yet.
+        return;
+      }
+      array.push_back(draw_info.resource_id());
+    }
+
+    // Enqueue a callback which will be triggered when all resources in |array|
+    // are ready for draw.
+    pending_activation_callback_id_ =
+        raster_buffer_provider_->SetReadyToDrawCallback(
+            array,
+            base::Bind(&TileManager::RequiredForActivationTilesAreReadyToDraw,
+                       weak_ptr_factory_.GetWeakPtr()),
+            pending_activation_callback_id_);
+
+    if (pending_activation_callback_id_ != 0) {
+      // We need to wait on the callback, don't schedule any notifications.
+      return;
+    }
+  }
+
   // TODO(vmpstr): Temporary check to debug crbug.com/642927.
   CHECK(tile_task_manager_);
   signals_.ready_to_activate = true;
   signals_check_notifier_.Schedule();
 }
 
 void TileManager::DidFinishRunningTileTasksRequiredForDraw() {
   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTileTasksRequiredForDraw");
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
@@ skipping 346 matching lines @@
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
   }
 
   // Cancel existing OnTaskSetFinished callbacks.
   task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Even when scheduling an empty set of tiles, the TTWP does some work, and
   // will always trigger a DidFinishRunningTileTasks notification. Because of
   // this we unconditionally set |has_scheduled_tile_tasks_| to true.
   has_scheduled_tile_tasks_ = true;
+  // And reset |pending_activation_callback_id_|.
+  pending_activation_callback_id_ = 0;
 
   // Track the number of dependents for each *_done task.
   size_t required_for_activate_count = 0;
   size_t required_for_draw_count = 0;
   size_t all_count = 0;
 
   size_t priority = kTileTaskPriorityBase;
 
   graph_.Reset();
 
@@ skipping 267 matching lines @@
     Tile* tile = all_queue->Top().tile();
     DCHECK(!tile->required_for_activation() ||
            tile->draw_info().IsReadyToDraw());
   }
 #endif
   return true;
 }
 
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
-  return AreRequiredTilesReadyToDraw(
-      RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
+  return pending_activation_callback_id_ == 0 &&
+         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");
@@ skipping 146 matching lines @@
                     signals_.all_tile_tasks_completed);
   state->EndDictionary();
   return std::move(state);
 }
 
 bool TileManager::UsePartialRaster() const {
   return use_partial_raster_ &&
          raster_buffer_provider_->CanPartialRasterIntoProvidedResource();
 }
 
+void TileManager::RequiredForActivationTilesAreReadyToDraw(
+    uint64_t callback_id) {
+  if (pending_activation_callback_id_ != callback_id) {
+    // This callback has already been superceded by a new one. Ignore it.
+    return;
+  }
+
+  pending_activation_callback_id_ = 0;
+  signals_.ready_to_activate = true;
+  signals_check_notifier_.Schedule();
+}
+
 // 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)()) {
   return make_scoped_refptr(new TaskSetFinishedTaskImpl(
       task_runner_,
       base::Bind(callback, task_set_finished_weak_ptr_factory_.GetWeakPtr())));
 }
 
 TileManager::MemoryUsage::MemoryUsage()
@@ skipping 71 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc