cc: Move internal::Task::did_schedule_ to internal::WorkerPoolTask.

This moves the task scheduling notion out of the TaskGraphRunner and
into the RasterWorkerPool. This is a more appropriate place to handle
this and required as tasks need to complete multiple times when used
with PixelRasterWorkerPool.

BUG=339201

Review URL: https://codereview.chromium.org/140333006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@249236 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 54 insertions, 36 deletions

diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc
index de9ba9d..845ed12 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -65,8 +65,6 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
       continue;
     }
 
-    task->ScheduleOnOriginThread(this);
-
     CreateGraphNodeForImageRasterTask(
         task,
         task->dependencies(),
diff --git a/cc/resources/image_raster_worker_pool.h b/cc/resources/image_raster_worker_pool.h
index b60004c..6de7479 100644
--- a/cc/resources/image_raster_worker_pool.h
+++ b/cc/resources/image_raster_worker_pool.h
@@ -9,8 +9,7 @@
 
 namespace cc {
 
-class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
-                                        public internal::WorkerPoolTaskClient {
+class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool {
  public:
   virtual ~ImageRasterWorkerPool();
 
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index 563b1f6..2ef6c83 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -132,6 +132,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
 
       raster_task_states_.erase(state_it);
     } else {
+      DCHECK(!task->HasBeenScheduled());
       new_raster_task_states[task] = UNSCHEDULED;
       if (IsRasterTaskRequiredForActivation(task))
         raster_tasks_required_for_activation_.insert(task);
@@ -149,6 +150,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
 
     // Unscheduled task can be canceled.
     if (it->second == UNSCHEDULED) {
+      DCHECK(!task->HasBeenScheduled());
       DCHECK(std::find(completed_raster_tasks_.begin(),
                        completed_raster_tasks_.end(),
                        task) == completed_raster_tasks_.end());
@@ -525,6 +527,7 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
 
     // If raster has finished, just update |bytes_pending_upload|.
     if (state_it->second == UPLOADING) {
+      DCHECK(task->HasCompleted());
       bytes_pending_upload = new_bytes_pending_upload;
       continue;
     }
@@ -546,7 +549,6 @@ void PixelBufferRasterWorkerPool::ScheduleMoreTasks() {
                               ? REQUIRED_FOR_ACTIVATION_TYPE
                               : PREPAINT_TYPE;
 
-    task->ScheduleOnOriginThread(this);
     DCHECK(state_it->second == UNSCHEDULED || state_it->second == SCHEDULED);
     state_it->second = SCHEDULED;
 
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h
index e794162..b0bb93f 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_raster_worker_pool.h
@@ -13,9 +13,7 @@
 
 namespace cc {
 
-class CC_EXPORT PixelBufferRasterWorkerPool
-    : public RasterWorkerPool,
-      public internal::WorkerPoolTaskClient {
+class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
  public:
   virtual ~PixelBufferRasterWorkerPool();
 
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 7f98a16..09b65bc 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -179,14 +179,15 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
-    DCHECK(!use_gpu_rasterization());
-    if (buffer_)
+    if (use_gpu_rasterization())
       return;
+    DCHECK(!buffer_);
     buffer_ = client->AcquireBufferForRaster(this, &stride_);
   }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
-    DCHECK(!use_gpu_rasterization());
+    if (use_gpu_rasterization())
+      return;
     buffer_ = NULL;
     client->OnRasterCompleted(this, analysis_);
   }
@@ -458,18 +459,28 @@ int g_num_raster_threads = 0;
 
 namespace internal {
 
-WorkerPoolTask::WorkerPoolTask() : did_complete_(false) {}
+WorkerPoolTask::WorkerPoolTask() : did_schedule_(false), did_complete_(false) {}
 
 WorkerPoolTask::~WorkerPoolTask() {
-  DCHECK_EQ(did_schedule_, did_complete_);
+  DCHECK(!did_schedule_);
   DCHECK(!did_run_ || did_complete_);
 }
 
+void WorkerPoolTask::WillSchedule() { DCHECK(!did_schedule_); }
+
+void WorkerPoolTask::DidSchedule() {
+  did_schedule_ = true;
+  did_complete_ = false;
+}
+
+bool WorkerPoolTask::HasBeenScheduled() const { return did_schedule_; }
+
 void WorkerPoolTask::WillComplete() { DCHECK(!did_complete_); }
 
 void WorkerPoolTask::DidComplete() {
   DCHECK(did_schedule_);
   DCHECK(!did_complete_);
+  did_schedule_ = false;
   did_complete_ = true;
 }
 
@@ -622,6 +633,19 @@ void RasterWorkerPool::SetTaskGraph(TaskGraph* graph) {
   TRACE_EVENT1(
       "cc", "RasterWorkerPool::SetTaskGraph", "num_tasks", graph->size());
 
+  for (internal::GraphNode::Map::iterator it = graph->begin();
+       it != graph->end();
+       ++it) {
+    internal::WorkerPoolTask* task =
+        static_cast<internal::WorkerPoolTask*>(it->first);
+
+    if (!task->HasBeenScheduled()) {
+      task->WillSchedule();
+      task->ScheduleOnOriginThread(this);
+      task->DidSchedule();
+    }
+  }
+
   g_task_graph_runner.Pointer()->SetTaskGraph(namespace_token_, graph);
 }
 
@@ -645,11 +669,16 @@ void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) {
     internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(task->use_gpu_rasterization());
 
+    task->WillSchedule();
+    task->ScheduleOnOriginThread(this);
     task->DidSchedule();
+
     task->WillRun();
     task->RunOnOriginThread(resource_provider_, context_provider_);
     task->DidRun();
+
     task->WillComplete();
+    task->CompleteOnOriginThread(this);
     task->DidComplete();
 
     completed_gpu_raster_tasks_.push_back(task);
@@ -735,8 +764,6 @@ internal::GraphNode* RasterWorkerPool::CreateGraphNodeForRasterTask(
     const internal::Task::Vector& decode_tasks,
     unsigned priority,
     TaskGraph* graph) {
-  DCHECK(!raster_task->HasCompleted());
-
   internal::GraphNode* raster_node =
       CreateGraphNodeForTask(raster_task, priority, graph);
 
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 081dbb3..c715e0e 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -47,6 +47,10 @@ class CC_EXPORT WorkerPoolTask : public Task {
   virtual void CompleteOnOriginThread(WorkerPoolTaskClient* client) = 0;
   virtual void RunReplyOnOriginThread() = 0;
 
+  void WillSchedule();
+  void DidSchedule();
+  bool HasBeenScheduled() const;
+
   void WillComplete();
   void DidComplete();
   bool HasCompleted() const;
@@ -56,6 +60,7 @@ class CC_EXPORT WorkerPoolTask : public Task {
   virtual ~WorkerPoolTask();
 
  private:
+  bool did_schedule_;
   bool did_complete_;
 };
 
@@ -107,7 +112,7 @@ class CC_EXPORT RasterWorkerPoolClient {
 };
 
 // A worker thread pool that runs raster tasks.
-class CC_EXPORT RasterWorkerPool {
+class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
  public:
   class CC_EXPORT Task {
    public:
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index e11c0ae..6a170d5 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -17,8 +17,7 @@ static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfRasterWorkerPool : public RasterWorkerPool,
-                             public internal::WorkerPoolTaskClient {
+class PerfRasterWorkerPool : public RasterWorkerPool {
  public:
   PerfRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}
   virtual ~PerfRasterWorkerPool() {}
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index 02dffde..9944bfc 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -56,11 +56,15 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
+    if (use_gpu_rasterization())
+      return;
     int stride;
     client->AcquireBufferForRaster(this, &stride);
   }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
+    if (use_gpu_rasterization())
+      return;
     client->OnRasterCompleted(this, PicturePileImpl::Analysis());
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
diff --git a/cc/resources/task_graph_runner.cc b/cc/resources/task_graph_runner.cc
index f1ed738..975881b 100644
--- a/cc/resources/task_graph_runner.cc
+++ b/cc/resources/task_graph_runner.cc
@@ -14,14 +14,11 @@
 namespace cc {
 namespace internal {
 
-Task::Task() : did_schedule_(false), did_run_(false) {}
+Task::Task() : did_run_(false) {}
 
-Task::~Task() { DCHECK(!did_run_ || did_schedule_); }
-
-void Task::DidSchedule() { did_schedule_ = true; }
+Task::~Task() {}
 
 void Task::WillRun() {
-  DCHECK(did_schedule_);
   DCHECK(!did_run_);
 }
 
@@ -174,10 +171,6 @@ void TaskGraphRunner::SetTaskGraph(NamespaceToken token, TaskGraph* graph) {
       // Completed tasks should not exist in |new_pending_tasks|.
       DCHECK(!task->HasFinishedRunning());
 
-      // Call DidSchedule() to indicate that this task has been scheduled.
-      // Note: This is only for debugging purposes.
-      task->DidSchedule();
-
       if (!node->num_dependencies())
         task_namespace->ready_to_run_tasks.push_back(node);
 
diff --git a/cc/resources/task_graph_runner.h b/cc/resources/task_graph_runner.h
index eb03467..5a55f6d 100644
--- a/cc/resources/task_graph_runner.h
+++ b/cc/resources/task_graph_runner.h
@@ -26,10 +26,8 @@ class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
 
   virtual void RunOnWorkerThread(unsigned thread_index) = 0;
 
-  void DidSchedule();
   void WillRun();
   void DidRun();
-
   bool HasFinishedRunning() const;
 
  protected:
@@ -38,7 +36,6 @@ class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
   Task();
   virtual ~Task();
 
-  bool did_schedule_;
   bool did_run_;
 };
 
diff --git a/cc/resources/task_graph_runner_perftest.cc b/cc/resources/task_graph_runner_perftest.cc
index f47df14..80c7fdc 100644
--- a/cc/resources/task_graph_runner_perftest.cc
+++ b/cc/resources/task_graph_runner_perftest.cc
@@ -28,10 +28,7 @@ class PerfTaskImpl : public internal::Task {
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {}
 
-  void Reset() {
-    did_schedule_ = false;
-    did_run_ = false;
-  }
+  void Reset() { did_run_ = false; }
 
  private:
   virtual ~PerfTaskImpl() {}
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 347d14f..9f0649a 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -13,8 +13,7 @@ namespace cc {
 
 namespace {
 
-class FakeRasterWorkerPool : public RasterWorkerPool,
-                             public internal::WorkerPoolTaskClient {
+class FakeRasterWorkerPool : public RasterWorkerPool {
  public:
   FakeRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}