cc: Remove all traces of synchronous GPU rasterization

Removed threaded gpu raster flag, and syncronous gpu raster tests and
all code required for syncronous gpu rasterization.

Removed the empty software rasterizer class, and base and moved
ownership of the gpu rasterizer into the GpuTileTaskWorkerPool, since
it is still a nice separation of functionality

BUG=457860

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

Cr-Commit-Position: refs/heads/master@{#323860}

14 files changed, 62 insertions, 441 deletions

diff --git a/cc/resources/gpu_rasterizer.cc b/cc/resources/gpu_rasterizer.cc
index d810386..1620c2b 100644
--- a/cc/resources/gpu_rasterizer.cc
+++ b/cc/resources/gpu_rasterizer.cc
@@ -26,74 +26,19 @@
 
 namespace cc {
 
-// static
-scoped_ptr<GpuRasterizer> GpuRasterizer::Create(
-    ContextProvider* context_provider,
-    ResourceProvider* resource_provider,
-    bool use_distance_field_text,
-    bool threaded_gpu_rasterization_enabled,
-    int msaa_sample_count) {
-  return make_scoped_ptr<GpuRasterizer>(new GpuRasterizer(
-      context_provider, resource_provider, use_distance_field_text,
-      threaded_gpu_rasterization_enabled, msaa_sample_count));
-}
-
 GpuRasterizer::GpuRasterizer(ContextProvider* context_provider,
                              ResourceProvider* resource_provider,
                              bool use_distance_field_text,
-                             bool threaded_gpu_rasterization_enabled,
                              int msaa_sample_count)
     : resource_provider_(resource_provider),
       use_distance_field_text_(use_distance_field_text),
-      threaded_gpu_rasterization_enabled_(threaded_gpu_rasterization_enabled),
       msaa_sample_count_(msaa_sample_count) {
 }
 
 GpuRasterizer::~GpuRasterizer() {
 }
 
-PrepareTilesMode GpuRasterizer::GetPrepareTilesMode() {
-  return threaded_gpu_rasterization_enabled_
-             ? PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES
-             : PrepareTilesMode::PREPARE_NONE;
-}
-
-ContextProvider* GpuRasterizer::GetContextProvider(bool worker_context) {
-  return worker_context
-             ? resource_provider_->output_surface()->worker_context_provider()
-             : resource_provider_->output_surface()->context_provider();
-}
-
-void GpuRasterizer::RasterizeTiles(
-    const TileVector& tiles,
-    ResourcePool* resource_pool,
-    ResourceFormat resource_format,
-    const UpdateTileDrawInfoCallback& update_tile_draw_info) {
-  ScopedGpuRaster gpu_raster(GetContextProvider(false));
-
-  ScopedResourceWriteLocks locks;
-
-  for (Tile* tile : tiles) {
-    RasterSource::SolidColorAnalysis analysis;
-
-    if (tile->use_picture_analysis())
-      PerformSolidColorAnalysis(tile, &analysis);
-
-    scoped_ptr<ScopedResource> resource;
-    if (!analysis.is_solid_color) {
-      resource = resource_pool->AcquireResource(tile->desired_texture_size(),
-                                                resource_format);
-      AddToMultiPictureDraw(tile, resource.get(), &locks);
-    }
-    update_tile_draw_info.Run(tile, resource.Pass(), analysis);
-  }
-
-  // If MSAA is enabled, tell Skia to resolve each render target after draw.
-  multi_picture_draw_.draw(msaa_sample_count_ > 0);
-}
-
 void GpuRasterizer::RasterizeSource(
-    bool use_worker_context,
     ResourceProvider::ScopedWriteLockGr* write_lock,
     const RasterSource* raster_source,
     const gfx::Rect& rect,
@@ -116,8 +61,9 @@ void GpuRasterizer::RasterizeSource(
 
   // Playback picture into resource.
   {
-    ScopedGpuRaster gpu_raster(GetContextProvider(use_worker_context));
-    write_lock->InitSkSurface(use_worker_context, use_distance_field_text,
+    ScopedGpuRaster gpu_raster(
+        resource_provider_->output_surface()->worker_context_provider());
+    write_lock->InitSkSurface(use_distance_field_text,
                               raster_source->CanUseLCDText(),
                               msaa_sample_count_);
 
@@ -135,70 +81,4 @@ void GpuRasterizer::RasterizeSource(
   }
 }
 
-void GpuRasterizer::PerformSolidColorAnalysis(
-    const Tile* tile,
-    RasterSource::SolidColorAnalysis* analysis) {
-  const void* tile_id = static_cast<const void*>(tile);
-  frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
-      tile_id, tile->combined_priority().resolution,
-      tile->source_frame_number(), tile->layer_id());
-
-  DCHECK(tile->raster_source());
-
-  tile->raster_source()->PerformSolidColorAnalysis(
-      tile->content_rect(), tile->contents_scale(), analysis);
-
-  // Record the solid color prediction.
-  UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
-                        analysis->is_solid_color);
-}
-
-void GpuRasterizer::AddToMultiPictureDraw(const Tile* tile,
-                                          const ScopedResource* resource,
-                                          ScopedResourceWriteLocks* locks) {
-  const void* tile_id = static_cast<const void*>(tile);
-  frame_viewer_instrumentation::ScopedRasterTask raster_task(
-      tile_id, tile->combined_priority().resolution,
-      tile->source_frame_number(), tile->layer_id());
-
-  DCHECK(tile->raster_source());
-
-  // Turn on distance fields for layers that have ever animated.
-  bool use_distance_field_text =
-      use_distance_field_text_ ||
-      tile->raster_source()->ShouldAttemptToUseDistanceFieldText();
-  scoped_ptr<ResourceProvider::ScopedWriteLockGr> lock(
-      new ResourceProvider::ScopedWriteLockGr(resource_provider_,
-                                              resource->id()));
-
-  lock->InitSkSurface(false, use_distance_field_text,
-                      tile->raster_source()->CanUseLCDText(),
-                      msaa_sample_count_);
-
-  SkSurface* sk_surface = lock->sk_surface();
-
-  // Allocating an SkSurface will fail after a lost context.  Pretend we
-  // rasterized, as the contents of the resource don't matter anymore.
-  if (!sk_surface)
-    return;
-
-  locks->push_back(lock.Pass());
-
-  SkRTreeFactory factory;
-  SkPictureRecorder recorder;
-  gfx::Size size = resource->size();
-  const int flags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
-  skia::RefPtr<SkCanvas> canvas = skia::SharePtr(
-      recorder.beginRecording(size.width(), size.height(), &factory, flags));
-
-  canvas->save();
-  tile->raster_source()->PlaybackToCanvas(canvas.get(), tile->content_rect(),
-                                          tile->contents_scale());
-  canvas->restore();
-
-  // Add the canvas and recorded picture to |multi_picture_draw_|.
-  skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
-  multi_picture_draw_.add(sk_surface->getCanvas(), picture.get());
-}
-
 }  // namespace cc
diff --git a/cc/resources/gpu_rasterizer.h b/cc/resources/gpu_rasterizer.h
index 8c75f32..69a200f 100644
--- a/cc/resources/gpu_rasterizer.h
+++ b/cc/resources/gpu_rasterizer.h
@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "cc/base/cc_export.h"
-#include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "third_party/skia/include/core/SkMultiPictureDraw.h"
@@ -18,27 +17,11 @@ namespace cc {
 class ContextProvider;
 class ResourceProvider;
 
-class CC_EXPORT GpuRasterizer : public Rasterizer {
+class CC_EXPORT GpuRasterizer {
  public:
-  ~GpuRasterizer() override;
+  ~GpuRasterizer();
 
-  static scoped_ptr<GpuRasterizer> Create(
-      ContextProvider* context_provider,
-      ResourceProvider* resource_provider,
-      bool use_distance_field_text,
-      bool threaded_gpu_rasterization_enabled,
-      int msaa_sample_count);
-
-  // Overriden from Rasterizer.
-  PrepareTilesMode GetPrepareTilesMode() override;
-  void RasterizeTiles(
-      const TileVector& tiles,
-      ResourcePool* resource_pool,
-      ResourceFormat resource_format,
-      const UpdateTileDrawInfoCallback& update_tile_draw_info) override;
-
-  void RasterizeSource(bool use_worker_context,
-                       ResourceProvider::ScopedWriteLockGr* write_lock,
+  void RasterizeSource(ResourceProvider::ScopedWriteLockGr* write_lock,
                        const RasterSource* raster_source,
                        const gfx::Rect& rect,
                        float scale);
@@ -49,26 +32,14 @@ class CC_EXPORT GpuRasterizer : public Rasterizer {
   GpuRasterizer(ContextProvider* context_provider,
                 ResourceProvider* resource_provider,
                 bool use_distance_filed_text,
-                bool threaded_gpu_rasterization_enabled,
                 int msaa_sample_count);
 
-  using ScopedResourceWriteLocks =
-      ScopedPtrVector<ResourceProvider::ScopedWriteLockGr>;
-
-  ContextProvider* GetContextProvider(bool worker_context);
-  void PerformSolidColorAnalysis(const Tile* tile,
-                                 RasterSource::SolidColorAnalysis* analysis);
-  void AddToMultiPictureDraw(const Tile* tile,
-                             const ScopedResource* resource,
-                             ScopedResourceWriteLocks* locks);
-
   ResourceProvider* resource_provider_;
-  SkMultiPictureDraw multi_picture_draw_;
 
   bool use_distance_field_text_;
-  bool threaded_gpu_rasterization_enabled_;
   int msaa_sample_count_;
 
+  friend class GpuTileTaskWorkerPool;
   DISALLOW_COPY_AND_ASSIGN(GpuRasterizer);
 };
 
diff --git a/cc/resources/gpu_tile_task_worker_pool.cc b/cc/resources/gpu_tile_task_worker_pool.cc
index c57d25a..bfda392 100644
--- a/cc/resources/gpu_tile_task_worker_pool.cc
+++ b/cc/resources/gpu_tile_task_worker_pool.cc
@@ -45,7 +45,7 @@ class RasterBufferImpl : public RasterBuffer {
     context_provider->DetachFromThread();
 
     // Rasterize source into resource.
-    rasterizer_->RasterizeSource(true, &lock_, raster_source, rect, scale);
+    rasterizer_->RasterizeSource(&lock_, raster_source, rect, scale);
 
     // Barrier to sync worker context output to cc context.
     context_provider->ContextGL()->OrderingBarrierCHROMIUM();
@@ -68,19 +68,29 @@ class RasterBufferImpl : public RasterBuffer {
 scoped_ptr<TileTaskWorkerPool> GpuTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
-    GpuRasterizer* rasterizer) {
-  return make_scoped_ptr<TileTaskWorkerPool>(
-      new GpuTileTaskWorkerPool(task_runner, task_graph_runner, rasterizer));
+    ContextProvider* context_provider,
+    ResourceProvider* resource_provider,
+    bool use_distance_field_text,
+    int gpu_rasterization_msaa_sample_count) {
+  return make_scoped_ptr<TileTaskWorkerPool>(new GpuTileTaskWorkerPool(
+      task_runner, task_graph_runner, context_provider, resource_provider,
+      use_distance_field_text, gpu_rasterization_msaa_sample_count));
 }
 
 GpuTileTaskWorkerPool::GpuTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
-    GpuRasterizer* rasterizer)
+    ContextProvider* context_provider,
+    ResourceProvider* resource_provider,
+    bool use_distance_field_text,
+    int gpu_rasterization_msaa_sample_count)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner_->GetNamespaceToken()),
-      rasterizer_(rasterizer),
+      rasterizer_(new GpuRasterizer(context_provider,
+                                    resource_provider,
+                                    use_distance_field_text,
+                                    gpu_rasterization_msaa_sample_count)),
       task_set_finished_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
 }
@@ -199,7 +209,7 @@ void GpuTileTaskWorkerPool::CompleteTasks(const Task::Vector& tasks) {
 scoped_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource) {
   return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(rasterizer_, resource));
+      new RasterBufferImpl(rasterizer_.get(), resource));
 }
 
 void GpuTileTaskWorkerPool::ReleaseBufferForRaster(
diff --git a/cc/resources/gpu_tile_task_worker_pool.h b/cc/resources/gpu_tile_task_worker_pool.h
index 5941852..630edce 100644
--- a/cc/resources/gpu_tile_task_worker_pool.h
+++ b/cc/resources/gpu_tile_task_worker_pool.h
@@ -10,7 +10,9 @@
 #include "cc/resources/tile_task_worker_pool.h"
 
 namespace cc {
+class ContextProvider;
 class GpuRasterizer;
+class ResourceProvider;
 
 class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
                                         public TileTaskRunner,
@@ -21,7 +23,10 @@ class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
   static scoped_ptr<TileTaskWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
       TaskGraphRunner* task_graph_runner,
-      GpuRasterizer* rasterizer);
+      ContextProvider* context_provider,
+      ResourceProvider* resource_provider,
+      bool use_distance_field_text,
+      int gpu_rasterization_msaa_sample_count);
 
   // Overridden from TileTaskWorkerPool:
   TileTaskRunner* AsTileTaskRunner() override;
@@ -41,7 +46,10 @@ class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
  private:
   GpuTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
                         TaskGraphRunner* task_graph_runner,
-                        GpuRasterizer* rasterizer);
+                        ContextProvider* context_provider,
+                        ResourceProvider* resource_provider,
+                        bool use_distance_field_text,
+                        int gpu_rasterization_msaa_sample_count);
 
   void OnTaskSetFinished(TaskSet task_set);
   void CompleteTasks(const Task::Vector& tasks);
