cc: Refactor RasterWorkerPool for better testing support.

This makes a number of RasterWorkerPool changes that are necessary
to implement proper performance tests and replaces existing tests
with more useful tests using realistic raster task numbers.

RasterWorkerPool is modified to allow tests to use a different
TaskGraphRunner instance. PixelBufferRasterWorkerPool
implementation is adjusted so repeated calls to ScheduleTasks
doesn't flood the message loop with canceled tasks.

BUG=246546

Review URL: https://codereview.chromium.org/150783004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@249959 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 487 insertions, 249 deletions

diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc
index 45cd08f..61478de 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -11,12 +11,37 @@
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 
 namespace cc {
+namespace {
+
+class RasterTaskGraphRunner : public internal::TaskGraphRunner {
+ public:
+  RasterTaskGraphRunner()
+      : internal::TaskGraphRunner(RasterWorkerPool::GetNumRasterThreads(),
+                                  "CompositorRaster") {}
+};
+base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static
+scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
+    ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
+    unsigned texture_target) {
+  return make_scoped_ptr<RasterWorkerPool>(
+      new ImageRasterWorkerPool(g_task_graph_runner.Pointer(),
+                                resource_provider,
+                                context_provider,
+                                texture_target));
+}
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
+    internal::TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider,
     unsigned texture_target)
-    : RasterWorkerPool(resource_provider, context_provider),
+    : RasterWorkerPool(task_graph_runner, resource_provider, context_provider),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {}
diff --git a/cc/resources/image_raster_worker_pool.h b/cc/resources/image_raster_worker_pool.h
index b0eb14b..a349564 100644
--- a/cc/resources/image_raster_worker_pool.h
+++ b/cc/resources/image_raster_worker_pool.h
@@ -16,10 +16,7 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool {
   static scoped_ptr<RasterWorkerPool> Create(
       ResourceProvider* resource_provider,
       ContextProvider* context_provider,
-      unsigned texture_target) {
-    return make_scoped_ptr<RasterWorkerPool>(new ImageRasterWorkerPool(
-        resource_provider, context_provider, texture_target));
-  }
+      unsigned texture_target);
 
   // Overridden from RasterWorkerPool:
   virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE;
@@ -35,11 +32,13 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool {
       OVERRIDE;
   virtual void OnImageDecodeCompleted(internal::WorkerPoolTask* task) OVERRIDE;
 
- private:
-  ImageRasterWorkerPool(ResourceProvider* resource_provider,
+ protected:
+  ImageRasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
+                        ResourceProvider* resource_provider,
                         ContextProvider* context_provider,
                         unsigned texture_target);
 
+ private:
   // Overridden from RasterWorkerPool:
   virtual void OnRasterTasksFinished() OVERRIDE;
   virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE;
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index 32a79aa..e87f995 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -25,13 +25,35 @@ bool WasCanceled(const internal::RasterWorkerPoolTask* task) {
   return !task->HasFinishedRunning();
 }
 
+class RasterTaskGraphRunner : public internal::TaskGraphRunner {
+ public:
+  RasterTaskGraphRunner()
+      : internal::TaskGraphRunner(RasterWorkerPool::GetNumRasterThreads(),
+                                  "CompositorRaster") {}
+};
+base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
+// static
+scoped_ptr<RasterWorkerPool> PixelBufferRasterWorkerPool::Create(
+    ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
+    size_t max_transfer_buffer_usage_bytes) {
+  return make_scoped_ptr<RasterWorkerPool>(
+      new PixelBufferRasterWorkerPool(g_task_graph_runner.Pointer(),
+                                      resource_provider,
+                                      context_provider,
+                                      max_transfer_buffer_usage_bytes));
+}
+
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
+    internal::TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider,
     size_t max_transfer_buffer_usage_bytes)
-    : RasterWorkerPool(resource_provider, context_provider),
+    : RasterWorkerPool(task_graph_runner, resource_provider, context_provider),
       shutdown_(false),
       scheduled_raster_task_count_(0),
       bytes_pending_upload_(0),
@@ -42,7 +64,8 @@ PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
       should_notify_client_if_no_tasks_required_for_activation_are_pending_(
           false),
       raster_finished_task_pending_(false),
