?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update V8 to version 4.6.65.
[chromium-blink-merge.git] / cc / tiles / picture_layer_tiling_unittest.cc
blob35d97ff31f407d88cf9a4dc25659cebc93fa6355
1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <limits>
6 #include <set>
7
8 #include "cc/base/math_util.h"
9 #include "cc/test/fake_output_surface.h"
10 #include "cc/test/fake_output_surface_client.h"
11 #include "cc/test/fake_picture_layer_tiling_client.h"
12 #include "cc/test/fake_picture_pile_impl.h"
13 #include "cc/test/test_context_provider.h"
14 #include "cc/test/test_shared_bitmap_manager.h"
15 #include "cc/tiles/picture_layer_tiling.h"
16 #include "cc/tiles/picture_layer_tiling_set.h"
17 #include "cc/trees/layer_tree_settings.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"
22
23 namespace cc {
24 namespace {
25
26 static gfx::Rect ViewportInLayerSpace(
27 const gfx::Transform& transform,
28 const gfx::Size& device_viewport) {
29
30 gfx::Transform inverse;
31 if (!transform.GetInverse(&inverse))
32 return gfx::Rect();
33
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);
37 }
38
39 class TestablePictureLayerTiling : public PictureLayerTiling {
40 public:
41 using PictureLayerTiling::SetLiveTilesRect;
42 using PictureLayerTiling::TileAt;
43
44 static scoped_ptr<TestablePictureLayerTiling> Create(
45 WhichTree tree,
46 float contents_scale,
47 scoped_refptr<RasterSource> raster_source,
48 PictureLayerTilingClient* client,
49 const LayerTreeSettings& settings) {
50 return make_scoped_ptr(new TestablePictureLayerTiling(
51 tree, contents_scale, raster_source, client,
52 settings.tiling_interest_area_padding,
53 settings.skewport_target_time_in_seconds,
54 settings.skewport_extrapolation_limit_in_content_pixels));
55 }
56
57 gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
58
59 using PictureLayerTiling::ComputeSkewport;
60 using PictureLayerTiling::RemoveTileAt;
61
62 protected:
63 TestablePictureLayerTiling(WhichTree tree,
64 float contents_scale,
65 scoped_refptr<RasterSource> raster_source,
66 PictureLayerTilingClient* client,
67 size_t tiling_interest_area_padding,
68 float skewport_target_time,
69 int skewport_extrapolation_limit)
70 : PictureLayerTiling(tree,
71 contents_scale,
72 raster_source,
73 client,
74 tiling_interest_area_padding,
75 skewport_target_time,
76 skewport_extrapolation_limit) {}
77 };
78
79 class PictureLayerTilingIteratorTest : public testing::Test {
80 public:
81 PictureLayerTilingIteratorTest() {}
82 ~PictureLayerTilingIteratorTest() override {}
83
84 void Initialize(const gfx::Size& tile_size,
85 float contents_scale,
86 const gfx::Size& layer_bounds) {
87 client_.SetTileSize(tile_size);
88 scoped_refptr<FakePicturePileImpl> pile =
89 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
90 tiling_ = TestablePictureLayerTiling::Create(
91 PENDING_TREE, contents_scale, pile, &client_, LayerTreeSettings());
92 }
93
94 void InitializeActive(const gfx::Size& tile_size,
95 float contents_scale,
96 const gfx::Size& layer_bounds) {
97 client_.SetTileSize(tile_size);
98 scoped_refptr<FakePicturePileImpl> pile =
99 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
100 tiling_ = TestablePictureLayerTiling::Create(
101 ACTIVE_TREE, contents_scale, pile, &client_, LayerTreeSettings());
102 }
103
104 void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
105 tiling_->SetLiveTilesRect(live_tiles_rect);
106
107 std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
108 for (std::vector<Tile*>::iterator iter = tiles.begin();
109 iter != tiles.end();
110 ++iter) {
111 EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
112 }
113 }
114
115 void VerifyTilesExactlyCoverRect(
116 float rect_scale,
117 const gfx::Rect& request_rect,
118 const gfx::Rect& expect_rect) {
119 EXPECT_TRUE(request_rect.Contains(expect_rect));
120
121 // Iterators are not valid if this ratio is too large (i.e. the
122 // tiling is too high-res for a low-res destination rect.) This is an
123 // artifact of snapping geometry to integer coordinates and then mapping
124 // back to floating point texture coordinates.
125 float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
126 ASSERT_LE(dest_to_contents_scale, 2.0);
127
128 Region remaining = expect_rect;
129 for (PictureLayerTiling::CoverageIterator
130 iter(tiling_.get(), rect_scale, request_rect);
131 iter;
132 ++iter) {
133 // Geometry cannot overlap previous geometry at all
134 gfx::Rect geometry = iter.geometry_rect();
135 EXPECT_TRUE(expect_rect.Contains(geometry));
136 EXPECT_TRUE(remaining.Contains(geometry));
137 remaining.Subtract(geometry);
138
139 // Sanity check that texture coords are within the texture rect.
140 gfx::RectF texture_rect = iter.texture_rect();
141 EXPECT_GE(texture_rect.x(), 0);
142 EXPECT_GE(texture_rect.y(), 0);
143 EXPECT_LE(texture_rect.right(), client_.TileSize().width());
144 EXPECT_LE(texture_rect.bottom(), client_.TileSize().height());
145 }
146
147 // The entire rect must be filled by geometry from the tiling.
148 EXPECT_TRUE(remaining.IsEmpty());
149 }
150
151 void VerifyTilesExactlyCoverRect(float rect_scale, const gfx::Rect& rect) {
152 VerifyTilesExactlyCoverRect(rect_scale, rect, rect);
153 }
154
155 void VerifyTiles(
156 float rect_scale,
157 const gfx::Rect& rect,
158 base::Callback<void(Tile* tile,
159 const gfx::Rect& geometry_rect)> callback) {
160 VerifyTiles(tiling_.get(),
161 rect_scale,
162 rect,
163 callback);
164 }
165
166 void VerifyTiles(
167 PictureLayerTiling* tiling,
168 float rect_scale,
169 const gfx::Rect& rect,
170 base::Callback<void(Tile* tile,
171 const gfx::Rect& geometry_rect)> callback) {
172 Region remaining = rect;
173 for (PictureLayerTiling::CoverageIterator iter(tiling, rect_scale, rect);
174 iter;
175 ++iter) {
176 remaining.Subtract(iter.geometry_rect());
177 callback.Run(*iter, iter.geometry_rect());
178 }
179 EXPECT_TRUE(remaining.IsEmpty());
180 }
181
182 void VerifyTilesCoverNonContainedRect(float rect_scale,
183 const gfx::Rect& dest_rect) {
184 float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
185 gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
186 gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
187 clamped_rect.Intersect(dest_rect);
188 VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
189 }
190
191 protected:
192 FakePictureLayerTilingClient client_;
193 scoped_ptr<TestablePictureLayerTiling> tiling_;
194
195 private:
196 DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
197 };
198
199 TEST_F(PictureLayerTilingIteratorTest, ResizeDeletesTiles) {
200 // Verifies that a resize with invalidation for newly exposed pixels will
201 // deletes tiles that intersect that invalidation.
202 gfx::Size tile_size(100, 100);
203 gfx::Size original_layer_size(10, 10);
204 InitializeActive(tile_size, 1.f, original_layer_size);
205 SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
206
207 // Tiling only has one tile, since its total size is less than one.
208 EXPECT_TRUE(tiling_->TileAt(0, 0));
209
210 // Stop creating tiles so that any invalidations are left as holes.
211 gfx::Size new_layer_size(200, 200);
212 scoped_refptr<FakePicturePileImpl> pile =
213 FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(new_layer_size);
214
215 Region invalidation =
216 SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
217 tiling_->SetRasterSourceAndResize(pile);
218 EXPECT_TRUE(tiling_->TileAt(0, 0));
219 tiling_->Invalidate(invalidation);
220 EXPECT_FALSE(tiling_->TileAt(0, 0));
221 }
222
223 TEST_F(PictureLayerTilingIteratorTest, CreateMissingTilesStaysInsideLiveRect) {
224 // The tiling has three rows and columns.
225 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 250));
226 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
227 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
228
229 // The live tiles rect is at the very edge of the right-most and
230 // bottom-most tiles. Their border pixels would still be inside the live
231 // tiles rect, but the tiles should not exist just for that.
232 int right = tiling_->TilingDataForTesting().TileBounds(2, 2).x();
233 int bottom = tiling_->TilingDataForTesting().TileBounds(2, 2).y();
234
235 SetLiveRectAndVerifyTiles(gfx::Rect(right, bottom));
236 EXPECT_FALSE(tiling_->TileAt(2, 0));
237 EXPECT_FALSE(tiling_->TileAt(2, 1));
238 EXPECT_FALSE(tiling_->TileAt(2, 2));
239 EXPECT_FALSE(tiling_->TileAt(1, 2));
240 EXPECT_FALSE(tiling_->TileAt(0, 2));
241
242 // Verify CreateMissingTilesInLiveTilesRect respects this.
243 tiling_->CreateMissingTilesInLiveTilesRect();
244 EXPECT_FALSE(tiling_->TileAt(2, 0));
245 EXPECT_FALSE(tiling_->TileAt(2, 1));
246 EXPECT_FALSE(tiling_->TileAt(2, 2));
247 EXPECT_FALSE(tiling_->TileAt(1, 2));
248 EXPECT_FALSE(tiling_->TileAt(0, 2));
249 }
250
251 TEST_F(PictureLayerTilingIteratorTest, ResizeTilingOverTileBorders) {
252 // The tiling has four rows and three columns.
253 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 350));
254 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
255 EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
256
257 // The live tiles rect covers the whole tiling.
258 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
259
260 // Tiles in the bottom row and right column exist.
261 EXPECT_TRUE(tiling_->TileAt(2, 0));
262 EXPECT_TRUE(tiling_->TileAt(2, 1));
263 EXPECT_TRUE(tiling_->TileAt(2, 2));
264 EXPECT_TRUE(tiling_->TileAt(2, 3));
265 EXPECT_TRUE(tiling_->TileAt(1, 3));
266 EXPECT_TRUE(tiling_->TileAt(0, 3));
267
268 int right = tiling_->TilingDataForTesting().TileBounds(2, 2).x();
269 int bottom = tiling_->TilingDataForTesting().TileBounds(2, 3).y();
270
271 // Shrink the tiling so that the last tile row/column is entirely in the
272 // border pixels of the interior tiles. That row/column is removed.
273 scoped_refptr<FakePicturePileImpl> pile =
274 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
275 gfx::Size(right + 1, bottom + 1));
276 tiling_->SetRasterSourceAndResize(pile);
277 EXPECT_EQ(2, tiling_->TilingDataForTesting().num_tiles_x());
278 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_y());
279
280 // The live tiles rect was clamped to the pile size.
281 EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
282
283 // Since the row/column is gone, the tiles should be gone too.
284 EXPECT_FALSE(tiling_->TileAt(2, 0));
285 EXPECT_FALSE(tiling_->TileAt(2, 1));
286 EXPECT_FALSE(tiling_->TileAt(2, 2));
287 EXPECT_FALSE(tiling_->TileAt(2, 3));
288 EXPECT_FALSE(tiling_->TileAt(1, 3));
289 EXPECT_FALSE(tiling_->TileAt(0, 3));
290
291 // Growing outside the current right/bottom tiles border pixels should create
292 // the tiles again, even though the live rect has not changed size.
293 pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
294 gfx::Size(right + 2, bottom + 2));
295 tiling_->SetRasterSourceAndResize(pile);
296 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
297 EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
298
299 // Not changed.
300 EXPECT_EQ(gfx::Rect(right + 1, bottom + 1), tiling_->live_tiles_rect());
301
302 // The last row/column tiles are inside the live tiles rect.
303 EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
304 tiling_->TilingDataForTesting().TileBounds(2, 0)));
305 EXPECT_TRUE(gfx::Rect(right + 1, bottom + 1).Intersects(
306 tiling_->TilingDataForTesting().TileBounds(0, 3)));
307
308 EXPECT_TRUE(tiling_->TileAt(2, 0));
309 EXPECT_TRUE(tiling_->TileAt(2, 1));
310 EXPECT_TRUE(tiling_->TileAt(2, 2));
311 EXPECT_TRUE(tiling_->TileAt(2, 3));
312 EXPECT_TRUE(tiling_->TileAt(1, 3));
313 EXPECT_TRUE(tiling_->TileAt(0, 3));
314 }
315
316 TEST_F(PictureLayerTilingIteratorTest, ResizeLiveTileRectOverTileBorders) {
317 // The tiling has three rows and columns.
318 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 350));
319 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
320 EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
321
322 // The live tiles rect covers the whole tiling.
323 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
324
325 // Tiles in the bottom row and right column exist.
326 EXPECT_TRUE(tiling_->TileAt(2, 0));
327 EXPECT_TRUE(tiling_->TileAt(2, 1));
328 EXPECT_TRUE(tiling_->TileAt(2, 2));
329 EXPECT_TRUE(tiling_->TileAt(2, 3));
330 EXPECT_TRUE(tiling_->TileAt(1, 3));
331 EXPECT_TRUE(tiling_->TileAt(0, 3));
332
333 // Shrink the live tiles rect to the very edge of the right-most and
334 // bottom-most tiles. Their border pixels would still be inside the live
335 // tiles rect, but the tiles should not exist just for that.
336 int right = tiling_->TilingDataForTesting().TileBounds(2, 3).x();
337 int bottom = tiling_->TilingDataForTesting().TileBounds(2, 3).y();
338
339 SetLiveRectAndVerifyTiles(gfx::Rect(right, bottom));
340 EXPECT_FALSE(tiling_->TileAt(2, 0));
341 EXPECT_FALSE(tiling_->TileAt(2, 1));
342 EXPECT_FALSE(tiling_->TileAt(2, 2));
343 EXPECT_FALSE(tiling_->TileAt(2, 3));
344 EXPECT_FALSE(tiling_->TileAt(1, 3));
345 EXPECT_FALSE(tiling_->TileAt(0, 3));
346
347 // Including the bottom row and right column again, should create the tiles.
348 SetLiveRectAndVerifyTiles(gfx::Rect(right + 1, bottom + 1));
349 EXPECT_TRUE(tiling_->TileAt(2, 0));
350 EXPECT_TRUE(tiling_->TileAt(2, 1));
351 EXPECT_TRUE(tiling_->TileAt(2, 2));
352 EXPECT_TRUE(tiling_->TileAt(2, 3));
353 EXPECT_TRUE(tiling_->TileAt(1, 2));
354 EXPECT_TRUE(tiling_->TileAt(0, 2));
355
356 // Shrink the live tiles rect to the very edge of the left-most and
357 // top-most tiles. Their border pixels would still be inside the live
358 // tiles rect, but the tiles should not exist just for that.
359 int left = tiling_->TilingDataForTesting().TileBounds(0, 0).right();
360 int top = tiling_->TilingDataForTesting().TileBounds(0, 0).bottom();
361
362 SetLiveRectAndVerifyTiles(gfx::Rect(left, top, 250 - left, 350 - top));
363 EXPECT_FALSE(tiling_->TileAt(0, 3));
364 EXPECT_FALSE(tiling_->TileAt(0, 2));
365 EXPECT_FALSE(tiling_->TileAt(0, 1));
366 EXPECT_FALSE(tiling_->TileAt(0, 0));
367 EXPECT_FALSE(tiling_->TileAt(1, 0));
368 EXPECT_FALSE(tiling_->TileAt(2, 0));
369
370 // Including the top row and left column again, should create the tiles.
371 SetLiveRectAndVerifyTiles(
372 gfx::Rect(left - 1, top - 1, 250 - left, 350 - top));
373 EXPECT_TRUE(tiling_->TileAt(0, 3));
374 EXPECT_TRUE(tiling_->TileAt(0, 2));
375 EXPECT_TRUE(tiling_->TileAt(0, 1));
376 EXPECT_TRUE(tiling_->TileAt(0, 0));
377 EXPECT_TRUE(tiling_->TileAt(1, 0));
378 EXPECT_TRUE(tiling_->TileAt(2, 0));
379 }
380
381 TEST_F(PictureLayerTilingIteratorTest, ResizeLiveTileRectOverSameTiles) {
382 // The tiling has four rows and three columns.
383 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(250, 350));
384 EXPECT_EQ(3, tiling_->TilingDataForTesting().num_tiles_x());
385 EXPECT_EQ(4, tiling_->TilingDataForTesting().num_tiles_y());
386
387 // The live tiles rect covers the whole tiling.
388 SetLiveRectAndVerifyTiles(gfx::Rect(250, 350));
389
390 // All tiles exist.
391 for (int i = 0; i < 3; ++i) {
392 for (int j = 0; j < 4; ++j)
393 EXPECT_TRUE(tiling_->TileAt(i, j)) << i << "," << j;
394 }
395
396 // Shrink the live tiles rect, but still cover all the tiles.
397 SetLiveRectAndVerifyTiles(gfx::Rect(1, 1, 249, 349));
398
399 // All tiles still exist.
400 for (int i = 0; i < 3; ++i) {
401 for (int j = 0; j < 4; ++j)
402 EXPECT_TRUE(tiling_->TileAt(i, j)) << i << "," << j;
403 }
404
405 // Grow the live tiles rect, but still cover all the same tiles.
406 SetLiveRectAndVerifyTiles(gfx::Rect(0, 0, 250, 350));
407
408 // All tiles still exist.
409 for (int i = 0; i < 3; ++i) {
410 for (int j = 0; j < 4; ++j)
411 EXPECT_TRUE(tiling_->TileAt(i, j)) << i << "," << j;
412 }
413 }
414
415 TEST_F(PictureLayerTilingIteratorTest, ResizeOverBorderPixelsDeletesTiles) {
416 // Verifies that a resize with invalidation for newly exposed pixels will
417 // deletes tiles that intersect that invalidation.
418 gfx::Size tile_size(100, 100);
419 gfx::Size original_layer_size(99, 99);
420 InitializeActive(tile_size, 1.f, original_layer_size);
421 SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
422
423 // Tiling only has one tile, since its total size is less than one.
424 EXPECT_TRUE(tiling_->TileAt(0, 0));
425
426 // Stop creating tiles so that any invalidations are left as holes.
427 scoped_refptr<FakePicturePileImpl> pile =
428 FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(
429 gfx::Size(200, 200));
430 tiling_->SetRasterSourceAndResize(pile);
431
432 Region invalidation =
433 SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
434 EXPECT_TRUE(tiling_->TileAt(0, 0));
435 tiling_->Invalidate(invalidation);
436 EXPECT_FALSE(tiling_->TileAt(0, 0));
437
438 // The original tile was the same size after resize, but it would include new
439 // border pixels.
440 EXPECT_EQ(gfx::Rect(original_layer_size),
441 tiling_->TilingDataForTesting().TileBounds(0, 0));
442 }
443
444 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
445 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(1099, 801));
446 SetLiveRectAndVerifyTiles(gfx::Rect(100, 100));
447 SetLiveRectAndVerifyTiles(gfx::Rect(101, 99));
448 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1));
449 SetLiveRectAndVerifyTiles(gfx::Rect(1, 801));
450 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1));
451 SetLiveRectAndVerifyTiles(gfx::Rect(201, 800));
452 }
453
454 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsNoScale) {
455 Initialize(gfx::Size(100, 100), 1.f, gfx::Size(1099, 801));
456 VerifyTilesExactlyCoverRect(1, gfx::Rect());
457 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1099, 801));
458 VerifyTilesExactlyCoverRect(1, gfx::Rect(52, 83, 789, 412));
459
460 // With borders, a size of 3x3 = 1 pixel of content.
461 Initialize(gfx::Size(3, 3), 1.f, gfx::Size(10, 10));
462 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1));
463 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2));
464 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2));
465 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2));
466 }
467
468 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsTilingScale) {
469 Initialize(gfx::Size(200, 100), 2.0f, gfx::Size(1005, 2010));
470 VerifyTilesExactlyCoverRect(1, gfx::Rect());
471 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
472 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
473
474 Initialize(gfx::Size(3, 3), 2.0f, gfx::Size(10, 10));
475 VerifyTilesExactlyCoverRect(1, gfx::Rect());
476 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1));
477 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2));
478 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2));
479 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2));
480
481 Initialize(gfx::Size(100, 200), 0.5f, gfx::Size(1005, 2010));
482 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
483 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
484
485 Initialize(gfx::Size(150, 250), 0.37f, gfx::Size(1005, 2010));
486 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
487 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
488
489 Initialize(gfx::Size(312, 123), 0.01f, gfx::Size(1005, 2010));
490 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010));
491 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381));
492 }
493
494 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsBothScale) {
495 Initialize(gfx::Size(50, 50), 4.0f, gfx::Size(800, 600));
496 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect());
497 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(0, 0, 1600, 1200));
498 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(512, 365, 253, 182));
499
500 float scale = 6.7f;
501 gfx::Size bounds(800, 600);
502 gfx::Rect full_rect(gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale)));
503 Initialize(gfx::Size(256, 512), 5.2f, bounds);
504 VerifyTilesExactlyCoverRect(scale, full_rect);
505 VerifyTilesExactlyCoverRect(scale, gfx::Rect(2014, 1579, 867, 1033));
506 }
507
508 TEST_F(PictureLayerTilingIteratorTest, IteratorEmptyRect) {
509 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600));
510
511 gfx::Rect empty;
512 PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.0f, empty);
513 EXPECT_FALSE(iter);
514 }
515
516 TEST_F(PictureLayerTilingIteratorTest, NonIntersectingRect) {
517 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600));
518 gfx::Rect non_intersecting(1000, 1000, 50, 50);
519 PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1, non_intersecting);
520 EXPECT_FALSE(iter);
521 }
522
523 TEST_F(PictureLayerTilingIteratorTest, LayerEdgeTextureCoordinates) {
524 Initialize(gfx::Size(300, 300), 1.0f, gfx::Size(256, 256));
525 // All of these sizes are 256x256, scaled and ceiled.
526 VerifyTilesExactlyCoverRect(1.0f, gfx::Rect(0, 0, 256, 256));
527 VerifyTilesExactlyCoverRect(0.8f, gfx::Rect(0, 0, 205, 205));
528 VerifyTilesExactlyCoverRect(1.2f, gfx::Rect(0, 0, 308, 308));
529 }
530
531 TEST_F(PictureLayerTilingIteratorTest, NonContainedDestRect) {
532 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(400, 400));
533
534 // Too large in all dimensions
535 VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, -1000, 2000, 2000));
536 VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, -1000, 2000, 2000));
537 VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000));
538
539 // Partially covering content, but too large
540 VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100));
541 VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100));
542 VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
543 }
544
545 TEST(PictureLayerTilingTest, SkewportLimits) {
546 FakePictureLayerTilingClient client;
547
548 gfx::Rect viewport(0, 0, 100, 100);
549 gfx::Size layer_bounds(200, 200);
550
551 client.SetTileSize(gfx::Size(100, 100));
552 LayerTreeSettings settings;
553 settings.skewport_extrapolation_limit_in_content_pixels = 75;
554
555 scoped_refptr<FakePicturePileImpl> pile =
556 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
557 scoped_ptr<TestablePictureLayerTiling> tiling =
558 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
559 settings);
560
561 tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
562
563 // Move viewport down 50 pixels in 0.5 seconds.
564 gfx::Rect down_skewport =
565 tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
566
567 EXPECT_EQ(0, down_skewport.x());
568 EXPECT_EQ(50, down_skewport.y());
569 EXPECT_EQ(100, down_skewport.width());
570 EXPECT_EQ(175, down_skewport.height());
571 EXPECT_TRUE(down_skewport.Contains(gfx::Rect(0, 50, 100, 100)));
572
573 // Move viewport down 50 and right 10 pixels.
574 gfx::Rect down_right_skewport =
575 tiling->ComputeSkewport(1.5, gfx::Rect(10, 50, 100, 100));
576
577 EXPECT_EQ(10, down_right_skewport.x());
578 EXPECT_EQ(50, down_right_skewport.y());
579 EXPECT_EQ(120, down_right_skewport.width());
580 EXPECT_EQ(175, down_right_skewport.height());
581 EXPECT_TRUE(down_right_skewport.Contains(gfx::Rect(10, 50, 100, 100)));
582
583 // Move viewport left.
584 gfx::Rect left_skewport =
585 tiling->ComputeSkewport(1.5, gfx::Rect(-50, 0, 100, 100));
586
587 EXPECT_EQ(-125, left_skewport.x());
588 EXPECT_EQ(0, left_skewport.y());
589 EXPECT_EQ(175, left_skewport.width());
590 EXPECT_EQ(100, left_skewport.height());
591 EXPECT_TRUE(left_skewport.Contains(gfx::Rect(-50, 0, 100, 100)));
592
593 // Expand viewport.
594 gfx::Rect expand_skewport =
595 tiling->ComputeSkewport(1.5, gfx::Rect(-50, -50, 200, 200));
596
597 // x and y moved by -75 (-50 - 75 = -125).
598 // right side and bottom side moved by 75 [(350 - 125) - (200 - 50) = 75].
599 EXPECT_EQ(-125, expand_skewport.x());
600 EXPECT_EQ(-125, expand_skewport.y());
601 EXPECT_EQ(350, expand_skewport.width());
602 EXPECT_EQ(350, expand_skewport.height());
603 EXPECT_TRUE(expand_skewport.Contains(gfx::Rect(-50, -50, 200, 200)));
604
605 // Expand the viewport past the limit in all directions.
606 gfx::Rect big_expand_skewport =
607 tiling->ComputeSkewport(1.5, gfx::Rect(-500, -500, 1500, 1500));
608
609 EXPECT_EQ(-575, big_expand_skewport.x());
610 EXPECT_EQ(-575, big_expand_skewport.y());
611 EXPECT_EQ(1650, big_expand_skewport.width());
612 EXPECT_EQ(1650, big_expand_skewport.height());
613 EXPECT_TRUE(big_expand_skewport.Contains(gfx::Rect(-500, -500, 1500, 1500)));
614
615 // Shrink the skewport in all directions.
616 gfx::Rect shrink_viewport =
617 tiling->ComputeSkewport(1.5, gfx::Rect(0, 0, 100, 100));
618 EXPECT_EQ(0, shrink_viewport.x());
619 EXPECT_EQ(0, shrink_viewport.y());
620 EXPECT_EQ(100, shrink_viewport.width());
621 EXPECT_EQ(100, shrink_viewport.height());
622
623 // Move the skewport really far in one direction.
624 gfx::Rect move_skewport_far =
625 tiling->ComputeSkewport(1.5, gfx::Rect(0, 5000, 100, 100));
626 EXPECT_EQ(0, move_skewport_far.x());
627 EXPECT_EQ(5000, move_skewport_far.y());
628 EXPECT_EQ(100, move_skewport_far.width());
629 EXPECT_EQ(175, move_skewport_far.height());
630 EXPECT_TRUE(move_skewport_far.Contains(gfx::Rect(0, 5000, 100, 100)));
631 }
632
633 TEST(PictureLayerTilingTest, ComputeSkewportExtremeCases) {
634 FakePictureLayerTilingClient client;
635
636 gfx::Size layer_bounds(200, 200);
637 client.SetTileSize(gfx::Size(100, 100));
638 LayerTreeSettings settings;
639 scoped_refptr<FakePicturePileImpl> pile =
640 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
641 scoped_ptr<TestablePictureLayerTiling> tiling =
642 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
643 settings);
644
645 gfx::Rect viewport1(-1918, 255860, 4010, 2356);
646 gfx::Rect viewport2(-7088, -91738, 14212, 8350);
647 gfx::Rect viewport3(-12730024, -158883296, 24607540, 14454512);
648 double time = 1.0;
649 tiling->ComputeTilePriorityRects(viewport1, 1.f, time, Occlusion());
650 time += 0.016;
651 EXPECT_TRUE(tiling->ComputeSkewport(time, viewport2).Contains(viewport2));
652 tiling->ComputeTilePriorityRects(viewport2, 1.f, time, Occlusion());
653 time += 0.016;
654 EXPECT_TRUE(tiling->ComputeSkewport(time, viewport3).Contains(viewport3));
655 }
656
657 TEST(PictureLayerTilingTest, ComputeSkewport) {
658 FakePictureLayerTilingClient client;
659
660 gfx::Rect viewport(0, 0, 100, 100);
661 gfx::Size layer_bounds(200, 200);
662
663 client.SetTileSize(gfx::Size(100, 100));
664
665 scoped_refptr<FakePicturePileImpl> pile =
666 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
667 scoped_ptr<TestablePictureLayerTiling> tiling =
668 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
669 LayerTreeSettings());
670
671 tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
672
673 // Move viewport down 50 pixels in 0.5 seconds.
674 gfx::Rect down_skewport =
675 tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
676
677 EXPECT_EQ(0, down_skewport.x());
678 EXPECT_EQ(50, down_skewport.y());
679 EXPECT_EQ(100, down_skewport.width());
680 EXPECT_EQ(200, down_skewport.height());
681
682 // Shrink viewport.
683 gfx::Rect shrink_skewport =
684 tiling->ComputeSkewport(1.5, gfx::Rect(25, 25, 50, 50));
685
686 EXPECT_EQ(25, shrink_skewport.x());
687 EXPECT_EQ(25, shrink_skewport.y());
688 EXPECT_EQ(50, shrink_skewport.width());
689 EXPECT_EQ(50, shrink_skewport.height());
690
691 // Move viewport down 50 and right 10 pixels.
692 gfx::Rect down_right_skewport =
693 tiling->ComputeSkewport(1.5, gfx::Rect(10, 50, 100, 100));
694
695 EXPECT_EQ(10, down_right_skewport.x());
696 EXPECT_EQ(50, down_right_skewport.y());
697 EXPECT_EQ(120, down_right_skewport.width());
698 EXPECT_EQ(200, down_right_skewport.height());
699
700 // Move viewport left.
701 gfx::Rect left_skewport =
702 tiling->ComputeSkewport(1.5, gfx::Rect(-20, 0, 100, 100));
703
704 EXPECT_EQ(-60, left_skewport.x());
705 EXPECT_EQ(0, left_skewport.y());
706 EXPECT_EQ(140, left_skewport.width());
707 EXPECT_EQ(100, left_skewport.height());
708
709 // Expand viewport in 0.2 seconds.
710 gfx::Rect expanded_skewport =
711 tiling->ComputeSkewport(1.2, gfx::Rect(-5, -5, 110, 110));
712
713 EXPECT_EQ(-30, expanded_skewport.x());
714 EXPECT_EQ(-30, expanded_skewport.y());
715 EXPECT_EQ(160, expanded_skewport.width());
716 EXPECT_EQ(160, expanded_skewport.height());
717 }
718
719 TEST(PictureLayerTilingTest, SkewportThroughUpdateTilePriorities) {
720 FakePictureLayerTilingClient client;
721
722 gfx::Rect viewport(0, 0, 100, 100);
723 gfx::Size layer_bounds(200, 200);
724
725 client.SetTileSize(gfx::Size(100, 100));
726
727 scoped_refptr<FakePicturePileImpl> pile =
728 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
729 scoped_ptr<TestablePictureLayerTiling> tiling =
730 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
731 LayerTreeSettings());
732
733 tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
734
735 // Move viewport down 50 pixels in 0.5 seconds.
736 gfx::Rect viewport_50 = gfx::Rect(0, 50, 100, 100);
737 gfx::Rect skewport_50 = tiling->ComputeSkewport(1.5, viewport_50);
738
739 EXPECT_EQ(gfx::Rect(0, 50, 100, 200), skewport_50);
740 tiling->ComputeTilePriorityRects(viewport_50, 1.f, 1.5, Occlusion());
741
742 gfx::Rect viewport_100 = gfx::Rect(0, 100, 100, 100);
743 gfx::Rect skewport_100 = tiling->ComputeSkewport(2.0, viewport_100);
744
745 EXPECT_EQ(gfx::Rect(0, 100, 100, 200), skewport_100);
746 tiling->ComputeTilePriorityRects(viewport_100, 1.f, 2.0, Occlusion());
747
748 // Advance time, but not the viewport.
749 gfx::Rect result = tiling->ComputeSkewport(2.5, viewport_100);
750 // Since the history did advance, we should still get a skewport but a smaller
751 // one.
752 EXPECT_EQ(gfx::Rect(0, 100, 100, 150), result);
753 tiling->ComputeTilePriorityRects(viewport_100, 1.f, 2.5, Occlusion());
754
755 // Advance time again.
756 result = tiling->ComputeSkewport(3.0, viewport_100);
757 EXPECT_EQ(viewport_100, result);
758 tiling->ComputeTilePriorityRects(viewport_100, 1.f, 3.0, Occlusion());
759
760 // Ensure we have a skewport.
761 gfx::Rect viewport_150 = gfx::Rect(0, 150, 100, 100);
762 gfx::Rect skewport_150 = tiling->ComputeSkewport(3.5, viewport_150);
763 EXPECT_EQ(gfx::Rect(0, 150, 100, 150), skewport_150);
764 tiling->ComputeTilePriorityRects(viewport_150, 1.f, 3.5, Occlusion());
765
766 // Advance the viewport, but not the time.
767 gfx::Rect viewport_200 = gfx::Rect(0, 200, 100, 100);
768 gfx::Rect skewport_200 = tiling->ComputeSkewport(3.5, viewport_200);
769 EXPECT_EQ(gfx::Rect(0, 200, 100, 300), skewport_200);
770
771 // Ensure that continued calls with the same value, produce the same skewport.
772 tiling->ComputeTilePriorityRects(viewport_150, 1.f, 3.5, Occlusion());
773 EXPECT_EQ(gfx::Rect(0, 200, 100, 300), skewport_200);
774 tiling->ComputeTilePriorityRects(viewport_150, 1.f, 3.5, Occlusion());
775 EXPECT_EQ(gfx::Rect(0, 200, 100, 300), skewport_200);
776
777 tiling->ComputeTilePriorityRects(viewport_200, 1.f, 3.5, Occlusion());
778
779 // This should never happen, but advance the viewport yet again keeping the
780 // time the same.
781 gfx::Rect viewport_250 = gfx::Rect(0, 250, 100, 100);
782 gfx::Rect skewport_250 = tiling->ComputeSkewport(3.5, viewport_250);
783 EXPECT_EQ(viewport_250, skewport_250);
784 tiling->ComputeTilePriorityRects(viewport_250, 1.f, 3.5, Occlusion());
785 }
786
787 TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
788 FakePictureLayerTilingClient client;
789
790 gfx::Rect viewport(0, 0, 100, 100);
791 gfx::Size layer_bounds(1500, 1500);
792
793 client.SetTileSize(gfx::Size(10, 10));
794 LayerTreeSettings settings;
795
796 // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
797 // The reason is that each tile has a one pixel border, so tile at (1, 2)
798 // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
799 // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
800 // tiling.
801 scoped_refptr<FakePicturePileImpl> pile =
802 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
803 scoped_ptr<TestablePictureLayerTiling> tiling =
804 TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.25f, pile, &client,
805 settings);
806 gfx::Rect viewport_in_content_space =
807 gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
808
809 tiling->ComputeTilePriorityRects(viewport, 1.f, 1.0, Occlusion());
810 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
811
812 // Compute the soon border.
813 float inset = PictureLayerTiling::CalculateSoonBorderDistance(
814 viewport_in_content_space, 1.0f / 0.25f);
815 gfx::Rect soon_rect_in_content_space = viewport_in_content_space;
816 soon_rect_in_content_space.Inset(-inset, -inset);
817
818 // Sanity checks.
819 for (int i = 0; i < 47; ++i) {
820 for (int j = 0; j < 47; ++j) {
821 EXPECT_TRUE(tiling->TileAt(i, j)) << "i: " << i << " j: " << j;
822 }
823 }
824 for (int i = 0; i < 47; ++i) {
825 EXPECT_FALSE(tiling->TileAt(i, 47)) << "i: " << i;
826 EXPECT_FALSE(tiling->TileAt(47, i)) << "i: " << i;
827 }
828
829 // No movement in the viewport implies that tiles will either be NOW
830 // or EVENTUALLY, with the exception of tiles that are between 0 and 312
831 // pixels away from the viewport, which will be in the SOON bin.
832 bool have_now = false;
833 bool have_eventually = false;
834 bool have_soon = false;
835 for (int i = 0; i < 47; ++i) {
836 for (int j = 0; j < 47; ++j) {
837 Tile* tile = tiling->TileAt(i, j);
838 PrioritizedTile prioritized_tile = prioritized_tiles[tile];
839 TilePriority priority = prioritized_tile.priority();
840
841 gfx::Rect tile_rect = tiling->TilingDataForTesting().TileBounds(i, j);
842 if (viewport_in_content_space.Intersects(tile_rect)) {
843 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
844 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
845 have_now = true;
846 } else if (soon_rect_in_content_space.Intersects(tile_rect)) {
847 EXPECT_EQ(TilePriority::SOON, priority.priority_bin);
848 have_soon = true;
849 } else {
850 EXPECT_EQ(TilePriority::EVENTUALLY, priority.priority_bin);
851 EXPECT_GT(priority.distance_to_visible, 0.f);
852 have_eventually = true;
853 }
854 }
855 }
856
857 EXPECT_TRUE(have_now);
858 EXPECT_TRUE(have_soon);
859 EXPECT_TRUE(have_eventually);
860
861 // Spot check some distances.
862 // Tile at 5, 1 should begin at 41x9 in content space (without borders),
863 // so the distance to a viewport that ends at 25x25 in content space
864 // should be 17 (41 - 25 + 1). In layer space, then that should be
865 // 17 / 0.25 = 68 pixels.
866
867 // We can verify that the content rect (with borders) is one pixel off
868 // 41,9 8x8 on all sides.
869 EXPECT_EQ(tiling->TileAt(5, 1)->content_rect().ToString(), "40,8 10x10");
870
871 TilePriority priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
872 EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
873
874 priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
875 EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
876
877 priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
878 EXPECT_FLOAT_EQ(40.f, priority.distance_to_visible);
879
880 // Move the viewport down 40 pixels.
881 viewport = gfx::Rect(0, 40, 100, 100);
882 viewport_in_content_space =
883 gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
884 gfx::Rect skewport = tiling->ComputeSkewport(2.0, viewport_in_content_space);
885
886 // Compute the soon border.
887 inset = PictureLayerTiling::CalculateSoonBorderDistance(
888 viewport_in_content_space, 1.0f / 0.25f);
889 soon_rect_in_content_space = viewport_in_content_space;
890 soon_rect_in_content_space.Inset(-inset, -inset);
891
892 EXPECT_EQ(0, skewport.x());
893 EXPECT_EQ(10, skewport.y());
894 EXPECT_EQ(25, skewport.width());
895 EXPECT_EQ(35, skewport.height());
896
897 tiling->ComputeTilePriorityRects(viewport, 1.f, 2.0, Occlusion());
898 prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
899
900 have_now = false;
901 have_eventually = false;
902 have_soon = false;
903
904 // Viewport moved, so we expect to find some NOW tiles, some SOON tiles and
905 // some EVENTUALLY tiles.
906 for (int i = 0; i < 47; ++i) {
907 for (int j = 0; j < 47; ++j) {
908 Tile* tile = tiling->TileAt(i, j);
909 TilePriority priority = prioritized_tiles[tile].priority();
910
911 gfx::Rect tile_rect = tiling->TilingDataForTesting().TileBounds(i, j);
912 if (viewport_in_content_space.Intersects(tile_rect)) {
913 EXPECT_EQ(TilePriority::NOW, priority.priority_bin) << "i: " << i
914 << " j: " << j;
915 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible) << "i: " << i
916 << " j: " << j;
917 have_now = true;
918 } else if (skewport.Intersects(tile_rect) ||
919 soon_rect_in_content_space.Intersects(tile_rect)) {
920 EXPECT_EQ(TilePriority::SOON, priority.priority_bin) << "i: " << i
921 << " j: " << j;
922 EXPECT_GT(priority.distance_to_visible, 0.f) << "i: " << i
923 << " j: " << j;
924 have_soon = true;
925 } else {
926 EXPECT_EQ(TilePriority::EVENTUALLY, priority.priority_bin)
927 << "i: " << i << " j: " << j;
928 EXPECT_GT(priority.distance_to_visible, 0.f) << "i: " << i
929 << " j: " << j;
930 have_eventually = true;
931 }
932 }
933 }
934
935 EXPECT_TRUE(have_now);
936 EXPECT_TRUE(have_soon);
937 EXPECT_TRUE(have_eventually);
938
939 priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
940 EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
941
942 priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
943 EXPECT_FLOAT_EQ(28.f, priority.distance_to_visible);
944
945 priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
946 EXPECT_FLOAT_EQ(4.f, priority.distance_to_visible);
947
948 // Change the underlying layer scale.
949 tiling->ComputeTilePriorityRects(viewport, 2.0f, 3.0, Occlusion());
950 prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
951
952 priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
953 EXPECT_FLOAT_EQ(136.f, priority.distance_to_visible);
954
955 priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
956 EXPECT_FLOAT_EQ(56.f, priority.distance_to_visible);
957
958 priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
959 EXPECT_FLOAT_EQ(8.f, priority.distance_to_visible);
960
961 // Test additional scales.
962 tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 0.2f, pile, &client,
963 LayerTreeSettings());
964 tiling->ComputeTilePriorityRects(viewport, 1.0f, 4.0, Occlusion());
965 prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
966
967 priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
968 EXPECT_FLOAT_EQ(110.f, priority.distance_to_visible);
969
970 priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
971 EXPECT_FLOAT_EQ(70.f, priority.distance_to_visible);
972
973 priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
974 EXPECT_FLOAT_EQ(60.f, priority.distance_to_visible);
975
976 tiling->ComputeTilePriorityRects(viewport, 0.5f, 5.0, Occlusion());
977 prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
978
979 priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
980 EXPECT_FLOAT_EQ(55.f, priority.distance_to_visible);
981
982 priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
983 EXPECT_FLOAT_EQ(35.f, priority.distance_to_visible);
984
985 priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
986 EXPECT_FLOAT_EQ(30.f, priority.distance_to_visible);
987 }
988
989 static void TileExists(bool exists, Tile* tile,
990 const gfx::Rect& geometry_rect) {
991 EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
992 }
993
994 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
995 gfx::Size layer_bounds(1099, 801);
996 Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
997 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
998 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
999
1000 tiling_->ComputeTilePriorityRects(
1001 gfx::Rect(layer_bounds), // visible content rect
1002 1.f, // current contents scale
1003 1.0, // current frame time
1004 Occlusion());
1005 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
1006
1007 // Make the viewport rect empty. All tiles are killed and become zombies.
1008 tiling_->ComputeTilePriorityRects(gfx::Rect(), // visible content rect
1009 1.f, // current contents scale
1010 2.0, // current frame time
1011 Occlusion());
1012 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
1013 }
1014
1015 TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
1016 gfx::Size layer_bounds(1099, 801);
1017 Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
1018 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
1019 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
1020
1021 gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
1022
1023 tiling_->ComputeTilePriorityRects(
1024 gfx::Rect(layer_bounds), // visible content rect
1025 1.f, // current contents scale
1026 1.0, // current frame time
1027 Occlusion());
1028 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
1029
1030 // If the visible content rect is empty, it should still have live tiles.
1031 tiling_->ComputeTilePriorityRects(giant_rect, // visible content rect
1032 1.f, // current contents scale
1033 2.0, // current frame time
1034 Occlusion());
1035 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
1036 }
1037
1038 TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
1039 gfx::Size layer_bounds(1099, 801);
1040 Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
1041 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
1042 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
1043
1044 // This rect does not intersect with the layer, as the layer is outside the
1045 // viewport.
1046 gfx::Rect viewport_rect(1100, 0, 1000, 1000);
1047 EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
1048
1049 tiling_->ComputeTilePriorityRects(viewport_rect, // visible content rect
1050 1.f, // current contents scale
1051 1.0, // current frame time
1052 Occlusion());
1053 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
1054 }
1055
1056 static void TilesIntersectingRectExist(const gfx::Rect& rect,
1057 bool intersect_exists,
1058 Tile* tile,
1059 const gfx::Rect& geometry_rect) {
1060 bool intersects = rect.Intersects(geometry_rect);
1061 bool expected_exists = intersect_exists ? intersects : !intersects;
1062 EXPECT_EQ(expected_exists, tile != NULL)
1063 << "Rects intersecting " << rect.ToString() << " should exist. "
1064 << "Current tile rect is " << geometry_rect.ToString();
1065 }
1066
1067 TEST_F(PictureLayerTilingIteratorTest,
1068 TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
1069 gfx::Size layer_bounds(10000, 10000);
1070 client_.SetTileSize(gfx::Size(100, 100));
1071 LayerTreeSettings settings;
1072 settings.tiling_interest_area_padding = 1;
1073
1074 scoped_refptr<FakePicturePileImpl> pile =
1075 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
1076 tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, 1.f, pile,
1077 &client_, settings);
1078 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
1079 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
1080
1081 gfx::Rect visible_rect(8000, 8000, 50, 50);
1082
1083 tiling_->ComputeTilePriorityRects(visible_rect, // visible content rect
1084 1.f, // current contents scale
1085 1.0, // current frame time
1086 Occlusion());
1087 VerifyTiles(1.f,
1088 gfx::Rect(layer_bounds),
1089 base::Bind(&TilesIntersectingRectExist, visible_rect, true));
1090 }
1091
1092 TEST(ComputeTilePriorityRectsTest, VisibleTiles) {
1093 // The TilePriority of visible tiles should have zero distance_to_visible
1094 // and time_to_visible.
1095 FakePictureLayerTilingClient client;
1096
1097 gfx::Size device_viewport(800, 600);
1098 gfx::Size last_layer_bounds(200, 200);
1099 gfx::Size current_layer_bounds(200, 200);
1100 float current_layer_contents_scale = 1.f;
1101 gfx::Transform current_screen_transform;
1102 double current_frame_time_in_seconds = 1.0;
1103
1104 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1105 current_screen_transform, device_viewport);
1106
1107 client.SetTileSize(gfx::Size(100, 100));
1108
1109 scoped_refptr<FakePicturePileImpl> pile =
1110 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1111 current_layer_bounds);
1112 scoped_ptr<TestablePictureLayerTiling> tiling =
1113 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1114 LayerTreeSettings());
1115
1116 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1117 current_layer_contents_scale,
1118 current_frame_time_in_seconds, Occlusion());
1119 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1120
1121 ASSERT_TRUE(tiling->TileAt(0, 0));
1122 ASSERT_TRUE(tiling->TileAt(0, 1));
1123 ASSERT_TRUE(tiling->TileAt(1, 0));
1124 ASSERT_TRUE(tiling->TileAt(1, 1));
1125
1126 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1127 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1128 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1129
1130 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1131 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1132 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1133
1134 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1135 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1136 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1137
1138 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1139 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1140 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1141 }
1142
1143 TEST(ComputeTilePriorityRectsTest, OffscreenTiles) {
1144 // The TilePriority of offscreen tiles (without movement) should have nonzero
1145 // distance_to_visible and infinite time_to_visible.
1146 FakePictureLayerTilingClient client;
1147
1148 gfx::Size device_viewport(800, 600);
1149 gfx::Size last_layer_bounds(200, 200);
1150 gfx::Size current_layer_bounds(200, 200);
1151 float current_layer_contents_scale = 1.f;
1152 gfx::Transform last_screen_transform;
1153 gfx::Transform current_screen_transform;
1154 double current_frame_time_in_seconds = 1.0;
1155
1156 current_screen_transform.Translate(850, 0);
1157 last_screen_transform = current_screen_transform;
1158
1159 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1160 current_screen_transform, device_viewport);
1161
1162 client.SetTileSize(gfx::Size(100, 100));
1163
1164 scoped_refptr<FakePicturePileImpl> pile =
1165 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1166 current_layer_bounds);
1167 scoped_ptr<TestablePictureLayerTiling> tiling =
1168 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1169 LayerTreeSettings());
1170
1171 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1172 current_layer_contents_scale,
1173 current_frame_time_in_seconds, Occlusion());
1174 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1175
1176 ASSERT_TRUE(tiling->TileAt(0, 0));
1177 ASSERT_TRUE(tiling->TileAt(0, 1));
1178 ASSERT_TRUE(tiling->TileAt(1, 0));
1179 ASSERT_TRUE(tiling->TileAt(1, 1));
1180
1181 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1182 EXPECT_GT(priority.distance_to_visible, 0.f);
1183 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1184
1185 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1186 EXPECT_GT(priority.distance_to_visible, 0.f);
1187 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1188
1189 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1190 EXPECT_GT(priority.distance_to_visible, 0.f);
1191 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1192
1193 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1194 EXPECT_GT(priority.distance_to_visible, 0.f);
1195 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1196
1197 // Furthermore, in this scenario tiles on the right hand side should have a
1198 // larger distance to visible.
1199 TilePriority left = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1200 TilePriority right = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1201 EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
1202
1203 left = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1204 right = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1205 EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
1206 }
1207
1208 TEST(ComputeTilePriorityRectsTest, PartiallyOffscreenLayer) {
1209 // Sanity check that a layer with some tiles visible and others offscreen has
1210 // correct TilePriorities for each tile.
1211 FakePictureLayerTilingClient client;
1212
1213 gfx::Size device_viewport(800, 600);
1214 gfx::Size last_layer_bounds(200, 200);
1215 gfx::Size current_layer_bounds(200, 200);
1216 float current_layer_contents_scale = 1.f;
1217 gfx::Transform last_screen_transform;
1218 gfx::Transform current_screen_transform;
1219 double current_frame_time_in_seconds = 1.0;
1220
1221 current_screen_transform.Translate(705, 505);
1222 last_screen_transform = current_screen_transform;
1223
1224 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1225 current_screen_transform, device_viewport);
1226
1227 client.SetTileSize(gfx::Size(100, 100));
1228
1229 scoped_refptr<FakePicturePileImpl> pile =
1230 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1231 current_layer_bounds);
1232 scoped_ptr<TestablePictureLayerTiling> tiling =
1233 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1234 LayerTreeSettings());
1235
1236 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1237 current_layer_contents_scale,
1238 current_frame_time_in_seconds, Occlusion());
1239 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1240
1241 ASSERT_TRUE(tiling->TileAt(0, 0));
1242 ASSERT_TRUE(tiling->TileAt(0, 1));
1243 ASSERT_TRUE(tiling->TileAt(1, 0));
1244 ASSERT_TRUE(tiling->TileAt(1, 1));
1245
1246 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1247 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1248 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1249
1250 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1251 EXPECT_GT(priority.distance_to_visible, 0.f);
1252 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1253
1254 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1255 EXPECT_GT(priority.distance_to_visible, 0.f);
1256 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1257
1258 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1259 EXPECT_GT(priority.distance_to_visible, 0.f);
1260 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1261 }
1262
1263 TEST(ComputeTilePriorityRectsTest, PartiallyOffscreenRotatedLayer) {
1264 // Each tile of a layer may be affected differently by a transform; Check
1265 // that ComputeTilePriorityRects correctly accounts for the transform between
1266 // layer space and screen space.
1267 FakePictureLayerTilingClient client;
1268
1269 gfx::Size device_viewport(800, 600);
1270 gfx::Size last_layer_bounds(200, 200);
1271 gfx::Size current_layer_bounds(200, 200);
1272 float current_layer_contents_scale = 1.f;
1273 gfx::Transform last_screen_transform;
1274 gfx::Transform current_screen_transform;
1275 double current_frame_time_in_seconds = 1.0;
1276
1277 // A diagonally rotated layer that is partially off the bottom of the screen.
1278 // In this configuration, only the top-left tile would be visible.
1279 current_screen_transform.Translate(600, 750);
1280 current_screen_transform.RotateAboutZAxis(45);
1281 last_screen_transform = current_screen_transform;
1282
1283 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1284 current_screen_transform, device_viewport);
1285
1286 client.SetTileSize(gfx::Size(100, 100));
1287
1288 scoped_refptr<FakePicturePileImpl> pile =
1289 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1290 current_layer_bounds);
1291 scoped_ptr<TestablePictureLayerTiling> tiling =
1292 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1293 LayerTreeSettings());
1294
1295 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1296 current_layer_contents_scale,
1297 current_frame_time_in_seconds, Occlusion());
1298 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1299
1300 ASSERT_TRUE(tiling->TileAt(0, 0));
1301 ASSERT_TRUE(tiling->TileAt(0, 1));
1302 ASSERT_TRUE(tiling->TileAt(1, 0));
1303 ASSERT_TRUE(tiling->TileAt(1, 1));
1304
1305 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1306 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1307 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1308
1309 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1310 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1311 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1312
1313 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1314 EXPECT_GT(priority.distance_to_visible, 0.f);
1315 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1316
1317 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1318 EXPECT_GT(priority.distance_to_visible, 0.f);
1319 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1320
1321 // Furthermore, in this scenario the bottom-right tile should have the larger
1322 // distance to visible.
1323 TilePriority top_left = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1324 TilePriority top_right = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1325 TilePriority bottom_right =
1326 prioritized_tiles[tiling->TileAt(1, 1)].priority();
1327 EXPECT_GT(top_right.distance_to_visible, top_left.distance_to_visible);
1328
1329 EXPECT_EQ(bottom_right.distance_to_visible, top_right.distance_to_visible);
1330 }
1331
1332 TEST(ComputeTilePriorityRectsTest, PerspectiveLayer) {
1333 // Perspective transforms need to take a different code path.
1334 // This test checks tile priorities of a perspective layer.
1335 FakePictureLayerTilingClient client;
1336
1337 gfx::Size device_viewport(800, 600);
1338 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen.
1339 gfx::Size last_layer_bounds(200, 200);
1340 gfx::Size current_layer_bounds(200, 200);
1341 float current_layer_contents_scale = 1.f;
1342 gfx::Transform last_screen_transform;
1343 gfx::Transform current_screen_transform;
1344 double current_frame_time_in_seconds = 1.0;
1345
1346 // A 3d perspective layer rotated about its Y axis, translated to almost
1347 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
1348 // the right side, so the top-left tile will technically be closer than the
1349 // top-right.
1350
1351 // Translate layer to offscreen
1352 current_screen_transform.Translate(400.0, 630.0);
1353 // Apply perspective about the center of the layer
1354 current_screen_transform.Translate(100.0, 100.0);
1355 current_screen_transform.ApplyPerspectiveDepth(100.0);
1356 current_screen_transform.RotateAboutYAxis(10.0);
1357 current_screen_transform.Translate(-100.0, -100.0);
1358 last_screen_transform = current_screen_transform;
1359
1360 // Sanity check that this transform wouldn't cause w<0 clipping.
1361 bool clipped;
1362 MathUtil::MapQuad(current_screen_transform,
1363 gfx::QuadF(gfx::RectF(0, 0, 200, 200)),
1364 &clipped);
1365 ASSERT_FALSE(clipped);
1366
1367 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1368 current_screen_transform, device_viewport);
1369
1370 client.SetTileSize(gfx::Size(100, 100));
1371
1372 scoped_refptr<FakePicturePileImpl> pile =
1373 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1374 current_layer_bounds);
1375 scoped_ptr<TestablePictureLayerTiling> tiling =
1376 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1377 LayerTreeSettings());
1378
1379 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1380 current_layer_contents_scale,
1381 current_frame_time_in_seconds, Occlusion());
1382 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1383
1384 ASSERT_TRUE(tiling->TileAt(0, 0));
1385 ASSERT_TRUE(tiling->TileAt(0, 1));
1386 ASSERT_TRUE(tiling->TileAt(1, 0));
1387 ASSERT_TRUE(tiling->TileAt(1, 1));
1388
1389 // All tiles will have a positive distance_to_visible
1390 // and an infinite time_to_visible.
1391 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1392 EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
1393 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1394
1395 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1396 EXPECT_GT(priority.distance_to_visible, 0.f);
1397 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1398
1399 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1400 EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
1401 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1402
1403 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1404 EXPECT_GT(priority.distance_to_visible, 0.f);
1405 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1406
1407 // Furthermore, in this scenario the top-left distance_to_visible
1408 // will be smallest, followed by top-right. The bottom layers
1409 // will of course be further than the top layers.
1410 TilePriority top_left = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1411 TilePriority top_right = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1412 TilePriority bottom_left = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1413 TilePriority bottom_right =
1414 prioritized_tiles[tiling->TileAt(1, 1)].priority();
1415
1416 EXPECT_GT(bottom_right.distance_to_visible, top_right.distance_to_visible);
1417
1418 EXPECT_GT(bottom_left.distance_to_visible, top_left.distance_to_visible);
1419 }
1420
1421 TEST(ComputeTilePriorityRectsTest, PerspectiveLayerClippedByW) {
1422 // Perspective transforms need to take a different code path.
1423 // This test checks tile priorities of a perspective layer.
1424 FakePictureLayerTilingClient client;
1425
1426 gfx::Size device_viewport(800, 600);
1427 gfx::Size last_layer_bounds(200, 200);
1428 gfx::Size current_layer_bounds(200, 200);
1429 float current_layer_contents_scale = 1.f;
1430 gfx::Transform last_screen_transform;
1431 gfx::Transform current_screen_transform;
1432 double current_frame_time_in_seconds = 1.0;
1433
1434 // A 3d perspective layer rotated about its Y axis, translated to almost
1435 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
1436 // the right side, so the top-left tile will technically be closer than the
1437 // top-right.
1438
1439 // Translate layer to offscreen
1440 current_screen_transform.Translate(400.0, 970.0);
1441 // Apply perspective and rotation about the center of the layer
1442 current_screen_transform.Translate(100.0, 100.0);
1443 current_screen_transform.ApplyPerspectiveDepth(10.0);
1444 current_screen_transform.RotateAboutYAxis(10.0);
1445 current_screen_transform.Translate(-100.0, -100.0);
1446 last_screen_transform = current_screen_transform;
1447
1448 // Sanity check that this transform does cause w<0 clipping for the left side
1449 // of the layer, but not the right side.
1450 bool clipped;
1451 MathUtil::MapQuad(current_screen_transform,
1452 gfx::QuadF(gfx::RectF(0, 0, 100, 200)),
1453 &clipped);
1454 ASSERT_TRUE(clipped);
1455
1456 MathUtil::MapQuad(current_screen_transform,
1457 gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
1458 &clipped);
1459 ASSERT_FALSE(clipped);
1460
1461 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1462 current_screen_transform, device_viewport);
1463
1464 client.SetTileSize(gfx::Size(100, 100));
1465
1466 scoped_refptr<FakePicturePileImpl> pile =
1467 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1468 current_layer_bounds);
1469 scoped_ptr<TestablePictureLayerTiling> tiling =
1470 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1471 LayerTreeSettings());
1472
1473 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1474 current_layer_contents_scale,
1475 current_frame_time_in_seconds, Occlusion());
1476 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1477
1478 ASSERT_TRUE(tiling->TileAt(0, 0));
1479 ASSERT_TRUE(tiling->TileAt(0, 1));
1480 ASSERT_TRUE(tiling->TileAt(1, 0));
1481 ASSERT_TRUE(tiling->TileAt(1, 1));
1482
1483 // Left-side tiles will be clipped by the transform, so we have to assume
1484 // they are visible just in case.
1485 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1486 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1487 EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
1488
1489 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1490 EXPECT_GT(priority.distance_to_visible, 0.f);
1491 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1492
1493 // Right-side tiles will have a positive distance_to_visible
1494 // and an infinite time_to_visible.
1495 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1496 EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
1497 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1498
1499 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1500 EXPECT_GT(priority.distance_to_visible, 0.f);
1501 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1502 }
1503
1504 TEST(ComputeTilePriorityRectsTest, BasicMotion) {
1505 // Test that time_to_visible is computed correctly when
1506 // there is some motion.
1507 FakePictureLayerTilingClient client;
1508
1509 gfx::Size device_viewport(800, 600);
1510 gfx::Rect visible_layer_rect(0, 0, 0, 0);
1511 gfx::Size last_layer_bounds(200, 200);
1512 gfx::Size current_layer_bounds(200, 200);
1513 float last_layer_contents_scale = 1.f;
1514 float current_layer_contents_scale = 1.f;
1515 gfx::Transform last_screen_transform;
1516 gfx::Transform current_screen_transform;
1517 double last_frame_time_in_seconds = 1.0;
1518 double current_frame_time_in_seconds = 2.0;
1519
1520 // Offscreen layer is coming closer to viewport at 1000 pixels per second.
1521 current_screen_transform.Translate(1800, 0);
1522 last_screen_transform.Translate(2800, 0);
1523
1524 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1525 current_screen_transform, device_viewport);
1526
1527 client.SetTileSize(gfx::Size(100, 100));
1528 LayerTreeSettings settings;
1529
1530 scoped_refptr<FakePicturePileImpl> pile =
1531 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1532 current_layer_bounds);
1533 scoped_ptr<TestablePictureLayerTiling> tiling =
1534 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1535 settings);
1536
1537 // previous ("last") frame
1538 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1539 last_layer_contents_scale,
1540 last_frame_time_in_seconds, Occlusion());
1541
1542 // current frame
1543 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1544 current_layer_contents_scale,
1545 current_frame_time_in_seconds, Occlusion());
1546 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1547
1548 ASSERT_TRUE(tiling->TileAt(0, 0));
1549 ASSERT_TRUE(tiling->TileAt(0, 1));
1550 ASSERT_TRUE(tiling->TileAt(1, 0));
1551 ASSERT_TRUE(tiling->TileAt(1, 1));
1552
1553 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1554 EXPECT_GT(priority.distance_to_visible, 0.f);
1555 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1556
1557 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1558 EXPECT_GT(priority.distance_to_visible, 0.f);
1559 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1560
1561 // time_to_visible for the right hand side layers needs an extra 0.099
1562 // seconds because this tile is 99 pixels further away.
1563 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1564 EXPECT_GT(priority.distance_to_visible, 0.f);
1565 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1566
1567 priority = prioritized_tiles[tiling->TileAt(1, 1)].priority();
1568 EXPECT_GT(priority.distance_to_visible, 0.f);
1569 EXPECT_NE(TilePriority::NOW, priority.priority_bin);
1570 }
1571
1572 TEST(ComputeTilePriorityRectsTest, RotationMotion) {
1573 // Each tile of a layer may be affected differently by a transform; Check
1574 // that ComputeTilePriorityRects correctly accounts for the transform between
1575 // layer space and screen space.
1576
1577 FakePictureLayerTilingClient client;
1578 scoped_ptr<TestablePictureLayerTiling> tiling;
1579
1580 gfx::Size device_viewport(800, 600);
1581 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscren.
1582 gfx::Size last_layer_bounds(200, 200);
1583 gfx::Size current_layer_bounds(200, 200);
1584 float last_layer_contents_scale = 1.f;
1585 float current_layer_contents_scale = 1.f;
1586 gfx::Transform last_screen_transform;
1587 gfx::Transform current_screen_transform;
1588 double last_frame_time_in_seconds = 1.0;
1589 double current_frame_time_in_seconds = 2.0;
1590
1591 // Rotation motion is set up specifically so that:
1592 // - rotation occurs about the center of the layer
1593 // - the top-left tile becomes visible on rotation
1594 // - the top-right tile will have an infinite time_to_visible
1595 // because it is rotating away from viewport.
1596 // - bottom-left layer will have a positive non-zero time_to_visible
1597 // because it is rotating toward the viewport.
1598 current_screen_transform.Translate(400, 550);
1599 current_screen_transform.RotateAboutZAxis(45);
1600
1601 last_screen_transform.Translate(400, 550);
1602
1603 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
1604 current_screen_transform, device_viewport);
1605
1606 client.SetTileSize(gfx::Size(100, 100));
1607
1608 scoped_refptr<FakePicturePileImpl> pile =
1609 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1610 current_layer_bounds);
1611 tiling = TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile, &client,
1612 LayerTreeSettings());
1613
1614 // previous ("last") frame
1615 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1616 last_layer_contents_scale,
1617 last_frame_time_in_seconds, Occlusion());
1618
1619 // current frame
1620 tiling->ComputeTilePriorityRects(viewport_in_layer_space,
1621 current_layer_contents_scale,
1622 current_frame_time_in_seconds, Occlusion());
1623 auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
1624
1625 ASSERT_TRUE(tiling->TileAt(0, 0));
1626 ASSERT_TRUE(tiling->TileAt(0, 1));
1627 ASSERT_TRUE(tiling->TileAt(1, 0));
1628 ASSERT_TRUE(tiling->TileAt(1, 1));
1629
1630 TilePriority priority = prioritized_tiles[tiling->TileAt(0, 0)].priority();
1631 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1632 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1633
1634 priority = prioritized_tiles[tiling->TileAt(0, 1)].priority();
1635 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1636 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1637
1638 priority = prioritized_tiles[tiling->TileAt(1, 0)].priority();
1639 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
1640 EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
1641 }
1642
1643 TEST(PictureLayerTilingTest, RecycledTilesCleared) {
1644 // This test performs the following:
1645 // Setup:
1646 // - Two tilings, one active one recycled with all tiles shared.
1647 // Procedure:
1648 // - Viewport moves somewhere far away and active tiling clears tiles.
1649 // - Viewport moves back and a new active tiling tile is created.
1650 // Result:
1651 // - Recycle tiling does _not_ have the tile in the same location (thus it
1652 // will be shared next time a pending tiling is created).
1653
1654 FakePictureLayerTilingClient active_client;
1655
1656 active_client.SetTileSize(gfx::Size(100, 100));
1657 LayerTreeSettings settings;
1658
1659 scoped_refptr<FakePicturePileImpl> pile =
1660 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1661 gfx::Size(10000, 10000));
1662 scoped_ptr<TestablePictureLayerTiling> active_tiling =
1663 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile,
1664 &active_client, settings);
1665 // Create all tiles on this tiling.
1666 active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
1667 Occlusion());
1668
1669 FakePictureLayerTilingClient recycle_client;
1670 recycle_client.SetTileSize(gfx::Size(100, 100));
1671 recycle_client.set_twin_tiling(active_tiling.get());
1672
1673 pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1674 gfx::Size(10000, 10000));
1675 scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
1676 TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, pile,
1677 &recycle_client, settings);
1678
1679 // Create all tiles on the second tiling. All tiles should be shared.
1680 recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
1681 1.0f, Occlusion());
1682
1683 // Set the second tiling as recycled.
1684 active_client.set_twin_tiling(NULL);
1685 recycle_client.set_twin_tiling(NULL);
1686
1687 EXPECT_TRUE(active_tiling->TileAt(0, 0));
1688 EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
1689
1690 // Move the viewport far away from the (0, 0) tile.
1691 active_tiling->ComputeTilePriorityRects(gfx::Rect(9000, 9000, 100, 100), 1.0f,
1692 2.0, Occlusion());
1693 // Ensure the tile was deleted.
1694 EXPECT_FALSE(active_tiling->TileAt(0, 0));
1695 EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
1696
1697 // Move the viewport back to (0, 0) tile.
1698 active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 3.0,
1699 Occlusion());
1700
1701 // Ensure that we now have a tile here on both active.
1702 EXPECT_TRUE(active_tiling->TileAt(0, 0));
1703 EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
1704 }
1705
1706 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
1707 FakePictureLayerTilingClient active_client;
1708 active_client.SetTileSize(gfx::Size(100, 100));
1709
1710 scoped_refptr<FakePicturePileImpl> pile =
1711 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1712 gfx::Size(100, 100));
1713 scoped_ptr<TestablePictureLayerTiling> active_tiling =
1714 TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, pile,
1715 &active_client, LayerTreeSettings());
1716 // Create all tiles on this tiling.
1717 active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 1.0f,
1718 Occlusion());
1719
1720 FakePictureLayerTilingClient recycle_client;
1721 recycle_client.SetTileSize(gfx::Size(100, 100));
1722 recycle_client.set_twin_tiling(active_tiling.get());
1723
1724 LayerTreeSettings settings;
1725
1726 pile = FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1727 gfx::Size(100, 100));
1728 scoped_ptr<TestablePictureLayerTiling> recycle_tiling =
1729 TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, pile,
1730 &recycle_client, settings);
1731
1732 // Create all tiles on the recycle tiling. All tiles should be shared.
1733 recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
1734 1.0f, Occlusion());
1735
1736 // Set the second tiling as recycled.
1737 active_client.set_twin_tiling(NULL);
1738 recycle_client.set_twin_tiling(NULL);
1739
1740 EXPECT_TRUE(active_tiling->TileAt(0, 0));
1741 EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
1742
1743 // Reset the active tiling. The recycle tiles should be released too.
1744 active_tiling->Reset();
1745 EXPECT_FALSE(active_tiling->TileAt(0, 0));
1746 EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
1747 }
1748
1749 TEST_F(PictureLayerTilingIteratorTest, ResizeTilesAndUpdateToCurrent) {
1750 // The tiling has four rows and three columns.
1751 Initialize(gfx::Size(150, 100), 1.f, gfx::Size(250, 150));
1752 tiling_->CreateAllTilesForTesting();
1753 EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
1754 EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
1755 EXPECT_EQ(4u, tiling_->AllTilesForTesting().size());
1756
1757 client_.SetTileSize(gfx::Size(250, 200));
1758
1759 // Tile size in the tiling should still be 150x100.
1760 EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
1761 EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
1762
1763 // The layer's size isn't changed, but the tile size was.
1764 scoped_refptr<FakePicturePileImpl> pile =
1765 FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
1766 gfx::Size(250, 150));
1767 tiling_->SetRasterSourceAndResize(pile);
1768
1769 // Tile size in the tiling should be resized to 250x200.
1770 EXPECT_EQ(250, tiling_->TilingDataForTesting().max_texture_size().width());
1771 EXPECT_EQ(200, tiling_->TilingDataForTesting().max_texture_size().height());
1772 EXPECT_EQ(0u, tiling_->AllTilesForTesting().size());
1773 }
1774
1775 // This test runs into floating point issues because of big numbers.
1776 TEST_F(PictureLayerTilingIteratorTest, GiantRect) {
1777 gfx::Size tile_size(256, 256);
1778 gfx::Size layer_size(33554432, 33554432);
1779 bool filled = false;
1780 float contents_scale = 1.f;
1781
1782 client_.SetTileSize(tile_size);
1783 scoped_refptr<FakePicturePileImpl> pile =
1784 FakePicturePileImpl::CreatePile(tile_size, layer_size, filled);
1785 tiling_ = TestablePictureLayerTiling::Create(
1786 PENDING_TREE, contents_scale, pile, &client_, LayerTreeSettings());
1787
1788 gfx::Rect content_rect(25554432, 25554432, 950, 860);
1789 VerifyTilesExactlyCoverRect(contents_scale, content_rect);
1790 }
1791
1792 } // namespace
1793 } // namespace cc