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.
5 #ifndef CC_RESOURCES_PICTURE_LAYER_TILING_H_
6 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
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"
24 namespace trace_event
{
31 class PictureLayerTiling
;
34 class CC_EXPORT PictureLayerTilingClient
{
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;
54 virtual ~PictureLayerTilingClient() {}
57 class CC_EXPORT PictureLayerTiling
{
59 static const int kBorderTexels
= 1;
61 ~PictureLayerTiling();
63 static float CalculateSoonBorderDistance(
64 const gfx::Rect
& visible_rect_in_content_space
,
65 float content_to_screen_scale
);
67 // Create a tiling with no tiles. CreateTile() must be called to add some.
68 static scoped_ptr
<PictureLayerTiling
> Create(
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
);
76 void SetRasterSourceAndResize(scoped_refptr
<RasterSource
> raster_source
);
77 void Invalidate(const Region
& layer_invalidation
);
78 void SetRasterSourceOnTiles();
79 void CreateMissingTilesInLiveTilesRect();
81 void CloneTilesAndPropertiesFrom(const PictureLayerTiling
& twin_tiling
);
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
;
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_
; }
95 Tile
* TileAt(int i
, int j
) const {
96 TileMap::const_iterator iter
= tiles_
.find(TileMapKey(i
, j
));
97 return (iter
== tiles_
.end()) ? NULL
: iter
->second
.get();
100 void CreateAllTilesForTesting() {
101 SetLiveTilesRect(gfx::Rect(tiling_data_
.tiling_size()));
104 const TilingData
& TilingDataForTesting() const { return tiling_data_
; }
106 std::vector
<Tile
*> AllTilesForTesting() const {
107 std::vector
<Tile
*> all_tiles
;
108 for (TileMap::const_iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
)
109 all_tiles
.push_back(it
->second
.get());
113 void UpdateAllTilePrioritiesForTesting() {
114 for (TileMap::const_iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
)
115 UpdateTileAndTwinPriority(it
->second
.get());
118 std::vector
<scoped_refptr
<Tile
>> AllRefTilesForTesting() const {
119 std::vector
<scoped_refptr
<Tile
>> all_tiles
;
120 for (TileMap::const_iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
)
121 all_tiles
.push_back(it
->second
);
125 void SetAllTilesOccludedForTesting() {
126 gfx::Rect viewport_in_layer_space
=
127 ScaleToEnclosingRect(current_visible_rect_
, 1.0f
/ contents_scale_
);
128 current_occlusion_in_layer_space_
=
129 Occlusion(gfx::Transform(),
130 SimpleEnclosedRegion(viewport_in_layer_space
),
131 SimpleEnclosedRegion(viewport_in_layer_space
));
134 const gfx::Rect
& GetCurrentVisibleRectForTesting() const {
135 return current_visible_rect_
;
138 bool IsTileOccluded(const Tile
* tile
) const;
139 bool IsTileRequiredForActivationIfVisible(const Tile
* tile
) const;
140 bool IsTileRequiredForDrawIfVisible(const Tile
* tile
) const;
142 void UpdateTileAndTwinPriority(Tile
* tile
) const;
143 TilePriority
ComputePriorityForTile(const Tile
* tile
) const;
144 void UpdateRequiredStateForTile(Tile
* tile
, WhichTree tree
) const;
145 bool has_visible_rect_tiles() const { return has_visible_rect_tiles_
; }
146 bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_
; }
147 bool has_soon_border_rect_tiles() const {
148 return has_soon_border_rect_tiles_
;
150 bool has_eventually_rect_tiles() const { return has_eventually_rect_tiles_
; }
152 const gfx::Rect
& current_visible_rect() const {
153 return current_visible_rect_
;
155 const gfx::Rect
& current_skewport_rect() const {
156 return current_skewport_rect_
;
158 const gfx::Rect
& current_soon_border_rect() const {
159 return current_soon_border_rect_
;
161 const gfx::Rect
& current_eventually_rect() const {
162 return current_eventually_rect_
;
165 // Iterate over all tiles to fill content_rect. Even if tiles are invalid
166 // (i.e. no valid resource) this tiling should still iterate over them.
167 // The union of all geometry_rect calls for each element iterated over should
168 // exactly equal content_rect and no two geometry_rects should intersect.
169 class CC_EXPORT CoverageIterator
{
172 CoverageIterator(const PictureLayerTiling
* tiling
,
174 const gfx::Rect
& rect
);
177 // Visible rect (no borders), always in the space of content_rect,
178 // regardless of the contents scale of the tiling.
179 gfx::Rect
geometry_rect() const;
180 // Texture rect (in texels) for geometry_rect
181 gfx::RectF
texture_rect() const;
183 Tile
* operator->() const { return current_tile_
; }
184 Tile
* operator*() const { return current_tile_
; }
186 CoverageIterator
& operator++();
187 operator bool() const { return tile_j_
<= bottom_
; }
189 int i() const { return tile_i_
; }
190 int j() const { return tile_j_
; }
193 const PictureLayerTiling
* tiling_
;
194 gfx::Rect dest_rect_
;
195 float dest_to_content_scale_
;
198 gfx::Rect current_geometry_rect_
;
206 friend class PictureLayerTiling
;
211 bool ComputeTilePriorityRects(const gfx::Rect
& viewport_in_layer_space
,
212 float ideal_contents_scale
,
213 double current_frame_time_in_seconds
,
214 const Occlusion
& occlusion_in_layer_space
);
216 void GetAllTilesAndPrioritiesForTracing(
217 std::map
<const Tile
*, TilePriority
>* tile_map
) const;
218 void AsValueInto(base::trace_event::TracedValue
* array
) const;
219 size_t GPUMemoryUsageInBytes() const;
221 struct RectExpansionCache
{
222 RectExpansionCache();
224 gfx::Rect previous_start
;
225 gfx::Rect previous_bounds
;
226 gfx::Rect previous_result
;
227 int64 previous_target
;
231 gfx::Rect
ExpandRectEquallyToAreaBoundedBy(
232 const gfx::Rect
& starting_rect
,
234 const gfx::Rect
& bounding_rect
,
235 RectExpansionCache
* cache
);
237 bool has_ever_been_updated() const {
238 return visible_rect_history_
[0].frame_time_in_seconds
!= 0.0;
242 friend class CoverageIterator
;
243 friend class TilingSetRasterQueueAll
;
244 friend class TilingSetRasterQueueRequired
;
245 friend class TilingSetEvictionQueue
;
247 typedef std::pair
<int, int> TileMapKey
;
248 typedef base::hash_map
<TileMapKey
, scoped_refptr
<Tile
>> TileMap
;
250 struct FrameVisibleRect
{
251 gfx::Rect visible_rect_in_content_space
;
252 double frame_time_in_seconds
= 0.0;
255 PictureLayerTiling(float contents_scale
,
256 scoped_refptr
<RasterSource
> raster_source
,
257 PictureLayerTilingClient
* client
,
258 size_t max_tiles_for_interest_area
,
259 float skewport_target_time_in_seconds
,
260 int skewport_extrapolation_limit_in_content_pixels
);
261 void SetLiveTilesRect(const gfx::Rect
& live_tiles_rect
);
262 void VerifyLiveTilesRect(bool is_on_recycle_tree
) const;
263 Tile
* CreateTile(int i
,
265 const PictureLayerTiling
* twin_tiling
,
266 PictureLayerTiling
* recycled_twin
);
267 // Returns true if the Tile existed and was removed from the tiling.
268 bool RemoveTileAt(int i
, int j
, PictureLayerTiling
* recycled_twin
);
270 // Computes a skewport. The calculation extrapolates the last visible
271 // rect and the current visible rect to expand the skewport to where it
272 // would be in |skewport_target_time| seconds. Note that the skewport
273 // is guaranteed to contain the current visible rect.
274 gfx::Rect
ComputeSkewport(double current_frame_time_in_seconds
,
275 const gfx::Rect
& visible_rect_in_content_space
)
278 // Save the required data for computing tile priorities later.
279 void UpdateTilePriorityRects(float content_to_screen_scale_
,
280 const gfx::Rect
& visible_rect_in_content_space
,
281 const gfx::Rect
& skewport
,
282 const gfx::Rect
& soon_border_rect
,
283 const gfx::Rect
& eventually_rect
,
284 const Occlusion
& occlusion_in_layer_space
);
286 void UpdateTilePriorityForTree(Tile
* tile
, WhichTree tree
) const;
287 bool NeedsUpdateForFrameAtTimeAndViewport(
288 double frame_time_in_seconds
,
289 const gfx::Rect
& viewport_in_layer_space
) {
290 return frame_time_in_seconds
!=
291 visible_rect_history_
[0].frame_time_in_seconds
||
292 viewport_in_layer_space
!= last_viewport_in_layer_space_
;
294 void UpdateVisibleRectHistory(
295 double frame_time_in_seconds
,
296 const gfx::Rect
& visible_rect_in_content_space
) {
297 visible_rect_history_
[1] = visible_rect_history_
[0];
298 visible_rect_history_
[0].frame_time_in_seconds
= frame_time_in_seconds
;
299 visible_rect_history_
[0].visible_rect_in_content_space
=
300 visible_rect_in_content_space
;
301 // If we don't have a second history item, set it to the most recent one.
302 if (visible_rect_history_
[1].frame_time_in_seconds
== 0.0)
303 visible_rect_history_
[1] = visible_rect_history_
[0];
306 const size_t max_tiles_for_interest_area_
;
307 const float skewport_target_time_in_seconds_
;
308 const int skewport_extrapolation_limit_in_content_pixels_
;
311 const float contents_scale_
;
312 PictureLayerTilingClient
* const client_
;
313 scoped_refptr
<RasterSource
> raster_source_
;
314 TileResolution resolution_
;
317 TilingData tiling_data_
;
318 TileMap tiles_
; // It is not legal to have a NULL tile in the tiles_ map.
319 gfx::Rect live_tiles_rect_
;
321 gfx::Rect last_viewport_in_layer_space_
;
322 // State saved for computing velocities based upon finite differences.
323 FrameVisibleRect visible_rect_history_
[2];
325 bool can_require_tiles_for_activation_
;
327 // Iteration rects in content space.
328 gfx::Rect current_visible_rect_
;
329 gfx::Rect current_skewport_rect_
;
330 gfx::Rect current_soon_border_rect_
;
331 gfx::Rect current_eventually_rect_
;
332 // Other properties used for tile iteration and prioritization.
333 float current_content_to_screen_scale_
;
334 Occlusion current_occlusion_in_layer_space_
;
336 bool has_visible_rect_tiles_
;
337 bool has_skewport_rect_tiles_
;
338 bool has_soon_border_rect_tiles_
;
339 bool has_eventually_rect_tiles_
;
342 DISALLOW_ASSIGN(PictureLayerTiling
);
344 RectExpansionCache expansion_cache_
;
349 #endif // CC_RESOURCES_PICTURE_LAYER_TILING_H_