cc: Switch to vector based TaskGraph implementation.

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"
 #include "base/values.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 
 namespace cc {
-
 namespace {
 
 // Subclass of Allocator that takes a suitably allocated pointer and uses
 // it as the pixel memory for the bitmap.
 class IdentityAllocator : public SkBitmap::Allocator {
  public:
   explicit IdentityAllocator(void* buffer) : buffer_(buffer) {}
   virtual bool allocPixelRef(SkBitmap* dst, SkColorTable*) OVERRIDE {
     dst->setPixels(buffer_);
     return true;
@@ skipping 186 matching lines @@
     skia::RefPtr<GrTexture> texture =
         skia::AdoptRef(gr_context->wrapBackendTexture(desc));
     skia::RefPtr<SkGpuDevice> device =
         skia::AdoptRef(SkGpuDevice::Create(texture.get()));
     skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(new SkCanvas(device.get()));
 
     Raster(picture_pile_, canvas.get());
   }
 
  protected:
-  virtual ~RasterWorkerPoolTaskImpl() {}
+  virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!buffer_); }
 
  private:
   scoped_ptr<base::Value> DataAsValue() const {
     scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
     res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
     res->SetInteger("source_frame_number", source_frame_number_);
     res->SetInteger("layer_id", layer_id_);
     return res.PassAs<base::Value>();
   }
@@ skipping 288 matching lines @@
 RasterWorkerPool::RasterTask::RasterTask() {}
 
 RasterWorkerPool::RasterTask::RasterTask(
     internal::RasterWorkerPoolTask* internal)
     : internal_(internal) {}
 
 void RasterWorkerPool::RasterTask::Reset() { internal_ = NULL; }
 
 RasterWorkerPool::RasterTask::~RasterTask() {}
 
+// Task priorities that make sure raster finished tasks run before any
+// remaining raster tasks.
+unsigned RasterWorkerPool::kRasterFinishedTaskPriority = 1u;
+unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
+    0u;
+unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
+
 RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
                                    ContextProvider* context_provider)
     : namespace_token_(g_task_graph_runner.Pointer()->GetNamespaceToken()),
       client_(NULL),
       resource_provider_(resource_provider),
       context_provider_(context_provider),
       weak_ptr_factory_(this) {}
 
 RasterWorkerPool::~RasterWorkerPool() {}
 
@@ skipping 54 matching lines @@
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = client;
 }
 
 void RasterWorkerPool::Shutdown() {
   TRACE_EVENT0("cc", "RasterWorkerPool::Shutdown");
 
   raster_tasks_.clear();
-  TaskGraph empty;
+  internal::TaskGraph empty;
   SetTaskGraph(&empty);
   g_task_graph_runner.Pointer()->WaitForTasksToFinishRunning(namespace_token_);
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
   raster_tasks_.swap(queue->tasks_);
   raster_tasks_required_for_activation_.swap(
       queue->tasks_required_for_activation_);
 }
 
 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());
+void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) {
+  TRACE_EVENT0("cc", "RasterWorkerPool::SetTaskGraph");
 
-  for (internal::GraphNode::Map::iterator it = graph->begin();
-       it != graph->end();
+  for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+       it != graph->nodes.end();
        ++it) {
+    internal::TaskGraph::Node& node = *it;
     internal::WorkerPoolTask* task =
-        static_cast<internal::WorkerPoolTask*>(it->first);
+        static_cast<internal::WorkerPoolTask*>(node.task);
 
     if (!task->HasBeenScheduled()) {
       task->WillSchedule();
       task->ScheduleOnOriginThread(this);
       task->DidSchedule();
     }
   }
 
   g_task_graph_runner.Pointer()->SetTaskGraph(namespace_token_, graph);
 }
@@ skipping 90 matching lines @@
 
 scoped_ptr<base::Value> RasterWorkerPool::ScheduledStateAsValue() const {
   scoped_ptr<base::DictionaryValue> scheduled_state(new base::DictionaryValue);
   scheduled_state->SetInteger("task_count", raster_tasks_.size());
   scheduled_state->SetInteger("task_required_for_activation_count",
                               raster_tasks_required_for_activation_.size());
   return scheduled_state.PassAs<base::Value>();
 }
 
 // static
-internal::GraphNode* RasterWorkerPool::CreateGraphNodeForTask(
-    internal::WorkerPoolTask* task,
-    unsigned priority,
-    TaskGraph* graph) {
-  internal::GraphNode* node = new internal::GraphNode(task, priority);
-  DCHECK(graph->find(task) == graph->end());
-  graph->set(task, make_scoped_ptr(node));
-  return node;
+void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
+                                         internal::WorkerPoolTask* task,
+                                         unsigned priority,
+                                         size_t dependencies) {
+  DCHECK(std::find_if(graph->nodes.begin(),
+                      graph->nodes.end(),
+                      internal::TaskGraph::Node::TaskComparator(task)) ==
+         graph->nodes.end());
+  graph->nodes.push_back(
+      internal::TaskGraph::Node(task, priority, dependencies));
 }
 
 // static
-internal::GraphNode* RasterWorkerPool::CreateGraphNodeForRasterTask(
+void RasterWorkerPool::InsertNodeForRasterTask(
+    internal::TaskGraph* graph,
     internal::WorkerPoolTask* raster_task,
     const internal::Task::Vector& decode_tasks,
-    unsigned priority,
-    TaskGraph* graph) {
-  internal::GraphNode* raster_node =
-      CreateGraphNodeForTask(raster_task, priority, graph);
+    unsigned priority) {
+  size_t dependencies = 0u;
 
   // 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());
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
       continue;
 
-    raster_node->add_dependency();
+    dependencies++;
 
-    // Check if decode task already exists in graph.
-    internal::GraphNode::Map::iterator decode_it = graph->find(decode_task);
-    if (decode_it != graph->end()) {
-      internal::GraphNode* decode_node = decode_it->second;
-      decode_node->add_dependent(raster_node);
-      continue;
-    }
+    // Add decode task if it doesn't already exists in graph.
+    internal::TaskGraph::Node::Vector::iterator decode_it =
+        std::find_if(graph->nodes.begin(),
+                     graph->nodes.end(),
+                     internal::TaskGraph::Node::TaskComparator(decode_task));
+    if (decode_it == graph->nodes.end())
+      InsertNodeForTask(graph, decode_task, priority, 0u);
 
-    internal::GraphNode* decode_node =
-        CreateGraphNodeForTask(decode_task, priority, graph);
-    decode_node->add_dependent(raster_node);
+    graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
   }
 
-  return raster_node;
+  InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 }  // namespace cc