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

cc/resources/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/raster_worker_pool.h"
 
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
@@ skipping 161 matching lines @@
     // TODO(alokp): For now run-on-worker-thread implies software rasterization.
     DCHECK(!use_gpu_rasterization());
     RunAnalysisOnThread(thread_index);
     if (buffer_ && !analysis_.is_solid_color)
       RunRasterOnThread(thread_index, buffer_, resource()->size(), stride_);
   }
 
   // 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_);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     DCHECK(!buffer_);
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual void RunOnOriginThread(ResourceProvider* resource_provider,
@@ skipping 251 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
 }  // namespace
 
 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;
 }
 
 bool WorkerPoolTask::HasCompleted() const { return did_complete_; }
 
 RasterWorkerPoolTask::RasterWorkerPoolTask(const Resource* resource,
                                            internal::Task::Vector* dependencies,
                                            bool use_gpu_rasterization)
     : resource_(resource), use_gpu_rasterization_(use_gpu_rasterization) {
   dependencies_.swap(*dependencies);
@@ skipping 132 matching lines @@
 bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
     internal::RasterWorkerPoolTask* task) const {
   return raster_tasks_required_for_activation_.find(task) !=
          raster_tasks_required_for_activation_.end();
 }
 
 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);
 }
 
 void RasterWorkerPool::CollectCompletedWorkerPoolTasks(
     internal::Task::Vector* completed_tasks) {
   g_task_graph_runner.Pointer()->CollectCompletedTasks(namespace_token_,
                                                        completed_tasks);
 }
 
 void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) {
   if (tasks.empty())
     return;
 
   GrContext* gr_context = context_provider_->GrContext();
   // TODO(alokp): Implement TestContextProvider::GrContext().
   if (gr_context)
     gr_context->resetContext();
 
   for (RasterTaskVector::const_iterator it = tasks.begin(); it != tasks.end();
        ++it) {
     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);
   }
 
   // TODO(alokp): Implement TestContextProvider::GrContext().
   if (gr_context)
     gr_context->flush();
 }
 
@@ skipping 65 matching lines @@
   graph->set(task, make_scoped_ptr(node));
   return node;
 }
 
 // static
 internal::GraphNode* RasterWorkerPool::CreateGraphNodeForRasterTask(
     internal::WorkerPoolTask* raster_task,
     const internal::Task::Vector& decode_tasks,
     unsigned priority,
     TaskGraph* graph) {
-  DCHECK(!raster_task->HasCompleted());
-
   internal::GraphNode* raster_node =
       CreateGraphNodeForTask(raster_task, priority, graph);
 
   // Insert image decode tasks.
   for (internal::Task::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end();
        ++it) {
     internal::WorkerPoolTask* decode_task =
         static_cast<internal::WorkerPoolTask*>(it->get());
 
@@ skipping 13 matching lines @@
 
     internal::GraphNode* decode_node =
         CreateGraphNodeForTask(decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc