cc: Do solid color analysis before scheduling tiles.

Instead of creating separate analysis task in raster thread for
solid color detection, we do it while scheduling and rasterization
in cc thread itself. This would save us the thread overhead etc.

BUG=553612
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

9 files changed, 166 insertions, 146 deletions

diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index de681700..86340ab 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -43,20 +43,19 @@ void RunBenchmark(DisplayListRasterSource* raster_source,
     LapTimer timer(kWarmupRuns,
                    base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                    kTimeCheckInterval);
+    SkColor color = SK_ColorTRANSPARENT;
+    *is_solid_color = raster_source->PerformSolidColorAnalysis(
+        content_rect, contents_scale, &color);
+
     do {
       SkBitmap bitmap;
       bitmap.allocPixels(SkImageInfo::MakeN32Premul(content_rect.width(),
                                                     content_rect.height()));
       SkCanvas canvas(bitmap);
-      DisplayListRasterSource::SolidColorAnalysis analysis;
 
-      raster_source->PerformSolidColorAnalysis(content_rect, contents_scale,
-                                               &analysis);
       raster_source->PlaybackToCanvas(&canvas, content_rect, content_rect,
                                       contents_scale);
 
-      *is_solid_color = analysis.is_solid_color;
-
       timer.NextLap();
     } while (!timer.HasTimeLimitExpired());
     base::TimeDelta duration =
diff --git a/cc/playback/display_list_raster_source.cc b/cc/playback/display_list_raster_source.cc
index eac4916..c1a5318 100644
--- a/cc/playback/display_list_raster_source.cc
+++ b/cc/playback/display_list_raster_source.cc
@@ -219,11 +219,10 @@ size_t DisplayListRasterSource::GetPictureMemoryUsage() const {
          painter_reported_memory_usage_;
 }
 
-void DisplayListRasterSource::PerformSolidColorAnalysis(
+bool DisplayListRasterSource::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
-    DisplayListRasterSource::SolidColorAnalysis* analysis) const {
-  DCHECK(analysis);
+    SkColor* color) const {
   TRACE_EVENT0("cc", "DisplayListRasterSource::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect =
@@ -232,7 +231,7 @@ void DisplayListRasterSource::PerformSolidColorAnalysis(
   layer_rect.Intersect(gfx::Rect(size_));
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
   RasterForAnalysis(&canvas, layer_rect, 1.0f);
-  analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
+  return canvas.GetColorIfSolid(color);
 }
 
 void DisplayListRasterSource::GetDiscardableImagesInRect(
diff --git a/cc/playback/display_list_raster_source.h b/cc/playback/display_list_raster_source.h
index 8466542..ac4a80a 100644
--- a/cc/playback/display_list_raster_source.h
+++ b/cc/playback/display_list_raster_source.h
@@ -25,15 +25,6 @@ class DrawImage;
 class CC_EXPORT DisplayListRasterSource
     : public base::RefCountedThreadSafe<DisplayListRasterSource> {
  public:
-  struct CC_EXPORT SolidColorAnalysis {
-    SolidColorAnalysis()
-        : is_solid_color(false), solid_color(SK_ColorTRANSPARENT) {}
-    ~SolidColorAnalysis() {}
-
-    bool is_solid_color;
-    SkColor solid_color;
-  };
-
   static scoped_refptr<DisplayListRasterSource>
   CreateFromDisplayListRecordingSource(const DisplayListRecordingSource* other,
                                        bool can_use_lcd_text);
@@ -57,11 +48,11 @@ class CC_EXPORT DisplayListRasterSource
                               const gfx::Rect& canvas_rect,
                               float contents_scale) const;
 
-  // Analyze to determine if the given rect at given scale is of solid color in
-  // this raster source.
-  void PerformSolidColorAnalysis(const gfx::Rect& content_rect,
+  // Returns whether the given rect at given scale is of solid color in
+  // this raster source, as well as the solid color value.
+  bool PerformSolidColorAnalysis(const gfx::Rect& content_rect,
                                  float contents_scale,
-                                 SolidColorAnalysis* analysis) const;
+                                 SkColor* color) const;
 
   // Returns true iff the whole raster source is of solid color.
   bool IsSolidColor() const;
diff --git a/cc/playback/display_list_raster_source_unittest.cc b/cc/playback/display_list_raster_source_unittest.cc
index ca746fc..2cf6f06 100644
--- a/cc/playback/display_list_raster_source_unittest.cc
+++ b/cc/playback/display_list_raster_source_unittest.cc
@@ -29,7 +29,9 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidUnscaled) {
   solid_paint.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
+  SkColor color = SK_ColorTRANSPARENT;
   SkPaint non_solid_paint;
+  bool is_solid_color = false;
   non_solid_paint.setColor(non_solid_color);
 
   recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
@@ -43,11 +45,10 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidUnscaled) {
   // Ensure everything is solid.
   for (int y = 0; y <= 300; y += 100) {
     for (int x = 0; x <= 300; x += 100) {
-      DisplayListRasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 100, 100);
-      raster->PerformSolidColorAnalysis(rect, 1.0, &analysis);
-      EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
-      EXPECT_EQ(solid_color, analysis.solid_color) << rect.ToString();
+      is_solid_color = raster->PerformSolidColorAnalysis(rect, 1.0, &color);
+      EXPECT_TRUE(is_solid_color) << rect.ToString();
+      EXPECT_EQ(solid_color, color) << rect.ToString();
     }
   }
 
@@ -58,33 +59,35 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidUnscaled) {
   raster = DisplayListRasterSource::CreateFromDisplayListRecordingSource(
       recording_source.get(), false);
 
-  DisplayListRasterSource::SolidColorAnalysis analysis;
-  raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), 1.0, &analysis);
-  EXPECT_FALSE(analysis.is_solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), 1.0, &color);
+  EXPECT_FALSE(is_solid_color);
 
