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
22namespace cc {
23namespace {
24
25class TileManagerTest : public testing::TestWithParam<bool>,
26                        public TileManagerClient {
27 public:
28  typedef std::vector<scoped_refptr<Tile> > TileVector;
29
30  TileManagerTest()
31      : memory_limit_policy_(ALLOW_ANYTHING),
32        max_tiles_(0),
33        ready_to_activate_(false) {}
34
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
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
84  virtual void TearDown() OVERRIDE {
85    tile_manager_.reset(NULL);
86    picture_pile_ = NULL;
87
88    testing::Test::TearDown();
89  }
90
91  // TileManagerClient implementation.
92  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers()
93      const OVERRIDE {
94    return picture_layers_;
95  }
96  virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
97  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
98  virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
99                                TreePriority priority) OVERRIDE {}
100  virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
101                                  TreePriority priority) OVERRIDE {}
102
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
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
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
138  FakeTileManager* tile_manager() { return tile_manager_.get(); }
139
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
150  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.
154  bool UsingResourceLimit() { return !GetParam(); }
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
175TEST_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
200TEST_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
226TEST_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
240TEST_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
266TEST_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
292TEST_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
319TEST_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
341TEST_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
375TEST_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
409TEST_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
436TEST_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.
480INSTANTIATE_TEST_CASE_P(TileManagerTests,
481                        TileManagerTest,
482                        ::testing::Values(true, false));
483
484class LowResTilingsSettings : public ImplSidePaintingSettings {
485 public:
486  LowResTilingsSettings() { create_low_res_tiling = true; }
487};
488
489class TileManagerTilePriorityQueueTest : public testing::Test {
490 public:
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
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
517  virtual void SetUp() OVERRIDE {
518    InitializeRenderer();
519    SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
520  }
521
522  virtual void InitializeRenderer() {
523    host_impl_.InitializeRenderer(
524        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
525  }
526
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
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
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
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
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
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
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
600TEST_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
764TEST_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
931TEST_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
1048TEST_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
1095TEST_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