cc: Refactor TileTaskWorkerPool.

cc/tiles/tile_task_manager.cc

Index: cc/tiles/tile_task_manager.cc
diff --git a/cc/tiles/tile_task_manager.cc b/cc/tiles/tile_task_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ec871202045dc3bc6b14506d2fb57279ab1047d3
--- /dev/null
+++ b/cc/tiles/tile_task_manager.cc
@@ -0,0 +1,85 @@
+// Copyright 2016 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/tiles/tile_task_manager.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
+
+namespace cc {
+
+// static
+std::unique_ptr<TileTaskManager> TileTaskManager::Create(
+    std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool,
+    TaskGraphRunner* task_graph_runner) {
+  return base::WrapUnique<TileTaskManager>(
+      new TileTaskManager(std::move(tile_task_worker_pool), task_graph_runner));
+}
+
+TileTaskManager::TileTaskManager(
+    std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool,
+    TaskGraphRunner* task_graph_runner)
+    : tile_task_worker_pool_(std::move(tile_task_worker_pool)),
+      task_graph_runner_(task_graph_runner),
+      namespace_token_(task_graph_runner->GetNamespaceToken()) {}
+
+TileTaskManager::TileTaskManager(
+    std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool)
+    : tile_task_worker_pool_(std::move(tile_task_worker_pool)) {}
+
+TileTaskManager::~TileTaskManager() {
+  DCHECK_EQ(0u, completed_tasks_.size());
+}
+
+void TileTaskManager::ScheduleTasks(TaskGraph* graph) {
+  TRACE_EVENT0("cc", "TileTaskManager::ScheduleTasksOnOriginThread");

[ericrk, 2016/04/25 20:56:07]

nit: trace event should read "TileTaskManager::ScheduleTasks"

+
+  for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+       it != graph->nodes.end(); ++it) {
+    TaskGraph::Node& node = *it;
+    TileTask* task = static_cast<TileTask*>(node.task);
+
+    if (!task->HasBeenScheduled()) {
+      task->WillSchedule();
+      task->ScheduleOnOriginThread(
+          tile_task_worker_pool_->AsRasterBufferProvider());
+      task->DidSchedule();
+    }
+  }
+
+  tile_task_worker_pool_->BarrierToSyncResources();
+
+  task_graph_runner_->ScheduleTasks(namespace_token_, graph);
+}
+
+void TileTaskManager::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "TileTaskManager::CheckForCompletedTasks");
+
+  task_graph_runner_->CollectCompletedTasks(namespace_token_,
+                                            &completed_tasks_);
+  for (Task::Vector::const_iterator it = completed_tasks_.begin();
+       it != completed_tasks_.end(); ++it) {
+    TileTask* task = static_cast<TileTask*>(it->get());
+
+    task->WillComplete();
+    task->CompleteOnOriginThread(
+        tile_task_worker_pool_->AsRasterBufferProvider());
+    task->DidComplete();
+  }
+  completed_tasks_.clear();
+}
+
+void TileTaskManager::Shutdown() {
+  TRACE_EVENT0("cc", "TileTaskManager::Shutdown");
+
+  TaskGraph empty;
+  task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
+  task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+}
+
+TileTaskWorkerPool* TileTaskManager::GetTileTaskWorkerPool() const {
+  return tile_task_worker_pool_.get();
+}
+
+}  // namespace cc