-      raster_required_for_activation_finished_task_pending_(false) {}
+      raster_required_for_activation_finished_task_pending_(false),
+      weak_factory_(this) {}
 
 PixelBufferRasterWorkerPool::~PixelBufferRasterWorkerPool() {
   DCHECK(shutdown_);
@@ -59,8 +82,10 @@ void PixelBufferRasterWorkerPool::Shutdown() {
 
   CheckForCompletedWorkerPoolTasks();
   CheckForCompletedUploads();
-  check_for_completed_raster_tasks_callback_.Cancel();
+
+  weak_factory_.InvalidateWeakPtrs();
   check_for_completed_raster_tasks_pending_ = false;
+
   for (RasterTaskStateMap::iterator it = raster_task_states_.begin();
        it != raster_task_states_.end();
        ++it) {
@@ -160,8 +185,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
 
   // Cancel any pending check for completed raster tasks and schedule
   // another check.
-  check_for_completed_raster_tasks_callback_.Cancel();
-  check_for_completed_raster_tasks_pending_ = false;
+  check_for_completed_raster_tasks_time_ = base::TimeTicks();
   ScheduleCheckForCompletedRasterTasks();
 
   if (!gpu_raster_tasks.empty())
@@ -393,27 +417,52 @@ void PixelBufferRasterWorkerPool::CheckForCompletedUploads() {
 }
 
 void PixelBufferRasterWorkerPool::ScheduleCheckForCompletedRasterTasks() {
+  base::TimeDelta delay =
+      base::TimeDelta::FromMilliseconds(kCheckForCompletedRasterTasksDelayMs);
+  if (check_for_completed_raster_tasks_time_.is_null())
+    check_for_completed_raster_tasks_time_ = base::TimeTicks::Now() + delay;
+
   if (check_for_completed_raster_tasks_pending_)
     return;
 
-  check_for_completed_raster_tasks_callback_.Reset(
-      base::Bind(&PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks,
-                 base::Unretained(this)));
   base::MessageLoopProxy::current()->PostDelayedTask(
       FROM_HERE,
-      check_for_completed_raster_tasks_callback_.callback(),
-      base::TimeDelta::FromMilliseconds(kCheckForCompletedRasterTasksDelayMs));
+      base::Bind(&PixelBufferRasterWorkerPool::OnCheckForCompletedRasterTasks,
+                 weak_factory_.GetWeakPtr()),
+      delay);
   check_for_completed_raster_tasks_pending_ = true;
 }
 
+void PixelBufferRasterWorkerPool::OnCheckForCompletedRasterTasks() {
+  if (check_for_completed_raster_tasks_time_.is_null()) {
+    check_for_completed_raster_tasks_pending_ = false;
+    return;
+  }
+
+  base::TimeDelta delay =
+      check_for_completed_raster_tasks_time_ - base::TimeTicks::Now();
+
+  // Post another delayed task if it is not yet time to check for completed
+  // raster tasks.
+  if (delay > base::TimeDelta()) {
+    base::MessageLoopProxy::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PixelBufferRasterWorkerPool::OnCheckForCompletedRasterTasks,
+                   weak_factory_.GetWeakPtr()),
+        delay);
+    return;
+  }
+
+  check_for_completed_raster_tasks_pending_ = false;
+  CheckForCompletedRasterTasks();
+}
+
 void PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks() {
   TRACE_EVENT0("cc",
                "PixelBufferRasterWorkerPool::CheckForCompletedRasterTasks");
 
   DCHECK(should_notify_client_if_no_tasks_are_pending_);
-
-  check_for_completed_raster_tasks_callback_.Cancel();
-  check_for_completed_raster_tasks_pending_ = false;
+  check_for_completed_raster_tasks_time_ = base::TimeTicks();
 
   CheckForCompletedWorkerPoolTasks();
   CheckForCompletedUploads();
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h
index b0bb93f..b3e1893 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_raster_worker_pool.h
@@ -20,10 +20,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
   static scoped_ptr<RasterWorkerPool> Create(
       ResourceProvider* resource_provider,
       ContextProvider* context_provider,
-      size_t max_transfer_buffer_usage_bytes) {
-    return make_scoped_ptr<RasterWorkerPool>(new PixelBufferRasterWorkerPool(
-        resource_provider, context_provider, max_transfer_buffer_usage_bytes));
-  }
+      size_t max_transfer_buffer_usage_bytes);
 
   // Overridden from RasterWorkerPool:
   virtual void Shutdown() OVERRIDE;
@@ -40,6 +37,12 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
       OVERRIDE;
   virtual void OnImageDecodeCompleted(internal::WorkerPoolTask* task) OVERRIDE;
 
+ protected:
+  PixelBufferRasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
+                              ResourceProvider* resource_provider,
+                              ContextProvider* context_provider,
+                              size_t max_transfer_buffer_usage_bytes);
+
  private:
   enum RasterTaskState { UNSCHEDULED, SCHEDULED, UPLOADING, COMPLETED };
   typedef std::deque<scoped_refptr<internal::RasterWorkerPoolTask> >
@@ -47,10 +50,6 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
   typedef internal::RasterWorkerPoolTask* RasterTaskMapKey;
   typedef base::hash_map<RasterTaskMapKey, RasterTaskState> RasterTaskStateMap;
 
-  PixelBufferRasterWorkerPool(ResourceProvider* resource_provider,
-                              ContextProvider* context_provider,
-                              size_t max_transfer_buffer_usage_bytes);
-
   // Overridden from RasterWorkerPool:
   virtual void OnRasterTasksFinished() OVERRIDE;
   virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE;
@@ -58,6 +57,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
   void FlushUploads();
   void CheckForCompletedUploads();
   void ScheduleCheckForCompletedRasterTasks();
+  void OnCheckForCompletedRasterTasks();
   void CheckForCompletedRasterTasks();
   void ScheduleMoreTasks();
   unsigned PendingRasterTaskCount() const;
@@ -81,14 +81,15 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool {
   size_t bytes_pending_upload_;
   size_t max_bytes_pending_upload_;
   bool has_performed_uploads_since_last_flush_;
-  base::CancelableClosure check_for_completed_raster_tasks_callback_;
+  base::TimeTicks check_for_completed_raster_tasks_time_;
   bool check_for_completed_raster_tasks_pending_;
 
   bool should_notify_client_if_no_tasks_are_pending_;
   bool should_notify_client_if_no_tasks_required_for_activation_are_pending_;
   bool raster_finished_task_pending_;
   bool raster_required_for_activation_finished_task_pending_;
-  ResourceFormat format_;
+
+  base::WeakPtrFactory<PixelBufferRasterWorkerPool> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PixelBufferRasterWorkerPool);
 };
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 510c636..3f164bd 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -448,15 +448,6 @@ class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
       RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
 };
 