-  raster->PerformSolidColorAnalysis(gfx::Rect(100, 0, 100, 100), 1.0,
-                                    &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(solid_color, analysis.solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color = raster->PerformSolidColorAnalysis(
+      gfx::Rect(100, 0, 100, 100), 1.0, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(solid_color, color);
 
   // Boundaries should be clipped.
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(350, 0, 100, 100), 1.0,
-                                    &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(solid_color, analysis.solid_color);
-
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(0, 350, 100, 100), 1.0,
-                                    &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(solid_color, analysis.solid_color);
-
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(350, 350, 100, 100), 1.0,
-                                    &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(solid_color, analysis.solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color = raster->PerformSolidColorAnalysis(
+      gfx::Rect(350, 0, 100, 100), 1.0, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(solid_color, color);
+
+  color = SK_ColorTRANSPARENT;
+  is_solid_color = raster->PerformSolidColorAnalysis(
+      gfx::Rect(0, 350, 100, 100), 1.0, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(solid_color, color);
+
+  color = SK_ColorTRANSPARENT;
+  is_solid_color = raster->PerformSolidColorAnalysis(
+      gfx::Rect(350, 350, 100, 100), 1.0, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(solid_color, color);
 }
 
 TEST(DisplayListRasterSourceTest, AnalyzeIsSolidScaled) {
@@ -94,7 +97,9 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidScaled) {
       FakeDisplayListRecordingSource::CreateFilledRecordingSource(layer_bounds);
 
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
+  SkColor color = SK_ColorTRANSPARENT;
   SkPaint solid_paint;
+  bool is_solid_color = false;
   solid_paint.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
@@ -112,11 +117,10 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidScaled) {
   // Ensure everything is solid.
   for (int y = 0; y <= 30; y += 10) {
     for (int x = 0; x <= 30; x += 10) {
-      DisplayListRasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 10, 10);
-      raster->PerformSolidColorAnalysis(rect, 0.1f, &analysis);
-      EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
-      EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString();
+      is_solid_color = raster->PerformSolidColorAnalysis(rect, 0.1f, &color);
+      EXPECT_TRUE(is_solid_color) << rect.ToString();
+      EXPECT_EQ(color, solid_color) << rect.ToString();
     }
   }
 
@@ -127,29 +131,35 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidScaled) {
   raster = DisplayListRasterSource::CreateFromDisplayListRecordingSource(
       recording_source.get(), false);
 
-  DisplayListRasterSource::SolidColorAnalysis analysis;
-  raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 10, 10), 0.1f, &analysis);
-  EXPECT_FALSE(analysis.is_solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 10, 10), 0.1f, &color);
+  EXPECT_FALSE(is_solid_color);
 
-  raster->PerformSolidColorAnalysis(gfx::Rect(10, 0, 10, 10), 0.1f, &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(analysis.solid_color, solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(10, 0, 10, 10), 0.1f, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(color, solid_color);
 
   // Boundaries should be clipped.
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(35, 0, 10, 10), 0.1f, &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(analysis.solid_color, solid_color);
-
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(0, 35, 10, 10), 0.1f, &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(analysis.solid_color, solid_color);
-
-  analysis.is_solid_color = false;
-  raster->PerformSolidColorAnalysis(gfx::Rect(35, 35, 10, 10), 0.1f, &analysis);
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(analysis.solid_color, solid_color);
+  color = SK_ColorTRANSPARENT;
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(35, 0, 10, 10), 0.1f, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(color, solid_color);
+
+  color = SK_ColorTRANSPARENT;
+  is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 35, 10, 10), 0.1f, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(color, solid_color);
+
+  color = SK_ColorTRANSPARENT;
+  is_solid_color = raster->PerformSolidColorAnalysis(gfx::Rect(35, 35, 10, 10),
+                                                     0.1f, &color);
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(color, solid_color);
 }
 
 TEST(DisplayListRasterSourceTest, AnalyzeIsSolidEmpty) {
@@ -162,13 +172,13 @@ TEST(DisplayListRasterSourceTest, AnalyzeIsSolidEmpty) {
   scoped_refptr<DisplayListRasterSource> raster =
       DisplayListRasterSource::CreateFromDisplayListRecordingSource(
           recording_source.get(), false);
-  DisplayListRasterSource::SolidColorAnalysis analysis;
-  EXPECT_FALSE(analysis.is_solid_color);
 
-  raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 400, 400), 1.f, &analysis);
+  SkColor color = SK_ColorTRANSPARENT;
+  bool is_solid_color =
+      raster->PerformSolidColorAnalysis(gfx::Rect(0, 0, 400, 400), 1.f, &color);
 
-  EXPECT_TRUE(analysis.is_solid_color);
-  EXPECT_EQ(analysis.solid_color, SkColorSetARGB(0, 0, 0, 0));
+  EXPECT_TRUE(is_solid_color);
+  EXPECT_EQ(color, SkColorSetARGB(0, 0, 0, 0));
 }
 
 TEST(DisplayListRasterSourceTest, PixelRefIteratorDiscardableRefsOneTile) {
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/tile_task_worker_pool_unittest.cc
index c873089..9f8b003 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/tile_task_worker_pool_unittest.cc
@@ -53,9 +53,7 @@ enum TileTaskWorkerPoolType {
 
 class TestRasterTaskImpl : public RasterTask {
  public:
-  typedef base::Callback<void(
-      const DisplayListRasterSource::SolidColorAnalysis& analysis,
-      bool was_canceled)> Reply;
+  typedef base::Callback<void(bool was_canceled)> Reply;
 
   TestRasterTaskImpl(const Resource* resource,
                      const Reply& reply,
@@ -81,8 +79,7 @@ class TestRasterTaskImpl : public RasterTask {
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(std::move(raster_buffer_));
-    reply_.Run(DisplayListRasterSource::SolidColorAnalysis(),
-               !HasFinishedRunning());
+    reply_.Run(!HasFinishedRunning());
   }
 
  protected:
@@ -273,7 +270,6 @@ class TileTaskWorkerPoolTest
   void OnTaskCompleted(
       scoped_ptr<ScopedResource> resource,
       unsigned id,
-      const DisplayListRasterSource::SolidColorAnalysis& analysis,
       bool was_canceled) {
     RasterTaskResult result;
     result.id = id;
diff --git a/cc/tiles/tile.h b/cc/tiles/tile.h
index 6ca9e87..99497f3 100644
--- a/cc/tiles/tile.h
+++ b/cc/tiles/tile.h
@@ -104,6 +104,8 @@ class CC_EXPORT Tile {
     return invalidated_content_rect_;
   }
 
+  bool HasRasterTask() const { return !!raster_task_.get(); }
+
  private:
   friend class TileManager;
   friend class FakeTileManager;
@@ -117,8 +119,6 @@ class CC_EXPORT Tile {
        int flags);
   ~Tile();
 
-  bool HasRasterTask() const { return !!raster_task_.get(); }
-
   TileManager* const tile_manager_;
   const gfx::Rect content_rect_;
   const gfx::Rect enclosing_layer_rect_;
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 88afa63..ebb1d3f 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -56,10 +56,7 @@ class RasterTaskImpl : public RasterTask {
                  uint64_t previous_content_id,
                  uint64_t resource_content_id,
                  int source_frame_number,
-                 bool analyze_picture,
-                 const base::Callback<
-                     void(const DisplayListRasterSource::SolidColorAnalysis&,
-                          bool)>& reply,
+                 const base::Callback<void(bool)>& reply,
                  ImageDecodeTask::Vector* dependencies)
       : RasterTask(dependencies),
         resource_(resource),
@@ -75,7 +72,6 @@ class RasterTaskImpl : public RasterTask {
         previous_content_id_(previous_content_id),
         resource_content_id_(resource_content_id),
         source_frame_number_(source_frame_number),
-        analyze_picture_(analyze_picture),
         reply_(reply) {}
 
   // Overridden from Task:
@@ -86,12 +82,6 @@ class RasterTaskImpl : public RasterTask {
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
-    if (analyze_picture_) {
-      Analyze(raster_source_.get());
-      if (analysis_.is_solid_color)
-        return;
-    }
-
     Raster(raster_source_.get());
   }
 
@@ -103,25 +93,13 @@ class RasterTaskImpl : public RasterTask {
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(std::move(raster_buffer_));
-    reply_.Run(analysis_, !HasFinishedRunning());
+    reply_.Run(!HasFinishedRunning());
   }
 
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
-  void Analyze(const DisplayListRasterSource* raster_source) {
-    frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
-        tile_, tile_resolution_, source_frame_number_, layer_id_);
-
-    DCHECK(raster_source);
-
-    raster_source->PerformSolidColorAnalysis(content_rect_, contents_scale_,
-                                             &analysis_);
-    // Clear the flag if we're not using the estimator.
-    analysis_.is_solid_color &= kUseColorEstimator;
-  }
-
   void Raster(const DisplayListRasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_, tile_resolution_, source_frame_number_, layer_id_);
@@ -137,7 +115,6 @@ class RasterTaskImpl : public RasterTask {
   }
 
   const Resource* resource_;
-  DisplayListRasterSource::SolidColorAnalysis analysis_;
   scoped_refptr<DisplayListRasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
@@ -150,9 +127,7 @@ class RasterTaskImpl : public RasterTask {
   uint64_t previous_content_id_;
   uint64_t resource_content_id_;
   int source_frame_number_;
-  bool analyze_picture_;
-  const base::Callback<void(const DisplayListRasterSource::SolidColorAnalysis&,
-                            bool)> reply_;
+  const base::Callback<void(bool)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
@@ -624,6 +599,23 @@ void TileManager::AssignGpuMemoryToTiles(
       break;
     }
 
+    if (tile->use_picture_analysis() && kUseColorEstimator) {
+      // We analyze for solid color here, to decide to continue
+      // or drop the tile for scheduling and raster.
+      // TODO(sohanjg): Check if we could use a shared analysis
+      // canvas which is reset between tiles.
+      SkColor color = SK_ColorTRANSPARENT;
+      bool is_solid_color =
+          prioritized_tile.raster_source()->PerformSolidColorAnalysis(
+              tile->content_rect(), tile->contents_scale(), &color);
+      if (is_solid_color) {
+        tile->draw_info().set_solid_color(color);
+        tile->draw_info().set_was_ever_ready_to_draw();
+        client_->NotifyTileStateChanged(tile);
+        continue;
+      }
+    }
+
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
         scheduled_raster_task_limit) {
@@ -865,7 +857,6 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
       prioritized_tile.priority().resolution, tile->layer_id(),
       prepare_tiles_count_, static_cast<const void*>(tile), tile->id(),
       tile->invalidated_id(), resource_content_id, tile->source_frame_number(),
-      tile->use_picture_analysis(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
                  tile->id(), resource),
       &decode_tasks));
@@ -874,11 +865,11 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     Resource* resource,
-    const DisplayListRasterSource::SolidColorAnalysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
+  TileDrawInfo& draw_info = tile->draw_info();
   DCHECK(tile->raster_task_.get());
   orphan_tasks_.push_back(tile->raster_task_);
   tile->raster_task_ = nullptr;
@@ -893,32 +884,12 @@ void TileManager::OnRasterTaskCompleted(
     return;
   }
 
-  UpdateTileDrawInfo(tile, resource, analysis);
-}
-
-void TileManager::UpdateTileDrawInfo(
-    Tile* tile,
-    Resource* resource,
-    const DisplayListRasterSource::SolidColorAnalysis& analysis) {
-  TileDrawInfo& draw_info = tile->draw_info();
-
   ++flush_stats_.completed_count;
 
-  if (analysis.is_solid_color) {
-    draw_info.set_solid_color(analysis.solid_color);
-    if (resource) {
-      // TODO(ericrk): If more partial raster work is done in the future, it may
-      // be worth returning the resource to the pool with its previous ID (not
-      // currently tracked). crrev.com/1370333002/#ps40001 has a possible method
-      // of achieving this.
-      resource_pool_->ReleaseResource(resource, 0 /* content_id */);
-    }
-  } else {
-    DCHECK(resource);
-    draw_info.set_use_resource();
-    draw_info.resource_ = resource;
-    draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
-  }
+  draw_info.set_use_resource();
+  draw_info.resource_ = resource;
+  draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
+
   DCHECK(draw_info.IsReadyToDraw());
   draw_info.set_was_ever_ready_to_draw();
 
diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index bb58c57..1f0e3fe 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h
@@ -243,12 +243,7 @@ class CC_EXPORT TileManager {
   void OnRasterTaskCompleted(
       Tile::Id tile,
       Resource* resource,
-      const DisplayListRasterSource::SolidColorAnalysis& analysis,
       bool was_canceled);
-  void UpdateTileDrawInfo(
-      Tile* tile,
-      Resource* resource,
-      const DisplayListRasterSource::SolidColorAnalysis& analysis);
 
   void FreeResourcesForTile(Tile* tile);
   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index ff67be2..1801389 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -1452,6 +1452,65 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterQueueAllUsesCorrectTileBounds) {
   }
 }
 
+TEST_F(TileManagerTilePriorityQueueTest, NoRasterTasksforSolidColorTiles) {
+  gfx::Size size(10, 10);
+  const gfx::Size layer_bounds(1000, 1000);
+
+  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(layer_bounds);
+
+  SkPaint solid_paint;
+  SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
+  solid_paint.setColor(solid_color);
+  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
+                                             solid_paint);
+
+  // Create non solid tile as well, otherwise tilings wouldnt be created.
+  SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
+  SkPaint non_solid_paint;
+  non_solid_paint.setColor(non_solid_color);
+
+  recording_source->add_draw_rect_with_paint(gfx::Rect(0, 0, 10, 10),
+                                             non_solid_paint);
+  recording_source->Rerecord();
+
+  scoped_refptr<DisplayListRasterSource> raster_source =
+      DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+          recording_source.get(), false);
+
+  FakePictureLayerTilingClient tiling_client;
+  tiling_client.SetTileSize(size);
+
+  scoped_ptr<PictureLayerImpl> layer_impl =
+      PictureLayerImpl::Create(host_impl_.active_tree(), 1, false, nullptr);
+  PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
+
+  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  tiling->set_resolution(HIGH_RESOLUTION);
+  tiling->CreateAllTilesForTesting();
+  tiling->SetTilePriorityRectsForTesting(
+      gfx::Rect(layer_bounds),   // Visible rect.
+      gfx::Rect(layer_bounds),   // Skewport rect.
+      gfx::Rect(layer_bounds),   // Soon rect.
+      gfx::Rect(layer_bounds));  // Eventually rect.
+
+  host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+
+  std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+  for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
+    Tile* tile = tiles[tile_idx];
+    if (tile->id() == 1) {
+      // Non-solid tile.
+      EXPECT_TRUE(tile->HasRasterTask());
+      EXPECT_EQ(TileDrawInfo::RESOURCE_MODE, tile->draw_info().mode());
+    } else {
+      EXPECT_FALSE(tile->HasRasterTask());
+      EXPECT_EQ(TileDrawInfo::SOLID_COLOR_MODE, tile->draw_info().mode());
+      EXPECT_EQ(solid_color, tile->draw_info().solid_color());
+    }
+  }
+}
+
 // TODO(vmpstr): Merge TileManagerTest and TileManagerTilePriorityQueueTest.
 class TileManagerTest : public testing::Test {
  public: