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..96a13623ec7ed2a434c40ea187886cb89bae4bdb 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() {
@@ -121,6 +124,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,6 +166,18 @@ 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)) {
+      DCHECK(std::find(tasks_required_for_activation_.begin(),

[vmpstr, 2013/06/21 18:38:33]

I don't think we need this dcheck. We already dcheck to ensure
new_pixel_buffer_tasks contains unique tasks above, and we clear the activation
list right above the loop.

[reveman, 2013/06/24 16:04:03]

Done.

+                       tasks_required_for_activation_.end(),
+                       task) == tasks_required_for_activation_.end());
+      tasks_required_for_activation_.insert(task);
+    }
+  }
+
   pixel_buffer_tasks_.swap(new_pixel_buffer_tasks);
 
   // This will schedule more tasks after checking for completed raster
@@ -196,6 +214,11 @@ void PixelBufferRasterWorkerPool::OnRasterTasksFinished() {
   CheckForCompletedRasterTasks();
 }
 
+void PixelBufferRasterWorkerPool::
+    OnRasterTasksRequiredForActivationFinished() {
+  OnRasterTasksFinished();
+}
+
 void PixelBufferRasterWorkerPool::FlushUploads() {
   if (!has_performed_uploads_since_last_flush_)
     return;
@@ -263,6 +286,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 +317,16 @@ void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   CheckForCompletedUploads();
   FlushUploads();
 
-  ScheduleMoreTasks();
+  if (NumPendingRasterTasks())
+    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 (NumPendingRasterTasks() || !tasks_with_pending_upload_.empty())
     ScheduleCheckForCompletedRasterTasks();
+
+  CheckIfFinishedRunningTasks();
+  CheckIfFinishedRunningTasksRequiredForActivation();
 }
 
 void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
@@ -352,7 +381,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 +404,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 +432,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 +443,35 @@ void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
   tasks_with_pending_upload_.push_back(task);
 }
 
+unsigned PixelBufferRasterWorkerPool::NumPendingRasterTasks() const {

[vmpstr, 2013/06/21 18:38:33]

nit: I prefer PendingRasterTaskCount

[reveman, 2013/06/24 16:04:03]

Done.

+  DCHECK_GE(pixel_buffer_tasks_.size(), completed_tasks_.size());
+  return pixel_buffer_tasks_.size() - completed_tasks_.size();
+}
+
+void PixelBufferRasterWorkerPool::CheckIfFinishedRunningTasks() {

[vmpstr, 2013/06/21 18:38:33]

Maybe something like NotifyClientIfFinishedRunningTasks? I think that would
better reflect what the function is doing

[reveman, 2013/06/24 16:04:03]

Done.

+  if (!finished_running_tasks_pending_)
+    return;
+
+  if (NumPendingRasterTasks())
+    return;
+
+  if (tasks_with_pending_upload_.empty())
+    return;
+
+  client()->DidFinishedRunningTasks();
+  finished_running_tasks_pending_ = false;
+}
+
+void PixelBufferRasterWorkerPool::
+    CheckIfFinishedRunningTasksRequiredForActivation() {

[vmpstr, 2013/06/21 18:38:33]

NotifyClient... The function name gets to be a bit too long though.

[reveman, 2013/06/24 16:04:03]

Done.

+  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;
+}
+
 }  // namespace cc