cc: Remove max tiles and skewport constants from tiling client.

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 30 matching lines @@
   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;
-  virtual size_t GetMaxTilesForInterestArea() const = 0;
-  virtual float GetSkewportTargetTimeInSeconds() const = 0;
-  virtual int GetSkewportExtrapolationLimitInContentPixels() const = 0;
   virtual WhichTree GetTree() const = 0;
   virtual bool RequiresHighResToDraw() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
@@ skipping 55 matching lines @@
   };
 
   ~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?
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
-      PictureLayerTilingClient* client);
+      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 Invalidate(const Region& layer_invalidation);
   void SetRasterSource(scoped_refptr<RasterSource> raster_source);
   void CreateMissingTilesInLiveTilesRect();
 
   void CloneTilesAndPropertiesFrom(const PictureLayerTiling& twin_tiling);
 
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
@@ skipping 143 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,
-                     PictureLayerTilingClient* client);
+                     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();
   Tile* CreateTile(int i, int j, const PictureLayerTiling* twin_tiling);
   // Returns true if the Tile existed and was removed from the tiling.
   bool RemoveTileAt(int i, int j, PictureLayerTiling* recycled_twin);
 
   // Computes a skewport. The calculation extrapolates the last visible
   // rect and the current visible rect to expand the skewport to where it
   // would be in |skewport_target_time| seconds. Note that the skewport
   // is guaranteed to contain the current visible rect.
   gfx::Rect ComputeSkewport(double current_frame_time_in_seconds,
                             const gfx::Rect& visible_rect_in_content_space)
       const;
 
   void UpdateEvictionCacheIfNeeded(TreePriority tree_priority);
   const std::vector<Tile*>* GetEvictionTiles(TreePriority tree_priority,
                                              EvictionCategory category);
 
   // 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;
 
+  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.
   float contents_scale_;
   gfx::Size layer_bounds_;
   TileResolution resolution_;
   PictureLayerTilingClient* client_;
 
   // 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_;
@@ skipping 34 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_