cc: Make raster tasks separate objects.

Instead of using bind on tile manager static functions, this
patch makes the tasks explicit objects that live in the raster
worker pool. This should allow, among other things, to do
different work for different raster worker pools.

Review URL: https://chromiumcodereview.appspot.com/15766006

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

10 files changed, 379 insertions, 303 deletions

diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 9488b4e..73ec9d8 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -163,7 +163,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
          ++iter) {
       SkColor color;
       float width;
-      TileRasterMode raster_mode;
+      RasterMode raster_mode;
       if (*iter && iter->IsReadyToDraw(&raster_mode)) {
         ManagedTileState::TileVersion::Mode mode =
             iter->tile_version(raster_mode).mode();
@@ -209,7 +209,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
-    TileRasterMode raster_mode;
+    RasterMode raster_mode;
     if (!*iter || !iter->IsReadyToDraw(&raster_mode)) {
       if (DrawCheckerboardForMissingTiles()) {
         // TODO(enne): Figure out how to show debug "invalidated checker" color
@@ -620,7 +620,7 @@ ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
        iter;
        ++iter) {
     // Mask resource not ready yet.
-    TileRasterMode raster_mode;
+    RasterMode raster_mode;
     if (!*iter || !iter->IsReadyToDraw(&raster_mode))
       return 0;
 
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index 26322c9..9b633ea 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -116,7 +116,7 @@ class CC_EXPORT ManagedTileState {
 
   // Persisted state: valid all the time.
   TileVersion tile_versions[NUM_RASTER_MODES];
-  TileRasterMode raster_mode;
+  RasterMode raster_mode;
 
   bool picture_pile_analyzed;
   PicturePileImpl::Analysis picture_pile_analysis;
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 90ac60f..6589f2a 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -499,7 +499,7 @@ size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
     const Tile* tile = it->second.get();
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
       amount += tile->tile_version(
-          static_cast<TileRasterMode>(mode)).GPUMemoryUsageInBytes();
+          static_cast<RasterMode>(mode)).GPUMemoryUsageInBytes();
     }
   }
   return amount;
diff --git a/cc/resources/picture_layer_tiling_set_unittest.cc b/cc/resources/picture_layer_tiling_set_unittest.cc
index 0f3d9a5..7d92d83 100644
--- a/cc/resources/picture_layer_tiling_set_unittest.cc
+++ b/cc/resources/picture_layer_tiling_set_unittest.cc
@@ -69,7 +69,7 @@ class PictureLayerTilingSetTestWithResources : public testing::Test {
     PictureLayerTilingSet set(&client, layer_bounds);
 
     float scale = min_scale;
-    TileRasterMode mode = HIGH_QUALITY_RASTER_MODE;
+    RasterMode mode = HIGH_QUALITY_RASTER_MODE;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
       PictureLayerTiling* tiling = set.AddTiling(scale);
       tiling->CreateAllTilesForTesting();
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index f914ab5..c79901a 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -4,33 +4,50 @@
 
 #include "cc/resources/raster_worker_pool.h"
 
+#include "base/json/json_writer.h"
+#include "base/metrics/histogram.h"
+#include "base/values.h"
+#include "cc/debug/devtools_instrumentation.h"
+#include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
+#include "skia/ext/lazy_pixel_ref.h"
+#include "skia/ext/paint_simplifier.h"
 
 namespace cc {
 
 namespace {
 
+class DisableLCDTextFilter : public SkDrawFilter {
+ public:
+  // SkDrawFilter interface.
+  virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
+    if (type != SkDrawFilter::kText_Type)
+      return true;
+
+    paint->setLCDRenderText(false);
+    return true;
+  }
+};
+
 void Noop() {}
 
-class WorkerPoolTaskImpl : public internal::WorkerPoolTask {
+class RootWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
-  WorkerPoolTaskImpl(const base::Closure& callback,
-                     const base::Closure& reply)
-      : callback_(callback),
-        reply_(reply) {
-  }
-  explicit WorkerPoolTaskImpl(
+  RootWorkerPoolTaskImpl(const base::Closure& callback,
+                         const base::Closure& reply)
+      : callback_(callback), reply_(reply) {}
+
+  explicit RootWorkerPoolTaskImpl(
       internal::WorkerPoolTask::TaskVector* dependencies)
       : internal::WorkerPoolTask(dependencies),
         callback_(base::Bind(&Noop)),
-        reply_(base::Bind(&Noop)) {
-  }
-  WorkerPoolTaskImpl(const base::Closure& callback,
-                     internal::WorkerPoolTask::TaskVector* dependencies)
+        reply_(base::Bind(&Noop)) {}
+
+  RootWorkerPoolTaskImpl(const base::Closure& callback,
+                         internal::WorkerPoolTask::TaskVector* dependencies)
       : internal::WorkerPoolTask(dependencies),
         callback_(callback),
-        reply_(base::Bind(&Noop)) {
-  }
+        reply_(base::Bind(&Noop)) {}
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnThread(unsigned thread_index) OVERRIDE {
@@ -41,47 +58,189 @@ class WorkerPoolTaskImpl : public internal::WorkerPoolTask {
   }
 
  private:
-  virtual ~WorkerPoolTaskImpl() {}
+  virtual ~RootWorkerPoolTaskImpl() {}
 
   const base::Closure callback_;
   const base::Closure reply_;
 
-  DISALLOW_COPY_AND_ASSIGN(WorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RootWorkerPoolTaskImpl);
 };
 
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
-  RasterWorkerPoolTaskImpl(
-      PicturePileImpl* picture_pile,
-      const Resource* resource,
-      const RasterWorkerPool::RasterTask::Callback& callback,
-      const RasterWorkerPool::RasterTask::Reply& reply,
-      internal::WorkerPoolTask::TaskVector* dependencies)
+  RasterWorkerPoolTaskImpl(const Resource* resource,
+                           PicturePileImpl::Analysis* analysis,
+                           PicturePileImpl* picture_pile,
+                           gfx::Rect content_rect,
+                           float contents_scale,
+                           RasterMode raster_mode,
+                           bool use_color_estimator,
+                           const RasterTaskMetadata& metadata,
+                           RenderingStatsInstrumentation* rendering_stats,
+                           const RasterWorkerPool::RasterTask::Reply& reply,
+                           internal::WorkerPoolTask::TaskVector* dependencies)
       : internal::RasterWorkerPoolTask(resource, dependencies),
+        analysis_(analysis),
         picture_pile_(picture_pile),
-        callback_(callback),
-        reply_(reply) {
+        content_rect_(content_rect),
+        contents_scale_(contents_scale),
+        raster_mode_(raster_mode),
+        use_color_estimator_(use_color_estimator),
+        metadata_(metadata),
+        rendering_stats_(rendering_stats),
+        reply_(reply) {}
+
+  void RunAnalysisOnThread(unsigned thread_index) {
+    TRACE_EVENT1("cc",
+                 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
+                 "metadata",
+                 TracedValue::FromValue(metadata_.AsValue().release()));
+
+    DCHECK(picture_pile_);
+    DCHECK(analysis_);
+    DCHECK(rendering_stats_);
+
+    PicturePileImpl* picture_clone =
+        picture_pile_->GetCloneForDrawingOnThread(thread_index);
+
+    DCHECK(picture_clone);
+
+    base::TimeTicks start_time = rendering_stats_->StartRecording();
+    picture_clone->AnalyzeInRect(content_rect_, contents_scale_, analysis_);
+    base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
+
+    // Record the solid color prediction.
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
+                          analysis_->is_solid_color);
+    rendering_stats_->AddTileAnalysisResult(duration,
+                                            analysis_->is_solid_color);
+
+    // Clear the flag if we're not using the estimator.
+    analysis_->is_solid_color &= use_color_estimator_;
+  }
+
+  bool RunRasterOnThread(SkDevice* device, unsigned thread_index) {
+    TRACE_EVENT1(
+        "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
+        "metadata", TracedValue::FromValue(metadata_.AsValue().release()));
+    devtools_instrumentation::ScopedLayerTask raster_task(
+        devtools_instrumentation::kRasterTask, metadata_.layer_id);
+
+    DCHECK(picture_pile_);
+    DCHECK(analysis_);
+    DCHECK(device);
+
+    if (analysis_->is_solid_color)
+      return false;
+
+    PicturePileImpl* picture_clone =
+        picture_pile_->GetCloneForDrawingOnThread(thread_index);
+
+    SkCanvas canvas(device);
+
+    skia::RefPtr<SkDrawFilter> draw_filter;
+    switch (raster_mode_) {
+      case LOW_QUALITY_RASTER_MODE:
+        draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
+        break;
+      case HIGH_QUALITY_NO_LCD_RASTER_MODE:
+        draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
+        break;
+      case HIGH_QUALITY_RASTER_MODE:
+        break;
+      case NUM_RASTER_MODES:
+      default:
+        NOTREACHED();
+    }
+
+    canvas.setDrawFilter(draw_filter.get());
+
+    if (rendering_stats_->record_rendering_stats()) {
+      PicturePileImpl::RasterStats raster_stats;
+      picture_clone->RasterToBitmap(
+          &canvas, content_rect_, contents_scale_, &raster_stats);
+      rendering_stats_->AddRaster(
+          raster_stats.total_rasterize_time,
+          raster_stats.best_rasterize_time,
+          raster_stats.total_pixels_rasterized,
+          metadata_.is_tile_in_pending_tree_now_bin);
+
+      HISTOGRAM_CUSTOM_COUNTS(
+          "Renderer4.PictureRasterTimeUS",
+          raster_stats.total_rasterize_time.InMicroseconds(),
+          0,
+          100000,
+          100);
+    } else {
+      picture_clone->RasterToBitmap(
+          &canvas, content_rect_, contents_scale_, NULL);
+    }
+    return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnThread(SkDevice* device, unsigned thread_index) OVERRIDE {
-    return callback_.Run(
-        device, picture_pile_->GetCloneForDrawingOnThread(thread_index));
+    RunAnalysisOnThread(thread_index);
+    return RunRasterOnThread(device, thread_index);
   }
   virtual void DispatchCompletionCallback() OVERRIDE {
     reply_.Run(!HasFinishedRunning());
   }
 
- private:
+ protected:
   virtual ~RasterWorkerPoolTaskImpl() {}
 
+ private:
+  PicturePileImpl::Analysis* analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
-  const RasterWorkerPool::RasterTask::Callback callback_;
+  gfx::Rect content_rect_;
+  float contents_scale_;
+  RasterMode raster_mode_;
+  bool use_color_estimator_;
+  RasterTaskMetadata metadata_;
+  RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
+class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+ public:
+  ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
+                                int layer_id,
+                                RenderingStatsInstrumentation* rendering_stats,
+                                const RasterWorkerPool::Task::Reply& reply)
+      : pixel_ref_(pixel_ref),
+        layer_id_(layer_id),
+        rendering_stats_(rendering_stats),
+        reply_(reply) {}
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnThread(unsigned thread_index) OVERRIDE {
+    TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnThread");
+    devtools_instrumentation::ScopedLayerTask image_decode_task(
+        devtools_instrumentation::kImageDecodeTask, layer_id_);
+    base::TimeTicks start_time = rendering_stats_->StartRecording();
+    pixel_ref_->Decode();
+    base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
+    rendering_stats_->AddDeferredImageDecode(duration);
+  }
+  virtual void DispatchCompletionCallback() OVERRIDE {
+    reply_.Run();
+  }
+
+ protected:
+  virtual ~ImageDecodeWorkerPoolTaskImpl() {}
+
+ private:
+  skia::LazyPixelRef* pixel_ref_;
+  int layer_id_;
+  RenderingStatsInstrumentation* rendering_stats_;
+  const RasterWorkerPool::Task::Reply reply_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl);
+};
+
 const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
@@ -120,6 +279,16 @@ bool RasterWorkerPoolTask::HasCompleted() const {
 
 }  // namespace internal
 
+scoped_ptr<base::Value> RasterTaskMetadata::AsValue() const {
+  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
+  res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
+  res->SetBoolean("is_tile_in_pending_tree_now_bin",
+                  is_tile_in_pending_tree_now_bin);
+  res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
+  res->SetInteger("source_frame_number", source_frame_number);
+  return res.PassAs<base::Value>();
+}
+
 RasterWorkerPool::Task::Set::Set() {
 }
 
@@ -134,9 +303,8 @@ void RasterWorkerPool::Task::Set::Insert(const Task& task) {
 RasterWorkerPool::Task::Task() {
 }
 
-RasterWorkerPool::Task::Task(const base::Closure& callback,
-                             const base::Closure& reply)
-    : internal_(new WorkerPoolTaskImpl(callback, reply)) {
+RasterWorkerPool::Task::Task(internal::WorkerPoolTask* internal)
+    : internal_(internal) {
 }
 
 RasterWorkerPool::Task::~Task() {
@@ -160,16 +328,9 @@ void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task) {
 RasterWorkerPool::RasterTask::RasterTask() {
 }
 
-RasterWorkerPool::RasterTask::RasterTask(PicturePileImpl* picture_pile,
-                                         const Resource* resource,
-                                         const Callback& callback,
-                                         const Reply& reply,
-                                         Task::Set* dependencies)
-    : internal_(new RasterWorkerPoolTaskImpl(picture_pile,
-                                             resource,
-                                             callback,
-                                             reply,
-                                             &dependencies->tasks_)) {
+RasterWorkerPool::RasterTask::RasterTask(
+    internal::RasterWorkerPoolTask* internal)
+    : internal_(internal) {
 }
 
 void RasterWorkerPool::RasterTask::Reset() {
@@ -184,13 +345,13 @@ RasterWorkerPool::RootTask::RootTask() {
 
 RasterWorkerPool::RootTask::RootTask(
     internal::WorkerPoolTask::TaskVector* dependencies)
-    : internal_(new WorkerPoolTaskImpl(dependencies)) {
+    : internal_(new RootWorkerPoolTaskImpl(dependencies)) {
 }
 
 RasterWorkerPool::RootTask::RootTask(
     const base::Closure& callback,
     internal::WorkerPoolTask::TaskVector* dependencies)
-    : internal_(new WorkerPoolTaskImpl(callback, dependencies)) {
+    : internal_(new RootWorkerPoolTaskImpl(callback, dependencies)) {
 }
 
 RasterWorkerPool::RootTask::~RootTask() {
@@ -210,6 +371,40 @@ void RasterWorkerPool::Shutdown() {
   WorkerPool::Shutdown();
 }
 
+RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
+    const Resource* resource,
+    PicturePileImpl::Analysis* analysis,
+    PicturePileImpl* picture_pile,
+    gfx::Rect content_rect,
+    float contents_scale,
+    RasterMode raster_mode,
+    bool use_color_estimator,
+    const RasterTaskMetadata& metadata,
+    RenderingStatsInstrumentation* rendering_stats,
+    const RasterTask::Reply& reply,
+    Task::Set& dependencies) {
+  return RasterTask(new RasterWorkerPoolTaskImpl(resource,
+                                       analysis,
+                                       picture_pile,
+                                       content_rect,
+                                       contents_scale,
+                                       raster_mode,
+                                       use_color_estimator,
+                                       metadata,
+                                       rendering_stats,
+                                       reply,
+                                       &dependencies.tasks_));
+}
+
+RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
+    skia::LazyPixelRef* pixel_ref,
+    int layer_id,
+    RenderingStatsInstrumentation* stats_instrumentation,
+    const Task::Reply& reply) {
+  return Task(new ImageDecodeWorkerPoolTaskImpl(
+      pixel_ref, layer_id, stats_instrumentation, reply));
+}
+
 bool RasterWorkerPool::ForceUploadToComplete(const RasterTask& raster_task) {
   return false;
 }
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 7205a42..9a8bd43 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -9,10 +9,17 @@
 
 #include "base/containers/hash_tables.h"
 #include "cc/base/worker_pool.h"
+#include "cc/debug/rendering_stats_instrumentation.h"
+#include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/resource_provider.h"
+#include "cc/resources/tile_priority.h"
 
 class SkDevice;
 
+namespace skia {
+class LazyPixelRef;
+}
+
 namespace cc {
 class PicturePileImpl;
 class PixelBufferRasterWorkerPool;
@@ -25,6 +32,9 @@ class CC_EXPORT RasterWorkerPoolTask
  public:
   typedef std::vector<scoped_refptr<RasterWorkerPoolTask> > TaskVector;
 
+  // Returns true if |device| was written to. False indicate that
+  // the content of |device| is undefined and the resource doesn't
+  // need to be initialized.
   virtual bool RunOnThread(SkDevice* device, unsigned thread_index) = 0;
   virtual void DispatchCompletionCallback() = 0;
 
@@ -67,11 +77,36 @@ template <> struct hash<cc::internal::RasterWorkerPoolTask*> {
 
 namespace cc {
 
+// Low quality implies no lcd test;
+// high quality implies lcd text.
+// Note that the order of these matters, from "better" to "worse" in terms of
+// quality.
+// TODO(vmpstr): Find a better place for this.
+enum RasterMode {
+  HIGH_QUALITY_RASTER_MODE = 0,
+  HIGH_QUALITY_NO_LCD_RASTER_MODE = 1,
+  LOW_QUALITY_RASTER_MODE = 2,
+  NUM_RASTER_MODES = 3
+};
+
+// Data that is passed to raster tasks.
+// TODO(vmpstr): Find a better place for this.
+struct RasterTaskMetadata {
+    scoped_ptr<base::Value> AsValue() const;
+    bool is_tile_in_pending_tree_now_bin;
+    TileResolution tile_resolution;
+    int layer_id;
+    const void* tile_id;
+    int source_frame_number;
+};
+
 // A worker thread pool that runs raster tasks.
 class CC_EXPORT RasterWorkerPool : public WorkerPool {
  public:
   class CC_EXPORT Task {
    public:
+    typedef base::Callback<void()> Reply;
+
     class CC_EXPORT Set {
      public:
       typedef internal::WorkerPoolTask::TaskVector TaskVector;
@@ -83,12 +118,12 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
 
      private:
       friend class RasterWorkerPool;
+      friend class RasterWorkerPoolTest;
 
       TaskVector tasks_;
     };
 
     Task();
-    Task(const base::Closure& callback, const base::Closure& reply);
     ~Task();
 
     // Returns true if Task is null (doesn't refer to anything).
@@ -99,18 +134,15 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
 
    protected:
     friend class RasterWorkerPool;
+    friend class RasterWorkerPoolTest;
+
+    explicit Task(internal::WorkerPoolTask* internal);
 
     scoped_refptr<internal::WorkerPoolTask> internal_;
   };
 
   class CC_EXPORT RasterTask {
    public:
-    // Returns true if |device| was written to. False indicate that
-    // the content of |device| is undefined and the resource doesn't
-    // need to be initialized.
-    typedef base::Callback<bool(SkDevice* device,
-                                PicturePileImpl* picture_pile)> Callback;
-
     typedef base::Callback<void(bool was_canceled)> Reply;
 
     class CC_EXPORT Queue {
@@ -129,11 +161,6 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
     };
 
     RasterTask();
-    RasterTask(PicturePileImpl* picture_pile,
-               const Resource* resource,
-               const Callback& callback,
-               const Reply& reply,
-               Task::Set* dependencies);
     ~RasterTask();
 
     // Returns true if Task is null (doesn't refer to anything).
@@ -145,10 +172,33 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
    protected:
     friend class PixelBufferRasterWorkerPool;
     friend class RasterWorkerPool;
+    friend class RasterWorkerPoolTest;
+
+    explicit RasterTask(internal::RasterWorkerPoolTask* internal);
 
     scoped_refptr<internal::RasterWorkerPoolTask> internal_;
   };
 
+  // TODO(vmpstr): Try to elimiate some variables.
+  static RasterTask CreateRasterTask(
+      const Resource* resource,
+      PicturePileImpl::Analysis* analysis,
+      PicturePileImpl* picture_pile,
+      gfx::Rect content_rect,
+      float contents_scale,
+      RasterMode raster_mode,
+      bool use_color_estimator,
+      const RasterTaskMetadata& metadata,
+      RenderingStatsInstrumentation* rendering_stats,
+      const RasterTask::Reply& reply,
+      Task::Set& dependencies);
+
+  static Task CreateImageDecodeTask(
+      skia::LazyPixelRef* pixel_ref,
+      int layer_id,
+      RenderingStatsInstrumentation* stats_instrumentation,
+      const Task::Reply& reply);
+
   virtual ~RasterWorkerPool();
 
   // Tells the worker pool to shutdown after canceling all previously
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index b8fdb66..7f49443 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -17,7 +17,27 @@
 
 namespace cc {
 
-namespace {
+class TestRasterTaskImpl : public internal::RasterWorkerPoolTask {
+ public:
+  TestRasterTaskImpl(const Resource* resource,
+                     const RasterWorkerPool::RasterTask::Reply& reply,
+                     internal::WorkerPoolTask::TaskVector* dependencies)
+      : internal::RasterWorkerPoolTask(resource, dependencies),
+        reply_(reply) {}
+
+  virtual bool RunOnThread(SkDevice* device, unsigned thread_index) OVERRIDE {
+    return true;
+  }
+  virtual void DispatchCompletionCallback() OVERRIDE {
+    reply_.Run(!HasFinishedRunning());
+  }
+
+ protected:
+  virtual ~TestRasterTaskImpl() {}
+
+ private:
+  const RasterWorkerPool::RasterTask::Reply reply_;
+};
 
 class RasterWorkerPoolTest : public testing::Test {
  public:
@@ -52,6 +72,14 @@ class RasterWorkerPoolTest : public testing::Test {
     return raster_worker_pool_.get();
   }
 
+  RasterWorkerPool::RasterTask CreateRasterTask(
+      const Resource* resource,
+      const RasterWorkerPool::RasterTask::Reply& reply,
+      RasterWorkerPool::Task::Set& dependencies) {
+    return RasterWorkerPool::RasterTask(
+        new TestRasterTaskImpl(resource, reply, &dependencies.tasks_));
+  }
+
   void RunTest(bool use_map_image) {
     if (use_map_image) {
       raster_worker_pool_ = ImageRasterWorkerPool::Create(
@@ -120,6 +148,8 @@ class RasterWorkerPoolTest : public testing::Test {
   bool timed_out_;
 };
 
+namespace {
+
 #define PIXEL_BUFFER_TEST_F(TEST_FIXTURE_NAME)                  \
   TEST_F(TEST_FIXTURE_NAME, RunPixelBuffer) {                   \
     RunTest(false);                                             \
@@ -162,16 +192,13 @@ class BasicRasterWorkerPoolTest : public RasterWorkerPoolTest {
     const Resource* const_resource = resource.get();
 
     RasterWorkerPool::Task::Set empty;
-    tasks_.push_back(RasterWorkerPool::RasterTask(
-        picture_pile_impl.get(),
+    tasks_.push_back(CreateRasterTask(
         const_resource,
-        base::Bind(&BasicRasterWorkerPoolTest::RunRasterTask,
-                   base::Unretained(this)),
         base::Bind(&BasicRasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
                    base::Passed(&resource),
                    id),
-        &empty));
+        empty));
   }
 
   void ScheduleTasks() {
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 6f9d987..8b4e304 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -62,22 +62,22 @@ class CC_EXPORT Tile : public base::RefCounted<Tile> {
 
   scoped_ptr<base::Value> AsValue() const;
 
-  bool IsReadyToDraw(TileRasterMode* ready_mode) const {
+  bool IsReadyToDraw(RasterMode* ready_mode) const {
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
       if (managed_state_.tile_versions[mode].IsReadyToDraw()) {
         if (ready_mode)
-          *ready_mode = static_cast<TileRasterMode>(mode);
+          *ready_mode = static_cast<RasterMode>(mode);
         return true;
       }
     }
     return false;
   }
 
-  const ManagedTileState::TileVersion& tile_version(TileRasterMode mode) const {
+  const ManagedTileState::TileVersion& tile_version(RasterMode mode) const {
     return managed_state_.tile_versions[mode];
   }
 
-  ManagedTileState::TileVersion& tile_version(TileRasterMode mode) {
+  ManagedTileState::TileVersion& tile_version(RasterMode mode) {
     return managed_state_.tile_versions[mode];
   }
 
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 46f38fb..955244e 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -16,7 +16,6 @@
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/tile.h"
-#include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/rect_conversions.h"
 
@@ -24,18 +23,6 @@ namespace cc {
 
 namespace {
 
-class DisableLCDTextFilter : public SkDrawFilter {
- public:
-  // SkDrawFilter interface.
-  virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
-    if (type != SkDrawFilter::kText_Type)
-      return true;
-
-    paint->setLCDRenderText(false);
-    return true;
-  }
-};
-
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline TileManagerBin BinFromTilePriority(const TilePriority& prio) {
@@ -359,7 +346,7 @@ void TileManager::GetMemoryStats(
     const Tile* tile = *it;
     const ManagedTileState& mts = tile->managed_state();
 
-    TileRasterMode mode = HIGH_QUALITY_RASTER_MODE;
+    RasterMode mode = HIGH_QUALITY_RASTER_MODE;
     if (tile->IsReadyToDraw(&mode) &&
         !mts.tile_versions[mode].requires_resource())
       continue;
@@ -415,11 +402,11 @@ void TileManager::AddRequiredTileForActivation(Tile* tile) {
   tiles_that_need_to_be_initialized_for_activation_.insert(tile);
 }
 
-TileRasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
+RasterMode TileManager::DetermineRasterMode(const Tile* tile) const {
   DCHECK(tile);
   DCHECK(tile->picture_pile());
 
-  TileRasterMode raster_mode;
+  RasterMode raster_mode;
 
   if (tile->managed_state().resolution == LOW_RESOLUTION)
     raster_mode = LOW_QUALITY_RASTER_MODE;
@@ -603,7 +590,7 @@ void TileManager::AssignGpuMemoryToTiles() {
       bytes_that_exceeded_memory_budget_in_now_bin;
 }
 
-void TileManager::FreeResourceForTile(Tile* tile, TileRasterMode mode) {
+void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.tile_versions[mode].resource_) {
     resource_pool_->ReleaseResource(
@@ -615,16 +602,16 @@ void TileManager::FreeResourceForTile(Tile* tile, TileRasterMode mode) {
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-    FreeResourceForTile(tile, static_cast<TileRasterMode>(mode));
+    FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
-  TileRasterMode used_mode = HIGH_QUALITY_RASTER_MODE;
+  RasterMode used_mode = HIGH_QUALITY_RASTER_MODE;
   bool version_is_used = tile->IsReadyToDraw(&used_mode);
   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     if (!version_is_used || mode != used_mode)
-      FreeResourceForTile(tile, static_cast<TileRasterMode>(mode));
+      FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
@@ -662,11 +649,10 @@ RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
     Tile* tile, skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::CreateImageDecodeTask");
 
-  return RasterWorkerPool::Task(
-      base::Bind(&TileManager::RunImageDecodeTask,
-                 pixel_ref,
-                 tile->layer_id(),
-                 rendering_stats_instrumentation_),
+  return RasterWorkerPool::CreateImageDecodeTask(
+      pixel_ref,
+      tile->layer_id(),
+      rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  make_scoped_refptr(tile),
@@ -681,7 +667,7 @@ void TileManager::OnImageDecodeTaskCompleted(scoped_refptr<Tile> tile,
   pending_decode_tasks_.erase(pixel_ref_id);
 }
 
-TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
+RasterTaskMetadata TileManager::GetRasterTaskMetadata(
     const Tile& tile) const {
   RasterTaskMetadata metadata;
   const ManagedTileState& mts = tile.managed_state();
@@ -691,7 +677,6 @@ TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
   metadata.layer_id = tile.layer_id();
   metadata.tile_id = &tile;
   metadata.source_frame_number = tile.source_frame_number();
-  metadata.raster_mode = mts.raster_mode;
   return metadata;
 }
 
@@ -712,6 +697,7 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
   DCHECK(!mts.tile_versions[mts.raster_mode].forced_upload_);
   mts.tile_versions[mts.raster_mode].resource_id_ = resource->id();
 
+  // TODO(vmpstr): Move analysis into RasterTask.
   PicturePileImpl::Analysis* analysis = new PicturePileImpl::Analysis;
 
   // Create and queue all image decode tasks that this tile depends on.
@@ -748,37 +734,30 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
   }
 
   RasterTaskMetadata metadata = GetRasterTaskMetadata(*tile);
-  return RasterWorkerPool::RasterTask(
-      tile->picture_pile(),
+  return RasterWorkerPool::CreateRasterTask(
       const_resource,
-      base::Bind(&TileManager::RunAnalyzeAndRasterTask,
-                 base::Bind(&TileManager::RunAnalyzeTask,
-                            analysis,
-                            tile->content_rect(),
-                            tile->contents_scale(),
-                            use_color_estimator_,
-                            metadata,
-                            rendering_stats_instrumentation_),
-                 base::Bind(&TileManager::RunRasterTask,
-                            analysis,
-                            tile->content_rect(),
-                            tile->contents_scale(),
-                            metadata,
-                            rendering_stats_instrumentation_)),
+      analysis,
+      tile->picture_pile(),
+      tile->content_rect(),
+      tile->contents_scale(),
+      mts.raster_mode,
+      use_color_estimator_,
+      metadata,
+      rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  make_scoped_refptr(tile),
                  base::Passed(&resource),
                  base::Owned(analysis),
-                 metadata.raster_mode),
-      &decode_tasks);
+                 mts.raster_mode),
+      decode_tasks);
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     PicturePileImpl::Analysis* analysis,
-    TileRasterMode raster_mode,
+    RasterMode raster_mode,
     bool was_canceled) {
   TRACE_EVENT1("cc", "TileManager::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
@@ -832,133 +811,4 @@ void TileManager::DidTileTreeBinChange(Tile* tile,
   mts.tree_bin[tree] = new_tree_bin;
 }
 
-// static
-void TileManager::RunImageDecodeTask(
-    skia::LazyPixelRef* pixel_ref,
-    int layer_id,
-    RenderingStatsInstrumentation* stats_instrumentation) {
-  TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
-  devtools_instrumentation::ScopedLayerTask image_decode_task(
-      devtools_instrumentation::kImageDecodeTask, layer_id);
-  base::TimeTicks start_time = stats_instrumentation->StartRecording();
-  pixel_ref->Decode();
-  base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
-  stats_instrumentation->AddDeferredImageDecode(duration);
-}
-
-// static
-bool TileManager::RunAnalyzeAndRasterTask(
-    const base::Callback<void(PicturePileImpl* picture_pile)>& analyze_task,
-    const RasterWorkerPool::RasterTask::Callback& raster_task,
-    SkDevice* device,
-    PicturePileImpl* picture_pile) {
-  analyze_task.Run(picture_pile);
-  return raster_task.Run(device, picture_pile);
-}
-
-// static
-void TileManager::RunAnalyzeTask(
-    PicturePileImpl::Analysis* analysis,
-    gfx::Rect rect,
-    float contents_scale,
-    bool use_color_estimator,
-    const RasterTaskMetadata& metadata,
-    RenderingStatsInstrumentation* stats_instrumentation,
-    PicturePileImpl* picture_pile) {
-  TRACE_EVENT1(
-      "cc", "TileManager::RunAnalyzeTask",
-      "metadata", TracedValue::FromValue(metadata.AsValue().release()));
-
-  DCHECK(picture_pile);
-  DCHECK(analysis);
-  DCHECK(stats_instrumentation);
-
-  base::TimeTicks start_time = stats_instrumentation->StartRecording();
-  picture_pile->AnalyzeInRect(rect, contents_scale, analysis);
-  base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
-
-  // Record the solid color prediction.
-  UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
-                        analysis->is_solid_color);
-  stats_instrumentation->AddTileAnalysisResult(duration,
-                                               analysis->is_solid_color);
-
-  // Clear the flag if we're not using the estimator.
-  analysis->is_solid_color &= use_color_estimator;
-}
-
-scoped_ptr<base::Value> TileManager::RasterTaskMetadata::AsValue() const {
-  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
-  res->SetBoolean("is_tile_in_pending_tree_now_bin",
-                  is_tile_in_pending_tree_now_bin);
-  res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
-  res->SetInteger("source_frame_number", source_frame_number);
-  res->SetInteger("raster_mode", raster_mode);
-  return res.PassAs<base::Value>();
-}
-
-// static
-bool TileManager::RunRasterTask(
-    PicturePileImpl::Analysis* analysis,
-    gfx::Rect rect,
-    float contents_scale,
-    const RasterTaskMetadata& metadata,
-    RenderingStatsInstrumentation* stats_instrumentation,
-    SkDevice* device,
-    PicturePileImpl* picture_pile) {
-  TRACE_EVENT1(
-      "cc", "TileManager::RunRasterTask",
-      "metadata", TracedValue::FromValue(metadata.AsValue().release()));
-  devtools_instrumentation::ScopedLayerTask raster_task(
-      devtools_instrumentation::kRasterTask, metadata.layer_id);
-
-  DCHECK(picture_pile);
-  DCHECK(analysis);
-  DCHECK(device);
-
-  if (analysis->is_solid_color)
-    return false;
-
-  SkCanvas canvas(device);
-
-  skia::RefPtr<SkDrawFilter> draw_filter;
-  switch (metadata.raster_mode) {
-    case LOW_QUALITY_RASTER_MODE:
-      draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
-      break;
-    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
-      draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
-      break;
-    case HIGH_QUALITY_RASTER_MODE:
-      break;
-    case NUM_RASTER_MODES:
-    default:
-      NOTREACHED();
-  }
-
-  canvas.setDrawFilter(draw_filter.get());
-
-  if (stats_instrumentation->record_rendering_stats()) {
-    PicturePileImpl::RasterStats raster_stats;
-    picture_pile->RasterToBitmap(&canvas, rect, contents_scale, &raster_stats);
-    stats_instrumentation->AddRaster(
-        raster_stats.total_rasterize_time,
-        raster_stats.best_rasterize_time,
-        raster_stats.total_pixels_rasterized,
-        metadata.is_tile_in_pending_tree_now_bin);
-
-    HISTOGRAM_CUSTOM_COUNTS(
-        "Renderer4.PictureRasterTimeUS",
-        raster_stats.total_rasterize_time.InMicroseconds(),
-        0,
-        100000,
-        100);
-  } else {
-    picture_pile->RasterToBitmap(&canvas, rect, contents_scale, NULL);
-  }
-
-  return true;
-}
-
 }  // namespace cc
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index bacb30b..fda25a3 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -24,17 +24,6 @@ class ResourceProvider;
 class Tile;
 class TileVersion;
 
-// Low quality implies no lcd test;
-// high quality implies lcd text.
-// Note that the order of these matters, from "better" to "worse" in terms of
-// quality.
-enum TileRasterMode {
-  HIGH_QUALITY_RASTER_MODE = 0,
-  HIGH_QUALITY_NO_LCD_RASTER_MODE = 1,
-  LOW_QUALITY_RASTER_MODE = 2,
-  NUM_RASTER_MODES = 3
-};
-
 class CC_EXPORT TileManagerClient {
  public:
   virtual void DidInitializeVisibleTile() = 0;
@@ -123,39 +112,30 @@ class CC_EXPORT TileManager {
   virtual void ScheduleTasks();
 
  private:
-  // Data that is passed to raster tasks.
-  struct RasterTaskMetadata {
-      scoped_ptr<base::Value> AsValue() const;
-      bool is_tile_in_pending_tree_now_bin;
-      TileResolution tile_resolution;
-      int layer_id;
-      const void* tile_id;
-      int source_frame_number;
-      TileRasterMode raster_mode;
-  };
+  // Task callbacks.
+  void OnImageDecodeTaskCompleted(
+      scoped_refptr<Tile> tile,
+      uint32_t pixel_ref_id);
+  void OnRasterTaskCompleted(
+      scoped_refptr<Tile> tile,
+      scoped_ptr<ResourcePool::Resource> resource,
+      PicturePileImpl::Analysis* analysis,
+      RasterMode raster_mode,
+      bool was_canceled);
 
   void AssignBinsToTiles();
   void SortTiles();
-  TileRasterMode DetermineRasterMode(const Tile* tile) const;
+  RasterMode DetermineRasterMode(const Tile* tile) const;
   void AssignGpuMemoryToTiles();
-  void FreeResourceForTile(Tile* tile, TileRasterMode mode);
+  void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
-  void OnImageDecodeTaskCompleted(
-      scoped_refptr<Tile> tile,
-      uint32_t pixel_ref_id);
   RasterTaskMetadata GetRasterTaskMetadata(const Tile& tile) const;
   RasterWorkerPool::RasterTask CreateRasterTask(
       Tile* tile,
       PixelRefSet* decoded_images);
-  void OnRasterTaskCompleted(
-      scoped_refptr<Tile> tile,
-      scoped_ptr<ResourcePool::Resource> resource,
-      PicturePileImpl::Analysis* analysis,
-      TileRasterMode raster_mode,
-      bool was_canceled);
   void DidFinishTileInitialization(Tile* tile);
   void DidTileTreeBinChange(Tile* tile,
                             TileManagerBin new_tree_bin,
@@ -163,32 +143,6 @@ class CC_EXPORT TileManager {
   scoped_ptr<Value> GetMemoryRequirementsAsValue() const;
   void AddRequiredTileForActivation(Tile* tile);
 
-  static void RunImageDecodeTask(
-      skia::LazyPixelRef* pixel_ref,
-      int layer_id,
-      RenderingStatsInstrumentation* stats_instrumentation);
-  static bool RunAnalyzeAndRasterTask(
-      const base::Callback<void(PicturePileImpl* picture_pile)>& analyze_task,
-      const RasterWorkerPool::RasterTask::Callback& raster_task,
-      SkDevice* device,
-      PicturePileImpl* picture_pile);
-  static void RunAnalyzeTask(
-      PicturePileImpl::Analysis* analysis,
-      gfx::Rect rect,
-      float contents_scale,
-      bool use_color_estimator,
-      const RasterTaskMetadata& metadata,
-      RenderingStatsInstrumentation* stats_instrumentation,
-      PicturePileImpl* picture_pile);
-  static bool RunRasterTask(
-      PicturePileImpl::Analysis* analysis,
-      gfx::Rect rect,
-      float contents_scale,
-      const RasterTaskMetadata& metadata,
-      RenderingStatsInstrumentation* stats_instrumentation,
-      SkDevice* device,
-      PicturePileImpl* picture_pile);
-
   TileManagerClient* client_;
   scoped_ptr<ResourcePool> resource_pool_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;