Re-land: cc: Add raster finished signals to RasterWorkerPool.

cc/resources/pixel_buffer_raster_worker_pool.cc

Index: cc/resources/pixel_buffer_raster_worker_pool.cc
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index 2f3e4d2d28c64d67642db1d07f3610f4e5a4a959..1db98d5e502e99a41cc2c7c0f4c67878c67cf11c 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -84,11 +84,14 @@ const size_t kMaxPendingRasterBytes =
 
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
     ResourceProvider* resource_provider,
-    size_t num_threads) : RasterWorkerPool(resource_provider, num_threads),
-                          shutdown_(false),
-                          bytes_pending_upload_(0),
-                          has_performed_uploads_since_last_flush_(false),
-                          check_for_completed_raster_tasks_pending_(false) {
+    size_t num_threads)
+    : RasterWorkerPool(resource_provider, num_threads),
+      shutdown_(false),
+      bytes_pending_upload_(0),
+      has_performed_uploads_since_last_flush_(false),
+      check_for_completed_raster_tasks_pending_(false),
+      finished_running_tasks_pending_(false),
+      finished_running_tasks_required_for_activation_pending_(false) {
 }
 
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
@@ -102,7 +105,10 @@ PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
 void PixelBufferRasterWorkerPool::Shutdown() {
   shutdown_ = true;
   RasterWorkerPool::Shutdown();
-  CheckForCompletedRasterTasks();
+  RasterWorkerPool::CheckForCompletedTasks();
+  CheckForCompletedUploads();
+  check_for_completed_raster_tasks_callback_.Cancel();
+  check_for_completed_raster_tasks_pending_ = false;
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
        it != pixel_buffer_tasks_.end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
@@ -114,6 +120,7 @@ void PixelBufferRasterWorkerPool::Shutdown() {
       completed_tasks_.push_back(task);
     }
   }
+  DCHECK_EQ(completed_tasks_.size(), pixel_buffer_tasks_.size());
 }
 
 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
@@ -121,6 +128,9 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
 
   RasterWorkerPool::SetRasterTasks(queue);
 
+  finished_running_tasks_pending_ = true;
+  finished_running_tasks_required_for_activation_pending_ = true;
+
   // Build new pixel buffer task set.
   TaskMap new_pixel_buffer_tasks;
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
@@ -160,13 +170,31 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
     }
   }
 
+  tasks_required_for_activation_.clear();
+  for (TaskMap::iterator it = new_pixel_buffer_tasks.begin();
+       it != new_pixel_buffer_tasks.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = it->first;
+    if (IsRasterTaskRequiredForActivation(task))
+      tasks_required_for_activation_.insert(task);
+  }
+
   pixel_buffer_tasks_.swap(new_pixel_buffer_tasks);
 
-  // This will schedule more tasks after checking for completed raster
-  // tasks. It's worth checking for completed tasks when ScheduleTasks()
-  // is called as priorities might have changed and this allows us to
-  // schedule as many new top priority tasks as possible.
-  CheckForCompletedRasterTasks();
+  // Check for completed tasks when ScheduleTasks() is called as
+  // priorities might have changed and this maximizes the number
+  // of top priority tasks that are scheduled.
+  RasterWorkerPool::CheckForCompletedTasks();
+  CheckForCompletedUploads();
+  FlushUploads();
+
+  // Schedule new tasks.
+  ScheduleMoreTasks();
+
+  // Cancel any pending check for completed raster tasks and schedule
+  // another check.
+  check_for_completed_raster_tasks_callback_.Cancel();
+  check_for_completed_raster_tasks_pending_ = false;
+  ScheduleCheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
@@ -176,8 +204,11 @@ void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
   CheckForCompletedUploads();
   FlushUploads();
 
-  while (!completed_tasks_.empty()) {
-    internal::RasterWorkerPoolTask* task = completed_tasks_.front().get();
+  TaskDeque completed_tasks;
+  completed_tasks_.swap(completed_tasks);
+
+  while (!completed_tasks.empty()) {
+    internal::RasterWorkerPoolTask* task = completed_tasks.front().get();
     DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
     pixel_buffer_tasks_.erase(task);
@@ -185,7 +216,7 @@ void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
     task->DidComplete();
     task->DispatchCompletionCallback();
 
-    completed_tasks_.pop_front();
+    completed_tasks.pop_front();
   }
 }
 
