cc: Remove the base RasterSource

cc/tiles/tile_manager.cc

 // Copyright 2012 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/tiles/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 20 matching lines @@
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     ScopedRasterTaskTimer,
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
 class RasterTaskImpl : public RasterTask {
  public:
-  RasterTaskImpl(
-      const Resource* resource,
-      RasterSource* raster_source,
-      const gfx::Rect& content_rect,
-      const gfx::Rect& invalid_content_rect,
-      float contents_scale,
-      TileResolution tile_resolution,
-      int layer_id,
-      uint64_t source_prepare_tiles_id,
-      const void* tile,
-      uint64_t new_content_id,
-      uint64_t previous_content_id,
-      uint64_t resource_content_id,
-      int source_frame_number,
-      bool analyze_picture,
-      const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
-          reply,
-      ImageDecodeTask::Vector* dependencies)
+  RasterTaskImpl(const Resource* resource,
+                 DisplayListRasterSource* raster_source,
+                 const gfx::Rect& content_rect,
+                 const gfx::Rect& invalid_content_rect,
+                 float contents_scale,
+                 TileResolution tile_resolution,
+                 int layer_id,
+                 uint64_t source_prepare_tiles_id,
+                 const void* tile,
+                 uint64_t new_content_id,
+                 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,
+                 ImageDecodeTask::Vector* dependencies)
       : RasterTask(dependencies),
         resource_(resource),
         raster_source_(raster_source),
         content_rect_(content_rect),
         invalid_content_rect_(invalid_content_rect),
         contents_scale_(contents_scale),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         source_prepare_tiles_id_(source_prepare_tiles_id),
         tile_(tile),
@@ skipping 29 matching lines @@
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
-  void Analyze(const RasterSource* raster_source) {
+  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 RasterSource* raster_source) {
+  void Raster(const DisplayListRasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_, tile_resolution_, source_frame_number_, layer_id_);
     ScopedRasterTaskTimer timer;
     timer.SetArea(content_rect_.size().GetArea());
 
     DCHECK(raster_source);
 
     bool include_images = tile_resolution_ != LOW_RESOLUTION;
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              invalid_content_rect_, new_content_id_,
                              contents_scale_, include_images);
   }
 
   const Resource* resource_;
-  RasterSource::SolidColorAnalysis analysis_;
-  scoped_refptr<RasterSource> raster_source_;
+  DisplayListRasterSource::SolidColorAnalysis analysis_;
+  scoped_refptr<DisplayListRasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
   float contents_scale_;
   TileResolution tile_resolution_;
   int layer_id_;
   uint64_t source_prepare_tiles_id_;
   const void* tile_;
   uint64_t new_content_id_;
   uint64_t previous_content_id_;
   uint64_t resource_content_id_;
   int source_frame_number_;
   bool analyze_picture_;
-  const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
-      reply_;
+  const base::Callback<void(const DisplayListRasterSource::SolidColorAnalysis&,
+                            bool)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 const char* TaskSetName(TaskSet task_set) {
   switch (task_set) {
     case TileManager::ALL:
       return "ALL";
     case TileManager::REQUIRED_FOR_ACTIVATION:
@@ skipping 532 matching lines @@
       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));
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     Resource* resource,
-    const RasterSource::SolidColorAnalysis& analysis,
+    const DisplayListRasterSource::SolidColorAnalysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
   DCHECK(tile->raster_task_.get());
   orphan_raster_tasks_.push_back(tile->raster_task_);
   tile->raster_task_ = nullptr;
 
   if (was_canceled) {
     ++flush_stats_.canceled_count;
     // 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 */);
     return;
   }
 
   UpdateTileDrawInfo(tile, resource, analysis);
 }
 
 void TileManager::UpdateTileDrawInfo(
     Tile* tile,
     Resource* resource,
-    const RasterSource::SolidColorAnalysis& analysis) {
+    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
@@ skipping 263 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc