1 // Copyright 2013 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 "cc/resources/eviction_tile_priority_queue.h"
6 #include "cc/resources/raster_tile_priority_queue.h"
7 #include "cc/resources/tile.h"
8 #include "cc/resources/tile_priority.h"
9 #include "cc/test/fake_impl_proxy.h"
10 #include "cc/test/fake_layer_tree_host_impl.h"
11 #include "cc/test/fake_output_surface.h"
12 #include "cc/test/fake_output_surface_client.h"
13 #include "cc/test/fake_picture_layer_impl.h"
14 #include "cc/test/fake_picture_pile_impl.h"
15 #include "cc/test/fake_tile_manager.h"
16 #include "cc/test/impl_side_painting_settings.h"
17 #include "cc/test/test_shared_bitmap_manager.h"
18 #include "cc/test/test_tile_priorities.h"
19 #include "cc/trees/layer_tree_impl.h"
20 #include "testing/gtest/include/gtest/gtest.h"
21
22 namespace cc {
23 namespace {
24
25 class TileManagerTest : public testing::TestWithParam<bool>,
26 public TileManagerClient {
27 public:
28 typedef std::vector<scoped_refptr<Tile> > TileVector;
29
TileManagerTest()30 TileManagerTest()
31 : memory_limit_policy_(ALLOW_ANYTHING),
32 max_tiles_(0),
33 ready_to_activate_(false) {}
34
Initialize(int max_tiles,TileMemoryLimitPolicy memory_limit_policy,TreePriority tree_priority)35 void Initialize(int max_tiles,
36 TileMemoryLimitPolicy memory_limit_policy,
37 TreePriority tree_priority) {
38 output_surface_ = FakeOutputSurface::Create3d();
39 CHECK(output_surface_->BindToClient(&output_surface_client_));
40
41 shared_bitmap_manager_.reset(new TestSharedBitmapManager());
42 resource_provider_ = ResourceProvider::Create(output_surface_.get(),
43 shared_bitmap_manager_.get(),
44 NULL,
45 0,
46 false,
47 1,
48 false);
49 resource_pool_ = ResourcePool::Create(
50 resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
51 tile_manager_ =
52 make_scoped_ptr(new FakeTileManager(this, resource_pool_.get()));
53
54 memory_limit_policy_ = memory_limit_policy;
55 max_tiles_ = max_tiles;
56 picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
57
58 SetTreePriority(tree_priority);
59 }
60
SetTreePriority(TreePriority tree_priority)61 void SetTreePriority(TreePriority tree_priority) {
62 GlobalStateThatImpactsTilePriority state;
63 gfx::Size tile_size = settings_.default_tile_size;
64
65 if (UsingMemoryLimit()) {
66 state.soft_memory_limit_in_bytes =
67 max_tiles_ * 4 * tile_size.width() * tile_size.height();
68 state.num_resources_limit = 100;
69 } else {
70 state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
71 state.num_resources_limit = max_tiles_;
72 }
73 state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
74 state.memory_limit_policy = memory_limit_policy_;
75 state.tree_priority = tree_priority;
76
77 global_state_ = state;
78 resource_pool_->SetResourceUsageLimits(state.soft_memory_limit_in_bytes,
79 state.soft_memory_limit_in_bytes,
80 state.num_resources_limit);
81 tile_manager_->SetGlobalStateForTesting(state);
82 }
83
TearDown()84 virtual void TearDown() OVERRIDE {
85 tile_manager_.reset(NULL);
86 picture_pile_ = NULL;
87
88 testing::Test::TearDown();
89 }
90
91 // TileManagerClient implementation.
GetPictureLayers() const92 virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
93 const OVERRIDE {
94 return picture_layers_;
95 }
NotifyReadyToActivate()96 virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
NotifyTileStateChanged(const Tile * tile)97 virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
BuildRasterQueue(RasterTilePriorityQueue * queue,TreePriority priority)98 virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
99 TreePriority priority) OVERRIDE {}
BuildEvictionQueue(EvictionTilePriorityQueue * queue,TreePriority priority)100 virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
101 TreePriority priority) OVERRIDE {}
102
CreateTilesWithSize(int count,TilePriority active_priority,TilePriority pending_priority,const gfx::Size & tile_size)103 TileVector CreateTilesWithSize(int count,
104 TilePriority active_priority,
105 TilePriority pending_priority,
106 const gfx::Size& tile_size) {
107 TileVector tiles;
108 for (int i = 0; i < count; ++i) {
109 scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(),
110 tile_size,
111 gfx::Rect(),
112 1.0,
113 0,
114 0,
115 0);
116 tile->SetPriority(ACTIVE_TREE, active_priority);
117 tile->SetPriority(PENDING_TREE, pending_priority);
118 tiles.push_back(tile);
119 }
120 return tiles;
121 }
122
CreateTiles(int count,TilePriority active_priority,TilePriority pending_priority)123 TileVector CreateTiles(int count,
124 TilePriority active_priority,
125 TilePriority pending_priority) {
126 return CreateTilesWithSize(
127 count, active_priority, pending_priority, settings_.default_tile_size);
128 }
129
ReleaseTiles(TileVector * tiles)130 void ReleaseTiles(TileVector* tiles) {
131 for (TileVector::iterator it = tiles->begin(); it != tiles->end(); it++) {
132 Tile* tile = it->get();
133 tile->SetPriority(ACTIVE_TREE, TilePriority());
134 tile->SetPriority(PENDING_TREE, TilePriority());
135 }
136 }
137
tile_manager()138 FakeTileManager* tile_manager() { return tile_manager_.get(); }
139
AssignedMemoryCount(const TileVector & tiles)140 int AssignedMemoryCount(const TileVector& tiles) {
141 int has_memory_count = 0;
142 for (TileVector::const_iterator it = tiles.begin(); it != tiles.end();
143 ++it) {
144 if (tile_manager_->HasBeenAssignedMemory(it->get()))
145 ++has_memory_count;
146 }
147 return has_memory_count;
148 }
149
ready_to_activate() const150 bool ready_to_activate() const { return ready_to_activate_; }
151
152 // The parametrization specifies whether the max tile limit should
153 // be applied to memory or resources.
UsingResourceLimit()154 bool UsingResourceLimit() { return !GetParam(); }
UsingMemoryLimit()155 bool UsingMemoryLimit() { return GetParam(); }
156
157 protected:
158 GlobalStateThatImpactsTilePriority global_state_;
159
160 private:
161 LayerTreeSettings settings_;
162 scoped_ptr<FakeTileManager> tile_manager_;
163 scoped_refptr<FakePicturePileImpl> picture_pile_;
164 FakeOutputSurfaceClient output_surface_client_;
165 scoped_ptr<FakeOutputSurface> output_surface_;
166 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
167 scoped_ptr<ResourceProvider> resource_provider_;
168 scoped_ptr<ResourcePool> resource_pool_;
169 TileMemoryLimitPolicy memory_limit_policy_;
170 int max_tiles_;
171 bool ready_to_activate_;
172 std::vector<PictureLayerImpl*> picture_layers_;
173 };
174
TEST_P(TileManagerTest,EnoughMemoryAllowAnything)175 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
176 // A few tiles of each type of priority, with enough memory for all tiles.
177
178 Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
179 TileVector active_now =
180 CreateTiles(3, TilePriorityForNowBin(), TilePriority());
181 TileVector pending_now =
182 CreateTiles(3, TilePriority(), TilePriorityForNowBin());
183 TileVector active_pending_soon =
184 CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
185 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
186
187 tile_manager()->AssignMemoryToTiles(global_state_);
188
189 EXPECT_EQ(3, AssignedMemoryCount(active_now));
190 EXPECT_EQ(3, AssignedMemoryCount(pending_now));
191 EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
192 EXPECT_EQ(0, AssignedMemoryCount(never_bin));
193
194 ReleaseTiles(&active_now);
195 ReleaseTiles(&pending_now);
196 ReleaseTiles(&active_pending_soon);
197 ReleaseTiles(&never_bin);
198 }
199
TEST_P(TileManagerTest,EnoughMemoryAllowPrepaintOnly)200 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
201 // A few tiles of each type of priority, with enough memory for all tiles,
202 // with the exception of never bin.
203
204 Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY);
205 TileVector active_now =
206 CreateTiles(3, TilePriorityForNowBin(), TilePriority());
207 TileVector pending_now =
208 CreateTiles(3, TilePriority(), TilePriorityForNowBin());
209 TileVector active_pending_soon =
210 CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
211 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
212
213 tile_manager()->AssignMemoryToTiles(global_state_);
214
215 EXPECT_EQ(3, AssignedMemoryCount(active_now));
216 EXPECT_EQ(3, AssignedMemoryCount(pending_now));
217 EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
218 EXPECT_EQ(0, AssignedMemoryCount(never_bin));
219
220 ReleaseTiles(&active_now);
221 ReleaseTiles(&pending_now);
222 ReleaseTiles(&active_pending_soon);
223 ReleaseTiles(&never_bin);
224 }
225
TEST_P(TileManagerTest,EnoughMemoryPendingLowResAllowAbsoluteMinimum)226 TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
227 // A few low-res tiles required for activation, with enough memory for all
228 // tiles.
229
230 Initialize(5, ALLOW_ABSOLUTE_MINIMUM, SAME_PRIORITY_FOR_BOTH_TREES);
231 TileVector pending_low_res =
232 CreateTiles(5, TilePriority(), TilePriorityLowRes());
233
234 tile_manager()->AssignMemoryToTiles(global_state_);
235
236 EXPECT_EQ(5, AssignedMemoryCount(pending_low_res));
237 ReleaseTiles(&pending_low_res);
238 }
239
TEST_P(TileManagerTest,EnoughMemoryAllowAbsoluteMinimum)240 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
241 // A few tiles of each type of priority, with enough memory for all tiles,
242 // with the exception of never and soon bins.
243
244 Initialize(10, ALLOW_ABSOLUTE_MINIMUM, SMOOTHNESS_TAKES_PRIORITY);
245 TileVector active_now =
246 CreateTiles(3, TilePriorityForNowBin(), TilePriority());
247 TileVector pending_now =
248 CreateTiles(3, TilePriority(), TilePriorityForNowBin());
249 TileVector active_pending_soon =
250 CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
251 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
252
253 tile_manager()->AssignMemoryToTiles(global_state_);
254
255 EXPECT_EQ(3, AssignedMemoryCount(active_now));
256 EXPECT_EQ(3, AssignedMemoryCount(pending_now));
257 EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
258 EXPECT_EQ(0, AssignedMemoryCount(never_bin));
259
260 ReleaseTiles(&active_now);
261 ReleaseTiles(&pending_now);
262 ReleaseTiles(&active_pending_soon);
263 ReleaseTiles(&never_bin);
264 }
265
TEST_P(TileManagerTest,EnoughMemoryAllowNothing)266 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
267 // A few tiles of each type of priority, with enough memory for all tiles,
268 // but allow nothing should not assign any memory.
269
270 Initialize(10, ALLOW_NOTHING, SMOOTHNESS_TAKES_PRIORITY);
271 TileVector active_now =
272 CreateTiles(3, TilePriorityForNowBin(), TilePriority());
273 TileVector pending_now =
274 CreateTiles(3, TilePriority(), TilePriorityForNowBin());
275 TileVector active_pending_soon =
276 CreateTiles(3, TilePriorityForSoonBin(), TilePriorityForSoonBin());
277 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority());
278
279 tile_manager()->AssignMemoryToTiles(global_state_);
280
281 EXPECT_EQ(0, AssignedMemoryCount(active_now));
282 EXPECT_EQ(0, AssignedMemoryCount(pending_now));
283 EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
284 EXPECT_EQ(0, AssignedMemoryCount(never_bin));
285
286 ReleaseTiles(&active_now);
287 ReleaseTiles(&pending_now);
288 ReleaseTiles(&active_pending_soon);
289 ReleaseTiles(&never_bin);
290 }
291
TEST_P(TileManagerTest,PartialOOMMemoryToPending)292 TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
293 // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are
294 // required for activation, but only enough memory for 8 tiles. The result
295 // is all pending tree tiles get memory, and 3 of the active tree tiles
296 // get memory. None of these tiles is needed to avoid calimity (flickering or
297 // raster-on-demand) so the soft memory limit is used.
298
299 Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
300 TileVector active_tree_tiles =
301 CreateTiles(5, TilePriorityForEventualBin(), TilePriority());
302 TileVector pending_tree_tiles =
303 CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation());
304 tile_manager()->AssignMemoryToTiles(global_state_);
305
306 EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
307 EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
308
309 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
310 tile_manager()->AssignMemoryToTiles(global_state_);
311
312 EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
313 EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
314
315 ReleaseTiles(&active_tree_tiles);
316 ReleaseTiles(&pending_tree_tiles);
317 }
318
TEST_P(TileManagerTest,PartialOOMMemoryToActive)319 TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
320 // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin,
321 // but only enough memory for 8 tiles. The result is all active tree tiles
322 // get memory, and 3 of the pending tree tiles get memory.
323 // The pending tiles are not needed to avoid calimity (flickering or
324 // raster-on-demand) and the active tiles fit, so the soft limit is used.
325
326 Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
327 TileVector active_tree_tiles =
328 CreateTiles(5, TilePriorityForNowBin(), TilePriority());
329 TileVector pending_tree_tiles =
330 CreateTiles(5, TilePriority(), TilePriorityForNowBin());
331
332 tile_manager()->AssignMemoryToTiles(global_state_);
333
334 EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
335 EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
336
337 ReleaseTiles(&active_tree_tiles);
338 ReleaseTiles(&pending_tree_tiles);
339 }
340
TEST_P(TileManagerTest,TotalOOMMemoryToPending)341 TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
342 // 10 tiles on active tree eventually bin, 10 tiles on pending tree that are
343 // required for activation, but only enough tiles for 4 tiles. The result
344 // is 4 pending tree tiles get memory, and none of the active tree tiles
345 // get memory.
346
347 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
348 TileVector active_tree_tiles =
349 CreateTiles(10, TilePriorityForEventualBin(), TilePriority());
350 TileVector pending_tree_tiles =
351 CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
352
353 tile_manager()->AssignMemoryToTiles(global_state_);
354
355 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
356 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
357
358 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
359 tile_manager()->AssignMemoryToTiles(global_state_);
360
361 if (UsingResourceLimit()) {
362 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
363 EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
364 } else {
365 // Pending tiles are now required to avoid calimity (flickering or
366 // raster-on-demand). Hard-limit is used and double the tiles fit.
367 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
368 EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
369 }
370
371 ReleaseTiles(&active_tree_tiles);
372 ReleaseTiles(&pending_tree_tiles);
373 }
374
TEST_P(TileManagerTest,TotalOOMActiveSoonMemoryToPending)375 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
376 // 10 tiles on active tree soon bin, 10 tiles on pending tree that are
377 // required for activation, but only enough tiles for 4 tiles. The result
378 // is 4 pending tree tiles get memory, and none of the active tree tiles
379 // get memory.
380
381 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
382 TileVector active_tree_tiles =
383 CreateTiles(10, TilePriorityForSoonBin(), TilePriority());
384 TileVector pending_tree_tiles =
385 CreateTiles(10, TilePriority(), TilePriorityRequiredForActivation());
386
387 tile_manager()->AssignMemoryToTiles(global_state_);
388
389 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
390 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
391
392 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
393 tile_manager()->AssignMemoryToTiles(global_state_);
394
395 if (UsingResourceLimit()) {
396 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
397 EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles));
398 } else {
399 // Pending tiles are now required to avoid calimity (flickering or
400 // raster-on-demand). Hard-limit is used and double the tiles fit.
401 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
402 EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
403 }
404
405 ReleaseTiles(&active_tree_tiles);
406 ReleaseTiles(&pending_tree_tiles);
407 }
408
TEST_P(TileManagerTest,TotalOOMMemoryToActive)409 TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
410 // 10 tiles on active tree eventually bin, 10 tiles on pending tree now bin,
411 // but only enough memory for 4 tiles. The result is 4 active tree tiles
412 // get memory, and none of the pending tree tiles get memory.
413
414 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
415 TileVector active_tree_tiles =
416 CreateTiles(10, TilePriorityForNowBin(), TilePriority());
417 TileVector pending_tree_tiles =
418 CreateTiles(10, TilePriority(), TilePriorityForNowBin());
419
420 tile_manager()->AssignMemoryToTiles(global_state_);
421
422 if (UsingResourceLimit()) {
423 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles));
424 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
425 } else {
426 // Active tiles are required to avoid calimity (flickering or
427 // raster-on-demand). Hard-limit is used and double the tiles fit.
428 EXPECT_EQ(8, AssignedMemoryCount(active_tree_tiles));
429 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
430 }
431
432 ReleaseTiles(&active_tree_tiles);
433 ReleaseTiles(&pending_tree_tiles);
434 }
435
TEST_P(TileManagerTest,TotalOOMMemoryToNewContent)436 TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
437 // 10 tiles on active tree now bin, 10 tiles on pending tree now bin,
438 // but only enough memory for 8 tiles. Any tile missing would cause
439 // a calamity (flickering or raster-on-demand). Depending on mode,
440 // we should use varying amounts of the higher hard memory limit.
441 if (UsingResourceLimit())
442 return;
443
444 Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
445 TileVector active_tree_tiles =
446 CreateTiles(10, TilePriorityForNowBin(), TilePriority());
447 TileVector pending_tree_tiles =
448 CreateTiles(10, TilePriority(), TilePriorityForNowBin());
449
450 // Active tiles are required to avoid calimity. The hard-limit is used and all
451 // active-tiles fit. No pending tiles are needed to avoid calamity so only 10
452 // tiles total are used.
453 tile_manager()->AssignMemoryToTiles(global_state_);
454 EXPECT_EQ(10, AssignedMemoryCount(active_tree_tiles));
455 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
456
457 // Even the hard-limit won't save us now. All tiles are required to avoid
458 // a clamity but we only have 16. The tiles will be distribted randomly
459 // given they are identical, in practice depending on their screen location.
460 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
461 tile_manager()->AssignMemoryToTiles(global_state_);
462 EXPECT_EQ(16,
463 AssignedMemoryCount(active_tree_tiles) +
464 AssignedMemoryCount(pending_tree_tiles));
465
466 // The pending tree is now more important. Active tiles will take higher
467 // priority if they are ready-to-draw in practice. Importantly though,
468 // pending tiles also utilize the hard-limit.
469 SetTreePriority(NEW_CONTENT_TAKES_PRIORITY);
470 tile_manager()->AssignMemoryToTiles(global_state_);
471 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
472 EXPECT_EQ(10, AssignedMemoryCount(pending_tree_tiles));
473
474 ReleaseTiles(&active_tree_tiles);
475 ReleaseTiles(&pending_tree_tiles);
476 }
477
478 // If true, the max tile limit should be applied as bytes; if false,
479 // as num_resources_limit.
480 INSTANTIATE_TEST_CASE_P(TileManagerTests,
481 TileManagerTest,
482 ::testing::Values(true, false));
483
484 class LowResTilingsSettings : public ImplSidePaintingSettings {
485 public:
LowResTilingsSettings()486 LowResTilingsSettings() { create_low_res_tiling = true; }
487 };
488
489 class TileManagerTilePriorityQueueTest : public testing::Test {
490 public:
TileManagerTilePriorityQueueTest()491 TileManagerTilePriorityQueueTest()
492 : memory_limit_policy_(ALLOW_ANYTHING),
493 max_tiles_(10000),
494 ready_to_activate_(false),
495 id_(7),
496 proxy_(base::MessageLoopProxy::current()),
497 host_impl_(LowResTilingsSettings(), &proxy_, &shared_bitmap_manager_) {}
498
SetTreePriority(TreePriority tree_priority)499 void SetTreePriority(TreePriority tree_priority) {
500 GlobalStateThatImpactsTilePriority state;
501 gfx::Size tile_size(256, 256);
502
503 state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
504 state.num_resources_limit = max_tiles_;
505 state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
506 state.memory_limit_policy = memory_limit_policy_;
507 state.tree_priority = tree_priority;
508
509 global_state_ = state;
510 host_impl_.resource_pool()->SetResourceUsageLimits(
511 state.soft_memory_limit_in_bytes,
512 state.soft_memory_limit_in_bytes,
513 state.num_resources_limit);
514 host_impl_.tile_manager()->SetGlobalStateForTesting(state);
515 }
516
SetUp()517 virtual void SetUp() OVERRIDE {
518 InitializeRenderer();
519 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
520 }
521
InitializeRenderer()522 virtual void InitializeRenderer() {
523 host_impl_.InitializeRenderer(
524 FakeOutputSurface::Create3d().PassAs<OutputSurface>());
525 }
526
SetupDefaultTrees(const gfx::Size & layer_bounds)527 void SetupDefaultTrees(const gfx::Size& layer_bounds) {
528 gfx::Size tile_size(100, 100);
529
530 scoped_refptr<FakePicturePileImpl> pending_pile =
531 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
532 scoped_refptr<FakePicturePileImpl> active_pile =
533 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
534
535 SetupTrees(pending_pile, active_pile);
536 }
537
ActivateTree()538 void ActivateTree() {
539 host_impl_.ActivateSyncTree();
540 CHECK(!host_impl_.pending_tree());
541 pending_layer_ = NULL;
542 active_layer_ = static_cast<FakePictureLayerImpl*>(
543 host_impl_.active_tree()->LayerById(id_));
544 }
545
SetupDefaultTreesWithFixedTileSize(const gfx::Size & layer_bounds,const gfx::Size & tile_size)546 void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
547 const gfx::Size& tile_size) {
548 SetupDefaultTrees(layer_bounds);
549 pending_layer_->set_fixed_tile_size(tile_size);
550 active_layer_->set_fixed_tile_size(tile_size);
551 }
552
SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,scoped_refptr<PicturePileImpl> active_pile)553 void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
554 scoped_refptr<PicturePileImpl> active_pile) {
555 SetupPendingTree(active_pile);
556 ActivateTree();
557 SetupPendingTree(pending_pile);
558 }
559
SetupPendingTree(scoped_refptr<PicturePileImpl> pile)560 void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
561 host_impl_.CreatePendingTree();
562 LayerTreeImpl* pending_tree = host_impl_.pending_tree();
563 // Clear recycled tree.
564 pending_tree->DetachLayerTree();
565
566 scoped_ptr<FakePictureLayerImpl> pending_layer =
567 FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
568 pending_layer->SetDrawsContent(true);
569 pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
570
571 pending_layer_ = static_cast<FakePictureLayerImpl*>(
572 host_impl_.pending_tree()->LayerById(id_));
573 pending_layer_->DoPostCommitInitializationIfNeeded();
574 }
575
CreateHighLowResAndSetAllTilesVisible()576 void CreateHighLowResAndSetAllTilesVisible() {
577 // Active layer must get updated first so pending layer can share from it.
578 active_layer_->CreateDefaultTilingsAndTiles();
579 active_layer_->SetAllTilesVisible();
580 pending_layer_->CreateDefaultTilingsAndTiles();
581 pending_layer_->SetAllTilesVisible();
582 }
583
tile_manager()584 TileManager* tile_manager() { return host_impl_.tile_manager(); }
585
586 protected:
587 GlobalStateThatImpactsTilePriority global_state_;
588
589 TestSharedBitmapManager shared_bitmap_manager_;
590 TileMemoryLimitPolicy memory_limit_policy_;
591 int max_tiles_;
592 bool ready_to_activate_;
593 int id_;
594 FakeImplProxy proxy_;
595 FakeLayerTreeHostImpl host_impl_;
596 FakePictureLayerImpl* pending_layer_;
597 FakePictureLayerImpl* active_layer_;
598 };
599
TEST_F(TileManagerTilePriorityQueueTest,RasterTilePriorityQueue)600 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
601 SetupDefaultTrees(gfx::Size(1000, 1000));
602
603 active_layer_->CreateDefaultTilingsAndTiles();
604 pending_layer_->CreateDefaultTilingsAndTiles();
605
606 RasterTilePriorityQueue queue;
607 host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
608 EXPECT_FALSE(queue.IsEmpty());
609
610 size_t tile_count = 0;
611 std::set<Tile*> all_tiles;
612 while (!queue.IsEmpty()) {
613 EXPECT_TRUE(queue.Top());
614 all_tiles.insert(queue.Top());
615 ++tile_count;
616 queue.Pop();
617 }
618
619 EXPECT_EQ(tile_count, all_tiles.size());
620 EXPECT_EQ(17u, tile_count);
621
622 // Sanity check, all tiles should be visible.
623 std::set<Tile*> smoothness_tiles;
624 queue.Reset();
625 host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
626 while (!queue.IsEmpty()) {
627 Tile* tile = queue.Top();
628 EXPECT_TRUE(tile);
629 EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
630 EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
631 smoothness_tiles.insert(tile);
632 queue.Pop();
633 }
634 EXPECT_EQ(all_tiles, smoothness_tiles);
635
636 Region invalidation(gfx::Rect(0, 0, 500, 500));
637
638 // Invalidate the pending tree.
639 pending_layer_->set_invalidation(invalidation);
640 pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
641 invalidation, gfx::Size(1000, 1000));
642 pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
643 invalidation, gfx::Size(1000, 1000));
644
645 active_layer_->ResetAllTilesPriorities();
646 pending_layer_->ResetAllTilesPriorities();
647
648 // Renew all of the tile priorities.
649 gfx::Rect viewport(50, 50, 100, 100);
650 pending_layer_->HighResTiling()->UpdateTilePriorities(
651 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
652 pending_layer_->LowResTiling()->UpdateTilePriorities(
653 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
654 active_layer_->HighResTiling()->UpdateTilePriorities(
655 ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
656 active_layer_->LowResTiling()->UpdateTilePriorities(
657 ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
658
659 // Populate all tiles directly from the tilings.
660 all_tiles.clear();
661 std::vector<Tile*> pending_high_res_tiles =
662 pending_layer_->HighResTiling()->AllTilesForTesting();
663 for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
664 all_tiles.insert(pending_high_res_tiles[i]);
665
666 std::vector<Tile*> pending_low_res_tiles =
667 pending_layer_->LowResTiling()->AllTilesForTesting();
668 for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
669 all_tiles.insert(pending_low_res_tiles[i]);
670
671 std::vector<Tile*> active_high_res_tiles =
672 active_layer_->HighResTiling()->AllTilesForTesting();
673 for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
674 all_tiles.insert(active_high_res_tiles[i]);
675
676 std::vector<Tile*> active_low_res_tiles =
677 active_layer_->LowResTiling()->AllTilesForTesting();
678 for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
679 all_tiles.insert(active_low_res_tiles[i]);
680
681 Tile* last_tile = NULL;
682 smoothness_tiles.clear();
683 tile_count = 0;
684 size_t increasing_distance_tiles = 0u;
685 // Here we expect to get increasing ACTIVE_TREE priority_bin.
686 queue.Reset();
687 host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
688 while (!queue.IsEmpty()) {
689 Tile* tile = queue.Top();
690 EXPECT_TRUE(tile);
691
692 if (!last_tile)
693 last_tile = tile;
694
695 EXPECT_LE(last_tile->priority(ACTIVE_TREE).priority_bin,
696 tile->priority(ACTIVE_TREE).priority_bin);
697 if (last_tile->priority(ACTIVE_TREE).priority_bin ==
698 tile->priority(ACTIVE_TREE).priority_bin) {
699 increasing_distance_tiles +=
700 last_tile->priority(ACTIVE_TREE).distance_to_visible <=
701 tile->priority(ACTIVE_TREE).distance_to_visible;
702 }
703
704 if (tile->priority(ACTIVE_TREE).priority_bin == TilePriority::NOW &&
705 last_tile->priority(ACTIVE_TREE).resolution !=
706 tile->priority(ACTIVE_TREE).resolution) {
707 // Low resolution should come first.
708 EXPECT_EQ(LOW_RESOLUTION, last_tile->priority(ACTIVE_TREE).resolution);
709 }
710
711 last_tile = tile;
712 ++tile_count;
713 smoothness_tiles.insert(tile);
714 queue.Pop();
715 }
716
717 EXPECT_EQ(tile_count, smoothness_tiles.size());
718 EXPECT_EQ(all_tiles, smoothness_tiles);
719 // Since we don't guarantee increasing distance due to spiral iterator, we
720 // should check that we're _mostly_ right.
721 EXPECT_GT(increasing_distance_tiles, 3 * tile_count / 4);
722
723 std::set<Tile*> new_content_tiles;
724 last_tile = NULL;
725 increasing_distance_tiles = 0u;
726 // Here we expect to get increasing PENDING_TREE priority_bin.
727 queue.Reset();
728 host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
729 while (!queue.IsEmpty()) {
730 Tile* tile = queue.Top();
731 EXPECT_TRUE(tile);
732
733 if (!last_tile)
734 last_tile = tile;
735
736 EXPECT_LE(last_tile->priority(PENDING_TREE).priority_bin,
737 tile->priority(PENDING_TREE).priority_bin);
738 if (last_tile->priority(PENDING_TREE).priority_bin ==
739 tile->priority(PENDING_TREE).priority_bin) {
740 increasing_distance_tiles +=
741 last_tile->priority(PENDING_TREE).distance_to_visible <=
742 tile->priority(PENDING_TREE).distance_to_visible;
743 }
744
745 if (tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW &&
746 last_tile->priority(PENDING_TREE).resolution !=
747 tile->priority(PENDING_TREE).resolution) {
748 // High resolution should come first.
749 EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority(PENDING_TREE).resolution);
750 }
751
752 last_tile = tile;
753 new_content_tiles.insert(tile);
754 queue.Pop();
755 }
756
757 EXPECT_EQ(tile_count, new_content_tiles.size());
758 EXPECT_EQ(all_tiles, new_content_tiles);
759 // Since we don't guarantee increasing distance due to spiral iterator, we
760 // should check that we're _mostly_ right.
761 EXPECT_GT(increasing_distance_tiles, 3 * tile_count / 4);
762 }
763
TEST_F(TileManagerTilePriorityQueueTest,EvictionTilePriorityQueue)764 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
765 SetupDefaultTrees(gfx::Size(1000, 1000));
766
767 active_layer_->CreateDefaultTilingsAndTiles();
768 pending_layer_->CreateDefaultTilingsAndTiles();
769
770 EvictionTilePriorityQueue empty_queue;
771 host_impl_.BuildEvictionQueue(&empty_queue, SAME_PRIORITY_FOR_BOTH_TREES);
772 EXPECT_TRUE(empty_queue.IsEmpty());
773 std::set<Tile*> all_tiles;
774 size_t tile_count = 0;
775
776 RasterTilePriorityQueue raster_queue;
777 host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
778 while (!raster_queue.IsEmpty()) {
779 ++tile_count;
780 EXPECT_TRUE(raster_queue.Top());
781 all_tiles.insert(raster_queue.Top());
782 raster_queue.Pop();
783 }
784
785 EXPECT_EQ(tile_count, all_tiles.size());
786 EXPECT_EQ(17u, tile_count);
787
788 tile_manager()->InitializeTilesWithResourcesForTesting(
789 std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
790
791 EvictionTilePriorityQueue queue;
792 host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
793 EXPECT_FALSE(queue.IsEmpty());
794
795 // Sanity check, all tiles should be visible.
796 std::set<Tile*> smoothness_tiles;
797 while (!queue.IsEmpty()) {
798 Tile* tile = queue.Top();
799 EXPECT_TRUE(tile);
800 EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
801 EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
802 EXPECT_TRUE(tile->HasResources());
803 smoothness_tiles.insert(tile);
804 queue.Pop();
805 }
806 EXPECT_EQ(all_tiles, smoothness_tiles);
807
808 tile_manager()->ReleaseTileResourcesForTesting(
809 std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
810
811 Region invalidation(gfx::Rect(0, 0, 500, 500));
812
813 // Invalidate the pending tree.
814 pending_layer_->set_invalidation(invalidation);
815 pending_layer_->HighResTiling()->UpdateTilesToCurrentPile(
816 invalidation, gfx::Size(1000, 1000));
817 pending_layer_->LowResTiling()->UpdateTilesToCurrentPile(
818 invalidation, gfx::Size(1000, 1000));
819
820 active_layer_->ResetAllTilesPriorities();
821 pending_layer_->ResetAllTilesPriorities();
822
823 // Renew all of the tile priorities.
824 gfx::Rect viewport(50, 50, 100, 100);
825 pending_layer_->HighResTiling()->UpdateTilePriorities(
826 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
827 pending_layer_->LowResTiling()->UpdateTilePriorities(
828 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
829 active_layer_->HighResTiling()->UpdateTilePriorities(
830 ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
831 active_layer_->LowResTiling()->UpdateTilePriorities(
832 ACTIVE_TREE, viewport, 1.0f, 1.0, Occlusion());
833
834 // Populate all tiles directly from the tilings.
835 all_tiles.clear();
836 std::vector<Tile*> pending_high_res_tiles =
837 pending_layer_->HighResTiling()->AllTilesForTesting();
838 for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
839 all_tiles.insert(pending_high_res_tiles[i]);
840
841 std::vector<Tile*> pending_low_res_tiles =
842 pending_layer_->LowResTiling()->AllTilesForTesting();
843 for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
844 all_tiles.insert(pending_low_res_tiles[i]);
845
846 std::vector<Tile*> active_high_res_tiles =
847 active_layer_->HighResTiling()->AllTilesForTesting();
848 for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
849 all_tiles.insert(active_high_res_tiles[i]);
850
851 std::vector<Tile*> active_low_res_tiles =
852 active_layer_->LowResTiling()->AllTilesForTesting();
853 for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
854 all_tiles.insert(active_low_res_tiles[i]);
855
856 tile_manager()->InitializeTilesWithResourcesForTesting(
857 std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
858
859 pending_layer_->MarkVisibleResourcesAsRequired();
860
861 Tile* last_tile = NULL;
862 smoothness_tiles.clear();
863 tile_count = 0;
864 // Here we expect to get increasing ACTIVE_TREE priority_bin.
865 queue.Reset();
866 host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
867 while (!queue.IsEmpty()) {
868 Tile* tile = queue.Top();
869 EXPECT_TRUE(tile);
870 EXPECT_TRUE(tile->HasResources());
871
872 if (!last_tile)
873 last_tile = tile;
874
875 EXPECT_GE(last_tile->priority(ACTIVE_TREE).priority_bin,
876 tile->priority(ACTIVE_TREE).priority_bin);
877 if (last_tile->priority(ACTIVE_TREE).priority_bin ==
878 tile->priority(ACTIVE_TREE).priority_bin) {
879 EXPECT_LE(last_tile->required_for_activation(),
880 tile->required_for_activation());
881 if (last_tile->required_for_activation() ==
882 tile->required_for_activation()) {
883 EXPECT_GE(last_tile->priority(ACTIVE_TREE).distance_to_visible,
884 tile->priority(ACTIVE_TREE).distance_to_visible);
885 }
886 }
887
888 last_tile = tile;
889 ++tile_count;
890 smoothness_tiles.insert(tile);
891 queue.Pop();
892 }
893
894 EXPECT_EQ(tile_count, smoothness_tiles.size());
895 EXPECT_EQ(all_tiles, smoothness_tiles);
896
897 std::set<Tile*> new_content_tiles;
898 last_tile = NULL;
899 // Here we expect to get increasing PENDING_TREE priority_bin.
900 queue.Reset();
901 host_impl_.BuildEvictionQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
902 while (!queue.IsEmpty()) {
903 Tile* tile = queue.Top();
904 EXPECT_TRUE(tile);
905
906 if (!last_tile)
907 last_tile = tile;
908
909 EXPECT_GE(last_tile->priority(PENDING_TREE).priority_bin,
910 tile->priority(PENDING_TREE).priority_bin);
911 if (last_tile->priority(PENDING_TREE).priority_bin ==
912 tile->priority(PENDING_TREE).priority_bin) {
913 EXPECT_LE(last_tile->required_for_activation(),
914 tile->required_for_activation());
915 if (last_tile->required_for_activation() ==
916 tile->required_for_activation()) {
917 EXPECT_GE(last_tile->priority(PENDING_TREE).distance_to_visible,
918 tile->priority(PENDING_TREE).distance_to_visible);
919 }
920 }
921
922 last_tile = tile;
923 new_content_tiles.insert(tile);
924 queue.Pop();
925 }
926
927 EXPECT_EQ(tile_count, new_content_tiles.size());
928 EXPECT_EQ(all_tiles, new_content_tiles);
929 }
930
TEST_F(TileManagerTilePriorityQueueTest,EvictionTilePriorityQueueWithOcclusion)931 TEST_F(TileManagerTilePriorityQueueTest,
932 EvictionTilePriorityQueueWithOcclusion) {
933 gfx::Size tile_size(102, 102);
934 gfx::Size layer_bounds(1000, 1000);
935
936 scoped_refptr<FakePicturePileImpl> pending_pile =
937 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
938 SetupPendingTree(pending_pile);
939 pending_layer_->CreateDefaultTilingsAndTiles();
940
941 scoped_ptr<FakePictureLayerImpl> pending_child =
942 FakePictureLayerImpl::CreateWithPile(
943 host_impl_.pending_tree(), 2, pending_pile);
944 pending_layer_->AddChild(pending_child.PassAs<LayerImpl>());
945
946 FakePictureLayerImpl* pending_child_layer =
947 static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
948 pending_child_layer->SetDrawsContent(true);
949 pending_child_layer->DoPostCommitInitializationIfNeeded();
950 pending_child_layer->CreateDefaultTilingsAndTiles();
951
952 std::set<Tile*> all_tiles;
953 size_t tile_count = 0;
954 RasterTilePriorityQueue raster_queue;
955 host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
956 while (!raster_queue.IsEmpty()) {
957 ++tile_count;
958 EXPECT_TRUE(raster_queue.Top());
959 all_tiles.insert(raster_queue.Top());
960 raster_queue.Pop();
961 }
962 EXPECT_EQ(tile_count, all_tiles.size());
963 EXPECT_EQ(34u, tile_count);
964
965 pending_layer_->ResetAllTilesPriorities();
966
967 // Renew all of the tile priorities.
968 gfx::Rect viewport(layer_bounds);
969 pending_layer_->HighResTiling()->UpdateTilePriorities(
970 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
971 pending_layer_->LowResTiling()->UpdateTilePriorities(
972 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
973 pending_child_layer->HighResTiling()->UpdateTilePriorities(
974 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
975 pending_child_layer->LowResTiling()->UpdateTilePriorities(
976 PENDING_TREE, viewport, 1.0f, 1.0, Occlusion());
977
978 // Populate all tiles directly from the tilings.
979 all_tiles.clear();
980 std::vector<Tile*> pending_high_res_tiles =
981 pending_layer_->HighResTiling()->AllTilesForTesting();
982 for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
983 all_tiles.insert(pending_high_res_tiles[i]);
984
985 std::vector<Tile*> pending_low_res_tiles =
986 pending_layer_->LowResTiling()->AllTilesForTesting();
987 for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
988 all_tiles.insert(pending_low_res_tiles[i]);
989
990 // Set all tiles on the pending_child_layer as occluded on the pending tree.
991 std::vector<Tile*> pending_child_high_res_tiles =
992 pending_child_layer->HighResTiling()->AllTilesForTesting();
993 for (size_t i = 0; i < pending_child_high_res_tiles.size(); ++i) {
994 pending_child_high_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
995 all_tiles.insert(pending_child_high_res_tiles[i]);
996 }
997
998 std::vector<Tile*> pending_child_low_res_tiles =
999 pending_child_layer->LowResTiling()->AllTilesForTesting();
1000 for (size_t i = 0; i < pending_child_low_res_tiles.size(); ++i) {
1001 pending_child_low_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
1002 all_tiles.insert(pending_child_low_res_tiles[i]);
1003 }
1004
1005 tile_manager()->InitializeTilesWithResourcesForTesting(
1006 std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
1007
1008 // Verify occlusion is considered by EvictionTilePriorityQueue.
1009 TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
1010 size_t occluded_count = 0u;
1011 Tile* last_tile = NULL;
1012 EvictionTilePriorityQueue queue;
1013 host_impl_.BuildEvictionQueue(&queue, tree_priority);
1014 while (!queue.IsEmpty()) {
1015 Tile* tile = queue.Top();
1016 if (!last_tile)
1017 last_tile = tile;
1018
1019 bool tile_is_occluded = tile->is_occluded_for_tree_priority(tree_priority);
1020
1021 // The only way we will encounter an occluded tile after an unoccluded
1022 // tile is if the priorty bin decreased, the tile is required for
1023 // activation, or the scale changed.
1024 if (tile_is_occluded) {
1025 occluded_count++;
1026
1027 bool last_tile_is_occluded =
1028 last_tile->is_occluded_for_tree_priority(tree_priority);
1029 if (!last_tile_is_occluded) {
1030 TilePriority::PriorityBin tile_priority_bin =
1031 tile->priority_for_tree_priority(tree_priority).priority_bin;
1032 TilePriority::PriorityBin last_tile_priority_bin =
1033 last_tile->priority_for_tree_priority(tree_priority).priority_bin;
1034
1035 EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
1036 tile->required_for_activation() ||
1037 (tile->contents_scale() != last_tile->contents_scale()));
1038 }
1039 }
1040 last_tile = tile;
1041 queue.Pop();
1042 }
1043 size_t expected_occluded_count =
1044 pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
1045 EXPECT_EQ(expected_occluded_count, occluded_count);
1046 }
1047
TEST_F(TileManagerTilePriorityQueueTest,RasterTilePriorityQueueEmptyLayers)1048 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
1049 SetupDefaultTrees(gfx::Size(1000, 1000));
1050
1051 active_layer_->CreateDefaultTilingsAndTiles();
1052 pending_layer_->CreateDefaultTilingsAndTiles();
1053
1054 RasterTilePriorityQueue queue;
1055 host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1056 EXPECT_FALSE(queue.IsEmpty());
1057
1058 size_t tile_count = 0;
1059 std::set<Tile*> all_tiles;
1060 while (!queue.IsEmpty()) {
1061 EXPECT_TRUE(queue.Top());
1062 all_tiles.insert(queue.Top());
1063 ++tile_count;
1064 queue.Pop();
1065 }
1066
1067 EXPECT_EQ(tile_count, all_tiles.size());
1068 EXPECT_EQ(17u, tile_count);
1069
1070 queue.Reset();
1071 for (int i = 1; i < 10; ++i) {
1072 scoped_ptr<FakePictureLayerImpl> pending_layer =
1073 FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1074 pending_layer->SetDrawsContent(true);
1075 pending_layer->DoPostCommitInitializationIfNeeded();
1076 pending_layer->set_has_valid_tile_priorities(true);
1077 pending_layer_->AddChild(pending_layer.PassAs<LayerImpl>());
1078 }
1079
1080 host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1081 EXPECT_FALSE(queue.IsEmpty());
1082
1083 tile_count = 0;
1084 all_tiles.clear();
1085 while (!queue.IsEmpty()) {
1086 EXPECT_TRUE(queue.Top());
1087 all_tiles.insert(queue.Top());
1088 ++tile_count;
1089 queue.Pop();
1090 }
1091 EXPECT_EQ(tile_count, all_tiles.size());
1092 EXPECT_EQ(17u, tile_count);
1093 }
1094
TEST_F(TileManagerTilePriorityQueueTest,EvictionTilePriorityQueueEmptyLayers)1095 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
1096 SetupDefaultTrees(gfx::Size(1000, 1000));
1097
1098 active_layer_->CreateDefaultTilingsAndTiles();
1099 pending_layer_->CreateDefaultTilingsAndTiles();
1100
1101 RasterTilePriorityQueue raster_queue;
1102 host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES);
1103 EXPECT_FALSE(raster_queue.IsEmpty());
1104
1105 size_t tile_count = 0;
1106 std::set<Tile*> all_tiles;
1107 while (!raster_queue.IsEmpty()) {
1108 EXPECT_TRUE(raster_queue.Top());
1109 all_tiles.insert(raster_queue.Top());
1110 ++tile_count;
1111 raster_queue.Pop();
1112 }
1113 EXPECT_EQ(tile_count, all_tiles.size());
1114 EXPECT_EQ(17u, tile_count);
1115
1116 std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
1117 host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
1118
1119 EvictionTilePriorityQueue queue;
1120 for (int i = 1; i < 10; ++i) {
1121 scoped_ptr<FakePictureLayerImpl> pending_layer =
1122 FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
1123 pending_layer->SetDrawsContent(true);
1124 pending_layer->DoPostCommitInitializationIfNeeded();
1125 pending_layer->set_has_valid_tile_priorities(true);
1126 pending_layer_->AddChild(pending_layer.PassAs<LayerImpl>());
1127 }
1128
1129 host_impl_.BuildEvictionQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
1130 EXPECT_FALSE(queue.IsEmpty());
1131
1132 tile_count = 0;
1133 all_tiles.clear();
1134 while (!queue.IsEmpty()) {
1135 EXPECT_TRUE(queue.Top());
1136 all_tiles.insert(queue.Top());
1137 ++tile_count;
1138 queue.Pop();
1139 }
1140 EXPECT_EQ(tile_count, all_tiles.size());
1141 EXPECT_EQ(17u, tile_count);
1142 }
1143
1144 } // namespace
1145 } // namespace cc
1146