@@ -196,6 +227,12 @@ void PixelBufferRasterWorkerPool::OnRasterTasksFinished() {
   CheckForCompletedRasterTasks();
 }
 
+void PixelBufferRasterWorkerPool::OnRasterTasksRequiredForActivationFinished() {
+  if (tasks_required_for_activation_.empty())
+    return;
+  OnRasterTasksFinished();
+}
+
 void PixelBufferRasterWorkerPool::FlushUploads() {
   if (!has_performed_uploads_since_last_flush_)
     return;
@@ -263,6 +300,8 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
                      task) == completed_tasks_.end());
     completed_tasks_.push_back(task);
 
+    tasks_required_for_activation_.erase(task);
+
     tasks_with_completed_uploads.pop_front();
   }
 }
@@ -292,12 +331,16 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   CheckForCompletedUploads();
   FlushUploads();
 
-  ScheduleMoreTasks();
+  if (PendingRasterTaskCount())
+    ScheduleMoreTasks();
 
-  // Make sure another check for completed uploads is scheduled
-  // while there is still pending uploads left.
-  if (!tasks_with_pending_upload_.empty())
+  // Schedule another check for completed raster tasks while there are
+  // pending raster tasks or pending uploads.
+  if (PendingRasterTaskCount() || !tasks_with_pending_upload_.empty())
     ScheduleCheckForCompletedRasterTasks();
+
+  NotifyClientIfFinishedRunningTasksRequiredForActivation();
+  NotifyClientIfFinishedRunningTasks();
 }
 
 void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
@@ -352,7 +395,9 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
 
     // Use existing pixel buffer task if available.
     if (pixel_buffer_task) {
-      graph.InsertRasterTask(pixel_buffer_task, task->dependencies());
+      graph.InsertRasterTask(pixel_buffer_task,
+                             task->dependencies(),
+                             IsRasterTaskRequiredForActivation(task));
       continue;
     }
 
@@ -373,16 +418,12 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
                        base::Unretained(this),
                        make_scoped_refptr(task))));
     pixel_buffer_tasks_[task] = new_pixel_buffer_task;
-    graph.InsertRasterTask(new_pixel_buffer_task.get(), task->dependencies());
+    graph.InsertRasterTask(new_pixel_buffer_task.get(),
+                           task->dependencies(),
+                           IsRasterTaskRequiredForActivation(task));
   }
 
   SetRasterTaskGraph(&graph);
-
-  // At least one task that could need an upload is now pending, schedule
-  // a check for completed raster tasks to ensure this upload is dispatched
-  // without too much latency.
-  if (bytes_pending_raster)
-    ScheduleCheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
@@ -405,6 +446,7 @@ void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
                      completed_tasks_.end(),
                      task) == completed_tasks_.end());
     completed_tasks_.push_back(task);
+    tasks_required_for_activation_.erase(task);
     return;
   }
 
@@ -415,4 +457,37 @@ void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
   tasks_with_pending_upload_.push_back(task);
 }
 
+unsigned PixelBufferRasterWorkerPool::PendingRasterTaskCount() const {
+  unsigned num_completed_raster_tasks =
+      tasks_with_pending_upload_.size() + completed_tasks_.size();
+  DCHECK_GE(pixel_buffer_tasks_.size(), num_completed_raster_tasks);
+  return pixel_buffer_tasks_.size() - num_completed_raster_tasks;
+}
+
+void PixelBufferRasterWorkerPool::
+    NotifyClientIfFinishedRunningTasksRequiredForActivation() {
+  if (!finished_running_tasks_required_for_activation_pending_)
+    return;
+
+  if (!tasks_required_for_activation_.empty())
+    return;
+
+  client()->DidFinishedRunningTasksRequiredForActivation();
+  finished_running_tasks_required_for_activation_pending_ = false;
+}
+
+void PixelBufferRasterWorkerPool::NotifyClientIfFinishedRunningTasks() {
+  if (!finished_running_tasks_pending_)
+    return;
+
+  if (PendingRasterTaskCount())
+    return;
+
+  if (!tasks_with_pending_upload_.empty())
+    return;
+
+  client()->DidFinishedRunningTasks();
+  finished_running_tasks_pending_ = false;
+}
+
 }  // namespace cc