diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index fae8e87..cbd38be 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -372,8 +372,9 @@
     "raster/staging_buffer_pool.h",
     "raster/synchronous_task_graph_runner.cc",
     "raster/synchronous_task_graph_runner.h",
+    "raster/task.cc",
+    "raster/task.h",
     "raster/task_category.h",
-    "raster/task_graph_runner.cc",
     "raster/task_graph_runner.h",
     "raster/task_graph_work_queue.cc",
     "raster/task_graph_work_queue.h",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 7b29a6e..6031f426 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -433,8 +433,9 @@
         'raster/staging_buffer_pool.h',
         'raster/synchronous_task_graph_runner.cc',
         'raster/synchronous_task_graph_runner.h',
+        'raster/task.cc',
+        'raster/task.h',
         'raster/task_category.h',
-        'raster/task_graph_runner.cc',
         'raster/task_graph_runner.h',
         'raster/task_graph_work_queue.cc',
         'raster/task_graph_work_queue.h',
diff --git a/cc/raster/task_graph_runner.cc b/cc/raster/task.cc
similarity index 73%
rename from cc/raster/task_graph_runner.cc
rename to cc/raster/task.cc
index 4f1af43..c19e549 100644
--- a/cc/raster/task_graph_runner.cc
+++ b/cc/raster/task.cc
@@ -1,15 +1,10 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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/raster/task_graph_runner.h"
+#include "cc/raster/task.h"
 
-#include <algorithm>
-#include <utility>
-
-#include "base/atomic_sequence_num.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/trace_event/trace_event.h"
+#include "base/logging.h"
 
 namespace cc {
 
diff --git a/cc/raster/task.h b/cc/raster/task.h
new file mode 100644
index 0000000..96959c1
--- /dev/null
+++ b/cc/raster/task.h
@@ -0,0 +1,93 @@
+// 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.
+
+#ifndef CC_RASTER_TASK_H_
+#define CC_RASTER_TASK_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "cc/base/cc_export.h"
+
+namespace cc {
+
+// A task which can be run by a TaskGraphRunner. To run a Task, it should be
+// inserted into a TaskGraph, which can then be scheduled on the
+// TaskGraphRunner.
+class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
+ public:
+  typedef std::vector<scoped_refptr<Task>> Vector;
+
+  // Subclasses should implement this method. RunOnWorkerThread may be called
+  // on any thread, and subclasses are responsible for locking and thread
+  // safety.
+  virtual void RunOnWorkerThread() = 0;
+
+  void WillRun();
+  void DidRun();
+  bool HasFinishedRunning() const;
+
+ protected:
+  friend class base::RefCountedThreadSafe<Task>;
+
+  Task();
+  virtual ~Task();
+
+  bool will_run_;
+  bool did_run_;
+};
+
+// A task dependency graph describes the order in which to execute a set
+// of tasks. Dependencies are represented as edges. Each node is assigned
+// a category, a priority and a run count that matches the number of
+// dependencies. Priority range from 0 (most favorable scheduling) to UINT16_MAX
+// (least favorable). Categories range from 0 to UINT16_MAX. It is up to the
+// implementation and its consumer to determine the meaning (if any) of a
+// category. A TaskGraphRunner implementation may chose to prioritize certain
+// categories over others, regardless of the individual priorities of tasks.
+struct CC_EXPORT TaskGraph {
+  struct Node {
+    typedef std::vector<Node> Vector;
+
+    Node(Task* task,
+         uint16_t category,
+         uint16_t priority,
+         uint32_t dependencies)
+        : task(task),
+          category(category),
+          priority(priority),
+          dependencies(dependencies) {}
+
+    Task* task;
+    uint16_t category;
+    uint16_t priority;
+    uint32_t dependencies;
+  };
+
+  struct Edge {
+    typedef std::vector<Edge> Vector;
+
+    Edge(const Task* task, Task* dependent)
+        : task(task), dependent(dependent) {}
+
+    const Task* task;
+    Task* dependent;
+  };
+
+  TaskGraph();
+  TaskGraph(const TaskGraph& other);
+  ~TaskGraph();
+
+  void Swap(TaskGraph* other);
+  void Reset();
+
+  Node::Vector nodes;
+  Edge::Vector edges;
+};
+
+}  // namespace cc
+
+#endif  // CC_RASTER_TASK_H_
diff --git a/cc/raster/task_graph_runner.h b/cc/raster/task_graph_runner.h
index d5f8cee..51ac3341c 100644
--- a/cc/raster/task_graph_runner.h
+++ b/cc/raster/task_graph_runner.h
@@ -16,85 +16,10 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
+#include "cc/raster/task.h"
 
 namespace cc {
 
-class TaskGraphRunner;
-
-// A task which can be run by a TaskGraphRunner. To run a Task, it should be
-// inserted into a TaskGraph, which can then be scheduled on the
-// TaskGraphRunner.
-class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
- public:
-  typedef std::vector<scoped_refptr<Task>> Vector;
-
-  // Subclasses should implement this method. RunOnWorkerThread may be called
-  // on any thread, and subclasses are responsible for locking and thread
-  // safety.
-  virtual void RunOnWorkerThread() = 0;
-
-  void WillRun();
-  void DidRun();
-  bool HasFinishedRunning() const;
-
- protected:
-  friend class base::RefCountedThreadSafe<Task>;
-
-  Task();
-  virtual ~Task();
-
-  bool will_run_;
-  bool did_run_;
-};
-
-// A task dependency graph describes the order in which to execute a set
-// of tasks. Dependencies are represented as edges. Each node is assigned
-// a category, a priority and a run count that matches the number of
-// dependencies. Priority range from 0 (most favorable scheduling) to UINT16_MAX
-// (least favorable). Categories range from 0 to UINT16_MAX. It is up to the
-// implementation and its consumer to determine the meaning (if any) of a
-// category. A TaskGraphRunner implementation may chose to prioritize certain
-// categories over others, regardless of the individual priorities of tasks.
-struct CC_EXPORT TaskGraph {
-  struct Node {
-    typedef std::vector<Node> Vector;
-
-    Node(Task* task,
-         uint16_t category,
-         uint16_t priority,
-         uint32_t dependencies)
-        : task(task),
-          category(category),
-          priority(priority),
-          dependencies(dependencies) {}
-
-    Task* task;
-    uint16_t category;
-    uint16_t priority;
-    uint32_t dependencies;
-  };
-
-  struct Edge {
-    typedef std::vector<Edge> Vector;
-
-    Edge(const Task* task, Task* dependent)
-        : task(task), dependent(dependent) {}
-
-    const Task* task;
-    Task* dependent;
-  };
-
-  TaskGraph();
-  TaskGraph(const TaskGraph& other);
-  ~TaskGraph();
-
-  void Swap(TaskGraph* other);
-  void Reset();
-
-  Node::Vector nodes;
-  Edge::Vector edges;
-};
-
 // Opaque identifier that defines a namespace of tasks.
 class CC_EXPORT NamespaceToken {
  public:
@@ -166,61 +91,6 @@
   virtual ~TaskGraphRunner() {}
 };
 
-// Helper class for iterating over all dependents of a task.
-class DependentIterator {
- public:
-  DependentIterator(TaskGraph* graph, const Task* task)
-      : graph_(graph),
-        task_(task),
-        current_index_(static_cast<size_t>(-1)),
-        current_node_(NULL) {
-    ++(*this);
-  }
-
-  TaskGraph::Node& operator->() const {
-    DCHECK_LT(current_index_, graph_->edges.size());
-    DCHECK_EQ(graph_->edges[current_index_].task, task_);
-    DCHECK(current_node_);
-    return *current_node_;
-  }
-
-  TaskGraph::Node& operator*() const {
-    DCHECK_LT(current_index_, graph_->edges.size());
-    DCHECK_EQ(graph_->edges[current_index_].task, task_);
-    DCHECK(current_node_);
-    return *current_node_;
-  }
-
-  // Note: Performance can be improved by keeping edges sorted.
-  DependentIterator& operator++() {
-    // Find next dependency edge for |task_|.
-    do {
-      ++current_index_;
-      if (current_index_ == graph_->edges.size())
-        return *this;
-    } while (graph_->edges[current_index_].task != task_);
-
-    // Now find the node for the dependent of this edge.
-    TaskGraph::Node::Vector::iterator it = std::find_if(
-        graph_->nodes.begin(), graph_->nodes.end(),
-        [this](const TaskGraph::Node& node) {
-          return node.task == graph_->edges[current_index_].dependent;
-        });
-    DCHECK(it != graph_->nodes.end());
-    current_node_ = &(*it);
-
-    return *this;
-  }
-
-  operator bool() const { return current_index_ < graph_->edges.size(); }
-
- private:
-  TaskGraph* graph_;
-  const Task* task_;
-  size_t current_index_;
-  TaskGraph::Node* current_node_;
-};
-
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_RUNNER_H_
diff --git a/cc/raster/task_graph_work_queue.cc b/cc/raster/task_graph_work_queue.cc
index 98413ee..aa75654 100644
--- a/cc/raster/task_graph_work_queue.cc
+++ b/cc/raster/task_graph_work_queue.cc
@@ -43,6 +43,62 @@
  private:
   uint16_t category_;
 };
+
+// Helper class for iterating over all dependents of a task.
+class DependentIterator {
+ public:
+  DependentIterator(TaskGraph* graph, const Task* task)
+      : graph_(graph),
+        task_(task),
+        current_index_(static_cast<size_t>(-1)),
+        current_node_(NULL) {
+    ++(*this);
+  }
+
+  TaskGraph::Node& operator->() const {
+    DCHECK_LT(current_index_, graph_->edges.size());
+    DCHECK_EQ(graph_->edges[current_index_].task, task_);
+    DCHECK(current_node_);
+    return *current_node_;
+  }
+
+  TaskGraph::Node& operator*() const {
+    DCHECK_LT(current_index_, graph_->edges.size());
+    DCHECK_EQ(graph_->edges[current_index_].task, task_);
+    DCHECK(current_node_);
+    return *current_node_;
+  }
+
+  // Note: Performance can be improved by keeping edges sorted.
+  DependentIterator& operator++() {
+    // Find next dependency edge for |task_|.
+    do {
+      ++current_index_;
+      if (current_index_ == graph_->edges.size())
+        return *this;
+    } while (graph_->edges[current_index_].task != task_);
+
+    // Now find the node for the dependent of this edge.
+    TaskGraph::Node::Vector::iterator it = std::find_if(
+        graph_->nodes.begin(), graph_->nodes.end(),
+        [this](const TaskGraph::Node& node) {
+          return node.task == graph_->edges[current_index_].dependent;
+        });
+    DCHECK(it != graph_->nodes.end());
+    current_node_ = &(*it);
+
+    return *this;
+  }
+
+  operator bool() const { return current_index_ < graph_->edges.size(); }
+
+ private:
+  TaskGraph* graph_;
+  const Task* task_;
+  size_t current_index_;
+  TaskGraph::Node* current_node_;
+};
+
 }  // namespace
 
 TaskGraphWorkQueue::TaskNamespace::TaskNamespace() {}
diff --git a/cc/raster/tile_task_runner.cc b/cc/raster/tile_task_runner.cc
index e76218c..fde8ad80 100644
--- a/cc/raster/tile_task_runner.cc
+++ b/cc/raster/tile_task_runner.cc
@@ -7,8 +7,17 @@
 
 namespace cc {
 
-TileTask::TileTask() : did_schedule_(false), did_complete_(false) {
-}
+TileTask::TileTask(bool supports_concurrent_execution)
+    : supports_concurrent_execution_(supports_concurrent_execution),
+      did_schedule_(false),
+      did_complete_(false) {}
+
+TileTask::TileTask(bool supports_concurrent_execution,
+                   TileTask::Vector* dependencies)
+    : supports_concurrent_execution_(supports_concurrent_execution),
+      dependencies_(std::move(*dependencies)),
+      did_schedule_(false),
+      did_complete_(false) {}
 
 TileTask::~TileTask() {
   DCHECK(!did_schedule_);
@@ -43,26 +52,6 @@
   return did_complete_;
 }
 
-ImageDecodeTask::ImageDecodeTask() {
-}
-
-ImageDecodeTask::ImageDecodeTask(scoped_refptr<ImageDecodeTask> dependency)
-    : dependency_(std::move(dependency)) {}
-
-ImageDecodeTask::~ImageDecodeTask() {
-}
-
-bool ImageDecodeTask::SupportsConcurrentExecution() const {
-  return true;
-}
-
-RasterTask::RasterTask(ImageDecodeTask::Vector* dependencies) {
-  dependencies_.swap(*dependencies);
-}
-
-RasterTask::~RasterTask() {
-}
-
 bool TileTaskRunner::ResourceFormatRequiresSwizzle(ResourceFormat format) {
   switch (format) {
     case RGBA_8888:
diff --git a/cc/raster/tile_task_runner.h b/cc/raster/tile_task_runner.h
index dc1586a..3bda3ad 100644
--- a/cc/raster/tile_task_runner.h
+++ b/cc/raster/tile_task_runner.h
@@ -11,7 +11,7 @@
 
 #include "base/callback.h"
 #include "cc/raster/raster_buffer.h"
-#include "cc/raster/task_graph_runner.h"
+#include "cc/raster/task.h"
 #include "cc/resources/resource_format.h"
 
 namespace cc {
@@ -20,6 +20,16 @@
  public:
   typedef std::vector<scoped_refptr<TileTask>> Vector;
 
+  const TileTask::Vector& dependencies() const { return dependencies_; }
+
+  // Indicates whether this TileTask can be run at the same time as other tasks
+  // in the task graph. If false, this task will be scheduled with
+  // TASK_CATEGORY_NONCONCURRENT_FOREGROUND. The base implementation always
+  // returns true.
+  bool SupportsConcurrentExecution() const {
+    return supports_concurrent_execution_;
+  }
+
   virtual void ScheduleOnOriginThread(RasterBufferProvider* provider) = 0;
   virtual void CompleteOnOriginThread(RasterBufferProvider* provider) = 0;
 
@@ -32,49 +42,16 @@
   bool HasCompleted() const;
 
  protected:
-  TileTask();
+  explicit TileTask(bool supports_concurrent_execution);
+  TileTask(bool supports_concurrent_execution, TileTask::Vector* dependencies);
   ~TileTask() override;
 
+  const bool supports_concurrent_execution_;
+  TileTask::Vector dependencies_;
   bool did_schedule_;
   bool did_complete_;
 };
 
-class CC_EXPORT ImageDecodeTask : public TileTask {
- public:
-  typedef std::vector<scoped_refptr<ImageDecodeTask>> Vector;
-
-  // Indicates whether this ImageDecodeTask can be run at the same time as
-  // other tasks in the task graph. If false, this task will be scheduled with
-  // TASK_CATEGORY_NONCONCURRENT_FOREGROUND. The base implementation always
-  // returns true.
-  virtual bool SupportsConcurrentExecution() const;
-
-  // Returns an optional task which this task depends on. May be null.
-  const scoped_refptr<ImageDecodeTask>& dependency() { return dependency_; }
-
- protected:
-  ImageDecodeTask();
-  explicit ImageDecodeTask(scoped_refptr<ImageDecodeTask> dependency);
-  ~ImageDecodeTask() override;
-
- private:
-  scoped_refptr<ImageDecodeTask> dependency_;
-};
-
-class CC_EXPORT RasterTask : public TileTask {
- public:
-  typedef std::vector<scoped_refptr<RasterTask>> Vector;
-
-  const ImageDecodeTask::Vector& dependencies() const { return dependencies_; }
-
- protected:
-  explicit RasterTask(ImageDecodeTask::Vector* dependencies);
-  ~RasterTask() override;
-
- private:
-  ImageDecodeTask::Vector dependencies_;
-};
-
 // This interface can be used to schedule and run tile tasks.
 // The client can call CheckForCompletedTasks() at any time to dispatch
 // pending completion callbacks for all tasks that have finished running.
diff --git a/cc/raster/tile_task_worker_pool.h b/cc/raster/tile_task_worker_pool.h
index e05256ef..f4e675c 100644
--- a/cc/raster/tile_task_worker_pool.h
+++ b/cc/raster/tile_task_worker_pool.h
@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include "cc/playback/raster_source.h"
+#include "cc/raster/task_graph_runner.h"
 #include "cc/raster/tile_task_runner.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
diff --git a/cc/raster/tile_task_worker_pool_perftest.cc b/cc/raster/tile_task_worker_pool_perftest.cc
index 2335ca7..04922d68 100644
--- a/cc/raster/tile_task_worker_pool_perftest.cc
+++ b/cc/raster/tile_task_worker_pool_perftest.cc
@@ -123,9 +123,9 @@
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfImageDecodeTaskImpl : public ImageDecodeTask {
+class PerfImageDecodeTaskImpl : public TileTask {
  public:
-  PerfImageDecodeTaskImpl() {}
+  PerfImageDecodeTaskImpl() : TileTask(true) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {}
@@ -148,11 +148,11 @@
   DISALLOW_COPY_AND_ASSIGN(PerfImageDecodeTaskImpl);
 };
 
-class PerfRasterTaskImpl : public RasterTask {
+class PerfRasterTaskImpl : public TileTask {
  public:
   PerfRasterTaskImpl(std::unique_ptr<ScopedResource> resource,
-                     ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies), resource_(std::move(resource)) {}
+                     TileTask::Vector* dependencies)
+      : TileTask(true, dependencies), resource_(std::move(resource)) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {}
@@ -184,7 +184,7 @@
 
 class TileTaskWorkerPoolPerfTestBase {
  public:
-  typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
+  typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
@@ -197,13 +197,13 @@
                kTimeCheckInterval) {}
 
   void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
-                              ImageDecodeTask::Vector* image_decode_tasks) {
+                              TileTask::Vector* image_decode_tasks) {
     for (unsigned i = 0; i < num_image_decode_tasks; ++i)
       image_decode_tasks->push_back(new PerfImageDecodeTaskImpl);
   }
 
   void CreateRasterTasks(unsigned num_raster_tasks,
-                         const ImageDecodeTask::Vector& image_decode_tasks,
+                         const TileTask::Vector& image_decode_tasks,
                          RasterTaskVector* raster_tasks) {
     const gfx::Size size(1, 1);
 
@@ -213,7 +213,7 @@
       resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                          RGBA_8888);
 
-      ImageDecodeTask::Vector dependencies = image_decode_tasks;
+      TileTask::Vector dependencies = image_decode_tasks;
       raster_tasks->push_back(
           new PerfRasterTaskImpl(std::move(resource), &dependencies));
     }
@@ -300,7 +300,7 @@
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
-    ImageDecodeTask::Vector image_decode_tasks;
+    TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
@@ -329,7 +329,7 @@
                                      unsigned num_raster_tasks,
                                      unsigned num_image_decode_tasks) {
     const size_t kNumVersions = 2;
-    ImageDecodeTask::Vector image_decode_tasks[kNumVersions];
+    TileTask::Vector image_decode_tasks[kNumVersions];
     RasterTaskVector raster_tasks[kNumVersions];
     for (size_t i = 0; i < kNumVersions; ++i) {
       CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
@@ -362,7 +362,7 @@
   void RunScheduleAndExecuteTasksTest(const std::string& test_name,
                                       unsigned num_raster_tasks,
                                       unsigned num_image_decode_tasks) {
-    ImageDecodeTask::Vector image_decode_tasks;
+    TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
@@ -471,7 +471,7 @@
   void RunBuildTileTaskGraphTest(const std::string& test_name,
                                  unsigned num_raster_tasks,
                                  unsigned num_image_decode_tasks) {
-    ImageDecodeTask::Vector image_decode_tasks;
+    TileTask::Vector image_decode_tasks;
     RasterTaskVector raster_tasks;
     CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
     CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/tile_task_worker_pool_unittest.cc
index e3d2ab5d..03f835c 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/tile_task_worker_pool_unittest.cc
@@ -51,14 +51,14 @@
   TILE_TASK_WORKER_POOL_TYPE_BITMAP
 };
 
-class TestRasterTaskImpl : public RasterTask {
+class TestRasterTaskImpl : public TileTask {
  public:
   typedef base::Callback<void(bool was_canceled)> Reply;
 
   TestRasterTaskImpl(const Resource* resource,
                      const Reply& reply,
-                     ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                     TileTask::Vector* dependencies)
+      : TileTask(true, dependencies),
         resource_(resource),
         reply_(reply),
         raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {}
@@ -99,7 +99,7 @@
   BlockingTestRasterTaskImpl(const Resource* resource,
                              const Reply& reply,
                              base::Lock* lock,
-                             ImageDecodeTask::Vector* dependencies)
+                             TileTask::Vector* dependencies)
       : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {}
 
   // Overridden from Task:
@@ -125,7 +125,7 @@
     bool canceled;
   };
 
-  typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
+  typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
@@ -210,7 +210,7 @@
                        RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    ImageDecodeTask::Vector empty;
+    TileTask::Vector empty;
     tasks_.push_back(new TestRasterTaskImpl(
         const_resource,
         base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
@@ -229,7 +229,7 @@
                        RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    ImageDecodeTask::Vector empty;
+    TileTask::Vector empty;
     tasks_.push_back(new BlockingTestRasterTaskImpl(
         const_resource,
         base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index ebc0b70a..7397ae4a3 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -26,7 +26,7 @@
   void Shutdown() override {}
   void ScheduleTasks(TaskGraph* graph) override {
     for (const auto& node : graph->nodes) {
-      RasterTask* task = static_cast<RasterTask*>(node.task);
+      TileTask* task = static_cast<TileTask*>(node.task);
 
       task->WillSchedule();
       task->ScheduleOnOriginThread(this);
@@ -36,10 +36,9 @@
     }
   }
   void CheckForCompletedTasks() override {
-    for (RasterTask::Vector::iterator it = completed_tasks_.begin();
-         it != completed_tasks_.end();
-         ++it) {
-      RasterTask* task = it->get();
+    for (TileTask::Vector::iterator it = completed_tasks_.begin();
+         it != completed_tasks_.end(); ++it) {
+      TileTask* task = it->get();
 
       task->WillComplete();
       task->CompleteOnOriginThread(this);
@@ -65,7 +64,7 @@
   void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {}
 
  private:
-  RasterTask::Vector completed_tasks_;
+  TileTask::Vector completed_tasks_;
 };
 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner =
     LAZY_INSTANCE_INITIALIZER;
diff --git a/cc/tiles/gpu_image_decode_controller.cc b/cc/tiles/gpu_image_decode_controller.cc
index ab683d6..b6aa1a6 100644
--- a/cc/tiles/gpu_image_decode_controller.cc
+++ b/cc/tiles/gpu_image_decode_controller.cc
@@ -57,12 +57,13 @@
 
 // Task which decodes an image and stores the result in discardable memory.
 // This task does not use GPU resources and can be run on any thread.
-class ImageDecodeTaskImpl : public ImageDecodeTask {
+class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       uint64_t source_prepare_tiles_id)
-      : controller_(controller),
+      : TileTask(true),
+        controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
@@ -97,18 +98,19 @@
 // Task which creates an image from decoded data. Typically this involves
 // uploading data to the GPU, which requires this task be run on the non-
 // concurrent thread.
-class ImageUploadTaskImpl : public ImageDecodeTask {
+class ImageUploadTaskImpl : public TileTask {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
-                      scoped_refptr<ImageDecodeTask> decode_dependency,
+                      scoped_refptr<TileTask> decode_dependency,
                       uint64_t source_prepare_tiles_id)
-      : ImageDecodeTask(std::move(decode_dependency)),
+      : TileTask(false),
         controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
+    dependencies_.push_back(std::move(decode_dependency));
   }
 
   // Override from Task:
@@ -123,9 +125,6 @@
     controller_->UploadTaskCompleted(image_);
   }
 
-  // Override from ImageDecodeTask:
-  bool SupportsConcurrentExecution() const override { return false; }
-
  protected:
   ~ImageUploadTaskImpl() override {}
 
@@ -174,7 +173,7 @@
 bool GpuImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& draw_image,
     uint64_t prepare_tiles_id,
-    scoped_refptr<ImageDecodeTask>* task) {
+    scoped_refptr<TileTask>* task) {
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
@@ -202,7 +201,7 @@
 
   // We didn't have a pre-uploaded image, so we need an upload task. Try to find
   // an existing one.
-  scoped_refptr<ImageDecodeTask>& existing_task =
+  scoped_refptr<TileTask>& existing_task =
       pending_image_upload_tasks_[image_id];
   if (existing_task) {
     // We had an existing upload task, ref the image and return the task.
@@ -387,9 +386,9 @@
 
 // Checks if an existing image decode exists. If not, returns a task to produce
 // the requested decode.
-scoped_refptr<ImageDecodeTask>
-GpuImageDecodeController::GetImageDecodeTaskAndRef(const DrawImage& draw_image,
-                                                   uint64_t prepare_tiles_id) {
+scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
+    const DrawImage& draw_image,
+    uint64_t prepare_tiles_id) {
   lock_.AssertAcquired();
 
   const uint32_t image_id = draw_image.image()->uniqueID();
@@ -408,7 +407,7 @@
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
-  scoped_refptr<ImageDecodeTask>& existing_task =
+  scoped_refptr<TileTask>& existing_task =
       pending_image_decode_tasks_[image_id];
   if (!existing_task) {
     // Ref image decode and create a decode task. This ref will be released in
diff --git a/cc/tiles/gpu_image_decode_controller.h b/cc/tiles/gpu_image_decode_controller.h
index 10b03e13..32b2b4c 100644
--- a/cc/tiles/gpu_image_decode_controller.h
+++ b/cc/tiles/gpu_image_decode_controller.h
@@ -61,7 +61,7 @@
   // upload task to upload the image if an exsiting image does not exist.
   bool GetTaskForImageAndRef(const DrawImage& image,
                              uint64_t prepare_tiles_id,
-                             scoped_refptr<ImageDecodeTask>* task) override;
+                             scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& draw_image) override;
   void DrawWithImageFinished(const DrawImage& image,
@@ -135,9 +135,8 @@
 
   // Similar to GetTaskForImageAndRef, but gets the dependent decode task
   // rather than the upload task, if necessary.
-  scoped_refptr<ImageDecodeTask> GetImageDecodeTaskAndRef(
-      const DrawImage& image,
-      uint64_t prepare_tiles_id);
+  scoped_refptr<TileTask> GetImageDecodeTaskAndRef(const DrawImage& image,
+                                                   uint64_t prepare_tiles_id);
 
   void RefImageDecode(const DrawImage& draw_image);
   void UnrefImageDecode(const DrawImage& draw_image);
@@ -170,9 +169,9 @@
   // All members below this point must only be accessed while holding |lock_|.
   base::Lock lock_;
 
-  std::unordered_map<uint32_t, scoped_refptr<ImageDecodeTask>>
+  std::unordered_map<uint32_t, scoped_refptr<TileTask>>
       pending_image_upload_tasks_;
-  std::unordered_map<uint32_t, scoped_refptr<ImageDecodeTask>>
+  std::unordered_map<uint32_t, scoped_refptr<TileTask>>
       pending_image_decode_tasks_;
 
   ImageDataMRUCache image_data_;
diff --git a/cc/tiles/gpu_image_decode_controller_unittest.cc b/cc/tiles/gpu_image_decode_controller_unittest.cc
index fef46e9..71bc063 100644
--- a/cc/tiles/gpu_image_decode_controller_unittest.cc
+++ b/cc/tiles/gpu_image_decode_controller_unittest.cc
@@ -31,25 +31,25 @@
   return matrix;
 }
 
-void ScheduleTask(ImageDecodeTask* task) {
+void ScheduleTask(TileTask* task) {
   task->WillSchedule();
   task->ScheduleOnOriginThread(nullptr);
   task->DidSchedule();
 }
 
-void RunTask(ImageDecodeTask* task) {
+void RunTask(TileTask* task) {
   task->WillRun();
   task->RunOnWorkerThread();
   task->DidRun();
 }
 
-void CompleteTask(ImageDecodeTask* task) {
+void CompleteTask(TileTask* task) {
   task->WillComplete();
   task->CompleteOnOriginThread(nullptr);
   task->DidComplete();
 }
 
-void ProcessTask(ImageDecodeTask* task) {
+void ProcessTask(TileTask* task) {
   ScheduleTask(task);
   RunTask(task);
   CompleteTask(task);
@@ -68,7 +68,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -77,13 +77,13 @@
   DrawImage another_draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(
       another_draw_image, prepare_tiles_id, &another_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ProcessTask(task.get());
 
   controller.UnrefImage(draw_image);
@@ -104,7 +104,7 @@
       first_image.get(),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> first_task;
+  scoped_refptr<TileTask> first_task;
   bool need_unref = controller.GetTaskForImageAndRef(
       first_draw_image, prepare_tiles_id, &first_task);
   EXPECT_TRUE(need_unref);
@@ -115,16 +115,16 @@
       second_image.get(),
       SkIRect::MakeWH(second_image->width(), second_image->height()), quality,
       CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> second_task;
+  scoped_refptr<TileTask> second_task;
   need_unref = controller.GetTaskForImageAndRef(second_draw_image,
                                                 prepare_tiles_id, &second_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(second_task);
   EXPECT_TRUE(first_task.get() != second_task.get());
 
-  ProcessTask(first_task->dependency().get());
+  ProcessTask(first_task->dependencies()[0].get());
   ProcessTask(first_task.get());
-  ProcessTask(second_task->dependency().get());
+  ProcessTask(second_task->dependencies()[0].get());
   ProcessTask(second_task.get());
 
   controller.UnrefImage(first_draw_image);
@@ -144,18 +144,19 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
-  EXPECT_TRUE(task->dependency());
+  EXPECT_EQ(task->dependencies().size(), 1u);
+  EXPECT_TRUE(task->dependencies()[0]);
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ScheduleTask(task.get());
   RunTask(task.get());
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -180,16 +181,16 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ScheduleTask(task.get());
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -203,14 +204,14 @@
   controller.UnrefImage(draw_image);
 
   // Here a new task is created.
-  scoped_refptr<ImageDecodeTask> third_task;
+  scoped_refptr<TileTask> third_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &third_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task);
   EXPECT_FALSE(third_task.get() == task.get());
 
-  ProcessTask(third_task->dependency().get());
+  ProcessTask(third_task->dependencies()[0].get());
   ProcessTask(third_task.get());
 
   controller.UnrefImage(draw_image);
@@ -230,16 +231,16 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ScheduleTask(task.get());
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -250,14 +251,14 @@
 
   // Note that here, everything is reffed, but a new task is created. This is
   // possible with repeated schedule/cancel operations.
-  scoped_refptr<ImageDecodeTask> third_task;
+  scoped_refptr<TileTask> third_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &third_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task);
   EXPECT_FALSE(third_task.get() == task.get());
 
-  ProcessTask(third_task->dependency().get());
+  ProcessTask(third_task->dependencies()[0].get());
   ProcessTask(third_task.get());
 
   // 3 Unrefs!
@@ -279,13 +280,13 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ProcessTask(task.get());
 
   // Must hold context lock before calling GetDecodedImageForDraw /
@@ -314,13 +315,13 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ProcessTask(task.get());
 
   // Must hold context lock before calling GetDecodedImageForDraw /
@@ -353,7 +354,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(need_unref);
@@ -388,7 +389,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(need_unref);
@@ -410,7 +411,7 @@
   // cache.
   controller.DrawWithImageFinished(draw_image, decoded_draw_image);
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   bool another_task_needs_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(another_task_needs_unref);
@@ -467,7 +468,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(task);
@@ -497,7 +498,7 @@
       image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(task);
@@ -527,15 +528,15 @@
       image.get(), SkIRect::MakeXYWH(0, 0, image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_NE(0u, controller.GetBytesUsedForTesting());
   EXPECT_TRUE(task);
   EXPECT_TRUE(need_unref);
 
-  ScheduleTask(task->dependency().get());
-  CompleteTask(task->dependency().get());
+  ScheduleTask(task->dependencies()[0].get());
+  CompleteTask(task->dependencies()[0].get());
   ScheduleTask(task.get());
   CompleteTask(task.get());
 
@@ -556,7 +557,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   {
     bool need_unref =
         controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
@@ -564,7 +565,7 @@
     EXPECT_TRUE(task);
   }
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ProcessTask(task.get());
 
   controller.UnrefImage(draw_image);
@@ -594,7 +595,7 @@
     EXPECT_TRUE(task);
   }
 
-  ProcessTask(task->dependency().get());
+  ProcessTask(task->dependencies()[0].get());
   ProcessTask(task.get());
 
   // The image should be in our cache after un-ref.
diff --git a/cc/tiles/image_decode_controller.h b/cc/tiles/image_decode_controller.h
index 6d3cd29a..af7c22a 100644
--- a/cc/tiles/image_decode_controller.h
+++ b/cc/tiles/image_decode_controller.h
@@ -11,14 +11,14 @@
 
 namespace cc {
 
-class ImageDecodeTask;
+class TileTask;
 
 // ImageDecodeController is responsible for generating decode tasks, decoding
 // images, storing images in cache, and being able to return the decoded images
 // when requested.
 
 // ImageDecodeController is responsible for the following things:
-// 1. Given a DrawImage, it can return an ImageDecodeTask which when run will
+// 1. Given a DrawImage, it can return an TileTask which when run will
 //    decode and cache the resulting image. If the image does not need a task to
 //    be decoded, then nullptr will be returned. The return value of the
 //    function indicates whether the image was or is going to be locked, so an
@@ -35,7 +35,7 @@
  public:
   virtual ~ImageDecodeController() {}
 
-  // Fill in an ImageDecodeTask which will decode the given image when run. In
+  // Fill in an TileTask which will decode the given image when run. In
   // case the image is already cached, fills in nullptr. Returns true if the
   // image needs to be unreffed when the caller is finished with it.
   //
@@ -43,7 +43,7 @@
   // a raster task.
   virtual bool GetTaskForImageAndRef(const DrawImage& image,
                                      uint64_t prepare_tiles_id,
-                                     scoped_refptr<ImageDecodeTask>* task) = 0;
+                                     scoped_refptr<TileTask>* task) = 0;
   // Unrefs an image. When the tile is finished, this should be called for every
   // GetTaskForImageAndRef call that returned true.
   virtual void UnrefImage(const DrawImage& image) = 0;
diff --git a/cc/tiles/software_image_decode_controller.cc b/cc/tiles/software_image_decode_controller.cc
index f05bb5d..80190b4 100644
--- a/cc/tiles/software_image_decode_controller.cc
+++ b/cc/tiles/software_image_decode_controller.cc
@@ -41,7 +41,7 @@
  public:
   AutoRemoveKeyFromTaskMap(
       std::unordered_map<SoftwareImageDecodeController::ImageKey,
-                         scoped_refptr<ImageDecodeTask>,
+                         scoped_refptr<TileTask>,
                          SoftwareImageDecodeController::ImageKeyHash>* task_map,
       const SoftwareImageDecodeController::ImageKey& key)
       : task_map_(task_map), key_(key) {}
@@ -49,18 +49,19 @@
 
  private:
   std::unordered_map<SoftwareImageDecodeController::ImageKey,
-                     scoped_refptr<ImageDecodeTask>,
+                     scoped_refptr<TileTask>,
                      SoftwareImageDecodeController::ImageKeyHash>* task_map_;
   SoftwareImageDecodeController::ImageKey key_;
 };
 
-class ImageDecodeTaskImpl : public ImageDecodeTask {
+class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
                       const SoftwareImageDecodeController::ImageKey& image_key,
                       const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
-      : controller_(controller),
+      : TileTask(true),
+        controller_(controller),
         image_key_(image_key),
         image_(image),
         image_ref_(skia::SharePtr(image.image())),
@@ -152,7 +153,7 @@
 bool SoftwareImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& image,
     uint64_t prepare_tiles_id,
-    scoped_refptr<ImageDecodeTask>* task) {
+    scoped_refptr<TileTask>* task) {
   // If the image already exists or if we're going to create a task for it, then
   // we'll likely need to ref this image (the exception is if we're prerolling
   // the image only). That means the image is or will be in the cache. When the
@@ -179,7 +180,7 @@
   if (!CanHandleImage(key)) {
     base::AutoLock lock(lock_);
     if (prerolled_images_.count(key.image_id()) == 0) {
-      scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+      scoped_refptr<TileTask>& existing_task = pending_image_tasks_[key];
       if (!existing_task) {
         existing_task = make_scoped_refptr(
             new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
@@ -212,7 +213,7 @@
   }
 
   // If the task exists, return it.
-  scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+  scoped_refptr<TileTask>& existing_task = pending_image_tasks_[key];
   if (existing_task) {
     RefImage(key);
     *task = existing_task;
diff --git a/cc/tiles/software_image_decode_controller.h b/cc/tiles/software_image_decode_controller.h
index 9697720..8f6ed0d 100644
--- a/cc/tiles/software_image_decode_controller.h
+++ b/cc/tiles/software_image_decode_controller.h
@@ -110,7 +110,7 @@
   // ImageDecodeController overrides.
   bool GetTaskForImageAndRef(const DrawImage& image,
                              uint64_t prepare_tiles_id,
-                             scoped_refptr<ImageDecodeTask>* task) override;
+                             scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& image) override;
   void DrawWithImageFinished(const DrawImage& image,
@@ -241,7 +241,7 @@
                                const char* cache_name,
                                base::trace_event::ProcessMemoryDump* pmd) const;
 
-  std::unordered_map<ImageKey, scoped_refptr<ImageDecodeTask>, ImageKeyHash>
+  std::unordered_map<ImageKey, scoped_refptr<TileTask>, ImageKeyHash>
       pending_image_tasks_;
 
   // The members below this comment can only be accessed if the lock is held to
diff --git a/cc/tiles/software_image_decode_controller_unittest.cc b/cc/tiles/software_image_decode_controller_unittest.cc
index 38246b38..cbf6e3c 100644
--- a/cc/tiles/software_image_decode_controller_unittest.cc
+++ b/cc/tiles/software_image_decode_controller_unittest.cc
@@ -359,7 +359,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -368,7 +368,7 @@
   DrawImage another_draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(
       another_draw_image, prepare_tiles_id, &another_task);
   EXPECT_TRUE(need_unref);
@@ -389,7 +389,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()),
       kHigh_SkFilterQuality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> high_quality_task;
+  scoped_refptr<TileTask> high_quality_task;
   bool need_unref = controller.GetTaskForImageAndRef(
       high_quality_draw_image, prepare_tiles_id, &high_quality_task);
   EXPECT_TRUE(need_unref);
@@ -399,7 +399,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()),
       kMedium_SkFilterQuality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> medium_quality_task;
+  scoped_refptr<TileTask> medium_quality_task;
   need_unref = controller.GetTaskForImageAndRef(
       medium_quality_draw_image, prepare_tiles_id, &medium_quality_task);
   // Medium quality isn't handled by the controller, so it won't ref it. Note
@@ -413,7 +413,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()),
       kLow_SkFilterQuality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> low_quality_task;
+  scoped_refptr<TileTask> low_quality_task;
   need_unref = controller.GetTaskForImageAndRef(
       low_quality_draw_image, prepare_tiles_id, &low_quality_task);
   EXPECT_TRUE(need_unref);
@@ -435,7 +435,7 @@
   DrawImage half_size_draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> half_size_task;
+  scoped_refptr<TileTask> half_size_task;
   bool need_unref = controller.GetTaskForImageAndRef(
       half_size_draw_image, prepare_tiles_id, &half_size_task);
   EXPECT_TRUE(need_unref);
@@ -444,7 +444,7 @@
   DrawImage quarter_size_draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> quarter_size_task;
+  scoped_refptr<TileTask> quarter_size_task;
   need_unref = controller.GetTaskForImageAndRef(
       quarter_size_draw_image, prepare_tiles_id, &quarter_size_task);
   EXPECT_TRUE(need_unref);
@@ -466,7 +466,7 @@
       first_image.get(),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> first_task;
+  scoped_refptr<TileTask> first_task;
   bool need_unref = controller.GetTaskForImageAndRef(
       first_draw_image, prepare_tiles_id, &first_task);
   EXPECT_TRUE(need_unref);
@@ -477,7 +477,7 @@
       second_image.get(),
       SkIRect::MakeWH(second_image->width(), second_image->height()), quality,
       CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> second_task;
+  scoped_refptr<TileTask> second_task;
   need_unref = controller.GetTaskForImageAndRef(second_draw_image,
                                                 prepare_tiles_id, &second_task);
   EXPECT_TRUE(need_unref);
@@ -498,7 +498,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -509,7 +509,7 @@
   task->DidSchedule();
   task->RunOnWorkerThread();
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -533,7 +533,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -544,7 +544,7 @@
   task->DidSchedule();
   task->RunOnWorkerThread();
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -554,7 +554,7 @@
   task->CompleteOnOriginThread(nullptr);
   task->DidComplete();
 
-  scoped_refptr<ImageDecodeTask> third_task;
+  scoped_refptr<TileTask> third_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &third_task);
   EXPECT_TRUE(need_unref);
@@ -575,7 +575,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -585,7 +585,7 @@
   task->ScheduleOnOriginThread(nullptr);
   task->DidSchedule();
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -601,7 +601,7 @@
   controller.UnrefImage(draw_image);
 
   // Here a new task is created.
-  scoped_refptr<ImageDecodeTask> third_task;
+  scoped_refptr<TileTask> third_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &third_task);
   EXPECT_TRUE(need_unref);
@@ -622,7 +622,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -632,7 +632,7 @@
   task->ScheduleOnOriginThread(nullptr);
   task->DidSchedule();
 
-  scoped_refptr<ImageDecodeTask> another_task;
+  scoped_refptr<TileTask> another_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &another_task);
   EXPECT_TRUE(need_unref);
@@ -645,7 +645,7 @@
 
   // Note that here, everything is reffed, but a new task is created. This is
   // possible with repeated schedule/cancel operations.
-  scoped_refptr<ImageDecodeTask> third_task;
+  scoped_refptr<TileTask> third_task;
   need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
                                                 &third_task);
   EXPECT_TRUE(need_unref);
@@ -668,7 +668,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -710,7 +710,7 @@
   DrawImage draw_image(
       image.get(), SkIRect::MakeXYWH(20, 30, image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -819,7 +819,7 @@
   EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
   EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -873,7 +873,7 @@
   EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
   EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(need_unref);
@@ -916,7 +916,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(task);
@@ -940,7 +940,7 @@
       image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_FALSE(task);
@@ -964,7 +964,7 @@
       image.get(), SkIRect::MakeWH(image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(task);
@@ -991,7 +991,7 @@
   DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(task);
@@ -1020,7 +1020,7 @@
   DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
 
-  scoped_refptr<ImageDecodeTask> task;
+  scoped_refptr<TileTask> task;
   bool need_unref =
       controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
   EXPECT_TRUE(task);
diff --git a/cc/tiles/tile.h b/cc/tiles/tile.h
index f6dd675..9dc8afc 100644
--- a/cc/tiles/tile.h
+++ b/cc/tiles/tile.h
@@ -144,7 +144,7 @@
 
   unsigned scheduled_priority_;
 
-  scoped_refptr<RasterTask> raster_task_;
+  scoped_refptr<TileTask> raster_task_;
 
   DISALLOW_COPY_AND_ASSIGN(Tile);
 };
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index cec859ff..74f1707e 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -42,7 +42,7 @@
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
-class RasterTaskImpl : public RasterTask {
+class RasterTaskImpl : public TileTask {
  public:
   RasterTaskImpl(const Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
@@ -59,8 +59,8 @@
                  uint64_t resource_content_id,
                  int source_frame_number,
                  const base::Callback<void(bool)>& reply,
-                 ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                 TileTask::Vector* dependencies)
+      : TileTask(true, dependencies),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
@@ -156,15 +156,18 @@
 }
 
 void InsertNodeForDecodeTask(TaskGraph* graph,
-                             ImageDecodeTask* task,
+                             TileTask* task,
                              uint16_t category,
                              uint16_t priority) {
   uint32_t dependency_count = 0u;
-  auto* dependency = task->dependency().get();
-  if (dependency && !dependency->HasCompleted()) {
-    InsertNodeForDecodeTask(graph, dependency, category, priority);
-    graph->edges.push_back(TaskGraph::Edge(dependency, task));
-    dependency_count = 1u;
+  if (task->dependencies().size()) {
+    DCHECK_EQ(task->dependencies().size(), 1u);
+    auto* dependency = task->dependencies()[0].get();
+    if (!dependency->HasCompleted()) {
+      InsertNodeForDecodeTask(graph, dependency, category, priority);
+      graph->edges.push_back(TaskGraph::Edge(dependency, task));
+      dependency_count = 1u;
+    }
   }
   InsertNodeForTask(graph, task, task->SupportsConcurrentExecution()
                                      ? category
@@ -173,8 +176,8 @@
 }
 
 void InsertNodesForRasterTask(TaskGraph* graph,
-                              RasterTask* raster_task,
-                              const ImageDecodeTask::Vector& decode_tasks,
+                              TileTask* raster_task,
+                              const TileTask::Vector& decode_tasks,
                               size_t priority,
                               bool use_gpu_rasterization,
                               bool high_priority) {
@@ -198,9 +201,9 @@
       high_priority ? TASK_CATEGORY_FOREGROUND : TASK_CATEGORY_BACKGROUND;
 
   // Insert image decode tasks.
-  for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
+  for (TileTask::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end(); ++it) {
-    ImageDecodeTask* decode_task = it->get();
+    TileTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
@@ -242,7 +245,8 @@
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& on_task_set_finished_callback)
-      : task_runner_(task_runner),
+      : TileTask(true),
+        task_runner_(task_runner),
         on_task_set_finished_callback_(on_task_set_finished_callback) {}
 
   // Overridden from Task:
@@ -779,7 +783,7 @@
     if (!tile->raster_task_)
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
-    RasterTask* task = tile->raster_task_.get();
+    TileTask* task = tile->raster_task_.get();
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
@@ -845,7 +849,7 @@
                                ScheduledTasksStateAsValue());
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(
+scoped_refptr<TileTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
@@ -872,7 +876,7 @@
       prioritized_tile.priority().resolution == LOW_RESOLUTION;
 
   // Create and queue all image decode tasks that this tile depends on.
-  ImageDecodeTask::Vector decode_tasks;
+  TileTask::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (!playback_settings.skip_images) {
@@ -883,7 +887,7 @@
   // We can skip the image hijack canvas if we have no images.
   playback_settings.use_image_hijack_canvas = !images.empty();
   for (auto it = images.begin(); it != images.end();) {
-    scoped_refptr<ImageDecodeTask> task;
+    scoped_refptr<TileTask> task;
     bool need_to_unref_when_finished =
         image_decode_controller_->GetTaskForImageAndRef(
             *it, prepare_tiles_count_, &task);
diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index 94eac03..d58d5b0 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h
@@ -249,7 +249,7 @@
 
   void FreeResourcesForTile(Tile* tile);
   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
-  scoped_refptr<RasterTask> CreateRasterTask(
+  scoped_refptr<TileTask> CreateRasterTask(
       const PrioritizedTile& prioritized_tile);
 
   std::unique_ptr<EvictionTilePriorityQueue>
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 9feb348..ba9b674e 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -74,6 +74,7 @@
 class SwapPromise;
 class SwapPromiseMonitor;
 class SynchronousTaskGraphRunner;
+class TaskGraphRunner;
 class TextureMailboxDeleter;
 class TopControlsManager;
 class UIResourceBitmap;