-class RasterTaskGraphRunner : public internal::TaskGraphRunner {
- public:
-  RasterTaskGraphRunner()
-      : internal::TaskGraphRunner(RasterWorkerPool::GetNumRasterThreads(),
-                                  "CompositorRaster") {}
-};
-base::LazyInstance<RasterTaskGraphRunner>::Leaky g_task_graph_runner =
-    LAZY_INSTANCE_INITIALIZER;
-
 const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
@@ -550,9 +541,11 @@ unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
     0u;
 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 2u;
 
-RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
+RasterWorkerPool::RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
+                                   ResourceProvider* resource_provider,
                                    ContextProvider* context_provider)
-    : namespace_token_(g_task_graph_runner.Pointer()->GetNamespaceToken()),
+    : task_graph_runner_(task_graph_runner),
+      namespace_token_(task_graph_runner_->GetNamespaceToken()),
       client_(NULL),
       resource_provider_(resource_provider),
       context_provider_(context_provider),
@@ -626,7 +619,7 @@ void RasterWorkerPool::Shutdown() {
   raster_tasks_.clear();
   internal::TaskGraph empty;
   SetTaskGraph(&empty);
-  g_task_graph_runner.Pointer()->WaitForTasksToFinishRunning(namespace_token_);
+  task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
@@ -659,13 +652,12 @@ void RasterWorkerPool::SetTaskGraph(internal::TaskGraph* graph) {
     }
   }
 
-  g_task_graph_runner.Pointer()->SetTaskGraph(namespace_token_, graph);
+  task_graph_runner_->SetTaskGraph(namespace_token_, graph);
 }
 
 void RasterWorkerPool::CollectCompletedWorkerPoolTasks(
     internal::Task::Vector* completed_tasks) {
-  g_task_graph_runner.Pointer()->CollectCompletedTasks(namespace_token_,
-                                                       completed_tasks);
+  task_graph_runner_->CollectCompletedTasks(namespace_token_, completed_tasks);
 }
 
 void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) {
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 81a9f9a..a161547 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -59,7 +59,6 @@ class CC_EXPORT WorkerPoolTask : public Task {
   WorkerPoolTask();
   virtual ~WorkerPoolTask();
 
- private:
   bool did_schedule_;
   bool did_complete_;
 };
@@ -127,7 +126,6 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
 
      private:
       friend class RasterWorkerPool;
-      friend class RasterWorkerPoolTest;
 
       internal::Task::Vector tasks_;
     };
@@ -143,7 +141,6 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
 
    protected:
     friend class RasterWorkerPool;
-    friend class RasterWorkerPoolTest;
 
     explicit Task(internal::WorkerPoolTask* internal);
 
@@ -183,7 +180,6 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
 
    protected:
     friend class RasterWorkerPool;
-    friend class RasterWorkerPoolTest;
 
     explicit RasterTask(internal::RasterWorkerPoolTask* internal);
 
@@ -247,7 +243,8 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
       RasterTaskVector;
   typedef base::hash_set<internal::RasterWorkerPoolTask*> RasterTaskSet;
 
-  RasterWorkerPool(ResourceProvider* resource_provider,
+  RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
+                   ResourceProvider* resource_provider,
                    ContextProvider* context_provider);
 
   virtual void OnRasterTasksFinished() = 0;
@@ -307,6 +304,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   void OnRasterRequiredForActivationFinished(
       const internal::WorkerPoolTask* source);
 
+  internal::TaskGraphRunner* task_graph_runner_;
   internal::NamespaceToken namespace_token_;
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index 274bfd0..cafc712 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -5,7 +5,14 @@
 #include "cc/resources/raster_worker_pool.h"
 
 #include "base/time/time.h"
+#include "cc/resources/image_raster_worker_pool.h"
+#include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/resource_provider.h"
+#include "cc/resources/scoped_resource.h"
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_output_surface_client.h"
 #include "cc/test/lap_timer.h"
+#include "cc/test/test_web_graphics_context_3d.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ -13,181 +20,241 @@
 namespace cc {
 namespace {
 
+enum RasterWorkerPoolType {
+  RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
+  RASTER_WORKER_POOL_TYPE_IMAGE
+};
+
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class PerfRasterWorkerPool : public RasterWorkerPool {
+class PerfWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
-  PerfRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}
-  virtual ~PerfRasterWorkerPool() {}
-
-  static scoped_ptr<PerfRasterWorkerPool> Create() {
-    return make_scoped_ptr(new PerfRasterWorkerPool);
-  }
+  PerfWorkerPoolTaskImpl() {}
 
-  // Overridden from RasterWorkerPool:
-  virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE {
-    NOTREACHED();
-  }
-  virtual unsigned GetResourceTarget() const OVERRIDE {
-    NOTREACHED();
-    return GL_TEXTURE_2D;
-  }
-  virtual ResourceFormat GetResourceFormat() const OVERRIDE {
-    NOTREACHED();
-    return RGBA_8888;
-  }
-  virtual void CheckForCompletedTasks() OVERRIDE {
-    internal::Task::Vector completed_tasks;
-    CollectCompletedWorkerPoolTasks(&completed_tasks);
+  // Overridden from internal::Task:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {}
 
-    for (internal::Task::Vector::const_iterator it = completed_tasks.begin();
-         it != completed_tasks.end();
-         ++it) {
-      internal::WorkerPoolTask* task =
-          static_cast<internal::WorkerPoolTask*>(it->get());
+  // Overridden from internal::WorkerPoolTask:
+  virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
+      OVERRIDE {}
+  virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
+      OVERRIDE {}
+  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
 
-      task->WillComplete();
-      task->CompleteOnOriginThread(this);
-      task->DidComplete();
+  void Reset() {
+    did_run_ = false;
+    did_complete_ = false;
+  }
 
-      task->RunReplyOnOriginThread();
-    }
+ protected:
+  virtual ~PerfWorkerPoolTaskImpl() {}
 
-    CheckForCompletedGpuRasterTasks();
-  }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PerfWorkerPoolTaskImpl);
+};
 
