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 #include "cc/resources/picture_layer_tiling.h"
10 #include "cc/base/math_util.h"
11 #include "cc/resources/picture_layer_tiling_set.h"
12 #include "cc/test/fake_output_surface.h"
13 #include "cc/test/fake_output_surface_client.h"
14 #include "cc/test/fake_picture_layer_tiling_client.h"
15 #include "cc/test/fake_picture_pile_impl.h"
16 #include "cc/test/test_context_provider.h"
17 #include "cc/test/test_shared_bitmap_manager.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19 #include "ui/gfx/geometry/quad_f.h"
20 #include "ui/gfx/geometry/rect_conversions.h"
21 #include "ui/gfx/geometry/size_conversions.h"
26 static gfx::Rect
ViewportInLayerSpace(
27 const gfx::Transform
& transform
,
28 const gfx::Size
& device_viewport
) {
30 gfx::Transform inverse
;
31 if (!transform
.GetInverse(&inverse
))
34 gfx::RectF viewport_in_layer_space
= MathUtil::ProjectClippedRect(
35 inverse
, gfx::RectF(gfx::Point(0, 0), device_viewport
));
36 return ToEnclosingRect(viewport_in_layer_space
);
39 class TestablePictureLayerTiling
: public PictureLayerTiling
{
41 using PictureLayerTiling::SetLiveTilesRect
;
42 using PictureLayerTiling::TileAt
;
44 static scoped_ptr
<TestablePictureLayerTiling
> Create(
46 scoped_refptr
<RasterSource
> raster_source
,
47 PictureLayerTilingClient
* client
,
48 const LayerTreeSettings
& settings
) {
49 return make_scoped_ptr(new TestablePictureLayerTiling(
50 contents_scale
, raster_source
, client
,
51 settings
.max_tiles_for_interest_area
,
52 settings
.skewport_target_time_in_seconds
,
53 settings
.skewport_extrapolation_limit_in_content_pixels
));
56 gfx::Rect
live_tiles_rect() const { return live_tiles_rect_
; }
58 using PictureLayerTiling::ComputeSkewport
;
59 using PictureLayerTiling::RemoveTileAt
;
62 TestablePictureLayerTiling(float contents_scale
,
63 scoped_refptr
<RasterSource
> raster_source
,
64 PictureLayerTilingClient
* client
,
65 size_t max_tiles_for_interest_area
,
66 float skewport_target_time
,
67 int skewport_extrapolation_limit
)
68 : PictureLayerTiling(contents_scale
,
71 max_tiles_for_interest_area
,
73 skewport_extrapolation_limit
) {}
76 class PictureLayerTilingIteratorTest
: public testing::Test
{
78 PictureLayerTilingIteratorTest() {}
79 virtual ~PictureLayerTilingIteratorTest() {}
81 void Initialize(const gfx::Size
& tile_size
,
83 const gfx::Size
& layer_bounds
) {
84 client_
.SetTileSize(tile_size
);
85 client_
.set_tree(PENDING_TREE
);
86 scoped_refptr
<FakePicturePileImpl
> pile
=
87 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
88 tiling_
= TestablePictureLayerTiling::Create(contents_scale
, pile
, &client_
,
92 void SetLiveRectAndVerifyTiles(const gfx::Rect
& live_tiles_rect
) {
93 tiling_
->SetLiveTilesRect(live_tiles_rect
);
95 std::vector
<Tile
*> tiles
= tiling_
->AllTilesForTesting();
96 for (std::vector
<Tile
*>::iterator iter
= tiles
.begin();
99 EXPECT_TRUE(live_tiles_rect
.Intersects((*iter
)->content_rect()));
103 void VerifyTilesExactlyCoverRect(
105 const gfx::Rect
& request_rect
,
106 const gfx::Rect
& expect_rect
) {
107 EXPECT_TRUE(request_rect
.Contains(expect_rect
));
109 // Iterators are not valid if this ratio is too large (i.e. the
110 // tiling is too high-res for a low-res destination rect.) This is an
111 // artifact of snapping geometry to integer coordinates and then mapping
112 // back to floating point texture coordinates.
113 float dest_to_contents_scale
= tiling_
->contents_scale() / rect_scale
;
114 ASSERT_LE(dest_to_contents_scale
, 2.0);
116 Region remaining
= expect_rect
;
117 for (PictureLayerTiling::CoverageIterator
118 iter(tiling_
.get(), rect_scale
, request_rect
);
121 // Geometry cannot overlap previous geometry at all
122 gfx::Rect geometry
= iter
.geometry_rect();
123 EXPECT_TRUE(expect_rect
.Contains(geometry
));
124 EXPECT_TRUE(remaining
.Contains(geometry
));
125 remaining
.Subtract(geometry
);
127 // Sanity check that texture coords are within the texture rect.
128 gfx::RectF texture_rect
= iter
.texture_rect();
129 EXPECT_GE(texture_rect
.x(), 0);
130 EXPECT_GE(texture_rect
.y(), 0);
131 EXPECT_LE(texture_rect
.right(), client_
.TileSize().width());
132 EXPECT_LE(texture_rect
.bottom(), client_
.TileSize().height());
134 EXPECT_EQ(iter
.texture_size(), client_
.TileSize());
137 // The entire rect must be filled by geometry from the tiling.
138 EXPECT_TRUE(remaining
.IsEmpty());
141 void VerifyTilesExactlyCoverRect(float rect_scale
, const gfx::Rect
& rect
) {
142 VerifyTilesExactlyCoverRect(rect_scale
, rect
, rect
);
147 const gfx::Rect
& rect
,
148 base::Callback
<void(Tile
* tile
,
149 const gfx::Rect
& geometry_rect
)> callback
) {
150 VerifyTiles(tiling_
.get(),
157 PictureLayerTiling
* tiling
,
159 const gfx::Rect
& rect
,
160 base::Callback
<void(Tile
* tile
,
161 const gfx::Rect
& geometry_rect
)> callback
) {
162 Region remaining
= rect
;
163 for (PictureLayerTiling::CoverageIterator
iter(tiling
, rect_scale
, rect
);
166 remaining
.Subtract(iter
.geometry_rect());
167 callback
.Run(*iter
, iter
.geometry_rect());
169 EXPECT_TRUE(remaining
.IsEmpty());
172 void VerifyTilesCoverNonContainedRect(float rect_scale
,
173 const gfx::Rect
& dest_rect
) {
174 float dest_to_contents_scale
= tiling_
->contents_scale() / rect_scale
;
175 gfx::Rect clamped_rect
= gfx::ScaleToEnclosingRect(
176 gfx::Rect(tiling_
->tiling_size()), 1.f
/ dest_to_contents_scale
);
177 clamped_rect
.Intersect(dest_rect
);
178 VerifyTilesExactlyCoverRect(rect_scale
, dest_rect
, clamped_rect
);
182 FakePictureLayerTilingClient client_
;
183 scoped_ptr
<TestablePictureLayerTiling
> tiling_
;
186 DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest
);
189 TEST_F(PictureLayerTilingIteratorTest
, ResizeDeletesTiles
) {
190 // Verifies that a resize with invalidation for newly exposed pixels will
191 // deletes tiles that intersect that invalidation.
192 gfx::Size
tile_size(100, 100);
193 gfx::Size
original_layer_size(10, 10);
194 Initialize(tile_size
, 1.f
, original_layer_size
);
195 SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size
));
197 // Tiling only has one tile, since its total size is less than one.
198 EXPECT_TRUE(tiling_
->TileAt(0, 0));
200 // Stop creating tiles so that any invalidations are left as holes.
201 gfx::Size
new_layer_size(200, 200);
202 scoped_refptr
<FakePicturePileImpl
> pile
=
203 FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(new_layer_size
);
205 Region invalidation
=
206 SubtractRegions(gfx::Rect(tile_size
), gfx::Rect(original_layer_size
));
207 tiling_
->SetRasterSourceAndResize(pile
);
208 EXPECT_TRUE(tiling_
->TileAt(0, 0));
209 tiling_
->Invalidate(invalidation
);
210 EXPECT_FALSE(tiling_
->TileAt(0, 0));
213 TEST_F(PictureLayerTilingIteratorTest
, CreateMissingTilesStaysInsideLiveRect
) {
214 // The tiling has three rows and columns.
215 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(250, 250));
216 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_x());
217 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_y());
219 // The live tiles rect is at the very edge of the right-most and
220 // bottom-most tiles. Their border pixels would still be inside the live
221 // tiles rect, but the tiles should not exist just for that.
222 int right
= tiling_
->TilingDataForTesting().TileBounds(2, 2).x();
223 int bottom
= tiling_
->TilingDataForTesting().TileBounds(2, 2).y();
225 SetLiveRectAndVerifyTiles(gfx::Rect(right
, bottom
));
226 EXPECT_FALSE(tiling_
->TileAt(2, 0));
227 EXPECT_FALSE(tiling_
->TileAt(2, 1));
228 EXPECT_FALSE(tiling_
->TileAt(2, 2));
229 EXPECT_FALSE(tiling_
->TileAt(1, 2));
230 EXPECT_FALSE(tiling_
->TileAt(0, 2));
232 // Verify CreateMissingTilesInLiveTilesRect respects this.
233 tiling_
->CreateMissingTilesInLiveTilesRect();
234 EXPECT_FALSE(tiling_
->TileAt(2, 0));
235 EXPECT_FALSE(tiling_
->TileAt(2, 1));
236 EXPECT_FALSE(tiling_
->TileAt(2, 2));
237 EXPECT_FALSE(tiling_
->TileAt(1, 2));
238 EXPECT_FALSE(tiling_
->TileAt(0, 2));
241 TEST_F(PictureLayerTilingIteratorTest
, ResizeTilingOverTileBorders
) {
242 // The tiling has four rows and three columns.
243 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(250, 350));
244 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_x());
245 EXPECT_EQ(4, tiling_
->TilingDataForTesting().num_tiles_y());
247 // The live tiles rect covers the whole tiling.
248 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
250 // Tiles in the bottom row and right column exist.
251 EXPECT_TRUE(tiling_
->TileAt(2, 0));
252 EXPECT_TRUE(tiling_
->TileAt(2, 1));
253 EXPECT_TRUE(tiling_
->TileAt(2, 2));
254 EXPECT_TRUE(tiling_
->TileAt(2, 3));
255 EXPECT_TRUE(tiling_
->TileAt(1, 3));
256 EXPECT_TRUE(tiling_
->TileAt(0, 3));
258 int right
= tiling_
->TilingDataForTesting().TileBounds(2, 2).x();
259 int bottom
= tiling_
->TilingDataForTesting().TileBounds(2, 3).y();
261 // Shrink the tiling so that the last tile row/column is entirely in the
262 // border pixels of the interior tiles. That row/column is removed.
263 scoped_refptr
<FakePicturePileImpl
> pile
=
264 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
265 gfx::Size(right
+ 1, bottom
+ 1));
266 tiling_
->SetRasterSourceAndResize(pile
);
267 EXPECT_EQ(2, tiling_
->TilingDataForTesting().num_tiles_x());
268 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_y());
270 // The live tiles rect was clamped to the pile size.
271 EXPECT_EQ(gfx::Rect(right
+ 1, bottom
+ 1), tiling_
->live_tiles_rect());
273 // Since the row/column is gone, the tiles should be gone too.
274 EXPECT_FALSE(tiling_
->TileAt(2, 0));
275 EXPECT_FALSE(tiling_
->TileAt(2, 1));
276 EXPECT_FALSE(tiling_
->TileAt(2, 2));
277 EXPECT_FALSE(tiling_
->TileAt(2, 3));
278 EXPECT_FALSE(tiling_
->TileAt(1, 3));
279 EXPECT_FALSE(tiling_
->TileAt(0, 3));
281 // Growing outside the current right/bottom tiles border pixels should create
282 // the tiles again, even though the live rect has not changed size.
283 pile
= FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
284 gfx::Size(right
+ 2, bottom
+ 2));
285 tiling_
->SetRasterSourceAndResize(pile
);
286 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_x());
287 EXPECT_EQ(4, tiling_
->TilingDataForTesting().num_tiles_y());
290 EXPECT_EQ(gfx::Rect(right
+ 1, bottom
+ 1), tiling_
->live_tiles_rect());
292 // The last row/column tiles are inside the live tiles rect.
293 EXPECT_TRUE(gfx::Rect(right
+ 1, bottom
+ 1).Intersects(
294 tiling_
->TilingDataForTesting().TileBounds(2, 0)));
295 EXPECT_TRUE(gfx::Rect(right
+ 1, bottom
+ 1).Intersects(
296 tiling_
->TilingDataForTesting().TileBounds(0, 3)));
298 EXPECT_TRUE(tiling_
->TileAt(2, 0));
299 EXPECT_TRUE(tiling_
->TileAt(2, 1));
300 EXPECT_TRUE(tiling_
->TileAt(2, 2));
301 EXPECT_TRUE(tiling_
->TileAt(2, 3));
302 EXPECT_TRUE(tiling_
->TileAt(1, 3));
303 EXPECT_TRUE(tiling_
->TileAt(0, 3));
306 TEST_F(PictureLayerTilingIteratorTest
, ResizeLiveTileRectOverTileBorders
) {
307 // The tiling has three rows and columns.
308 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(250, 350));
309 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_x());
310 EXPECT_EQ(4, tiling_
->TilingDataForTesting().num_tiles_y());
312 // The live tiles rect covers the whole tiling.
313 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
315 // Tiles in the bottom row and right column exist.
316 EXPECT_TRUE(tiling_
->TileAt(2, 0));
317 EXPECT_TRUE(tiling_
->TileAt(2, 1));
318 EXPECT_TRUE(tiling_
->TileAt(2, 2));
319 EXPECT_TRUE(tiling_
->TileAt(2, 3));
320 EXPECT_TRUE(tiling_
->TileAt(1, 3));
321 EXPECT_TRUE(tiling_
->TileAt(0, 3));
323 // Shrink the live tiles rect to the very edge of the right-most and
324 // bottom-most tiles. Their border pixels would still be inside the live
325 // tiles rect, but the tiles should not exist just for that.
326 int right
= tiling_
->TilingDataForTesting().TileBounds(2, 3).x();
327 int bottom
= tiling_
->TilingDataForTesting().TileBounds(2, 3).y();
329 SetLiveRectAndVerifyTiles(gfx::Rect(right
, bottom
));
330 EXPECT_FALSE(tiling_
->TileAt(2, 0));
331 EXPECT_FALSE(tiling_
->TileAt(2, 1));
332 EXPECT_FALSE(tiling_
->TileAt(2, 2));
333 EXPECT_FALSE(tiling_
->TileAt(2, 3));
334 EXPECT_FALSE(tiling_
->TileAt(1, 3));
335 EXPECT_FALSE(tiling_
->TileAt(0, 3));
337 // Including the bottom row and right column again, should create the tiles.
338 SetLiveRectAndVerifyTiles(gfx::Rect(right
+ 1, bottom
+ 1));
339 EXPECT_TRUE(tiling_
->TileAt(2, 0));
340 EXPECT_TRUE(tiling_
->TileAt(2, 1));
341 EXPECT_TRUE(tiling_
->TileAt(2, 2));
342 EXPECT_TRUE(tiling_
->TileAt(2, 3));
343 EXPECT_TRUE(tiling_
->TileAt(1, 2));
344 EXPECT_TRUE(tiling_
->TileAt(0, 2));
346 // Shrink the live tiles rect to the very edge of the left-most and
347 // top-most tiles. Their border pixels would still be inside the live
348 // tiles rect, but the tiles should not exist just for that.
349 int left
= tiling_
->TilingDataForTesting().TileBounds(0, 0).right();
350 int top
= tiling_
->TilingDataForTesting().TileBounds(0, 0).bottom();
352 SetLiveRectAndVerifyTiles(gfx::Rect(left
, top
, 250 - left
, 350 - top
));
353 EXPECT_FALSE(tiling_
->TileAt(0, 3));
354 EXPECT_FALSE(tiling_
->TileAt(0, 2));
355 EXPECT_FALSE(tiling_
->TileAt(0, 1));
356 EXPECT_FALSE(tiling_
->TileAt(0, 0));
357 EXPECT_FALSE(tiling_
->TileAt(1, 0));
358 EXPECT_FALSE(tiling_
->TileAt(2, 0));
360 // Including the top row and left column again, should create the tiles.
361 SetLiveRectAndVerifyTiles(
362 gfx::Rect(left
- 1, top
- 1, 250 - left
, 350 - top
));
363 EXPECT_TRUE(tiling_
->TileAt(0, 3));
364 EXPECT_TRUE(tiling_
->TileAt(0, 2));
365 EXPECT_TRUE(tiling_
->TileAt(0, 1));
366 EXPECT_TRUE(tiling_
->TileAt(0, 0));
367 EXPECT_TRUE(tiling_
->TileAt(1, 0));
368 EXPECT_TRUE(tiling_
->TileAt(2, 0));
371 TEST_F(PictureLayerTilingIteratorTest
, ResizeLiveTileRectOverSameTiles
) {
372 // The tiling has four rows and three columns.
373 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(250, 350));
374 EXPECT_EQ(3, tiling_
->TilingDataForTesting().num_tiles_x());
375 EXPECT_EQ(4, tiling_
->TilingDataForTesting().num_tiles_y());
377 // The live tiles rect covers the whole tiling.
378 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
381 for (int i
= 0; i
< 3; ++i
) {
382 for (int j
= 0; j
< 4; ++j
)
383 EXPECT_TRUE(tiling_
->TileAt(i
, j
)) << i
<< "," << j
;
386 // Shrink the live tiles rect, but still cover all the tiles.
387 SetLiveRectAndVerifyTiles(gfx::Rect(1, 1, 249, 349));
389 // All tiles still exist.
390 for (int i
= 0; i
< 3; ++i
) {
391 for (int j
= 0; j
< 4; ++j
)
392 EXPECT_TRUE(tiling_
->TileAt(i
, j
)) << i
<< "," << j
;
395 // Grow the live tiles rect, but still cover all the same tiles.
396 SetLiveRectAndVerifyTiles(gfx::Rect(0, 0, 250, 350));
398 // All tiles still exist.
399 for (int i
= 0; i
< 3; ++i
) {
400 for (int j
= 0; j
< 4; ++j
)
401 EXPECT_TRUE(tiling_
->TileAt(i
, j
)) << i
<< "," << j
;
405 TEST_F(PictureLayerTilingIteratorTest
, ResizeOverBorderPixelsDeletesTiles
) {
406 // Verifies that a resize with invalidation for newly exposed pixels will
407 // deletes tiles that intersect that invalidation.
408 gfx::Size
tile_size(100, 100);
409 gfx::Size
original_layer_size(99, 99);
410 Initialize(tile_size
, 1.f
, original_layer_size
);
411 SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size
));
413 // Tiling only has one tile, since its total size is less than one.
414 EXPECT_TRUE(tiling_
->TileAt(0, 0));
416 // Stop creating tiles so that any invalidations are left as holes.
417 scoped_refptr
<FakePicturePileImpl
> pile
=
418 FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(
419 gfx::Size(200, 200));
420 tiling_
->SetRasterSourceAndResize(pile
);
422 Region invalidation
=
423 SubtractRegions(gfx::Rect(tile_size
), gfx::Rect(original_layer_size
));
424 EXPECT_TRUE(tiling_
->TileAt(0, 0));
425 tiling_
->Invalidate(invalidation
);
426 EXPECT_FALSE(tiling_
->TileAt(0, 0));
428 // The original tile was the same size after resize, but it would include new
430 EXPECT_EQ(gfx::Rect(original_layer_size
),
431 tiling_
->TilingDataForTesting().TileBounds(0, 0));
434 TEST_F(PictureLayerTilingIteratorTest
, LiveTilesExactlyCoverLiveTileRect
) {
435 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(1099, 801));
436 SetLiveRectAndVerifyTiles(gfx::Rect(100, 100));
437 SetLiveRectAndVerifyTiles(gfx::Rect(101, 99));
438 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1));
439 SetLiveRectAndVerifyTiles(gfx::Rect(1, 801));
440 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1));
441 SetLiveRectAndVerifyTiles(gfx::Rect(201, 800));
444 TEST_F(PictureLayerTilingIteratorTest
, IteratorCoversLayerBoundsNoScale
) {
445 Initialize(gfx::Size(100, 100), 1.f
, gfx::Size(1099, 801));
446 VerifyTilesExactlyCoverRect(1, gfx::Rect());
447 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1099, 801));
448 VerifyTilesExactlyCoverRect(1, gfx::Rect(52, 83, 789, 412));
450 // With borders, a size of 3x3 = 1 pixel of content.
451 Initialize(gfx::Size(3, 3), 1.f
, gfx::Size(10, 10));
452 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1));
453 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2));
454 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2));
455 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2));
458 TEST_F(PictureLayerTilingIteratorTest
, IteratorCoversLayerBoundsTilingScale
) {
459 Initialize(gfx::Size(200, 100), 2.0f
, gfx::Size(1005, 2010));
460 VerifyTilesExactlyCoverRect(1, gfx::Rect());
461 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
462 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
464 Initialize(gfx::Size(3, 3), 2.0f
, gfx::Size(10, 10));
465 VerifyTilesExactlyCoverRect(1, gfx::Rect());
466 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1));
467 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2));
468 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2));
469 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2));
471 Initialize(gfx::Size(100, 200), 0.5f
, gfx::Size(1005, 2010));
472 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
473 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
475 Initialize(gfx::Size(150, 250), 0.37f
, gfx::Size(1005, 2010));
476 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
477 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
479 Initialize(gfx::Size(312, 123), 0.01f
, gfx::Size(1005, 2010));
480 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
481 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
484 TEST_F(PictureLayerTilingIteratorTest
, IteratorCoversLayerBoundsBothScale
) {
485 Initialize(gfx::Size(50, 50), 4.0f
, gfx::Size(800, 600));
486 VerifyTilesExactlyCoverRect(2.0f
, gfx::Rect());
487 VerifyTilesExactlyCoverRect(2.0f
, gfx::Rect(0, 0, 1600, 1200));
488 VerifyTilesExactlyCoverRect(2.0f
, gfx::Rect(512, 365, 253, 182));
491 gfx::Size
bounds(800, 600);
492 gfx::Rect
full_rect(gfx::ToCeiledSize(gfx::ScaleSize(bounds
, scale
)));
493 Initialize(gfx::Size(256, 512), 5.2f
, bounds
);
494 VerifyTilesExactlyCoverRect(scale
, full_rect
);
495 VerifyTilesExactlyCoverRect(scale
, gfx::Rect(2014, 1579, 867, 1033));
498 TEST_F(PictureLayerTilingIteratorTest
, IteratorEmptyRect
) {
499 Initialize(gfx::Size(100, 100), 1.0f
, gfx::Size(800, 600));
502 PictureLayerTiling::CoverageIterator
iter(tiling_
.get(), 1.0f
, empty
);
506 TEST_F(PictureLayerTilingIteratorTest
, NonIntersectingRect
) {
507 Initialize(gfx::Size(100, 100), 1.0f
, gfx::Size(800, 600));
508 gfx::Rect
non_intersecting(1000, 1000, 50, 50);
509 PictureLayerTiling::CoverageIterator
iter(tiling_
.get(), 1, non_intersecting
);
513 TEST_F(PictureLayerTilingIteratorTest
, LayerEdgeTextureCoordinates
) {
514 Initialize(gfx::Size(300, 300), 1.0f
, gfx::Size(256, 256));
515 // All of these sizes are 256x256, scaled and ceiled.
516 VerifyTilesExactlyCoverRect(1.0f
, gfx::Rect(0, 0, 256, 256));
517 VerifyTilesExactlyCoverRect(0.8f
, gfx::Rect(0, 0, 205, 205));
518 VerifyTilesExactlyCoverRect(1.2f
, gfx::Rect(0, 0, 308, 308));
521 TEST_F(PictureLayerTilingIteratorTest
, NonContainedDestRect
) {
522 Initialize(gfx::Size(100, 100), 1.0f
, gfx::Size(400, 400));
524 // Too large in all dimensions
525 VerifyTilesCoverNonContainedRect(1.0f
, gfx::Rect(-1000, -1000, 2000, 2000));
526 VerifyTilesCoverNonContainedRect(1.5f
, gfx::Rect(-1000, -1000, 2000, 2000));
527 VerifyTilesCoverNonContainedRect(0.5f
, gfx::Rect(-1000, -1000, 2000, 2000));
529 // Partially covering content, but too large
530 VerifyTilesCoverNonContainedRect(1.0f
, gfx::Rect(-1000, 100, 2000, 100));
531 VerifyTilesCoverNonContainedRect(1.5f
, gfx::Rect(-1000, 100, 2000, 100));
532 VerifyTilesCoverNonContainedRect(0.5f
, gfx::Rect(-1000, 100, 2000, 100));
535 TEST(PictureLayerTilingTest
, SkewportLimits
) {
536 FakePictureLayerTilingClient client
;
537 client
.set_tree(ACTIVE_TREE
);
539 gfx::Rect
viewport(0, 0, 100, 100);
540 gfx::Size
layer_bounds(200, 200);
542 client
.SetTileSize(gfx::Size(100, 100));
543 LayerTreeSettings settings
;
544 settings
.max_tiles_for_interest_area
= 10000;
545 settings
.skewport_extrapolation_limit_in_content_pixels
= 75;
547 scoped_refptr
<FakePicturePileImpl
> pile
=
548 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
549 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
550 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
, settings
);
552 tiling
->ComputeTilePriorityRects(viewport
, 1.f
, 1.0, Occlusion());
554 // Move viewport down 50 pixels in 0.5 seconds.
555 gfx::Rect down_skewport
=
556 tiling
->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
558 EXPECT_EQ(0, down_skewport
.x());
559 EXPECT_EQ(50, down_skewport
.y());
560 EXPECT_EQ(100, down_skewport
.width());
561 EXPECT_EQ(175, down_skewport
.height());
562 EXPECT_TRUE(down_skewport
.Contains(gfx::Rect(0, 50, 100, 100)));
564 // Move viewport down 50 and right 10 pixels.
565 gfx::Rect down_right_skewport
=
566 tiling
->ComputeSkewport(1.5, gfx::Rect(10, 50, 100, 100));
568 EXPECT_EQ(10, down_right_skewport
.x());
569 EXPECT_EQ(50, down_right_skewport
.y());
570 EXPECT_EQ(120, down_right_skewport
.width());
571 EXPECT_EQ(175, down_right_skewport
.height());
572 EXPECT_TRUE(down_right_skewport
.Contains(gfx::Rect(10, 50, 100, 100)));
574 // Move viewport left.
575 gfx::Rect left_skewport
=
576 tiling
->ComputeSkewport(1.5, gfx::Rect(-50, 0, 100, 100));
578 EXPECT_EQ(-125, left_skewport
.x());
579 EXPECT_EQ(0, left_skewport
.y());
580 EXPECT_EQ(175, left_skewport
.width());
581 EXPECT_EQ(100, left_skewport
.height());
582 EXPECT_TRUE(left_skewport
.Contains(gfx::Rect(-50, 0, 100, 100)));
585 gfx::Rect expand_skewport
=
586 tiling
->ComputeSkewport(1.5, gfx::Rect(-50, -50, 200, 200));
588 // x and y moved by -75 (-50 - 75 = -125).
589 // right side and bottom side moved by 75 [(350 - 125) - (200 - 50) = 75].
590 EXPECT_EQ(-125, expand_skewport
.x());
591 EXPECT_EQ(-125, expand_skewport
.y());
592 EXPECT_EQ(350, expand_skewport
.width());
593 EXPECT_EQ(350, expand_skewport
.height());
594 EXPECT_TRUE(expand_skewport
.Contains(gfx::Rect(-50, -50, 200, 200)));
596 // Expand the viewport past the limit.
597 gfx::Rect big_expand_skewport
=
598 tiling
->ComputeSkewport(1.5, gfx::Rect(-500, -500, 1500, 1500));
600 EXPECT_EQ(-575, big_expand_skewport
.x());
601 EXPECT_EQ(-575, big_expand_skewport
.y());
602 EXPECT_EQ(1650, big_expand_skewport
.width());
603 EXPECT_EQ(1650, big_expand_skewport
.height());
604 EXPECT_TRUE(big_expand_skewport
.Contains(gfx::Rect(-500, -500, 1500, 1500)));
607 TEST(PictureLayerTilingTest
, ComputeSkewport
) {
608 FakePictureLayerTilingClient client
;
610 gfx::Rect
viewport(0, 0, 100, 100);
611 gfx::Size
layer_bounds(200, 200);
613 client
.SetTileSize(gfx::Size(100, 100));
614 client
.set_tree(ACTIVE_TREE
);
616 scoped_refptr
<FakePicturePileImpl
> pile
=
617 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
618 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
619 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
620 LayerTreeSettings());
622 tiling
->ComputeTilePriorityRects(viewport
, 1.f
, 1.0, Occlusion());
624 // Move viewport down 50 pixels in 0.5 seconds.
625 gfx::Rect down_skewport
=
626 tiling
->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
628 EXPECT_EQ(0, down_skewport
.x());
629 EXPECT_EQ(50, down_skewport
.y());
630 EXPECT_EQ(100, down_skewport
.width());
631 EXPECT_EQ(200, down_skewport
.height());
634 gfx::Rect shrink_skewport
=
635 tiling
->ComputeSkewport(1.5, gfx::Rect(25, 25, 50, 50));
637 EXPECT_EQ(25, shrink_skewport
.x());
638 EXPECT_EQ(25, shrink_skewport
.y());
639 EXPECT_EQ(50, shrink_skewport
.width());
640 EXPECT_EQ(50, shrink_skewport
.height());
642 // Move viewport down 50 and right 10 pixels.
643 gfx::Rect down_right_skewport
=
644 tiling
->ComputeSkewport(1.5, gfx::Rect(10, 50, 100, 100));
646 EXPECT_EQ(10, down_right_skewport
.x());
647 EXPECT_EQ(50, down_right_skewport
.y());
648 EXPECT_EQ(120, down_right_skewport
.width());
649 EXPECT_EQ(200, down_right_skewport
.height());
651 // Move viewport left.
652 gfx::Rect left_skewport
=
653 tiling
->ComputeSkewport(1.5, gfx::Rect(-20, 0, 100, 100));
655 EXPECT_EQ(-60, left_skewport
.x());
656 EXPECT_EQ(0, left_skewport
.y());
657 EXPECT_EQ(140, left_skewport
.width());
658 EXPECT_EQ(100, left_skewport
.height());
660 // Expand viewport in 0.2 seconds.
661 gfx::Rect expanded_skewport
=
662 tiling
->ComputeSkewport(1.2, gfx::Rect(-5, -5, 110, 110));
664 EXPECT_EQ(-30, expanded_skewport
.x());
665 EXPECT_EQ(-30, expanded_skewport
.y());
666 EXPECT_EQ(160, expanded_skewport
.width());
667 EXPECT_EQ(160, expanded_skewport
.height());
670 TEST(PictureLayerTilingTest
, ViewportDistanceWithScale
) {
671 FakePictureLayerTilingClient client
;
673 gfx::Rect
viewport(0, 0, 100, 100);
674 gfx::Size
layer_bounds(1500, 1500);
676 client
.SetTileSize(gfx::Size(10, 10));
677 client
.set_tree(ACTIVE_TREE
);
678 LayerTreeSettings settings
;
679 settings
.max_tiles_for_interest_area
= 10000;
681 // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
682 // The reason is that each tile has a one pixel border, so tile at (1, 2)
683 // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
684 // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
686 scoped_refptr
<FakePicturePileImpl
> pile
=
687 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
688 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
689 TestablePictureLayerTiling::Create(0.25f
, pile
, &client
, settings
);
690 gfx::Rect viewport_in_content_space
=
691 gfx::ToEnclosedRect(gfx::ScaleRect(viewport
, 0.25f
));
693 tiling
->ComputeTilePriorityRects(viewport
, 1.f
, 1.0, Occlusion());
694 tiling
->UpdateAllTilePrioritiesForTesting();
696 gfx::Rect soon_rect
= viewport
;
697 soon_rect
.Inset(-312.f
, -312.f
, -312.f
, -312.f
);
698 gfx::Rect soon_rect_in_content_space
=
699 gfx::ToEnclosedRect(gfx::ScaleRect(soon_rect
, 0.25f
));
702 for (int i
= 0; i
< 47; ++i
) {
703 for (int j
= 0; j
< 47; ++j
) {
704 EXPECT_TRUE(tiling
->TileAt(i
, j
)) << "i: " << i
<< " j: " << j
;
707 for (int i
= 0; i
< 47; ++i
) {
708 EXPECT_FALSE(tiling
->TileAt(i
, 47)) << "i: " << i
;
709 EXPECT_FALSE(tiling
->TileAt(47, i
)) << "i: " << i
;
712 // No movement in the viewport implies that tiles will either be NOW
713 // or EVENTUALLY, with the exception of tiles that are between 0 and 312
714 // pixels away from the viewport, which will be in the SOON bin.
715 bool have_now
= false;
716 bool have_eventually
= false;
717 bool have_soon
= false;
718 for (int i
= 0; i
< 47; ++i
) {
719 for (int j
= 0; j
< 47; ++j
) {
720 Tile
* tile
= tiling
->TileAt(i
, j
);
721 TilePriority priority
= tile
->priority(ACTIVE_TREE
);
723 gfx::Rect tile_rect
= tiling
->TilingDataForTesting().TileBounds(i
, j
);
724 if (viewport_in_content_space
.Intersects(tile_rect
)) {
725 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
726 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
728 } else if (soon_rect_in_content_space
.Intersects(tile_rect
)) {
729 EXPECT_EQ(TilePriority::SOON
, priority
.priority_bin
);
732 EXPECT_EQ(TilePriority::EVENTUALLY
, priority
.priority_bin
);
733 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
734 have_eventually
= true;
739 EXPECT_TRUE(have_now
);
740 EXPECT_TRUE(have_soon
);
741 EXPECT_TRUE(have_eventually
);
743 // Spot check some distances.
744 // Tile at 5, 1 should begin at 41x9 in content space (without borders),
745 // so the distance to a viewport that ends at 25x25 in content space
746 // should be 17 (41 - 25 + 1). In layer space, then that should be
747 // 17 / 0.25 = 68 pixels.
749 // We can verify that the content rect (with borders) is one pixel off
750 // 41,9 8x8 on all sides.
751 EXPECT_EQ(tiling
->TileAt(5, 1)->content_rect().ToString(), "40,8 10x10");
753 TilePriority priority
= tiling
->TileAt(5, 1)->priority(ACTIVE_TREE
);
754 EXPECT_FLOAT_EQ(68.f
, priority
.distance_to_visible
);
756 priority
= tiling
->TileAt(2, 5)->priority(ACTIVE_TREE
);
757 EXPECT_FLOAT_EQ(68.f
, priority
.distance_to_visible
);
759 priority
= tiling
->TileAt(3, 4)->priority(ACTIVE_TREE
);
760 EXPECT_FLOAT_EQ(40.f
, priority
.distance_to_visible
);
762 // Move the viewport down 40 pixels.
763 viewport
= gfx::Rect(0, 40, 100, 100);
764 viewport_in_content_space
=
765 gfx::ToEnclosedRect(gfx::ScaleRect(viewport
, 0.25f
));
766 gfx::Rect skewport
= tiling
->ComputeSkewport(2.0, viewport_in_content_space
);
768 soon_rect
= viewport
;
769 soon_rect
.Inset(-312.f
, -312.f
, -312.f
, -312.f
);
770 soon_rect_in_content_space
=
771 gfx::ToEnclosedRect(gfx::ScaleRect(soon_rect
, 0.25f
));
773 EXPECT_EQ(0, skewport
.x());
774 EXPECT_EQ(10, skewport
.y());
775 EXPECT_EQ(25, skewport
.width());
776 EXPECT_EQ(35, skewport
.height());
778 tiling
->ComputeTilePriorityRects(viewport
, 1.f
, 2.0, Occlusion());
779 tiling
->UpdateAllTilePrioritiesForTesting();
782 have_eventually
= false;
785 // Viewport moved, so we expect to find some NOW tiles, some SOON tiles and
786 // some EVENTUALLY tiles.
787 for (int i
= 0; i
< 47; ++i
) {
788 for (int j
= 0; j
< 47; ++j
) {
789 Tile
* tile
= tiling
->TileAt(i
, j
);
790 TilePriority priority
= tile
->priority(ACTIVE_TREE
);
792 gfx::Rect tile_rect
= tiling
->TilingDataForTesting().TileBounds(i
, j
);
793 if (viewport_in_content_space
.Intersects(tile_rect
)) {
794 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
) << "i: " << i
796 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
) << "i: " << i
799 } else if (skewport
.Intersects(tile_rect
) ||
800 soon_rect_in_content_space
.Intersects(tile_rect
)) {
801 EXPECT_EQ(TilePriority::SOON
, priority
.priority_bin
) << "i: " << i
803 EXPECT_GT(priority
.distance_to_visible
, 0.f
) << "i: " << i
807 EXPECT_EQ(TilePriority::EVENTUALLY
, priority
.priority_bin
)
808 << "i: " << i
<< " j: " << j
;
809 EXPECT_GT(priority
.distance_to_visible
, 0.f
) << "i: " << i
811 have_eventually
= true;
816 EXPECT_TRUE(have_now
);
817 EXPECT_TRUE(have_soon
);
818 EXPECT_TRUE(have_eventually
);
820 priority
= tiling
->TileAt(5, 1)->priority(ACTIVE_TREE
);
821 EXPECT_FLOAT_EQ(68.f
, priority
.distance_to_visible
);
823 priority
= tiling
->TileAt(2, 5)->priority(ACTIVE_TREE
);
824 EXPECT_FLOAT_EQ(28.f
, priority
.distance_to_visible
);
826 priority
= tiling
->TileAt(3, 4)->priority(ACTIVE_TREE
);
827 EXPECT_FLOAT_EQ(4.f
, priority
.distance_to_visible
);
829 // Change the underlying layer scale.
830 tiling
->ComputeTilePriorityRects(viewport
, 2.0f
, 3.0, Occlusion());
831 tiling
->UpdateAllTilePrioritiesForTesting();
833 priority
= tiling
->TileAt(5, 1)->priority(ACTIVE_TREE
);
834 EXPECT_FLOAT_EQ(136.f
, priority
.distance_to_visible
);
836 priority
= tiling
->TileAt(2, 5)->priority(ACTIVE_TREE
);
837 EXPECT_FLOAT_EQ(56.f
, priority
.distance_to_visible
);
839 priority
= tiling
->TileAt(3, 4)->priority(ACTIVE_TREE
);
840 EXPECT_FLOAT_EQ(8.f
, priority
.distance_to_visible
);
842 // Test additional scales.
843 tiling
= TestablePictureLayerTiling::Create(0.2f
, pile
, &client
,
844 LayerTreeSettings());
845 tiling
->ComputeTilePriorityRects(viewport
, 1.0f
, 4.0, Occlusion());
846 tiling
->UpdateAllTilePrioritiesForTesting();
848 priority
= tiling
->TileAt(5, 1)->priority(ACTIVE_TREE
);
849 EXPECT_FLOAT_EQ(110.f
, priority
.distance_to_visible
);
851 priority
= tiling
->TileAt(2, 5)->priority(ACTIVE_TREE
);
852 EXPECT_FLOAT_EQ(70.f
, priority
.distance_to_visible
);
854 priority
= tiling
->TileAt(3, 4)->priority(ACTIVE_TREE
);
855 EXPECT_FLOAT_EQ(60.f
, priority
.distance_to_visible
);
857 tiling
->ComputeTilePriorityRects(viewport
, 0.5f
, 5.0, Occlusion());
858 tiling
->UpdateAllTilePrioritiesForTesting();
860 priority
= tiling
->TileAt(5, 1)->priority(ACTIVE_TREE
);
861 EXPECT_FLOAT_EQ(55.f
, priority
.distance_to_visible
);
863 priority
= tiling
->TileAt(2, 5)->priority(ACTIVE_TREE
);
864 EXPECT_FLOAT_EQ(35.f
, priority
.distance_to_visible
);
866 priority
= tiling
->TileAt(3, 4)->priority(ACTIVE_TREE
);
867 EXPECT_FLOAT_EQ(30.f
, priority
.distance_to_visible
);
870 TEST(PictureLayerTilingTest
, ExpandRectEqual
) {
871 gfx::Rect
in(40, 50, 100, 200);
872 gfx::Rect
bounds(-1000, -1000, 10000, 10000);
873 int64 target_area
= 100 * 200;
874 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
875 in
, target_area
, bounds
, NULL
);
876 EXPECT_EQ(in
.ToString(), out
.ToString());
879 TEST(PictureLayerTilingTest
, ExpandRectSmaller
) {
880 gfx::Rect
in(40, 50, 100, 200);
881 gfx::Rect
bounds(-1000, -1000, 10000, 10000);
882 int64 target_area
= 100 * 100;
883 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
884 in
, target_area
, bounds
, NULL
);
885 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.y() - out
.y());
886 EXPECT_EQ(out
.right() - in
.right(), in
.x() - out
.x());
887 EXPECT_EQ(out
.width() - in
.width(), out
.height() - in
.height());
889 // |in| represents the visible rect, and |out| represents the eventually rect.
890 // If the eventually rect doesn't contain the visible rect, we will start
892 EXPECT_TRUE(out
.Contains(in
));
893 EXPECT_TRUE(bounds
.Contains(out
));
896 TEST(PictureLayerTilingTest
, ExpandRectUnbounded
) {
897 gfx::Rect
in(40, 50, 100, 200);
898 gfx::Rect
bounds(-1000, -1000, 10000, 10000);
899 int64 target_area
= 200 * 200;
900 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
901 in
, target_area
, bounds
, NULL
);
902 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.y() - out
.y());
903 EXPECT_EQ(out
.right() - in
.right(), in
.x() - out
.x());
904 EXPECT_EQ(out
.width() - in
.width(), out
.height() - in
.height());
905 EXPECT_NEAR(200 * 200, out
.width() * out
.height(), 100);
906 EXPECT_TRUE(bounds
.Contains(out
));
909 TEST(PictureLayerTilingTest
, ExpandRectBoundedSmaller
) {
910 gfx::Rect
in(40, 50, 100, 200);
911 gfx::Rect
bounds(50, 60, 40, 30);
912 int64 target_area
= 200 * 200;
913 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
914 in
, target_area
, bounds
, NULL
);
915 EXPECT_EQ(bounds
.ToString(), out
.ToString());
918 TEST(PictureLayerTilingTest
, ExpandRectBoundedEqual
) {
919 gfx::Rect
in(40, 50, 100, 200);
920 gfx::Rect bounds
= in
;
921 int64 target_area
= 200 * 200;
922 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
923 in
, target_area
, bounds
, NULL
);
924 EXPECT_EQ(bounds
.ToString(), out
.ToString());
927 TEST(PictureLayerTilingTest
, ExpandRectBoundedSmallerStretchVertical
) {
928 gfx::Rect
in(40, 50, 100, 200);
929 gfx::Rect
bounds(45, 0, 90, 300);
930 int64 target_area
= 200 * 200;
931 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
932 in
, target_area
, bounds
, NULL
);
933 EXPECT_EQ(bounds
.ToString(), out
.ToString());
936 TEST(PictureLayerTilingTest
, ExpandRectBoundedEqualStretchVertical
) {
937 gfx::Rect
in(40, 50, 100, 200);
938 gfx::Rect
bounds(40, 0, 100, 300);
939 int64 target_area
= 200 * 200;
940 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
941 in
, target_area
, bounds
, NULL
);
942 EXPECT_EQ(bounds
.ToString(), out
.ToString());
945 TEST(PictureLayerTilingTest
, ExpandRectBoundedSmallerStretchHorizontal
) {
946 gfx::Rect
in(40, 50, 100, 200);
947 gfx::Rect
bounds(0, 55, 180, 190);
948 int64 target_area
= 200 * 200;
949 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
950 in
, target_area
, bounds
, NULL
);
951 EXPECT_EQ(bounds
.ToString(), out
.ToString());
954 TEST(PictureLayerTilingTest
, ExpandRectBoundedEqualStretchHorizontal
) {
955 gfx::Rect
in(40, 50, 100, 200);
956 gfx::Rect
bounds(0, 50, 180, 200);
957 int64 target_area
= 200 * 200;
958 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
959 in
, target_area
, bounds
, NULL
);
960 EXPECT_EQ(bounds
.ToString(), out
.ToString());
963 TEST(PictureLayerTilingTest
, ExpandRectBoundedLeft
) {
964 gfx::Rect
in(40, 50, 100, 200);
965 gfx::Rect
bounds(20, -1000, 10000, 10000);
966 int64 target_area
= 200 * 200;
967 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
968 in
, target_area
, bounds
, NULL
);
969 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.y() - out
.y());
970 EXPECT_EQ(out
.bottom() - in
.bottom(), out
.right() - in
.right());
971 EXPECT_LE(out
.width() * out
.height(), target_area
);
972 EXPECT_GT(out
.width() * out
.height(),
973 target_area
- out
.width() - out
.height() * 2);
974 EXPECT_TRUE(bounds
.Contains(out
));
977 TEST(PictureLayerTilingTest
, ExpandRectBoundedRight
) {
978 gfx::Rect
in(40, 50, 100, 200);
979 gfx::Rect
bounds(-1000, -1000, 1000+120, 10000);
980 int64 target_area
= 200 * 200;
981 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
982 in
, target_area
, bounds
, NULL
);
983 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.y() - out
.y());
984 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.x() - out
.x());
985 EXPECT_LE(out
.width() * out
.height(), target_area
);
986 EXPECT_GT(out
.width() * out
.height(),
987 target_area
- out
.width() - out
.height() * 2);
988 EXPECT_TRUE(bounds
.Contains(out
));
991 TEST(PictureLayerTilingTest
, ExpandRectBoundedTop
) {
992 gfx::Rect
in(40, 50, 100, 200);
993 gfx::Rect
bounds(-1000, 30, 10000, 10000);
994 int64 target_area
= 200 * 200;
995 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
996 in
, target_area
, bounds
, NULL
);
997 EXPECT_EQ(out
.right() - in
.right(), in
.x() - out
.x());
998 EXPECT_EQ(out
.right() - in
.right(), out
.bottom() - in
.bottom());
999 EXPECT_LE(out
.width() * out
.height(), target_area
);
1000 EXPECT_GT(out
.width() * out
.height(),
1001 target_area
- out
.width() * 2 - out
.height());
1002 EXPECT_TRUE(bounds
.Contains(out
));
1005 TEST(PictureLayerTilingTest
, ExpandRectBoundedBottom
) {
1006 gfx::Rect
in(40, 50, 100, 200);
1007 gfx::Rect
bounds(-1000, -1000, 10000, 1000 + 220);
1008 int64 target_area
= 200 * 200;
1009 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1010 in
, target_area
, bounds
, NULL
);
1011 EXPECT_EQ(out
.right() - in
.right(), in
.x() - out
.x());
1012 EXPECT_EQ(out
.right() - in
.right(), in
.y() - out
.y());
1013 EXPECT_LE(out
.width() * out
.height(), target_area
);
1014 EXPECT_GT(out
.width() * out
.height(),
1015 target_area
- out
.width() * 2 - out
.height());
1016 EXPECT_TRUE(bounds
.Contains(out
));
1019 TEST(PictureLayerTilingTest
, ExpandRectSquishedHorizontally
) {
1020 gfx::Rect
in(40, 50, 100, 200);
1021 gfx::Rect
bounds(0, -4000, 100+40+20, 100000);
1022 int64 target_area
= 400 * 400;
1023 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1024 in
, target_area
, bounds
, NULL
);
1025 EXPECT_EQ(20, out
.right() - in
.right());
1026 EXPECT_EQ(40, in
.x() - out
.x());
1027 EXPECT_EQ(out
.bottom() - in
.bottom(), in
.y() - out
.y());
1028 EXPECT_LE(out
.width() * out
.height(), target_area
);
1029 EXPECT_GT(out
.width() * out
.height(),
1030 target_area
- out
.width() * 2);
1031 EXPECT_TRUE(bounds
.Contains(out
));
1034 TEST(PictureLayerTilingTest
, ExpandRectSquishedVertically
) {
1035 gfx::Rect
in(40, 50, 100, 200);
1036 gfx::Rect
bounds(-4000, 0, 100000, 200+50+30);
1037 int64 target_area
= 400 * 400;
1038 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1039 in
, target_area
, bounds
, NULL
);
1040 EXPECT_EQ(30, out
.bottom() - in
.bottom());
1041 EXPECT_EQ(50, in
.y() - out
.y());
1042 EXPECT_EQ(out
.right() - in
.right(), in
.x() - out
.x());
1043 EXPECT_LE(out
.width() * out
.height(), target_area
);
1044 EXPECT_GT(out
.width() * out
.height(),
1045 target_area
- out
.height() * 2);
1046 EXPECT_TRUE(bounds
.Contains(out
));
1049 TEST(PictureLayerTilingTest
, ExpandRectOutOfBoundsFarAway
) {
1050 gfx::Rect
in(400, 500, 100, 200);
1051 gfx::Rect
bounds(0, 0, 10, 10);
1052 int64 target_area
= 400 * 400;
1053 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1054 in
, target_area
, bounds
, NULL
);
1055 EXPECT_TRUE(out
.IsEmpty());
1058 TEST(PictureLayerTilingTest
, ExpandRectOutOfBoundsExpandedFullyCover
) {
1059 gfx::Rect
in(40, 50, 100, 100);
1060 gfx::Rect
bounds(0, 0, 10, 10);
1061 int64 target_area
= 400 * 400;
1062 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1063 in
, target_area
, bounds
, NULL
);
1064 EXPECT_EQ(bounds
.ToString(), out
.ToString());
1067 TEST(PictureLayerTilingTest
, ExpandRectOutOfBoundsExpandedPartlyCover
) {
1068 gfx::Rect
in(600, 600, 100, 100);
1069 gfx::Rect
bounds(0, 0, 500, 500);
1070 int64 target_area
= 400 * 400;
1071 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1072 in
, target_area
, bounds
, NULL
);
1073 EXPECT_EQ(bounds
.right(), out
.right());
1074 EXPECT_EQ(bounds
.bottom(), out
.bottom());
1075 EXPECT_LE(out
.width() * out
.height(), target_area
);
1076 EXPECT_GT(out
.width() * out
.height(),
1077 target_area
- out
.width() - out
.height());
1078 EXPECT_TRUE(bounds
.Contains(out
));
1081 TEST(PictureLayerTilingTest
, EmptyStartingRect
) {
1082 // If a layer has a non-invertible transform, then the starting rect
1083 // for the layer would be empty.
1084 gfx::Rect
in(40, 40, 0, 0);
1085 gfx::Rect
bounds(0, 0, 10, 10);
1086 int64 target_area
= 400 * 400;
1087 gfx::Rect out
= PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
1088 in
, target_area
, bounds
, NULL
);
1089 EXPECT_TRUE(out
.IsEmpty());
1092 TEST(PictureLayerTilingTest
, TilingRasterTileIteratorStaticViewport
) {
1093 FakePictureLayerTilingClient client
;
1095 gfx::Rect
viewport(50, 50, 100, 100);
1096 gfx::Size
layer_bounds(800, 800);
1098 gfx::Rect soon_rect
= viewport
;
1099 soon_rect
.Inset(-312.f
, -312.f
, -312.f
, -312.f
);
1101 client
.SetTileSize(gfx::Size(30, 30));
1102 client
.set_tree(ACTIVE_TREE
);
1103 LayerTreeSettings settings
;
1104 settings
.max_tiles_for_interest_area
= 10000;
1106 scoped_refptr
<FakePicturePileImpl
> pile
=
1107 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
1108 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1109 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
, settings
);
1110 tiling
->ComputeTilePriorityRects(viewport
, 1.0f
, 1.0, Occlusion());
1111 tiling
->UpdateAllTilePrioritiesForTesting();
1113 PictureLayerTiling::TilingRasterTileIterator empty_iterator
;
1114 EXPECT_FALSE(empty_iterator
);
1116 std::vector
<Tile
*> all_tiles
= tiling
->AllTilesForTesting();
1119 EXPECT_EQ(841u, all_tiles
.size());
1121 // The explanation of each iteration is as follows:
1122 // 1. First iteration tests that we can get all of the tiles correctly.
1123 // 2. Second iteration ensures that we can get all of the tiles again (first
1124 // iteration didn't change any tiles), as well set all tiles to be ready to
1126 // 3. Third iteration ensures that no tiles are returned, since they were all
1127 // marked as ready to draw.
1128 for (int i
= 0; i
< 3; ++i
) {
1129 PictureLayerTiling::TilingRasterTileIterator
it(tiling
.get());
1131 // There are 3 bins in TilePriority.
1132 bool have_tiles
[3] = {};
1134 // On the third iteration, we should get no tiles since everything was
1135 // marked as ready to draw.
1142 std::set
<Tile
*> unique_tiles
;
1143 unique_tiles
.insert(*it
);
1144 Tile
* last_tile
= *it
;
1145 have_tiles
[last_tile
->priority(ACTIVE_TREE
).priority_bin
] = true;
1147 // On the second iteration, mark everything as ready to draw (solid color).
1149 TileDrawInfo
& draw_info
= last_tile
->draw_info();
1150 draw_info
.SetSolidColorForTesting(SK_ColorRED
);
1153 int eventually_bin_order_correct_count
= 0;
1154 int eventually_bin_order_incorrect_count
= 0;
1156 Tile
* new_tile
= *it
;
1158 unique_tiles
.insert(new_tile
);
1160 TilePriority last_priority
= last_tile
->priority(ACTIVE_TREE
);
1161 TilePriority new_priority
= new_tile
->priority(ACTIVE_TREE
);
1162 EXPECT_LE(last_priority
.priority_bin
, new_priority
.priority_bin
);
1163 if (last_priority
.priority_bin
== new_priority
.priority_bin
) {
1164 if (last_priority
.priority_bin
== TilePriority::EVENTUALLY
) {
1165 bool order_correct
= last_priority
.distance_to_visible
<=
1166 new_priority
.distance_to_visible
;
1167 eventually_bin_order_correct_count
+= order_correct
;
1168 eventually_bin_order_incorrect_count
+= !order_correct
;
1169 } else if (!soon_rect
.Intersects(new_tile
->content_rect()) &&
1170 !soon_rect
.Intersects(last_tile
->content_rect())) {
1171 EXPECT_LE(last_priority
.distance_to_visible
,
1172 new_priority
.distance_to_visible
);
1173 EXPECT_EQ(TilePriority::NOW
, new_priority
.priority_bin
);
1174 } else if (new_priority
.distance_to_visible
> 0.f
) {
1175 EXPECT_EQ(TilePriority::SOON
, new_priority
.priority_bin
);
1178 have_tiles
[new_priority
.priority_bin
] = true;
1180 last_tile
= new_tile
;
1182 // On the second iteration, mark everything as ready to draw (solid
1185 TileDrawInfo
& draw_info
= last_tile
->draw_info();
1186 draw_info
.SetSolidColorForTesting(SK_ColorRED
);
1190 EXPECT_GT(eventually_bin_order_correct_count
,
1191 eventually_bin_order_incorrect_count
);
1193 // We should have now and eventually tiles, as well as soon tiles from
1194 // the border region.
1195 EXPECT_TRUE(have_tiles
[TilePriority::NOW
]);
1196 EXPECT_TRUE(have_tiles
[TilePriority::SOON
]);
1197 EXPECT_TRUE(have_tiles
[TilePriority::EVENTUALLY
]);
1199 EXPECT_EQ(unique_tiles
.size(), all_tiles
.size());
1203 TEST(PictureLayerTilingTest
, TilingRasterTileIteratorMovingViewport
) {
1204 FakePictureLayerTilingClient client
;
1206 gfx::Rect
viewport(50, 0, 100, 100);
1207 gfx::Rect
moved_viewport(50, 0, 100, 500);
1208 gfx::Size
layer_bounds(1000, 1000);
1210 client
.SetTileSize(gfx::Size(30, 30));
1211 client
.set_tree(ACTIVE_TREE
);
1212 LayerTreeSettings settings
;
1213 settings
.max_tiles_for_interest_area
= 10000;
1215 scoped_refptr
<FakePicturePileImpl
> pile
=
1216 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
1217 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1218 TestablePictureLayerTiling::Create(1.f
, pile
, &client
, settings
);
1219 tiling
->ComputeTilePriorityRects(viewport
, 1.0f
, 1.0, Occlusion());
1220 tiling
->ComputeTilePriorityRects(moved_viewport
, 1.0f
, 2.0, Occlusion());
1221 tiling
->UpdateAllTilePrioritiesForTesting();
1223 gfx::Rect soon_rect
= moved_viewport
;
1224 soon_rect
.Inset(-312.f
, -312.f
, -312.f
, -312.f
);
1226 // There are 3 bins in TilePriority.
1227 bool have_tiles
[3] = {};
1228 Tile
* last_tile
= NULL
;
1229 int eventually_bin_order_correct_count
= 0;
1230 int eventually_bin_order_incorrect_count
= 0;
1231 for (PictureLayerTiling::TilingRasterTileIterator
it(tiling
.get()); it
;
1236 Tile
* new_tile
= *it
;
1238 TilePriority last_priority
= last_tile
->priority(ACTIVE_TREE
);
1239 TilePriority new_priority
= new_tile
->priority(ACTIVE_TREE
);
1241 have_tiles
[new_priority
.priority_bin
] = true;
1243 EXPECT_LE(last_priority
.priority_bin
, new_priority
.priority_bin
);
1244 if (last_priority
.priority_bin
== new_priority
.priority_bin
) {
1245 if (last_priority
.priority_bin
== TilePriority::EVENTUALLY
) {
1246 bool order_correct
= last_priority
.distance_to_visible
<=
1247 new_priority
.distance_to_visible
;
1248 eventually_bin_order_correct_count
+= order_correct
;
1249 eventually_bin_order_incorrect_count
+= !order_correct
;
1250 } else if (!soon_rect
.Intersects(new_tile
->content_rect()) &&
1251 !soon_rect
.Intersects(last_tile
->content_rect())) {
1252 EXPECT_LE(last_priority
.distance_to_visible
,
1253 new_priority
.distance_to_visible
);
1254 } else if (new_priority
.distance_to_visible
> 0.f
) {
1255 EXPECT_EQ(TilePriority::SOON
, new_priority
.priority_bin
);
1258 last_tile
= new_tile
;
1261 EXPECT_GT(eventually_bin_order_correct_count
,
1262 eventually_bin_order_incorrect_count
);
1264 EXPECT_TRUE(have_tiles
[TilePriority::NOW
]);
1265 EXPECT_TRUE(have_tiles
[TilePriority::SOON
]);
1266 EXPECT_TRUE(have_tiles
[TilePriority::EVENTUALLY
]);
1269 static void TileExists(bool exists
, Tile
* tile
,
1270 const gfx::Rect
& geometry_rect
) {
1271 EXPECT_EQ(exists
, tile
!= NULL
) << geometry_rect
.ToString();
1274 TEST_F(PictureLayerTilingIteratorTest
, TilesExist
) {
1275 gfx::Size
layer_bounds(1099, 801);
1276 Initialize(gfx::Size(100, 100), 1.f
, layer_bounds
);
1277 VerifyTilesExactlyCoverRect(1.f
, gfx::Rect(layer_bounds
));
1278 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, false));
1280 client_
.set_tree(ACTIVE_TREE
);
1281 tiling_
->ComputeTilePriorityRects(
1282 gfx::Rect(layer_bounds
), // visible content rect
1283 1.f
, // current contents scale
1284 1.0, // current frame time
1286 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, true));
1288 // Make the viewport rect empty. All tiles are killed and become zombies.
1289 tiling_
->ComputeTilePriorityRects(gfx::Rect(), // visible content rect
1290 1.f
, // current contents scale
1291 2.0, // current frame time
1293 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, false));
1296 TEST_F(PictureLayerTilingIteratorTest
, TilesExistGiantViewport
) {
1297 gfx::Size
layer_bounds(1099, 801);
1298 Initialize(gfx::Size(100, 100), 1.f
, layer_bounds
);
1299 VerifyTilesExactlyCoverRect(1.f
, gfx::Rect(layer_bounds
));
1300 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, false));
1302 gfx::Rect
giant_rect(-10000000, -10000000, 1000000000, 1000000000);
1304 client_
.set_tree(ACTIVE_TREE
);
1305 tiling_
->ComputeTilePriorityRects(
1306 gfx::Rect(layer_bounds
), // visible content rect
1307 1.f
, // current contents scale
1308 1.0, // current frame time
1310 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, true));
1312 // If the visible content rect is empty, it should still have live tiles.
1313 tiling_
->ComputeTilePriorityRects(giant_rect
, // visible content rect
1314 1.f
, // current contents scale
1315 2.0, // current frame time
1317 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, true));
1320 TEST_F(PictureLayerTilingIteratorTest
, TilesExistOutsideViewport
) {
1321 gfx::Size
layer_bounds(1099, 801);
1322 Initialize(gfx::Size(100, 100), 1.f
, layer_bounds
);
1323 VerifyTilesExactlyCoverRect(1.f
, gfx::Rect(layer_bounds
));
1324 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, false));
1326 // This rect does not intersect with the layer, as the layer is outside the
1328 gfx::Rect
viewport_rect(1100, 0, 1000, 1000);
1329 EXPECT_FALSE(viewport_rect
.Intersects(gfx::Rect(layer_bounds
)));
1331 client_
.set_tree(ACTIVE_TREE
);
1332 tiling_
->ComputeTilePriorityRects(viewport_rect
, // visible content rect
1333 1.f
, // current contents scale
1334 1.0, // current frame time
1336 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, true));
1339 static void TilesIntersectingRectExist(const gfx::Rect
& rect
,
1340 bool intersect_exists
,
1342 const gfx::Rect
& geometry_rect
) {
1343 bool intersects
= rect
.Intersects(geometry_rect
);
1344 bool expected_exists
= intersect_exists
? intersects
: !intersects
;
1345 EXPECT_EQ(expected_exists
, tile
!= NULL
)
1346 << "Rects intersecting " << rect
.ToString() << " should exist. "
1347 << "Current tile rect is " << geometry_rect
.ToString();
1350 TEST_F(PictureLayerTilingIteratorTest
,
1351 TilesExistLargeViewportAndLayerWithSmallVisibleArea
) {
1352 gfx::Size
layer_bounds(10000, 10000);
1353 client_
.SetTileSize(gfx::Size(100, 100));
1354 client_
.set_tree(PENDING_TREE
);
1355 LayerTreeSettings settings
;
1356 settings
.max_tiles_for_interest_area
= 1;
1358 scoped_refptr
<FakePicturePileImpl
> pile
=
1359 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds
);
1360 tiling_
= TestablePictureLayerTiling::Create(1.f
, pile
, &client_
, settings
);
1361 VerifyTilesExactlyCoverRect(1.f
, gfx::Rect(layer_bounds
));
1362 VerifyTiles(1.f
, gfx::Rect(layer_bounds
), base::Bind(&TileExists
, false));
1364 gfx::Rect
visible_rect(8000, 8000, 50, 50);
1366 client_
.set_tree(ACTIVE_TREE
);
1367 tiling_
->ComputeTilePriorityRects(visible_rect
, // visible content rect
1368 1.f
, // current contents scale
1369 1.0, // current frame time
1372 gfx::Rect(layer_bounds
),
1373 base::Bind(&TilesIntersectingRectExist
, visible_rect
, true));
1376 TEST(ComputeTilePriorityRectsTest
, VisibleTiles
) {
1377 // The TilePriority of visible tiles should have zero distance_to_visible
1378 // and time_to_visible.
1379 FakePictureLayerTilingClient client
;
1381 gfx::Size
device_viewport(800, 600);
1382 gfx::Size
last_layer_bounds(200, 200);
1383 gfx::Size
current_layer_bounds(200, 200);
1384 float current_layer_contents_scale
= 1.f
;
1385 gfx::Transform current_screen_transform
;
1386 double current_frame_time_in_seconds
= 1.0;
1388 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1389 current_screen_transform
, device_viewport
);
1391 client
.SetTileSize(gfx::Size(100, 100));
1392 client
.set_tree(ACTIVE_TREE
);
1394 scoped_refptr
<FakePicturePileImpl
> pile
=
1395 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1396 current_layer_bounds
);
1397 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1398 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1399 LayerTreeSettings());
1401 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1402 current_layer_contents_scale
,
1403 current_frame_time_in_seconds
, Occlusion());
1404 tiling
->UpdateAllTilePrioritiesForTesting();
1406 ASSERT_TRUE(tiling
->TileAt(0, 0));
1407 ASSERT_TRUE(tiling
->TileAt(0, 1));
1408 ASSERT_TRUE(tiling
->TileAt(1, 0));
1409 ASSERT_TRUE(tiling
->TileAt(1, 1));
1411 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1412 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1413 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1415 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1416 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1417 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1419 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1420 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1421 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1423 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1424 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1425 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1428 TEST(ComputeTilePriorityRectsTest
, OffscreenTiles
) {
1429 // The TilePriority of offscreen tiles (without movement) should have nonzero
1430 // distance_to_visible and infinite time_to_visible.
1431 FakePictureLayerTilingClient client
;
1433 gfx::Size
device_viewport(800, 600);
1434 gfx::Size
last_layer_bounds(200, 200);
1435 gfx::Size
current_layer_bounds(200, 200);
1436 float current_layer_contents_scale
= 1.f
;
1437 gfx::Transform last_screen_transform
;
1438 gfx::Transform current_screen_transform
;
1439 double current_frame_time_in_seconds
= 1.0;
1441 current_screen_transform
.Translate(850, 0);
1442 last_screen_transform
= current_screen_transform
;
1444 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1445 current_screen_transform
, device_viewport
);
1447 client
.SetTileSize(gfx::Size(100, 100));
1448 client
.set_tree(ACTIVE_TREE
);
1450 scoped_refptr
<FakePicturePileImpl
> pile
=
1451 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1452 current_layer_bounds
);
1453 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1454 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1455 LayerTreeSettings());
1457 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1458 current_layer_contents_scale
,
1459 current_frame_time_in_seconds
, Occlusion());
1460 tiling
->UpdateAllTilePrioritiesForTesting();
1462 ASSERT_TRUE(tiling
->TileAt(0, 0));
1463 ASSERT_TRUE(tiling
->TileAt(0, 1));
1464 ASSERT_TRUE(tiling
->TileAt(1, 0));
1465 ASSERT_TRUE(tiling
->TileAt(1, 1));
1467 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1468 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1469 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1471 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1472 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1473 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1475 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1476 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1477 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1479 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1480 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1481 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1483 // Furthermore, in this scenario tiles on the right hand side should have a
1484 // larger distance to visible.
1485 TilePriority left
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1486 TilePriority right
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1487 EXPECT_GT(right
.distance_to_visible
, left
.distance_to_visible
);
1489 left
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1490 right
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1491 EXPECT_GT(right
.distance_to_visible
, left
.distance_to_visible
);
1494 TEST(ComputeTilePriorityRectsTest
, PartiallyOffscreenLayer
) {
1495 // Sanity check that a layer with some tiles visible and others offscreen has
1496 // correct TilePriorities for each tile.
1497 FakePictureLayerTilingClient client
;
1499 gfx::Size
device_viewport(800, 600);
1500 gfx::Size
last_layer_bounds(200, 200);
1501 gfx::Size
current_layer_bounds(200, 200);
1502 float current_layer_contents_scale
= 1.f
;
1503 gfx::Transform last_screen_transform
;
1504 gfx::Transform current_screen_transform
;
1505 double current_frame_time_in_seconds
= 1.0;
1507 current_screen_transform
.Translate(705, 505);
1508 last_screen_transform
= current_screen_transform
;
1510 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1511 current_screen_transform
, device_viewport
);
1513 client
.SetTileSize(gfx::Size(100, 100));
1514 client
.set_tree(ACTIVE_TREE
);
1516 scoped_refptr
<FakePicturePileImpl
> pile
=
1517 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1518 current_layer_bounds
);
1519 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1520 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1521 LayerTreeSettings());
1523 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1524 current_layer_contents_scale
,
1525 current_frame_time_in_seconds
, Occlusion());
1526 tiling
->UpdateAllTilePrioritiesForTesting();
1528 ASSERT_TRUE(tiling
->TileAt(0, 0));
1529 ASSERT_TRUE(tiling
->TileAt(0, 1));
1530 ASSERT_TRUE(tiling
->TileAt(1, 0));
1531 ASSERT_TRUE(tiling
->TileAt(1, 1));
1533 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1534 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1535 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1537 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1538 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1539 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1541 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1542 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1543 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1545 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1546 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1547 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1550 TEST(ComputeTilePriorityRectsTest
, PartiallyOffscreenRotatedLayer
) {
1551 // Each tile of a layer may be affected differently by a transform; Check
1552 // that ComputeTilePriorityRects correctly accounts for the transform between
1553 // layer space and screen space.
1554 FakePictureLayerTilingClient client
;
1556 gfx::Size
device_viewport(800, 600);
1557 gfx::Size
last_layer_bounds(200, 200);
1558 gfx::Size
current_layer_bounds(200, 200);
1559 float current_layer_contents_scale
= 1.f
;
1560 gfx::Transform last_screen_transform
;
1561 gfx::Transform current_screen_transform
;
1562 double current_frame_time_in_seconds
= 1.0;
1564 // A diagonally rotated layer that is partially off the bottom of the screen.
1565 // In this configuration, only the top-left tile would be visible.
1566 current_screen_transform
.Translate(600, 750);
1567 current_screen_transform
.RotateAboutZAxis(45);
1568 last_screen_transform
= current_screen_transform
;
1570 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1571 current_screen_transform
, device_viewport
);
1573 client
.SetTileSize(gfx::Size(100, 100));
1574 client
.set_tree(ACTIVE_TREE
);
1576 scoped_refptr
<FakePicturePileImpl
> pile
=
1577 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1578 current_layer_bounds
);
1579 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1580 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1581 LayerTreeSettings());
1583 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1584 current_layer_contents_scale
,
1585 current_frame_time_in_seconds
, Occlusion());
1586 tiling
->UpdateAllTilePrioritiesForTesting();
1588 ASSERT_TRUE(tiling
->TileAt(0, 0));
1589 ASSERT_TRUE(tiling
->TileAt(0, 1));
1590 ASSERT_TRUE(tiling
->TileAt(1, 0));
1591 ASSERT_TRUE(tiling
->TileAt(1, 1));
1593 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1594 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1595 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1597 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1598 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1599 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1601 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1602 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1603 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1605 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1606 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1607 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1609 // Furthermore, in this scenario the bottom-right tile should have the larger
1610 // distance to visible.
1611 TilePriority top_left
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1612 TilePriority top_right
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1613 TilePriority bottom_right
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1614 EXPECT_GT(top_right
.distance_to_visible
, top_left
.distance_to_visible
);
1616 EXPECT_EQ(bottom_right
.distance_to_visible
, top_right
.distance_to_visible
);
1619 TEST(ComputeTilePriorityRectsTest
, PerspectiveLayer
) {
1620 // Perspective transforms need to take a different code path.
1621 // This test checks tile priorities of a perspective layer.
1622 FakePictureLayerTilingClient client
;
1624 gfx::Size
device_viewport(800, 600);
1625 gfx::Rect
visible_layer_rect(0, 0, 0, 0); // offscreen.
1626 gfx::Size
last_layer_bounds(200, 200);
1627 gfx::Size
current_layer_bounds(200, 200);
1628 float current_layer_contents_scale
= 1.f
;
1629 gfx::Transform last_screen_transform
;
1630 gfx::Transform current_screen_transform
;
1631 double current_frame_time_in_seconds
= 1.0;
1633 // A 3d perspective layer rotated about its Y axis, translated to almost
1634 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
1635 // the right side, so the top-left tile will technically be closer than the
1638 // Translate layer to offscreen
1639 current_screen_transform
.Translate(400.0, 630.0);
1640 // Apply perspective about the center of the layer
1641 current_screen_transform
.Translate(100.0, 100.0);
1642 current_screen_transform
.ApplyPerspectiveDepth(100.0);
1643 current_screen_transform
.RotateAboutYAxis(10.0);
1644 current_screen_transform
.Translate(-100.0, -100.0);
1645 last_screen_transform
= current_screen_transform
;
1647 // Sanity check that this transform wouldn't cause w<0 clipping.
1649 MathUtil::MapQuad(current_screen_transform
,
1650 gfx::QuadF(gfx::RectF(0, 0, 200, 200)),
1652 ASSERT_FALSE(clipped
);
1654 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1655 current_screen_transform
, device_viewport
);
1657 client
.SetTileSize(gfx::Size(100, 100));
1658 client
.set_tree(ACTIVE_TREE
);
1660 scoped_refptr
<FakePicturePileImpl
> pile
=
1661 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1662 current_layer_bounds
);
1663 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1664 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1665 LayerTreeSettings());
1667 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1668 current_layer_contents_scale
,
1669 current_frame_time_in_seconds
, Occlusion());
1670 tiling
->UpdateAllTilePrioritiesForTesting();
1672 ASSERT_TRUE(tiling
->TileAt(0, 0));
1673 ASSERT_TRUE(tiling
->TileAt(0, 1));
1674 ASSERT_TRUE(tiling
->TileAt(1, 0));
1675 ASSERT_TRUE(tiling
->TileAt(1, 1));
1677 // All tiles will have a positive distance_to_visible
1678 // and an infinite time_to_visible.
1679 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1680 EXPECT_FLOAT_EQ(priority
.distance_to_visible
, 0.f
);
1681 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1683 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1684 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1685 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1687 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1688 EXPECT_FLOAT_EQ(priority
.distance_to_visible
, 0.f
);
1689 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1691 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1692 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1693 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1695 // Furthermore, in this scenario the top-left distance_to_visible
1696 // will be smallest, followed by top-right. The bottom layers
1697 // will of course be further than the top layers.
1698 TilePriority top_left
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1699 TilePriority top_right
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1700 TilePriority bottom_left
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1701 TilePriority bottom_right
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1703 EXPECT_GT(bottom_right
.distance_to_visible
, top_right
.distance_to_visible
);
1705 EXPECT_GT(bottom_left
.distance_to_visible
, top_left
.distance_to_visible
);
1708 TEST(ComputeTilePriorityRectsTest
, PerspectiveLayerClippedByW
) {
1709 // Perspective transforms need to take a different code path.
1710 // This test checks tile priorities of a perspective layer.
1711 FakePictureLayerTilingClient client
;
1713 gfx::Size
device_viewport(800, 600);
1714 gfx::Size
last_layer_bounds(200, 200);
1715 gfx::Size
current_layer_bounds(200, 200);
1716 float current_layer_contents_scale
= 1.f
;
1717 gfx::Transform last_screen_transform
;
1718 gfx::Transform current_screen_transform
;
1719 double current_frame_time_in_seconds
= 1.0;
1721 // A 3d perspective layer rotated about its Y axis, translated to almost
1722 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
1723 // the right side, so the top-left tile will technically be closer than the
1726 // Translate layer to offscreen
1727 current_screen_transform
.Translate(400.0, 970.0);
1728 // Apply perspective and rotation about the center of the layer
1729 current_screen_transform
.Translate(100.0, 100.0);
1730 current_screen_transform
.ApplyPerspectiveDepth(10.0);
1731 current_screen_transform
.RotateAboutYAxis(10.0);
1732 current_screen_transform
.Translate(-100.0, -100.0);
1733 last_screen_transform
= current_screen_transform
;
1735 // Sanity check that this transform does cause w<0 clipping for the left side
1736 // of the layer, but not the right side.
1738 MathUtil::MapQuad(current_screen_transform
,
1739 gfx::QuadF(gfx::RectF(0, 0, 100, 200)),
1741 ASSERT_TRUE(clipped
);
1743 MathUtil::MapQuad(current_screen_transform
,
1744 gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
1746 ASSERT_FALSE(clipped
);
1748 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1749 current_screen_transform
, device_viewport
);
1751 client
.SetTileSize(gfx::Size(100, 100));
1752 client
.set_tree(ACTIVE_TREE
);
1754 scoped_refptr
<FakePicturePileImpl
> pile
=
1755 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1756 current_layer_bounds
);
1757 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1758 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1759 LayerTreeSettings());
1761 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1762 current_layer_contents_scale
,
1763 current_frame_time_in_seconds
, Occlusion());
1764 tiling
->UpdateAllTilePrioritiesForTesting();
1766 ASSERT_TRUE(tiling
->TileAt(0, 0));
1767 ASSERT_TRUE(tiling
->TileAt(0, 1));
1768 ASSERT_TRUE(tiling
->TileAt(1, 0));
1769 ASSERT_TRUE(tiling
->TileAt(1, 1));
1771 // Left-side tiles will be clipped by the transform, so we have to assume
1772 // they are visible just in case.
1773 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1774 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1775 EXPECT_FLOAT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1777 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1778 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1779 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1781 // Right-side tiles will have a positive distance_to_visible
1782 // and an infinite time_to_visible.
1783 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1784 EXPECT_FLOAT_EQ(priority
.distance_to_visible
, 0.f
);
1785 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1787 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1788 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1789 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1792 TEST(ComputeTilePriorityRectsTest
, BasicMotion
) {
1793 // Test that time_to_visible is computed correctly when
1794 // there is some motion.
1795 FakePictureLayerTilingClient client
;
1797 gfx::Size
device_viewport(800, 600);
1798 gfx::Rect
visible_layer_rect(0, 0, 0, 0);
1799 gfx::Size
last_layer_bounds(200, 200);
1800 gfx::Size
current_layer_bounds(200, 200);
1801 float last_layer_contents_scale
= 1.f
;
1802 float current_layer_contents_scale
= 1.f
;
1803 gfx::Transform last_screen_transform
;
1804 gfx::Transform current_screen_transform
;
1805 double last_frame_time_in_seconds
= 1.0;
1806 double current_frame_time_in_seconds
= 2.0;
1808 // Offscreen layer is coming closer to viewport at 1000 pixels per second.
1809 current_screen_transform
.Translate(1800, 0);
1810 last_screen_transform
.Translate(2800, 0);
1812 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1813 current_screen_transform
, device_viewport
);
1815 client
.SetTileSize(gfx::Size(100, 100));
1816 client
.set_tree(ACTIVE_TREE
);
1817 LayerTreeSettings settings
;
1818 settings
.max_tiles_for_interest_area
= 10000;
1820 scoped_refptr
<FakePicturePileImpl
> pile
=
1821 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1822 current_layer_bounds
);
1823 scoped_ptr
<TestablePictureLayerTiling
> tiling
=
1824 TestablePictureLayerTiling::Create(1.0f
, pile
, &client
, settings
);
1826 // previous ("last") frame
1827 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1828 last_layer_contents_scale
,
1829 last_frame_time_in_seconds
, Occlusion());
1832 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1833 current_layer_contents_scale
,
1834 current_frame_time_in_seconds
, Occlusion());
1835 tiling
->UpdateAllTilePrioritiesForTesting();
1837 ASSERT_TRUE(tiling
->TileAt(0, 0));
1838 ASSERT_TRUE(tiling
->TileAt(0, 1));
1839 ASSERT_TRUE(tiling
->TileAt(1, 0));
1840 ASSERT_TRUE(tiling
->TileAt(1, 1));
1842 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1843 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1844 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1846 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1847 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1848 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1850 // time_to_visible for the right hand side layers needs an extra 0.099
1851 // seconds because this tile is 99 pixels further away.
1852 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1853 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1854 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1856 priority
= tiling
->TileAt(1, 1)->priority(ACTIVE_TREE
);
1857 EXPECT_GT(priority
.distance_to_visible
, 0.f
);
1858 EXPECT_NE(TilePriority::NOW
, priority
.priority_bin
);
1861 TEST(ComputeTilePriorityRectsTest
, RotationMotion
) {
1862 // Each tile of a layer may be affected differently by a transform; Check
1863 // that ComputeTilePriorityRects correctly accounts for the transform between
1864 // layer space and screen space.
1866 FakePictureLayerTilingClient client
;
1867 scoped_ptr
<TestablePictureLayerTiling
> tiling
;
1869 gfx::Size
device_viewport(800, 600);
1870 gfx::Rect
visible_layer_rect(0, 0, 0, 0); // offscren.
1871 gfx::Size
last_layer_bounds(200, 200);
1872 gfx::Size
current_layer_bounds(200, 200);
1873 float last_layer_contents_scale
= 1.f
;
1874 float current_layer_contents_scale
= 1.f
;
1875 gfx::Transform last_screen_transform
;
1876 gfx::Transform current_screen_transform
;
1877 double last_frame_time_in_seconds
= 1.0;
1878 double current_frame_time_in_seconds
= 2.0;
1880 // Rotation motion is set up specifically so that:
1881 // - rotation occurs about the center of the layer
1882 // - the top-left tile becomes visible on rotation
1883 // - the top-right tile will have an infinite time_to_visible
1884 // because it is rotating away from viewport.
1885 // - bottom-left layer will have a positive non-zero time_to_visible
1886 // because it is rotating toward the viewport.
1887 current_screen_transform
.Translate(400, 550);
1888 current_screen_transform
.RotateAboutZAxis(45);
1890 last_screen_transform
.Translate(400, 550);
1892 gfx::Rect viewport_in_layer_space
= ViewportInLayerSpace(
1893 current_screen_transform
, device_viewport
);
1895 client
.SetTileSize(gfx::Size(100, 100));
1896 client
.set_tree(ACTIVE_TREE
);
1898 scoped_refptr
<FakePicturePileImpl
> pile
=
1899 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1900 current_layer_bounds
);
1901 tiling
= TestablePictureLayerTiling::Create(1.0f
, pile
, &client
,
1902 LayerTreeSettings());
1904 // previous ("last") frame
1905 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1906 last_layer_contents_scale
,
1907 last_frame_time_in_seconds
, Occlusion());
1910 tiling
->ComputeTilePriorityRects(viewport_in_layer_space
,
1911 current_layer_contents_scale
,
1912 current_frame_time_in_seconds
, Occlusion());
1913 tiling
->UpdateAllTilePrioritiesForTesting();
1915 ASSERT_TRUE(tiling
->TileAt(0, 0));
1916 ASSERT_TRUE(tiling
->TileAt(0, 1));
1917 ASSERT_TRUE(tiling
->TileAt(1, 0));
1918 ASSERT_TRUE(tiling
->TileAt(1, 1));
1920 TilePriority priority
= tiling
->TileAt(0, 0)->priority(ACTIVE_TREE
);
1921 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1922 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1924 priority
= tiling
->TileAt(0, 1)->priority(ACTIVE_TREE
);
1925 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1926 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1928 priority
= tiling
->TileAt(1, 0)->priority(ACTIVE_TREE
);
1929 EXPECT_FLOAT_EQ(0.f
, priority
.distance_to_visible
);
1930 EXPECT_EQ(TilePriority::NOW
, priority
.priority_bin
);
1933 TEST(PictureLayerTilingTest
, RecycledTilesCleared
) {
1934 // This test performs the following:
1936 // - Two tilings, one active one recycled with all tiles shared.
1938 // - Viewport moves somewhere far away and active tiling clears tiles.
1939 // - Viewport moves back and a new active tiling tile is created.
1941 // - Recycle tiling does _not_ have the tile in the same location (thus it
1942 // will be shared next time a pending tiling is created).
1944 FakePictureLayerTilingClient active_client
;
1946 active_client
.SetTileSize(gfx::Size(100, 100));
1947 active_client
.set_tree(ACTIVE_TREE
);
1948 LayerTreeSettings settings
;
1949 settings
.max_tiles_for_interest_area
= 10;
1951 scoped_refptr
<FakePicturePileImpl
> pile
=
1952 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1953 gfx::Size(10000, 10000));
1954 scoped_ptr
<TestablePictureLayerTiling
> active_tiling
=
1955 TestablePictureLayerTiling::Create(1.0f
, pile
, &active_client
, settings
);
1956 // Create all tiles on this tiling.
1957 active_tiling
->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f
, 1.0f
,
1960 FakePictureLayerTilingClient recycle_client
;
1961 recycle_client
.SetTileSize(gfx::Size(100, 100));
1962 recycle_client
.set_tree(PENDING_TREE
);
1963 recycle_client
.set_twin_tiling(active_tiling
.get());
1965 pile
= FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1966 gfx::Size(10000, 10000));
1967 scoped_ptr
<TestablePictureLayerTiling
> recycle_tiling
=
1968 TestablePictureLayerTiling::Create(1.0f
, pile
, &recycle_client
, settings
);
1970 // Create all tiles on the second tiling. All tiles should be shared.
1971 recycle_tiling
->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f
,
1974 // Set the second tiling as recycled.
1975 active_client
.set_twin_tiling(NULL
);
1976 active_client
.set_recycled_twin_tiling(recycle_tiling
.get());
1977 recycle_client
.set_twin_tiling(NULL
);
1979 // Verify that tiles exist and are shared.
1980 EXPECT_TRUE(active_tiling
->TileAt(0, 0));
1981 EXPECT_TRUE(recycle_tiling
->TileAt(0, 0));
1982 EXPECT_EQ(active_tiling
->TileAt(0, 0), recycle_tiling
->TileAt(0, 0));
1984 // Move the viewport far away from the (0, 0) tile.
1985 active_tiling
->ComputeTilePriorityRects(gfx::Rect(9000, 9000, 100, 100), 1.0f
,
1987 // Ensure the tile was deleted on both tilings.
1988 EXPECT_FALSE(active_tiling
->TileAt(0, 0));
1989 EXPECT_FALSE(recycle_tiling
->TileAt(0, 0));
1991 // Move the viewport back to (0, 0) tile.
1992 active_tiling
->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f
, 3.0,
1995 // Ensure that we now have a tile here on both tilings again.
1996 EXPECT_TRUE(active_tiling
->TileAt(0, 0));
1997 EXPECT_TRUE(recycle_tiling
->TileAt(0, 0));
2000 TEST(PictureLayerTilingTest
, RecycledTilesClearedOnReset
) {
2001 FakePictureLayerTilingClient active_client
;
2002 active_client
.SetTileSize(gfx::Size(100, 100));
2003 active_client
.set_tree(ACTIVE_TREE
);
2005 scoped_refptr
<FakePicturePileImpl
> pile
=
2006 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
2007 gfx::Size(100, 100));
2008 scoped_ptr
<TestablePictureLayerTiling
> active_tiling
=
2009 TestablePictureLayerTiling::Create(1.0f
, pile
, &active_client
,
2010 LayerTreeSettings());
2011 // Create all tiles on this tiling.
2012 active_tiling
->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f
, 1.0f
,
2015 FakePictureLayerTilingClient recycle_client
;
2016 recycle_client
.SetTileSize(gfx::Size(100, 100));
2017 recycle_client
.set_tree(PENDING_TREE
);
2018 recycle_client
.set_twin_tiling(active_tiling
.get());
2020 LayerTreeSettings settings
;
2021 settings
.max_tiles_for_interest_area
= 10;
2023 pile
= FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
2024 gfx::Size(100, 100));
2025 scoped_ptr
<TestablePictureLayerTiling
> recycle_tiling
=
2026 TestablePictureLayerTiling::Create(1.0f
, pile
, &recycle_client
, settings
);
2028 // Create all tiles on the recycle tiling. All tiles should be shared.
2029 recycle_tiling
->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f
,
2032 // Set the second tiling as recycled.
2033 active_client
.set_twin_tiling(NULL
);
2034 active_client
.set_recycled_twin_tiling(recycle_tiling
.get());
2035 recycle_client
.set_twin_tiling(NULL
);
2037 // Verify that tiles exist and are shared.
2038 EXPECT_TRUE(active_tiling
->TileAt(0, 0));
2039 EXPECT_TRUE(recycle_tiling
->TileAt(0, 0));
2040 EXPECT_EQ(active_tiling
->TileAt(0, 0), recycle_tiling
->TileAt(0, 0));
2042 // Reset the active tiling. The recycle tiles should be released too.
2043 active_tiling
->Reset();
2044 EXPECT_FALSE(active_tiling
->TileAt(0, 0));
2045 EXPECT_FALSE(recycle_tiling
->TileAt(0, 0));
2048 TEST_F(PictureLayerTilingIteratorTest
, ResizeTilesAndUpdateToCurrent
) {
2049 // The tiling has four rows and three columns.
2050 Initialize(gfx::Size(150, 100), 1.f
, gfx::Size(250, 150));
2051 tiling_
->CreateAllTilesForTesting();
2052 EXPECT_EQ(150, tiling_
->TilingDataForTesting().max_texture_size().width());
2053 EXPECT_EQ(100, tiling_
->TilingDataForTesting().max_texture_size().height());
2054 EXPECT_EQ(4u, tiling_
->AllRefTilesForTesting().size());
2056 client_
.SetTileSize(gfx::Size(250, 200));
2057 client_
.set_tree(PENDING_TREE
);
2059 // Tile size in the tiling should still be 150x100.
2060 EXPECT_EQ(150, tiling_
->TilingDataForTesting().max_texture_size().width());
2061 EXPECT_EQ(100, tiling_
->TilingDataForTesting().max_texture_size().height());
2063 // The layer's size isn't changed, but the tile size was.
2064 scoped_refptr
<FakePicturePileImpl
> pile
=
2065 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
2066 gfx::Size(250, 150));
2067 tiling_
->SetRasterSourceAndResize(pile
);
2069 // Tile size in the tiling should be resized to 250x200.
2070 EXPECT_EQ(250, tiling_
->TilingDataForTesting().max_texture_size().width());
2071 EXPECT_EQ(200, tiling_
->TilingDataForTesting().max_texture_size().height());
2072 EXPECT_EQ(0u, tiling_
->AllRefTilesForTesting().size());