cc: Rename DisplayListRasterSource to just RasterSource.

cc/tiles/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_TILES_PICTURE_LAYER_TILING_H_
 #define CC_TILES_PICTURE_LAYER_TILING_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 13 matching lines @@
 #include "ui/gfx/geometry/rect.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
 
-class DisplayListRasterSource;
+class RasterSource;
 class PictureLayerTiling;
 class PrioritizedTile;
 
 class CC_EXPORT PictureLayerTilingClient {
  public:
   // Create a tile at the given content_rect (in the contents scale of the
   // tiling) This might return null if the client cannot create such a tile.
   virtual ScopedTilePtr CreateTile(const Tile::CreateInfo& info) = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
@@ skipping 39 matching lines @@
   ~PictureLayerTiling();
 
   static float CalculateSoonBorderDistance(
       const gfx::Rect& visible_rect_in_content_space,
       float content_to_screen_scale);
 
   // Create a tiling with no tiles. CreateTile() must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       WhichTree tree,
       float contents_scale,
-      scoped_refptr<DisplayListRasterSource> raster_source,
+      scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       size_t tiling_interest_area_padding,
       float skewport_target_time_in_seconds,
       int skewport_extrapolation_limit_in_content_pixels);
 
-  void SetRasterSourceAndResize(
-      scoped_refptr<DisplayListRasterSource> raster_source);
+  void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
   void CreateMissingTilesInLiveTilesRect();
   void TakeTilesAndPropertiesFrom(PictureLayerTiling* pending_twin,
                                   const Region& layer_invalidation);
 
   bool IsTileRequiredForActivation(const Tile* tile) const;
   bool IsTileRequiredForDraw(const Tile* tile) const;
 
   void set_resolution(TileResolution resolution) {
     resolution_ = resolution;
     may_contain_low_resolution_tiles_ |= resolution == LOW_RESOLUTION;
   }
   TileResolution resolution() const { return resolution_; }
   bool may_contain_low_resolution_tiles() const {
     return may_contain_low_resolution_tiles_;
   }
   void reset_may_contain_low_resolution_tiles() {
     may_contain_low_resolution_tiles_ = false;
   }
   void set_can_require_tiles_for_activation(bool can_require_tiles) {
     can_require_tiles_for_activation_ = can_require_tiles;
   }
 
-  const scoped_refptr<DisplayListRasterSource>& raster_source() const {
+  const scoped_refptr<RasterSource>& raster_source() const {
     return raster_source_;
   }
   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
   float contents_scale() const { return contents_scale_; }
   const TilingData* tiling_data() const { return &tiling_data_; }
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
@@ skipping 133 matching lines @@
 
   using TileMap = std::unordered_map<TileMapKey, ScopedTilePtr, TileMapKeyHash>;
 
   struct FrameVisibleRect {
     gfx::Rect visible_rect_in_content_space;
     double frame_time_in_seconds = 0.0;
   };
 
   PictureLayerTiling(WhichTree tree,
                      float contents_scale,
-                     scoped_refptr<DisplayListRasterSource> raster_source,
+                     scoped_refptr<RasterSource> raster_source,
                      PictureLayerTilingClient* client,
                      size_t tiling_interest_area_padding,
                      float skewport_target_time_in_seconds,
                      int skewport_extrapolation_limit_in_content_pixels);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
   Tile* CreateTile(const Tile::CreateInfo& info);
   ScopedTilePtr TakeTileAt(int i, int j);
   // Returns true if the Tile existed and was removed from the tiling.
   bool RemoveTileAt(int i, int j);
@@ skipping 78 matching lines @@
   void RemoveTilesInRegion(const Region& layer_region, bool recreate_tiles);
 
   const size_t tiling_interest_area_padding_;
   const float skewport_target_time_in_seconds_;
   const int skewport_extrapolation_limit_in_content_pixels_;
 
   // Given properties.
   const float contents_scale_;
   PictureLayerTilingClient* const client_;
   const WhichTree tree_;
-  scoped_refptr<DisplayListRasterSource> raster_source_;
+  scoped_refptr<RasterSource> raster_source_;
   TileResolution resolution_;
   bool may_contain_low_resolution_tiles_;
 
   // Internal data.
   TilingData tiling_data_;
   TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
   gfx::Rect live_tiles_rect_;
 
   gfx::Rect last_viewport_in_layer_space_;
   // State saved for computing velocities based upon finite differences.
@@ skipping 16 matching lines @@
   bool has_eventually_rect_tiles_;
   bool all_tiles_done_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTiling);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_PICTURE_LAYER_TILING_H_