-  // Overridden from internal::WorkerPoolTaskClient:
-  virtual void* AcquireBufferForRaster(internal::RasterWorkerPoolTask* task,
-                                       int* stride) OVERRIDE {
-    return NULL;
+class PerfRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
+ public:
+  PerfRasterWorkerPoolTaskImpl(scoped_ptr<ScopedResource> resource,
+                               internal::Task::Vector* dependencies)
+      : internal::RasterWorkerPoolTask(resource.get(), dependencies, false),
+        resource_(resource.Pass()) {}
+
+  // Overridden from internal::Task:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {}
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
+      OVERRIDE {
+    int stride;
+    client->AcquireBufferForRaster(this, &stride);
   }
-  virtual void OnRasterCompleted(internal::RasterWorkerPoolTask* task,
-                                 const PicturePileImpl::Analysis& analysis)
-      OVERRIDE {}
-  virtual void OnImageDecodeCompleted(internal::WorkerPoolTask* task) OVERRIDE {
+  virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
+      OVERRIDE {
+    client->OnRasterCompleted(this, PicturePileImpl::Analysis());
   }
+  virtual void RunReplyOnOriginThread() OVERRIDE { Reset(); }
 
-  virtual void OnRasterTasksFinished() OVERRIDE { NOTREACHED(); }
-  virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE {
-    NOTREACHED();
-  }
+  // Overridden from internal::RasterWorkerPoolTask:
+  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
+                                 ContextProvider* context_provider) OVERRIDE {}
 
-  void SetRasterTasks(RasterTask::Queue* queue) {
-    RasterWorkerPool::SetRasterTasks(queue);
+  void Reset() {
+    did_run_ = false;
+    did_complete_ = false;
   }
 
-  void BuildTaskGraph() {
-    unsigned priority = 2u;
-    internal::TaskGraph graph;
+ protected:
+  virtual ~PerfRasterWorkerPoolTaskImpl() {}
+
+ private:
+  scoped_ptr<ScopedResource> resource_;
 
-    scoped_refptr<internal::WorkerPoolTask>
-        raster_required_for_activation_finished_task(
-            CreateRasterRequiredForActivationFinishedTask(
-                raster_tasks_required_for_activation().size()));
-    scoped_refptr<internal::WorkerPoolTask> raster_finished_task(
-        CreateRasterFinishedTask());
+  DISALLOW_COPY_AND_ASSIGN(PerfRasterWorkerPoolTaskImpl);
+};
+
+class PerfTaskGraphRunnerImpl : public internal::TaskGraphRunner {
+ public:
+  PerfTaskGraphRunnerImpl() : internal::TaskGraphRunner(0, "Perf") {}
+};
 
-    size_t raster_required_for_activation_finished_dependencies = 0u;
-    size_t raster_finished_dependencies = 0u;
+class PerfPixelBufferRasterWorkerPoolImpl : public PixelBufferRasterWorkerPool {
+ public:
+  PerfPixelBufferRasterWorkerPoolImpl(
+      internal::TaskGraphRunner* task_graph_runner,
+      ResourceProvider* resource_provider)
+      : PixelBufferRasterWorkerPool(task_graph_runner,
+                                    resource_provider,
+                                    NULL,
+                                    std::numeric_limits<size_t>::max()) {}
+};
 
-    for (RasterTaskVector::const_iterator it = raster_tasks().begin();
-         it != raster_tasks().end();
-         ++it) {
-      internal::RasterWorkerPoolTask* task = it->get();
+class PerfImageRasterWorkerPoolImpl : public ImageRasterWorkerPool {
+ public:
+  PerfImageRasterWorkerPoolImpl(internal::TaskGraphRunner* task_graph_runner,
+                                ResourceProvider* resource_provider)
+      : ImageRasterWorkerPool(task_graph_runner,
+                              resource_provider,
+                              NULL,
+                              GL_TEXTURE_2D) {}
+};
 
-      if (IsRasterTaskRequiredForActivation(task)) {
-        raster_required_for_activation_finished_dependencies++;
-        graph.edges.push_back(internal::TaskGraph::Edge(
-            task, raster_required_for_activation_finished_task.get()));
-      }
+class RasterWorkerPoolPerfTest
+    : public testing::TestWithParam<RasterWorkerPoolType>,
+      public RasterWorkerPoolClient {
+ public:
+  class Task : public RasterWorkerPool::Task {
+   public:
+    typedef std::vector<Task> Vector;
 
-      InsertNodeForRasterTask(&graph, task, task->dependencies(), priority++);
+    static Task Create() { return Task(new PerfWorkerPoolTaskImpl); }
 
-      raster_finished_dependencies++;
-      graph.edges.push_back(
-          internal::TaskGraph::Edge(task, raster_finished_task.get()));
+    void AppendTo(internal::Task::Vector* dependencies) const {
+      dependencies->push_back(internal_);
     }
 
-    InsertNodeForTask(&graph,
-                      raster_required_for_activation_finished_task.get(),
-                      0u,
-                      raster_required_for_activation_finished_dependencies);
-    InsertNodeForTask(
-        &graph, raster_finished_task.get(), 1u, raster_finished_dependencies);
-  }
+   private:
+    explicit Task(internal::WorkerPoolTask* task)
+        : RasterWorkerPool::Task(task) {}
+  };
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(PerfRasterWorkerPool);
-};
+  class RasterTask : public RasterWorkerPool::RasterTask {
+   public:
+    typedef std::vector<RasterTask> Vector;
+
+    static RasterTask Create(scoped_ptr<ScopedResource> resource,
+                             const Task::Vector& image_decode_tasks) {
+      internal::Task::Vector dependencies;
+      for (Task::Vector::const_iterator it = image_decode_tasks.begin();
+           it != image_decode_tasks.end();
+           ++it)
+        it->AppendTo(&dependencies);
+
+      return RasterTask(
+          new PerfRasterWorkerPoolTaskImpl(resource.Pass(), &dependencies));
+    }
+
+   private:
+    explicit RasterTask(internal::RasterWorkerPoolTask* task)
+        : RasterWorkerPool::RasterTask(task) {}
+  };
 
-class RasterWorkerPoolPerfTest : public testing::Test {
- public:
   RasterWorkerPoolPerfTest()
-      : timer_(kWarmupRuns,
+      : context_provider_(TestContextProvider::Create()),
+        task_graph_runner_(new PerfTaskGraphRunnerImpl),
+        timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
-               kTimeCheckInterval) {}
+               kTimeCheckInterval) {
+    output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+    CHECK(output_surface_->BindToClient(&output_surface_client_));
+
+    resource_provider_ = ResourceProvider::Create(
+                             output_surface_.get(), NULL, 0, false, 1).Pass();
+
+    switch (GetParam()) {
+      case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
+        raster_worker_pool_.reset(new PerfPixelBufferRasterWorkerPoolImpl(
+            task_graph_runner_.get(), resource_provider_.get()));
+        break;
+      case RASTER_WORKER_POOL_TYPE_IMAGE:
+        raster_worker_pool_.reset(new PerfImageRasterWorkerPoolImpl(
+            task_graph_runner_.get(), resource_provider_.get()));
+        break;
+    }
+
+    DCHECK(raster_worker_pool_);
+    raster_worker_pool_->SetClient(this);
+  }
+  virtual ~RasterWorkerPoolPerfTest() { resource_provider_.reset(); }
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
-    raster_worker_pool_ = PerfRasterWorkerPool::Create();
+  virtual void TearDown() OVERRIDE {
+    raster_worker_pool_->Shutdown();
+    raster_worker_pool_->CheckForCompletedTasks();
+  }
+
+  // Overriden from RasterWorkerPoolClient:
+  virtual bool ShouldForceTasksRequiredForActivationToComplete()
+      const OVERRIDE {
+    return false;
+  }
+  virtual void DidFinishRunningTasks() OVERRIDE {}
+  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
+
+  void CreateImageDecodeTasks(unsigned num_image_decode_tasks,
+                              Task::Vector* image_decode_tasks) {
+    for (unsigned i = 0; i < num_image_decode_tasks; ++i)
+      image_decode_tasks->push_back(Task::Create());
   }
-  virtual void TearDown() OVERRIDE { raster_worker_pool_->Shutdown(); }
-
-  void CreateTasks(RasterWorkerPool::RasterTask::Queue* tasks,
-                   unsigned num_raster_tasks,
-                   unsigned num_image_decode_tasks) {
-    typedef std::vector<RasterWorkerPool::Task> TaskVector;
-    TaskVector image_decode_tasks;
-
-    for (unsigned i = 0; i < num_image_decode_tasks; ++i) {
-      image_decode_tasks.push_back(RasterWorkerPool::CreateImageDecodeTask(
-          NULL,
-          0,
-          NULL,
-          base::Bind(&RasterWorkerPoolPerfTest::OnImageDecodeTaskCompleted)));
-    }
+
+  void CreateRasterTasks(unsigned num_raster_tasks,
+                         const Task::Vector& image_decode_tasks,
+                         RasterTask::Vector* raster_tasks) {
+    const gfx::Size size(1, 1);
 
     for (unsigned i = 0; i < num_raster_tasks; ++i) {
-      RasterWorkerPool::Task::Set decode_tasks;
-      for (TaskVector::iterator it = image_decode_tasks.begin();
-           it != image_decode_tasks.end();
-           ++it)
-        decode_tasks.Insert(*it);
-
-      tasks->Append(
-          RasterWorkerPool::CreateRasterTask(
-              NULL,
-              NULL,
-              gfx::Rect(),
-              1.0,
-              HIGH_QUALITY_RASTER_MODE,
-              TileResolution(),
-              1,
-              NULL,
-              1,
-              false,
-              NULL,
-              base::Bind(&RasterWorkerPoolPerfTest::OnRasterTaskCompleted),
-              &decode_tasks),
-          false);
+      scoped_ptr<ScopedResource> resource(
+          ScopedResource::Create(resource_provider_.get()));
+      resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
+
+      raster_tasks->push_back(
+          RasterTask::Create(resource.Pass(), image_decode_tasks));
     }
   }
 
-  void RunBuildTaskGraphTest(const std::string& test_name,
-                             unsigned num_raster_tasks,
-                             unsigned num_image_decode_tasks) {
-    timer_.Reset();
+  void ScheduleTasks(const RasterTask::Vector& raster_tasks) {
     RasterWorkerPool::RasterTask::Queue tasks;
-    CreateTasks(&tasks, num_raster_tasks, num_image_decode_tasks);
-    raster_worker_pool_->SetRasterTasks(&tasks);
+
+    for (RasterTask::Vector::const_iterator it = raster_tasks.begin();
+         it != raster_tasks.end();
+         ++it)
+      tasks.Append(*it, false);
+
+    raster_worker_pool_->ScheduleTasks(&tasks);
+  }
+
+  void RunScheduleTasksTest(const std::string& test_name,
+                            unsigned num_raster_tasks,
+                            unsigned num_image_decode_tasks) {
+    Task::Vector image_decode_tasks;
+    RasterTask::Vector raster_tasks;
+    CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+    CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+
+    timer_.Reset();
     do {
-      raster_worker_pool_->BuildTaskGraph();
+      ScheduleTasks(raster_tasks);
+      raster_worker_pool_->CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    perf_test::PrintResult("build_task_graph",
+    RasterWorkerPool::RasterTask::Queue empty;
+    raster_worker_pool_->ScheduleTasks(&empty);
+    raster_worker_pool_->CheckForCompletedTasks();
+
+    perf_test::PrintResult("schedule_tasks",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
@@ -195,29 +262,110 @@ class RasterWorkerPoolPerfTest : public testing::Test {
                            true);
   }
 
- protected:
-  static void OnRasterTaskCompleted(const PicturePileImpl::Analysis& analysis,
-                                    bool was_canceled) {}
-  static void OnImageDecodeTaskCompleted(bool was_canceled) {}
+  void RunScheduleAlternateTasksTest(const std::string& test_name,
+                                     unsigned num_raster_tasks,
+                                     unsigned num_image_decode_tasks) {
+    const size_t kNumVersions = 2;
+    Task::Vector image_decode_tasks[kNumVersions];
+    RasterTask::Vector raster_tasks[kNumVersions];
+    for (size_t i = 0; i < kNumVersions; ++i) {
+      CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
+      CreateRasterTasks(
+          num_raster_tasks, image_decode_tasks[i], &raster_tasks[i]);
+    }
+
+    size_t count = 0;
+    timer_.Reset();
+    do {
+      ScheduleTasks(raster_tasks[count % kNumVersions]);
+      raster_worker_pool_->CheckForCompletedTasks();
+      ++count;
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    RasterWorkerPool::RasterTask::Queue empty;
+    raster_worker_pool_->ScheduleTasks(&empty);
+    raster_worker_pool_->CheckForCompletedTasks();
 
-  scoped_ptr<PerfRasterWorkerPool> raster_worker_pool_;
+    perf_test::PrintResult("schedule_alternate_tasks",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }
+
+  void RunScheduleAndExecuteTasksTest(const std::string& test_name,
+                                      unsigned num_raster_tasks,
+                                      unsigned num_image_decode_tasks) {
+    Task::Vector image_decode_tasks;
+    RasterTask::Vector raster_tasks;
+    CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+    CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
+
+    timer_.Reset();
+    do {
+      ScheduleTasks(raster_tasks);
+      while (task_graph_runner_->RunTaskForTesting())
+        continue;
+      raster_worker_pool_->CheckForCompletedTasks();
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    RasterWorkerPool::RasterTask::Queue empty;
+    raster_worker_pool_->ScheduleTasks(&empty);
+    raster_worker_pool_->CheckForCompletedTasks();
+
+    perf_test::PrintResult("schedule_and_execute_tasks",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }
+
+ private:
+  scoped_refptr<TestContextProvider> context_provider_;
+  FakeOutputSurfaceClient output_surface_client_;
+  scoped_ptr<FakeOutputSurface> output_surface_;
+  scoped_ptr<ResourceProvider> resource_provider_;
+  scoped_ptr<internal::TaskGraphRunner> task_graph_runner_;
+  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+  std::vector<RasterWorkerPool::RasterTask> tasks_;
   LapTimer timer_;
 };
 
-TEST_F(RasterWorkerPoolPerfTest, BuildTaskGraph) {
-  RunBuildTaskGraphTest("10_0", 10, 0);
-  RunBuildTaskGraphTest("100_0", 100, 0);
-  RunBuildTaskGraphTest("1000_0", 1000, 0);
-  RunBuildTaskGraphTest("10_1", 10, 1);
-  RunBuildTaskGraphTest("100_1", 100, 1);
-  RunBuildTaskGraphTest("1000_1", 1000, 1);
-  RunBuildTaskGraphTest("10_4", 10, 4);
-  RunBuildTaskGraphTest("100_4", 100, 4);
-  RunBuildTaskGraphTest("1000_4", 1000, 4);
-  RunBuildTaskGraphTest("10_16", 10, 16);
-  RunBuildTaskGraphTest("100_16", 100, 16);
-  RunBuildTaskGraphTest("1000_16", 1000, 16);
+TEST_P(RasterWorkerPoolPerfTest, ScheduleTasks) {
+  RunScheduleTasksTest("1_0", 1, 0);
+  RunScheduleTasksTest("32_0", 32, 0);
+  RunScheduleTasksTest("1_1", 1, 1);
+  RunScheduleTasksTest("32_1", 32, 1);
+  RunScheduleTasksTest("1_4", 1, 4);
+  RunScheduleTasksTest("32_4", 32, 4);
 }
 
+TEST_P(RasterWorkerPoolPerfTest, ScheduleAlternateTasks) {
+  RunScheduleAlternateTasksTest("1_0", 1, 0);
+  RunScheduleAlternateTasksTest("32_0", 32, 0);
+  RunScheduleAlternateTasksTest("1_1", 1, 1);
+  RunScheduleAlternateTasksTest("32_1", 32, 1);
+  RunScheduleAlternateTasksTest("1_4", 1, 4);
+  RunScheduleAlternateTasksTest("32_4", 32, 4);
+}
+
+TEST_P(RasterWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
+  RunScheduleAndExecuteTasksTest("1_0", 1, 0);
+  RunScheduleAndExecuteTasksTest("32_0", 32, 0);
+  RunScheduleAndExecuteTasksTest("1_1", 1, 1);
+  RunScheduleAndExecuteTasksTest("32_1", 32, 1);
+  RunScheduleAndExecuteTasksTest("1_4", 1, 4);
+  RunScheduleAndExecuteTasksTest("32_4", 32, 4);
+}
+
+INSTANTIATE_TEST_CASE_P(RasterWorkerPoolPerfTests,
+                        RasterWorkerPoolPerfTest,
+                        ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
+                                          RASTER_WORKER_POOL_TYPE_IMAGE));
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index 9944bfc..b4dd79d 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -88,13 +88,14 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
 };
 
-class BlockingRasterWorkerPoolTaskImpl : public TestRasterWorkerPoolTaskImpl {
+class BlockingTestRasterWorkerPoolTaskImpl
+    : public TestRasterWorkerPoolTaskImpl {
  public:
-  BlockingRasterWorkerPoolTaskImpl(const Resource* resource,
-                                   const Reply& reply,
-                                   base::Lock* lock,
-                                   internal::Task::Vector* dependencies,
-                                   bool use_gpu_rasterization)
+  BlockingTestRasterWorkerPoolTaskImpl(const Resource* resource,
+                                       const Reply& reply,
+                                       base::Lock* lock,
+                                       internal::Task::Vector* dependencies,
+                                       bool use_gpu_rasterization)
       : TestRasterWorkerPoolTaskImpl(resource,
                                      reply,
                                      dependencies,
@@ -111,20 +112,47 @@ class BlockingRasterWorkerPoolTaskImpl : public TestRasterWorkerPoolTaskImpl {
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
-  virtual ~BlockingRasterWorkerPoolTaskImpl() {}
+  virtual ~BlockingTestRasterWorkerPoolTaskImpl() {}
 
  private:
   base::Lock* lock_;
 
-  DISALLOW_COPY_AND_ASSIGN(BlockingRasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterWorkerPoolTaskImpl);
 };
 
-}  // namespace
-
 class RasterWorkerPoolTest
     : public testing::TestWithParam<RasterWorkerPoolType>,
       public RasterWorkerPoolClient {
  public:
+  class RasterTask : public RasterWorkerPool::RasterTask {
+   public:
+    typedef std::vector<RasterTask> Vector;
+
+    static RasterTask Create(const Resource* resource,
+                             const TestRasterWorkerPoolTaskImpl::Reply& reply,
+                             bool use_gpu_rasterization) {
+      internal::Task::Vector dependencies;
+      return RasterTask(new TestRasterWorkerPoolTaskImpl(
+          resource, reply, &dependencies, use_gpu_rasterization));
+    }
+
+    static RasterTask CreateBlocking(
+        const Resource* resource,
+        const TestRasterWorkerPoolTaskImpl::Reply& reply,
+        base::Lock* lock,
+        bool use_gpu_rasterization) {
+      internal::Task::Vector dependencies;
+      return RasterTask(new BlockingTestRasterWorkerPoolTaskImpl(
+          resource, reply, lock, &dependencies, use_gpu_rasterization));
+    }
+
+   private:
+    friend class RasterWorkerPoolTest;
+
+    explicit RasterTask(internal::RasterWorkerPoolTask* task)
+        : RasterWorkerPool::RasterTask(task) {}
+  };
+
   struct RasterTaskResult {
     unsigned id;
     bool canceled;
@@ -142,16 +170,16 @@ class RasterWorkerPoolTest
                              output_surface_.get(), NULL, 0, false, 1).Pass();
 
     switch (GetParam()) {
-      case RASTER_WORKER_POOL_TYPE_IMAGE:
-        raster_worker_pool_ = ImageRasterWorkerPool::Create(
-            resource_provider_.get(), context_provider_.get(), GL_TEXTURE_2D);
-        break;
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
             resource_provider_.get(),
             context_provider_.get(),
             std::numeric_limits<size_t>::max());
         break;
+      case RASTER_WORKER_POOL_TYPE_IMAGE:
+        raster_worker_pool_ = ImageRasterWorkerPool::Create(
+            resource_provider_.get(), context_provider_.get(), GL_TEXTURE_2D);
+        break;
     }
 
     DCHECK(raster_worker_pool_);
@@ -196,9 +224,7 @@ class RasterWorkerPoolTest
   void ScheduleTasks() {
     RasterWorkerPool::RasterTask::Queue tasks;
 
-    for (std::vector<RasterWorkerPool::RasterTask>::iterator it =
-             tasks_.begin();
-         it != tasks_.end();
+    for (RasterTask::Vector::iterator it = tasks_.begin(); it != tasks_.end();
          ++it)
       tasks.Append(*it, false);
 
@@ -213,16 +239,13 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    RasterWorkerPool::Task::Set empty;
     tasks_.push_back(
-        RasterWorkerPool::RasterTask(new TestRasterWorkerPoolTaskImpl(
-            const_resource,
-            base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
-                       base::Unretained(this),
-                       base::Passed(&resource),
-                       id),
-            &empty.tasks_,
-            use_gpu_rasterization)));
+        RasterTask::Create(const_resource,
+                           base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
+                                      base::Unretained(this),
+                                      base::Passed(&resource),
+                                      id),
+                           use_gpu_rasterization));
   }
 
   void AppendBlockingTask(unsigned id, base::Lock* lock) {
@@ -233,17 +256,14 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    RasterWorkerPool::Task::Set empty;
-    tasks_.push_back(
-        RasterWorkerPool::RasterTask(new BlockingRasterWorkerPoolTaskImpl(
-            const_resource,
-            base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
-                       base::Unretained(this),
-                       base::Passed(&resource),
-                       id),
-            lock,
-            &empty.tasks_,
-            false)));
+    tasks_.push_back(RasterTask::CreateBlocking(
+        const_resource,
+        base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
+                   base::Unretained(this),
+                   base::Passed(&resource),
+                   id),
+        lock,
+        false));
   }
 
   const std::vector<RasterTaskResult>& completed_tasks() const {
@@ -277,12 +297,10 @@ class RasterWorkerPoolTest
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;
-  std::vector<RasterWorkerPool::RasterTask> tasks_;
+  std::vector<RasterTask> tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
 };
 
-namespace {
-
 TEST_P(RasterWorkerPoolTest, Basic) {
   AppendTask(0u, false);
   AppendTask(1u, false);
diff --git a/cc/resources/task_graph_runner_perftest.cc b/cc/resources/task_graph_runner_perftest.cc
index 7590450..71933f5 100644
--- a/cc/resources/task_graph_runner_perftest.cc
+++ b/cc/resources/task_graph_runner_perftest.cc
@@ -130,11 +130,11 @@ class TaskGraphRunnerPerfTest : public testing::Test {
                                      int num_top_level_tasks,
                                      int num_tasks,
                                      int num_leaf_tasks) {
-    const int kNumVersions = 2;
+    const size_t kNumVersions = 2;
     PerfTaskImpl::Vector top_level_tasks[kNumVersions];
     PerfTaskImpl::Vector tasks[kNumVersions];
     PerfTaskImpl::Vector leaf_tasks[kNumVersions];
-    for (int i = 0; i < kNumVersions; ++i) {
+    for (size_t i = 0; i < kNumVersions; ++i) {
       CreateTasks(num_top_level_tasks, &top_level_tasks[i]);
       CreateTasks(num_tasks, &tasks[i]);
       CreateTasks(num_leaf_tasks, &leaf_tasks[i]);
@@ -145,7 +145,7 @@ class TaskGraphRunnerPerfTest : public testing::Test {
     internal::TaskGraph graph;
     internal::Task::Vector completed_tasks;
 
-    int count = 0;
+    size_t count = 0;
     timer_.Reset();
     do {
       graph.Reset();
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 9f0649a..7740f33 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -13,9 +13,17 @@ namespace cc {
 
 namespace {
 
+class FakeTaskGraphRunner : public internal::TaskGraphRunner {
+ public:
+  FakeTaskGraphRunner() : internal::TaskGraphRunner(0, "CompositorRaster") {}
+};
+base::LazyInstance<FakeTaskGraphRunner> g_task_graph_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
 class FakeRasterWorkerPool : public RasterWorkerPool {
  public:
-  FakeRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}
+  FakeRasterWorkerPool()
+      : RasterWorkerPool(g_task_graph_runner.Pointer(), NULL, NULL) {}
 
   // Overridden from RasterWorkerPool:
   virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE {
@@ -30,6 +38,9 @@ class FakeRasterWorkerPool : public RasterWorkerPool {
     }
   }
   virtual void CheckForCompletedTasks() OVERRIDE {
+    internal::Task::Vector completed_tasks;
+    CollectCompletedWorkerPoolTasks(&completed_tasks);
+
     while (!completed_tasks_.empty()) {
       internal::WorkerPoolTask* task = completed_tasks_.front().get();
 
@@ -92,10 +103,7 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
                   raster_task_limit_bytes,
                   NULL) {}
 
-FakeTileManager::~FakeTileManager() {
-  RasterWorkerPoolForTesting()->Shutdown();
-  RasterWorkerPoolForTesting()->CheckForCompletedTasks();
-}
+FakeTileManager::~FakeTileManager() {}
 
 void FakeTileManager::AssignMemoryToTiles(
     const GlobalStateThatImpactsTilePriority& state) {