@@ -50,7 +58,7 @@ class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
   TaskGraphRunner* task_graph_runner_;
   const NamespaceToken namespace_token_;
   TileTaskRunnerClient* client_;
-  GpuRasterizer* rasterizer_;
+  scoped_ptr<GpuRasterizer> rasterizer_;
 
   TaskSetCollection tasks_pending_;
 
diff --git a/cc/resources/rasterizer.h b/cc/resources/rasterizer.h
deleted file mode 100644
index 43df0b0..0000000
--- a/cc/resources/rasterizer.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015 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_RESOURCES_RASTERIZER_H_
-#define CC_RESOURCES_RASTERIZER_H_
-
-#include <vector>
-
-#include "cc/base/cc_export.h"
-#include "cc/resources/resource_pool.h"
-#include "cc/resources/tile.h"
-
-namespace cc {
-class TileManager;
-
-enum class PrepareTilesMode {
-  RASTERIZE_PRIORITIZED_TILES,
-  PREPARE_NONE
-};
-
-class CC_EXPORT Rasterizer {
- public:
-  using TileVector = std::vector<Tile*>;
-  using UpdateTileDrawInfoCallback =
-      base::Callback<void(Tile*,
-                          scoped_ptr<ScopedResource>,
-                          const RasterSource::SolidColorAnalysis&)>;
-
-  virtual ~Rasterizer() {}
-  virtual PrepareTilesMode GetPrepareTilesMode() = 0;
-  virtual void RasterizeTiles(
-      const TileVector& tiles,
-      ResourcePool* resource_pool,
-      ResourceFormat resource_format,
-      const UpdateTileDrawInfoCallback& update_tile_draw_info) = 0;
-
- protected:
-  Rasterizer() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Rasterizer);
-};
-
-}  // namespace cc
-
-#endif  // CC_RESOURCES_RASTERIZER_H_
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 1d47497..f9893b7 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -1131,7 +1131,6 @@ ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
 }
 
 void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
