cc: Move task graph construction to RasterWorkerPool classes.

cc/resources/pixel_buffer_raster_worker_pool.cc

 // Copyright 2013 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/resources/pixel_buffer_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/resources/resource.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 
 namespace {
 
 class PixelBufferWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   typedef base::Callback<void(bool was_canceled, bool needs_upload)> Reply;
 
   PixelBufferWorkerPoolTaskImpl(internal::RasterWorkerPoolTask* task,
-                                TaskVector* dependencies,
                                 uint8_t* buffer,
                                 const Reply& reply)
-      : internal::WorkerPoolTask(dependencies),
-        task_(task),
+      : task_(task),
         buffer_(buffer),
         reply_(reply),
         needs_upload_(false) {
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnThread(unsigned thread_index) OVERRIDE {
     // |buffer_| can be NULL in lost context situations.
     if (!buffer_) {
       // |needs_upload_| still needs to be true as task has not
@@ skipping 48 matching lines @@
     kMaxBytesUploadedPerMs * kCheckForCompletedRasterTasksDelayMs;
 
 }  // namespace
 
 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),
-                          weak_ptr_factory_(this),
-                          schedule_more_tasks_count_(0) {
+                          check_for_completed_raster_tasks_pending_(false) {
 }
 
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK(shutdown_);
   DCHECK(!check_for_completed_raster_tasks_pending_);
   DCHECK_EQ(0u, pixel_buffer_tasks_.size());
   DCHECK_EQ(0u, tasks_with_pending_upload_.size());
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
 void PixelBufferRasterWorkerPool::Shutdown() {
   shutdown_ = true;
   RasterWorkerPool::Shutdown();
   CheckForCompletedRasterTasks();
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
        it != pixel_buffer_tasks_.end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
     internal::WorkerPoolTask* pixel_buffer_task = it->second.get();
 
     // All inactive tasks needs to be canceled.
     if (!pixel_buffer_task && !task->HasFinishedRunning()) {
       task->DidRun(true);
       completed_tasks_.push_back(task);
     }
   }
-  // Cancel any pending OnRasterFinished callback.
-  weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks");
 
   RasterWorkerPool::SetRasterTasks(queue);
 
   // Build new pixel buffer task set.
   TaskMap new_pixel_buffer_tasks;
-  for (RasterTask::Queue::TaskVector::const_iterator it =
-           raster_tasks().begin();
+  for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(new_pixel_buffer_tasks.find(task) == new_pixel_buffer_tasks.end());
     DCHECK(!task->HasCompleted());
 
     // Use existing pixel buffer task if available.
     TaskMap::iterator pixel_buffer_it = pixel_buffer_tasks_.find(task);
     if (pixel_buffer_it == pixel_buffer_tasks_.end()) {
       new_pixel_buffer_tasks[task] = NULL;
       continue;
@@ skipping 45 matching lines @@
 
     pixel_buffer_tasks_.erase(task);
 
     task->DidComplete();
     task->DispatchCompletionCallback();
 
     completed_tasks_.pop_front();
   }
 }
 
+void PixelBufferRasterWorkerPool::OnRasterTasksFinished() {
+  // Call CheckForCompletedTasks() when we've finished running all raster
+  // tasks needed since last time ScheduleMoreTasks() was called. This
+  // reduces latency when processing only a small number of raster tasks.
+  CheckForCompletedRasterTasks();
+}
+
 void PixelBufferRasterWorkerPool::FlushUploads() {
   if (!has_performed_uploads_since_last_flush_)
     return;
 
   resource_provider()->ShallowFlushIfSupported();
   has_performed_uploads_since_last_flush_ = false;
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
   TaskDeque tasks_with_completed_uploads;
@@ skipping 90 matching lines @@
   if (!tasks_with_pending_upload_.empty())
     ScheduleCheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
   size_t bytes_pending_upload = bytes_pending_upload_;
   size_t bytes_pending_raster = 0;
 
-  internal::WorkerPoolTask::TaskVector tasks;
-
-  for (RasterTask::Queue::TaskVector::const_iterator it =
-           raster_tasks().begin();
+  RasterTaskGraph graph;
+  for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
 
     // |pixel_buffer_tasks_| contains all tasks that have not yet completed.
     TaskMap::iterator pixel_buffer_it = pixel_buffer_tasks_.find(task);
     if (pixel_buffer_it == pixel_buffer_tasks_.end())
       continue;
 
     // HasFinishedRunning() will return true when set pixels has completed.
     if (task->HasFinishedRunning()) {
@@ skipping 24 matching lines @@
     if (new_bytes_pending_raster > kMaxPendingRasterBytes)
       break;
 
     // Update both |bytes_pending_raster| and |bytes_pending_upload|
     // now that task has cleared all throttling limits.
     bytes_pending_raster = new_bytes_pending_raster;
     bytes_pending_upload = new_bytes_pending_upload;
 
     // Use existing pixel buffer task if available.
     if (pixel_buffer_task) {
-      DCHECK(!pixel_buffer_task->HasCompleted());
-      tasks.push_back(pixel_buffer_task);
+      graph.InsertRasterTask(pixel_buffer_task, task->dependencies());
       continue;
     }
 
     // Request a pixel buffer. This will reserve shared memory.
     resource_provider()->AcquirePixelBuffer(task->resource()->id());
 
     // MapPixelBuffer() returns NULL if context was lost at the time
     // AcquirePixelBuffer() was called. For simplicity we still post
     // a raster task that is essentially a noop in these situations.
     uint8* buffer = resource_provider()->MapPixelBuffer(
         task->resource()->id());
 
-    // TODO(reveman): Avoid having to make a copy of dependencies.
-    internal::WorkerPoolTask::TaskVector dependencies = task->dependencies();
     scoped_refptr<internal::WorkerPoolTask> new_pixel_buffer_task(
         new PixelBufferWorkerPoolTaskImpl(
             task,
-            &dependencies,
             buffer,
             base::Bind(&PixelBufferRasterWorkerPool::OnRasterTaskCompleted,
                        base::Unretained(this),
                        make_scoped_refptr(task))));
-
     pixel_buffer_tasks_[task] = new_pixel_buffer_task;
-    tasks.push_back(new_pixel_buffer_task);
+    graph.InsertRasterTask(new_pixel_buffer_task.get(), task->dependencies());
   }
 
-  ++schedule_more_tasks_count_;
-
-  // We need to make sure not to schedule a check for completed raster
-  // tasks when |tasks| is empty as that would cause us to never stop
-  // checking.
-  if (tasks.empty()) {
-    ScheduleRasterTasks(RootTask());
-    return;
-  }
-
-  RootTask root(
-      base::Bind(&PixelBufferRasterWorkerPool::RunRasterFinishedTask,
-                 base::MessageLoopProxy::current(),
-                 base::Bind(&PixelBufferRasterWorkerPool::OnRasterFinished,
-                            weak_ptr_factory_.GetWeakPtr(),
-                            schedule_more_tasks_count_)),
-                &tasks);
-  ScheduleRasterTasks(root);
+  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.
-  ScheduleCheckForCompletedRasterTasks();
+  if (bytes_pending_raster)
+    ScheduleCheckForCompletedRasterTasks();
 }
 
 void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
     bool was_canceled,
     bool needs_upload) {
   TRACE_EVENT2("cc", "PixelBufferRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled,
                "needs_upload", needs_upload);
 
@@ skipping 12 matching lines @@
     return;
   }
 
   resource_provider()->BeginSetPixels(task->resource()->id());
   has_performed_uploads_since_last_flush_ = true;
 
   bytes_pending_upload_ += task->resource()->bytes();
   tasks_with_pending_upload_.push_back(task);
 }
 
-void PixelBufferRasterWorkerPool::OnRasterFinished(
-    int64 schedule_more_tasks_count) {
-  TRACE_EVENT1("cc",
-               "PixelBufferRasterWorkerPool::OnRasterFinishedTasks",
-               "schedule_more_tasks_count", schedule_more_tasks_count);
-  DCHECK_GE(schedule_more_tasks_count_, schedule_more_tasks_count);
-  // Call CheckForCompletedTasks() when we've finished running all raster
-  // tasks needed since last time ScheduleMoreTasks() was called. This
-  // reduces latency when processing only a small number of raster tasks.
-  if (schedule_more_tasks_count_ == schedule_more_tasks_count)
-    CheckForCompletedRasterTasks();
-}
-
-// static
-void PixelBufferRasterWorkerPool::RunRasterFinishedTask(
-    scoped_refptr<base::MessageLoopProxy> origin_loop,
-    const base::Closure& on_raster_finished_callback) {
-  TRACE_EVENT0("cc", "RasterWorkerPool::RunRasterFinishedTask");
-  origin_loop->PostTask(FROM_HERE, on_raster_finished_callback);
-}
-
 }  // namespace cc