cc/resources/picture_layer_tiling.h

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_RESOURCES_PICTURE_LAYER_TILING_H_
   6 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
   7
   8 #include <map>
   9 #include <utility>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "cc/base/cc_export.h"
  16 #include "cc/base/region.h"
  17 #include "cc/base/tiling_data.h"
  18 #include "cc/resources/tile.h"
  19 #include "cc/resources/tile_priority.h"
  20 #include "cc/trees/occlusion.h"
  21 #include "ui/gfx/geometry/rect.h"
  22
  23 namespace base {
  24 namespace trace_event {
  25 class TracedValue;
  26 }
  27 }
  28
  29 namespace cc {
  30
  31 class PictureLayerTiling;
  32 class RasterSource;
  33
  34 class CC_EXPORT PictureLayerTilingClient {
  35  public:
  36   // Create a tile at the given content_rect (in the contents scale of the
  37   // tiling) This might return null if the client cannot create such a tile.
  38   virtual scoped_refptr<Tile> CreateTile(float contents_scale,
  39                                          const gfx::Rect& content_rect) = 0;
  40   virtual gfx::Size CalculateTileSize(
  41     const gfx::Size& content_bounds) const = 0;
  42   // This invalidation region defines the area (if any, it can by null) that
  43   // tiles can not be shared between pending and active trees.
  44   virtual const Region* GetPendingInvalidation() = 0;
  45   virtual const PictureLayerTiling* GetPendingOrActiveTwinTiling(
  46       const PictureLayerTiling* tiling) const = 0;
  47   virtual PictureLayerTiling* GetRecycledTwinTiling(
  48       const PictureLayerTiling* tiling) = 0;
  49   virtual TilePriority::PriorityBin GetMaxTilePriorityBin() const = 0;
  50   virtual WhichTree GetTree() const = 0;
  51   virtual bool RequiresHighResToDraw() const = 0;
  52
  53  protected:
  54   virtual ~PictureLayerTilingClient() {}
  55 };
  56
  57 class CC_EXPORT PictureLayerTiling {
  58  public:
  59   static const int kBorderTexels = 1;
  60
  61   ~PictureLayerTiling();
  62
  63   static float CalculateSoonBorderDistance(
  64       const gfx::Rect& visible_rect_in_content_space,
  65       float content_to_screen_scale);
  66
  67   // Create a tiling with no tiles. CreateTile() must be called to add some.
  68   static scoped_ptr<PictureLayerTiling> Create(
  69       float contents_scale,
  70       scoped_refptr<RasterSource> raster_source,
  71       PictureLayerTilingClient* client,
  72       size_t max_tiles_for_interest_area,
  73       float skewport_target_time_in_seconds,
  74       int skewport_extrapolation_limit_in_content_pixels);
  75
  76   void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
  77   void Invalidate(const Region& layer_invalidation);
  78   void SetRasterSourceOnTiles();
  79   void CreateMissingTilesInLiveTilesRect();
  80
  81   void CloneTilesAndPropertiesFrom(const PictureLayerTiling& twin_tiling);
  82
  83   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
  84   TileResolution resolution() const { return resolution_; }
  85   void set_can_require_tiles_for_activation(bool can_require_tiles) {
  86     can_require_tiles_for_activation_ = can_require_tiles;
  87   }
  88
  89   RasterSource* raster_source() const { return raster_source_.get(); }
  90   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
  91   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
  92   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
  93   float contents_scale() const { return contents_scale_; }
  94   const TilingData* tiling_data() const { return &tiling_data_; }
  95
  96   Tile* TileAt(int i, int j) const {
  97     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
  98     return (iter == tiles_.end()) ? NULL : iter->second.get();
  99   }
 100
 101   void CreateAllTilesForTesting() {
 102     SetLiveTilesRect(gfx::Rect(tiling_data_.tiling_size()));
 103   }
 104
 105   const TilingData& TilingDataForTesting() const { return tiling_data_; }
 106
 107   std::vector<Tile*> AllTilesForTesting() const {
 108     std::vector<Tile*> all_tiles;
 109     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
 110       all_tiles.push_back(it->second.get());
 111     return all_tiles;
 112   }
 113
 114   void UpdateAllTilePrioritiesForTesting() {
 115     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
 116       UpdateTileAndTwinPriority(it->second.get());
 117   }
 118
 119   std::vector<scoped_refptr<Tile>> AllRefTilesForTesting() const {
 120     std::vector<scoped_refptr<Tile>> all_tiles;
 121     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
 122       all_tiles.push_back(it->second);
 123     return all_tiles;
 124   }
 125
 126   void SetAllTilesOccludedForTesting() {
 127     gfx::Rect viewport_in_layer_space =
 128         ScaleToEnclosingRect(current_visible_rect_, 1.0f / contents_scale_);
 129     current_occlusion_in_layer_space_ =
 130         Occlusion(gfx::Transform(),
 131                   SimpleEnclosedRegion(viewport_in_layer_space),
 132                   SimpleEnclosedRegion(viewport_in_layer_space));
 133   }
 134
 135   const gfx::Rect& GetCurrentVisibleRectForTesting() const {
 136     return current_visible_rect_;
 137   }
 138
 139   bool IsTileOccluded(const Tile* tile) const;
 140   bool IsTileRequiredForActivationIfVisible(const Tile* tile) const;
 141   bool IsTileRequiredForDrawIfVisible(const Tile* tile) const;
 142
 143   void UpdateTileAndTwinPriority(Tile* tile) const;
 144   TilePriority ComputePriorityForTile(const Tile* tile) const;
 145   void UpdateRequiredStateForTile(Tile* tile, WhichTree tree) const;
 146   bool has_visible_rect_tiles() const { return has_visible_rect_tiles_; }
 147   bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_; }
 148   bool has_soon_border_rect_tiles() const {
 149     return has_soon_border_rect_tiles_;
 150   }
 151   bool has_eventually_rect_tiles() const { return has_eventually_rect_tiles_; }
 152
 153   const gfx::Rect& current_visible_rect() const {
 154     return current_visible_rect_;
 155   }
 156   const gfx::Rect& current_skewport_rect() const {
 157     return current_skewport_rect_;
 158   }
 159   const gfx::Rect& current_soon_border_rect() const {
 160     return current_soon_border_rect_;
 161   }
 162   const gfx::Rect& current_eventually_rect() const {
 163     return current_eventually_rect_;
 164   }
 165   void VerifyAllTilesHaveCurrentRasterSource() const;
 166
 167   // Iterate over all tiles to fill content_rect.  Even if tiles are invalid
 168   // (i.e. no valid resource) this tiling should still iterate over them.
 169   // The union of all geometry_rect calls for each element iterated over should
 170   // exactly equal content_rect and no two geometry_rects should intersect.
 171   class CC_EXPORT CoverageIterator {
 172    public:
 173     CoverageIterator();
 174     CoverageIterator(const PictureLayerTiling* tiling,
 175         float dest_scale,
 176         const gfx::Rect& rect);
 177     ~CoverageIterator();
 178
 179     // Visible rect (no borders), always in the space of content_rect,
 180     // regardless of the contents scale of the tiling.
 181     gfx::Rect geometry_rect() const;
 182     // Texture rect (in texels) for geometry_rect
 183     gfx::RectF texture_rect() const;
 184
 185     Tile* operator->() const { return current_tile_; }
 186     Tile* operator*() const { return current_tile_; }
 187
 188     CoverageIterator& operator++();
 189     operator bool() const { return tile_j_ <= bottom_; }
 190
 191     int i() const { return tile_i_; }
 192     int j() const { return tile_j_; }
 193
 194    private:
 195     const PictureLayerTiling* tiling_;
 196     gfx::Rect dest_rect_;
 197     float dest_to_content_scale_;
 198
 199     Tile* current_tile_;
 200     gfx::Rect current_geometry_rect_;
 201     int tile_i_;
 202     int tile_j_;
 203     int left_;
 204     int top_;
 205     int right_;
 206     int bottom_;
 207
 208     friend class PictureLayerTiling;
 209   };
 210
 211   void Reset();
 212
 213   bool ComputeTilePriorityRects(const gfx::Rect& viewport_in_layer_space,
 214                                 float ideal_contents_scale,
 215                                 double current_frame_time_in_seconds,
 216                                 const Occlusion& occlusion_in_layer_space);
 217
 218   void GetAllTilesAndPrioritiesForTracing(
 219       std::map<const Tile*, TilePriority>* tile_map) const;
 220   void AsValueInto(base::trace_event::TracedValue* array) const;
 221   size_t GPUMemoryUsageInBytes() const;
 222
 223   struct RectExpansionCache {
 224     RectExpansionCache();
 225
 226     gfx::Rect previous_start;
 227     gfx::Rect previous_bounds;
 228     gfx::Rect previous_result;
 229     int64 previous_target;
 230   };
 231
 232   static
 233   gfx::Rect ExpandRectEquallyToAreaBoundedBy(
 234       const gfx::Rect& starting_rect,
 235       int64 target_area,
 236       const gfx::Rect& bounding_rect,
 237       RectExpansionCache* cache);
 238
 239   bool has_ever_been_updated() const {
 240     return visible_rect_history_[0].frame_time_in_seconds != 0.0;
 241   }
 242
 243  protected:
 244   friend class CoverageIterator;
 245   friend class TilingSetRasterQueueAll;
 246   friend class TilingSetRasterQueueRequired;
 247   friend class TilingSetEvictionQueue;
 248
 249   typedef std::pair<int, int> TileMapKey;
 250   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 251
 252   struct FrameVisibleRect {
 253     gfx::Rect visible_rect_in_content_space;
 254     double frame_time_in_seconds = 0.0;
 255   };
 256
 257   PictureLayerTiling(float contents_scale,
 258                      scoped_refptr<RasterSource> raster_source,
 259                      PictureLayerTilingClient* client,
 260                      size_t max_tiles_for_interest_area,
 261                      float skewport_target_time_in_seconds,
 262                      int skewport_extrapolation_limit_in_content_pixels);
 263   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
 264   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
 265   Tile* CreateTile(int i,
 266                    int j,
 267                    const PictureLayerTiling* twin_tiling,
 268                    PictureLayerTiling* recycled_twin);
 269   // Returns true if the Tile existed and was removed from the tiling.
 270   bool RemoveTileAt(int i, int j, PictureLayerTiling* recycled_twin);
 271
 272   // Computes a skewport. The calculation extrapolates the last visible
 273   // rect and the current visible rect to expand the skewport to where it
 274   // would be in |skewport_target_time| seconds. Note that the skewport
 275   // is guaranteed to contain the current visible rect.
 276   gfx::Rect ComputeSkewport(double current_frame_time_in_seconds,
 277                             const gfx::Rect& visible_rect_in_content_space)
 278       const;
 279
 280   // Save the required data for computing tile priorities later.
 281   void UpdateTilePriorityRects(float content_to_screen_scale_,
 282                                const gfx::Rect& visible_rect_in_content_space,
 283                                const gfx::Rect& skewport,
 284                                const gfx::Rect& soon_border_rect,
 285                                const gfx::Rect& eventually_rect,
 286                                const Occlusion& occlusion_in_layer_space);
 287
 288   void UpdateTilePriorityForTree(Tile* tile, WhichTree tree) const;
 289   bool NeedsUpdateForFrameAtTimeAndViewport(
 290       double frame_time_in_seconds,
 291       const gfx::Rect& viewport_in_layer_space) {
 292     return frame_time_in_seconds !=
 293                visible_rect_history_[0].frame_time_in_seconds ||
 294            viewport_in_layer_space != last_viewport_in_layer_space_;
 295   }
 296   void UpdateVisibleRectHistory(
 297       double frame_time_in_seconds,
 298       const gfx::Rect& visible_rect_in_content_space) {
 299     visible_rect_history_[1] = visible_rect_history_[0];
 300     visible_rect_history_[0].frame_time_in_seconds = frame_time_in_seconds;
 301     visible_rect_history_[0].visible_rect_in_content_space =
 302         visible_rect_in_content_space;
 303     // If we don't have a second history item, set it to the most recent one.
 304     if (visible_rect_history_[1].frame_time_in_seconds == 0.0)
 305       visible_rect_history_[1] = visible_rect_history_[0];
 306   }
 307
 308   const size_t max_tiles_for_interest_area_;
 309   const float skewport_target_time_in_seconds_;
 310   const int skewport_extrapolation_limit_in_content_pixels_;
 311
 312   // Given properties.
 313   const float contents_scale_;
 314   PictureLayerTilingClient* const client_;
 315   scoped_refptr<RasterSource> raster_source_;
 316   TileResolution resolution_;
 317
 318   // Internal data.
 319   TilingData tiling_data_;
 320   TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
 321   gfx::Rect live_tiles_rect_;
 322
 323   gfx::Rect last_viewport_in_layer_space_;
 324   // State saved for computing velocities based upon finite differences.
 325   FrameVisibleRect visible_rect_history_[2];
 326
 327   bool can_require_tiles_for_activation_;
 328
 329   // Iteration rects in content space.
 330   gfx::Rect current_visible_rect_;
 331   gfx::Rect current_skewport_rect_;
 332   gfx::Rect current_soon_border_rect_;
 333   gfx::Rect current_eventually_rect_;
 334   // Other properties used for tile iteration and prioritization.
 335   float current_content_to_screen_scale_;
 336   Occlusion current_occlusion_in_layer_space_;
 337
 338   bool has_visible_rect_tiles_;
 339   bool has_skewport_rect_tiles_;
 340   bool has_soon_border_rect_tiles_;
 341   bool has_eventually_rect_tiles_;
 342
 343  private:
 344   DISALLOW_ASSIGN(PictureLayerTiling);
 345
 346   RectExpansionCache expansion_cache_;
 347 };
 348
 349 }  // namespace cc
 350
 351 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_