-    bool use_worker_context,
     bool use_distance_field_text,
     bool can_use_lcd_text,
     int msaa_sample_count) {
@@ -1146,6 +1145,7 @@ void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
   desc.fTextureHandle = resource_->gl_id;
   desc.fSampleCnt = msaa_sample_count;
 
+  bool use_worker_context = true;
   class GrContext* gr_context =
       resource_provider_->GrContext(use_worker_context);
   skia::RefPtr<GrTexture> gr_texture =
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index 95e1294..aa8c761 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -339,8 +339,7 @@ class CC_EXPORT ResourceProvider {
                       ResourceProvider::ResourceId resource_id);
     ~ScopedWriteLockGr();
 
-    void InitSkSurface(bool use_worker_context,
-                       bool use_distance_field_text,
+    void InitSkSurface(bool use_distance_field_text,
                        bool can_use_lcd_text,
                        int msaa_sample_count);
     void ReleaseSkSurface();
diff --git a/cc/resources/software_rasterizer.cc b/cc/resources/software_rasterizer.cc
deleted file mode 100644
index 6060e9e..0000000
--- a/cc/resources/software_rasterizer.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 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/resources/software_rasterizer.h"
-
-namespace cc {
-
-scoped_ptr<SoftwareRasterizer> SoftwareRasterizer::Create() {
-  return make_scoped_ptr<SoftwareRasterizer>(new SoftwareRasterizer());
-}
-
-SoftwareRasterizer::SoftwareRasterizer() {
-}
-
-SoftwareRasterizer::~SoftwareRasterizer() {
-}
-
-PrepareTilesMode SoftwareRasterizer::GetPrepareTilesMode() {
-  return PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES;
-}
-
-void SoftwareRasterizer::RasterizeTiles(
-    const TileVector& tiles,
-    ResourcePool* resource_pool,
-    ResourceFormat resource_format,
-    const UpdateTileDrawInfoCallback& update_tile_draw_info) {
-}
-
-}  // namespace cc
diff --git a/cc/resources/software_rasterizer.h b/cc/resources/software_rasterizer.h
deleted file mode 100644
index 6cb751f..0000000
--- a/cc/resources/software_rasterizer.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2015 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_RESOURCES_SOFTWARE_RASTERIZER_H_
-#define CC_RESOURCES_SOFTWARE_RASTERIZER_H_
-
-#include <vector>
-
-#include "cc/base/cc_export.h"
-#include "cc/resources/rasterizer.h"
-
-namespace cc {
-
-// This class only returns |PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES| in
-// |GetPrepareTilesMode()| to tell rasterize as scheduled tasks.
-class CC_EXPORT SoftwareRasterizer : public Rasterizer {
- public:
-  ~SoftwareRasterizer() override;
-
-  static scoped_ptr<SoftwareRasterizer> Create();
-
-  PrepareTilesMode GetPrepareTilesMode() override;
-  void RasterizeTiles(
-      const TileVector& tiles,
-      ResourcePool* resource_pool,
-      ResourceFormat resource_format,
-      const UpdateTileDrawInfoCallback& update_tile_draw_info) override;
-
- private:
-  SoftwareRasterizer();
-
-  DISALLOW_COPY_AND_ASSIGN(SoftwareRasterizer);
-};
-
-}  // namespace cc
-
-#endif  // CC_RESOURCES_SOFTWARE_RASTERIZER_H_
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 9288617..5d183ae 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -18,7 +18,6 @@
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_buffer.h"
-#include "cc/resources/rasterizer.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_task_runner.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -203,10 +202,9 @@ scoped_ptr<TileManager> TileManager::Create(
     base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    Rasterizer* rasterizer,
     size_t scheduled_raster_task_limit) {
   return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
-                                         tile_task_runner, rasterizer,
+                                         tile_task_runner,
                                          scheduled_raster_task_limit));
 }
 
@@ -215,24 +213,15 @@ TileManager::TileManager(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    Rasterizer* rasterizer,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
       tile_task_runner_(tile_task_runner),
-      rasterizer_(rasterizer),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
-      ready_to_activate_notifier_(
-          task_runner_.get(),
-          base::Bind(&TileManager::NotifyReadyToActivate,
-                     base::Unretained(this))),
-      ready_to_draw_notifier_(
-          task_runner_.get(),
-          base::Bind(&TileManager::NotifyReadyToDraw, base::Unretained(this))),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
@@ -348,117 +337,38 @@ void TileManager::PrepareTiles(
 
   global_state_ = state;
 
-  PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
-
-  // TODO(hendrikw): Consider moving some of this code to the rasterizer.
-  if (prepare_tiles_mode != PrepareTilesMode::PREPARE_NONE) {
-    // We need to call CheckForCompletedTasks() once in-between each call
-    // to ScheduleTasks() to prevent canceled tasks from being scheduled.
-    if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
-      tile_task_runner_->CheckForCompletedTasks();
-      did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
-    }
-
-    FreeResourcesForReleasedTiles();
-    CleanUpReleasedTiles();
-
-    TileVector tiles_that_need_to_be_rasterized;
-    scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
-        client_->BuildRasterQueue(global_state_.tree_priority,
-                                  RasterTilePriorityQueue::Type::ALL));
-    AssignGpuMemoryToTiles(raster_priority_queue.get(),
-                           scheduled_raster_task_limit_,
-                           &tiles_that_need_to_be_rasterized);
-
-    // Inform the client that will likely require a draw if the highest priority
-    // tile that will be rasterized is required for draw.
-    client_->SetIsLikelyToRequireADraw(
-        !tiles_that_need_to_be_rasterized.empty() &&
-        (*tiles_that_need_to_be_rasterized.begin())->required_for_draw());
-
-    // Schedule tile tasks.
-    ScheduleTasks(tiles_that_need_to_be_rasterized);
-
-    did_notify_ready_to_activate_ = false;
-    did_notify_ready_to_draw_ = false;
-  } else {
-    if (global_state_.hard_memory_limit_in_bytes == 0) {
-      resource_pool_->CheckBusyResources(false);
-      MemoryUsage memory_limit(0, 0);
-      MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
-                               resource_pool_->acquired_resource_count());
-      FreeTileResourcesUntilUsageIsWithinLimit(nullptr, memory_limit,
-                                               &memory_usage);
-    }
-
-    did_notify_ready_to_activate_ = false;
-    did_notify_ready_to_draw_ = false;
-    ready_to_activate_notifier_.Schedule();
-    ready_to_draw_notifier_.Schedule();
+  // We need to call CheckForCompletedTasks() once in-between each call
+  // to ScheduleTasks() to prevent canceled tasks from being scheduled.
+  if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
+    tile_task_runner_->CheckForCompletedTasks();
+    did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
-  TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
-                       "state", BasicStateAsValue());
-
-  TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
-                    resource_pool_->total_memory_usage_bytes() -
-                        resource_pool_->acquired_memory_usage_bytes());
-}
-
-void TileManager::SynchronouslyRasterizeTiles(
-    const GlobalStateThatImpactsTilePriority& state) {
-  TRACE_EVENT0("cc", "TileManager::SynchronouslyRasterizeTiles");
-
-  DCHECK(rasterizer_->GetPrepareTilesMode() !=
-         PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES);
-
-  global_state_ = state;
-
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
-  scoped_ptr<RasterTilePriorityQueue> required_for_draw_queue(
-      client_->BuildRasterQueue(
-          global_state_.tree_priority,
-          RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(required_for_draw_queue.get(),
-                         std::numeric_limits<size_t>::max(),
+  scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+      client_->BuildRasterQueue(global_state_.tree_priority,
+                                RasterTilePriorityQueue::Type::ALL));
+  AssignGpuMemoryToTiles(raster_priority_queue.get(),
+                         scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
 
-  // Since we are synchronously rasterizing all tiles, we don't require further
-  // draws for that. Set the flag to false so that we can clear it if it was set
-  // earlier by PrepareTiles.
-  client_->SetIsLikelyToRequireADraw(false);
-
-  // We must reduce the amount of unused resources before calling
-  // RunTasks to prevent usage from rising above limits.
-  resource_pool_->ReduceResourceUsage();
+  // Inform the client that will likely require a draw if the highest priority
+  // tile that will be rasterized is required for draw.
+  client_->SetIsLikelyToRequireADraw(
+      !tiles_that_need_to_be_rasterized.empty() &&
+      (*tiles_that_need_to_be_rasterized.begin())->required_for_draw());
 
-  // Run and complete all raster task synchronously.
-  rasterizer_->RasterizeTiles(
-      tiles_that_need_to_be_rasterized, resource_pool_,
-      tile_task_runner_->GetResourceFormat(),
-      base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
-
-  // Use on-demand raster for any required-for-draw tiles that have not been
-  // assigned memory after reaching a steady memory state.
-  // TODO(hendrikw): Figure out why this would improve jank on some tests - See
-  // crbug.com/449288
-  required_for_draw_queue = client_->BuildRasterQueue(
-      global_state_.tree_priority,
-      RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+  // Schedule tile tasks.
+  ScheduleTasks(tiles_that_need_to_be_rasterized);
 
-  // Change to OOM mode for any tiles that have not been been assigned memory.
-  // This ensures that we draw even when OOM.
-  for (; !required_for_draw_queue->IsEmpty(); required_for_draw_queue->Pop()) {
-    Tile* tile = required_for_draw_queue->Top();
-    tile->draw_info().set_oom();
-    client_->NotifyTileStateChanged(tile);
-  }
+  did_notify_ready_to_activate_ = false;
+  did_notify_ready_to_draw_ = false;
 
-  TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
-                       BasicStateAsValue());
+  TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
+                       "state", BasicStateAsValue());
 
   TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
                     resource_pool_->total_memory_usage_bytes() -
@@ -471,11 +381,6 @@ void TileManager::UpdateVisibleTiles(
 
   tile_task_runner_->CheckForCompletedTasks();
 
-  DCHECK(rasterizer_);
-  PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
-  if (prepare_tiles_mode != PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES)
-    SynchronouslyRasterizeTiles(state);
-
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1(
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index cd08e30..087778a 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -34,7 +34,6 @@ class TracedValue;
 
 namespace cc {
 class PictureLayerImpl;
-class Rasterizer;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
@@ -96,7 +95,7 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
     // PixelBufferTileTaskWorkerPool depends on ALL being last.
     ALL
     // Adding additional values requires increasing kNumberOfTaskSets in
-    // rasterizer.h
+    // tile_task_runner.h
   };
 
   static_assert(NamedTaskSet::ALL == (kNumberOfTaskSets - 1),
@@ -107,7 +106,6 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
                                         base::SequencedTaskRunner* task_runner,
                                         ResourcePool* resource_pool,
                                         TileTaskRunner* tile_task_runner,
-                                        Rasterizer* rasterizer,
                                         size_t scheduled_raster_task_limit);
   ~TileManager() override;
 
@@ -189,7 +187,6 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
               const scoped_refptr<base::SequencedTaskRunner>& task_runner,
               ResourcePool* resource_pool,
               TileTaskRunner* tile_task_runner,
-              Rasterizer* rasterizer,
               size_t scheduled_raster_task_limit);
 
   void FreeResourcesForReleasedTiles();
@@ -214,9 +211,6 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
                               size_t scheduled_raser_task_limit,
                               TileVector* tiles_that_need_to_be_rasterized);
 
-  void SynchronouslyRasterizeTiles(
-      const GlobalStateThatImpactsTilePriority& state);
-
  private:
   class MemoryUsage {
    public:
@@ -278,7 +272,6 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   ResourcePool* resource_pool_;
   TileTaskRunner* tile_task_runner_;
-  Rasterizer* rasterizer_;
   GlobalStateThatImpactsTilePriority global_state_;
   size_t scheduled_raster_task_limit_;
 
@@ -308,8 +301,6 @@ class CC_EXPORT TileManager : public TileTaskRunnerClient,
 
   std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
 
-  UniqueNotifier ready_to_activate_notifier_;
-  UniqueNotifier ready_to_draw_notifier_;
   UniqueNotifier ready_to_activate_check_notifier_;
   UniqueNotifier ready_to_draw_check_notifier_;
   UniqueNotifier more_tiles_need_prepare_check_notifier_;
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 4b4b92c..cce307c 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -1353,27 +1353,5 @@ TEST_F(TileManagerTilePriorityQueueTest,
   host_impl_.resource_pool()->ReleaseResource(resource.Pass());
 }
 
-TEST_F(TileManagerTilePriorityQueueTest,
-       SetIsLikelyToRequireADrawOnSynchronousRaster) {
-  const gfx::Size layer_bounds(1000, 1000);
-  host_impl_.SetViewportSize(layer_bounds);
-  host_impl_.SetUseGpuRasterization(true);
-  EXPECT_EQ(host_impl_.rasterizer()->GetPrepareTilesMode(),
-            PrepareTilesMode::PREPARE_NONE);
-  SetupDefaultTrees(layer_bounds);
-
-  // Verify that the queue has a required for draw tile at Top.
-  scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
-      SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
-  EXPECT_FALSE(queue->IsEmpty());
-  EXPECT_TRUE(queue->Top()->required_for_draw());
-
-  host_impl_.SetIsLikelyToRequireADraw(true);
-
-  EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
-  host_impl_.tile_manager()->UpdateVisibleTiles(host_impl_.global_tile_state());
-  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
-}
-
 }  // namespace
 }  // namespace cc
diff --git a/cc/resources/tile_task_worker_pool_perftest.cc b/cc/resources/tile_task_worker_pool_perftest.cc
index 71da7b1..b36dd12 100644
--- a/cc/resources/tile_task_worker_pool_perftest.cc
+++ b/cc/resources/tile_task_worker_pool_perftest.cc
@@ -232,7 +232,6 @@ class TileTaskWorkerPoolPerfTestBase {
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<Rasterizer> rasterizer_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   scoped_ptr<TaskGraphRunner> task_graph_runner_;
   LapTimer timer_;
@@ -270,11 +269,9 @@ class TileTaskWorkerPoolPerfTest
         break;
       case TILE_TASK_WORKER_POOL_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
-        rasterizer_ = GpuRasterizer::Create(
-            context_provider_.get(), resource_provider_.get(), false, false, 0);
         tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
             task_runner_.get(), task_graph_runner_.get(),
-            static_cast<GpuRasterizer*>(rasterizer_.get()));
+            context_provider_.get(), resource_provider_.get(), false, 0);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
diff --git a/cc/resources/tile_task_worker_pool_unittest.cc b/cc/resources/tile_task_worker_pool_unittest.cc
index 3d74daf..c581e97 100644
--- a/cc/resources/tile_task_worker_pool_unittest.cc
+++ b/cc/resources/tile_task_worker_pool_unittest.cc
@@ -164,11 +164,9 @@ class TileTaskWorkerPoolTest
         break;
       case TILE_TASK_WORKER_POOL_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
-        rasterizer_ = GpuRasterizer::Create(
-            context_provider_.get(), resource_provider_.get(), false, false, 0);
         tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
             base::MessageLoopProxy::current().get(), &task_graph_runner_,
-            static_cast<GpuRasterizer*>(rasterizer_.get()));
+            context_provider_.get(), resource_provider_.get(), false, 0);
         break;
       case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
@@ -323,7 +321,6 @@ class TileTaskWorkerPoolTest
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   scoped_refptr<TestContextProvider> worker_context_provider_;
-  scoped_ptr<Rasterizer> rasterizer_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;