TaskGraphRunner refactor

cc/raster/tile_task_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/raster/tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/playback/display_list_raster_source.h"
@@ skipping 43 matching lines @@
 // since it should finish as quickly as possible.
 size_t TileTaskWorkerPool::kBenchmarkTaskPriority = 0u;
 // Task priorities that make sure task set finished tasks run before any
 // other remaining tasks. This is combined with the task set type to ensure
 // proper prioritization ordering between task set types.
 size_t TileTaskWorkerPool::kTaskSetFinishedTaskPriorityBase = 1u;
 // For correctness, |kTileTaskPriorityBase| must be greater than
 // |kTaskSetFinishedTaskPriorityBase + kNumberOfTaskSets|.
 size_t TileTaskWorkerPool::kTileTaskPriorityBase = 10u;
 
-TileTaskWorkerPool::TileTaskWorkerPool() {
-}
+TileTaskWorkerPool::TileTaskWorkerPool() {}
 
-TileTaskWorkerPool::~TileTaskWorkerPool() {
-}
+TileTaskWorkerPool::~TileTaskWorkerPool() {}
 
 // static
 scoped_refptr<TileTask> TileTaskWorkerPool::CreateTaskSetFinishedTask(
     base::SequencedTaskRunner* task_runner,
     const base::Closure& on_task_set_finished_callback) {
   return make_scoped_refptr(
       new TaskSetFinishedTaskImpl(task_runner, on_task_set_finished_callback));
 }
 
 // static
@@ skipping 13 matching lines @@
     }
   }
 }
 
 // static
 void TileTaskWorkerPool::InsertNodeForTask(TaskGraph* graph,
                                            TileTask* task,
                                            size_t priority,
                                            size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(), graph->nodes.end(),
-                      TaskGraph::Node::TaskComparator(task)) ==
-         graph->nodes.end());
+                      [task](const TaskGraph::Node& node) {
+                        return node.task == task;
+                      }) == graph->nodes.end());
   graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
 }
 
 // static
 void TileTaskWorkerPool::InsertNodesForRasterTask(
     TaskGraph* graph,
     RasterTask* raster_task,
     const ImageDecodeTask::Vector& decode_tasks,
     size_t priority) {
   size_t dependencies = 0u;
 
   // Insert image decode tasks.
   for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end(); ++it) {
     ImageDecodeTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
       continue;
 
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
     TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(), graph->nodes.end(),
-                     TaskGraph::Node::TaskComparator(decode_task));
+                     [decode_task](const TaskGraph::Node& node) {
+                       return node.task == decode_task;
+                     });
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
@@ skipping 84 matching lines @@
 
     SkImageInfo dst_info =
         SkImageInfo::Make(info.width(), info.height(), buffer_color_type,
                           info.alphaType(), info.profileType());
     bool rv = canvas->readPixels(dst_info, memory, stride, 0, 0);
     DCHECK(rv);
   }
 }
 
 }  // namespace cc