Update from https://crrev.com/309415

cc/resources/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_RESOURCES_PICTURE_LAYER_TILING_H_
 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
 
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 17 matching lines @@
 
 namespace cc {
 
 class PictureLayerTiling;
 class RasterSource;
 
 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 scoped_refptr<Tile> CreateTile(
-    PictureLayerTiling* tiling,
-    const gfx::Rect& content_rect) = 0;
+  virtual scoped_refptr<Tile> CreateTile(float contents_scale,
+                                         const gfx::Rect& content_rect) = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
   // This invalidation region defines the area (if any, it can by null) that
   // tiles can not be shared between pending and active trees.
   virtual const Region* GetPendingInvalidation() = 0;
   virtual const PictureLayerTiling* GetPendingOrActiveTwinTiling(
       const PictureLayerTiling* tiling) const = 0;
   virtual PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) = 0;
   virtual TilePriority::PriorityBin GetMaxTilePriorityBin() const = 0;
@@ skipping 50 matching lines @@
 
     Phase phase_;
 
     Tile* current_tile_;
     TilingData::Iterator visible_iterator_;
     TilingData::SpiralDifferenceIterator spiral_iterator_;
   };
 
   ~PictureLayerTiling();
 
-  // Create a tiling with no tiles.  CreateTiles must be called to add some.
-  // TODO(danakj): Pass the raster_source here instead of the size, store the
-  // raster source instead of layer bounds?
+  // Create a tiling with no tiles. CreateTile() must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
-      const gfx::Size& layer_bounds,
+      scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       size_t max_tiles_for_interest_area,
       float skewport_target_time_in_seconds,
       int skewport_extrapolation_limit_in_content_pixels);
 
-  gfx::Size layer_bounds() const { return layer_bounds_; }
-  void Resize(const gfx::Size& new_layer_bounds);
+  void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
-  void SetRasterSource(scoped_refptr<RasterSource> raster_source);
+  void SetRasterSourceOnTiles();
   void CreateMissingTilesInLiveTilesRect();
 
   void CloneTilesAndPropertiesFrom(const PictureLayerTiling& twin_tiling);
 
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
   void set_can_require_tiles_for_activation(bool can_require_tiles) {
     can_require_tiles_for_activation_ = can_require_tiles;
   }
 
+  RasterSource* raster_source() const { return raster_source_.get(); }
   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_; }
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
     return (iter == tiles_.end()) ? NULL : iter->second.get();
   }
 
@@ skipping 83 matching lines @@
     int left_;
     int top_;
     int right_;
     int bottom_;
 
     friend class PictureLayerTiling;
   };
 
   void Reset();
 
-  void ComputeTilePriorityRects(const gfx::Rect& viewport_in_layer_space,
+  bool ComputeTilePriorityRects(const gfx::Rect& viewport_in_layer_space,
                                 float ideal_contents_scale,
                                 double current_frame_time_in_seconds,
                                 const Occlusion& occlusion_in_layer_space);
 
-  bool NeedsUpdateForFrameAtTimeAndViewport(
-      double frame_time_in_seconds,
-      const gfx::Rect& viewport_in_layer_space) {
-    return frame_time_in_seconds != last_impl_frame_time_in_seconds_ ||
-           viewport_in_layer_space != last_viewport_in_layer_space_;
-  }
-
   void GetAllTilesForTracing(std::set<const Tile*>* tiles) const;
   void AsValueInto(base::debug::TracedValue* array) const;
   size_t GPUMemoryUsageInBytes() const;
 
   struct RectExpansionCache {
     RectExpansionCache();
 
     gfx::Rect previous_start;
     gfx::Rect previous_bounds;
     gfx::Rect previous_result;
@@ skipping 13 matching lines @@
 
  protected:
   friend class CoverageIterator;
   friend class TilingRasterTileIterator;
   friend class TilingSetEvictionQueue;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 
   PictureLayerTiling(float contents_scale,
-                     const gfx::Size& layer_bounds,
+                     scoped_refptr<RasterSource> raster_source,
                      PictureLayerTilingClient* client,
                      size_t max_tiles_for_interest_area,
                      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(int i,
                    int j,
                    const PictureLayerTiling* twin_tiling,
                    PictureLayerTiling* recycled_twin);
@@ skipping 11 matching lines @@
   // Save the required data for computing tile priorities later.
   void UpdateTilePriorityRects(float content_to_screen_scale_,
                                const gfx::Rect& visible_rect_in_content_space,
                                const gfx::Rect& skewport,
                                const gfx::Rect& soon_border_rect,
                                const gfx::Rect& eventually_rect,
                                const Occlusion& occlusion_in_layer_space);
 
   void UpdateTileAndTwinPriority(Tile* tile) const;
   void UpdateTilePriority(Tile* tile) const;
+  bool NeedsUpdateForFrameAtTimeAndViewport(
+      double frame_time_in_seconds,
+      const gfx::Rect& viewport_in_layer_space) {
+    return frame_time_in_seconds != last_impl_frame_time_in_seconds_ ||
+           viewport_in_layer_space != last_viewport_in_layer_space_;
+  }
 
   const size_t max_tiles_for_interest_area_;
   const float skewport_target_time_in_seconds_;
   const int skewport_extrapolation_limit_in_content_pixels_;
 
   // Given properties.
   const float contents_scale_;
   PictureLayerTilingClient* const client_;
-  gfx::Size layer_bounds_;
+  scoped_refptr<RasterSource> raster_source_;
   TileResolution resolution_;
 
   // 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_;
 
   // State saved for computing velocities based upon finite differences.
   double last_impl_frame_time_in_seconds_;
   gfx::Rect last_viewport_in_layer_space_;
@@ skipping 17 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_