Tile Compression

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(PictureLayerTiling* tiling,
+                                         const gfx::Rect& content_rect,
+                                         int flags) = 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 70 matching lines @@
   ~PictureLayerTiling();
 
   // Create a tiling with no tiles.  CreateTiles must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client);
   gfx::Size layer_bounds() const { return layer_bounds_; }
   void UpdateTilesToCurrentRasterSource(RasterSource* raster_source,
                                         const Region& layer_invalidation,
-                                        const gfx::Size& new_layer_bounds);
+                                        const gfx::Size& new_layer_bounds,
+                                        base::TimeTicks frame_time);
   void CreateMissingTilesInLiveTilesRect();
   void RemoveTilesInRegion(const Region& layer_region);
 
   void SetClient(PictureLayerTilingClient* client);
   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;
   }
 
@@ skipping 134 matching lines @@
 
   bool has_ever_been_updated() const {
     return last_impl_frame_time_in_seconds_ != 0.0;
   }
 
  protected:
   friend class CoverageIterator;
   friend class TilingRasterTileIterator;
   friend class TilingSetEvictionQueue;
 
+  class CC_EXPORT TileInvalidationState {
+   public:
+    TileInvalidationState();
+
+    void Invalidate(base::TimeTicks current_frame_time);
+    bool FrequentlyInvalidated() const;
+
+   private:
+    static const int kFrequentInvalidationThreshold;
+
+    base::TimeTicks last_frame_time_;
+    int frame_count_;
+  };
+
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
+  typedef base::hash_map<TileMapKey, TileInvalidationState>
+      TileInvalidationStateMap;
 
   PictureLayerTiling(float contents_scale,
                      const gfx::Size& layer_bounds,
                      PictureLayerTilingClient* client);
   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);
+  bool RemoveTileAt(int i,
+                    int j,
+                    PictureLayerTiling* recycled_twin,
+                    bool remove_invalidation_state);
 
   // 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);
 
-  void Invalidate(const Region& layer_region);
+  void Invalidate(const Region& layer_region, base::TimeTicks frame_time);
 
   void DoInvalidate(const Region& layer_region,
-                    bool recreate_invalidated_tiles);
+                    bool recreate_invalidated_tiles,
+                    base::TimeTicks frame_time);
 
   void UpdateTileAndTwinPriority(Tile* tile) const;
   void UpdateTilePriority(Tile* tile) const;
 
   // 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.
+  TileInvalidationStateMap tile_invalidation_states_;
   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_;
   gfx::Rect last_visible_rect_in_content_space_;
   float content_to_screen_scale_;
 
   bool can_require_tiles_for_activation_;
 
@@ skipping 25 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_