Consider occluded tiles during eviction with occluded as Tile property.

cc/resources/tile_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 937 matching lines @@
                 tile->priority(PENDING_TREE).distance_to_visible);
     }
 
     last_tile = tile;
     new_content_tiles.insert(tile);
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
+
+TEST_F(TileManagerTileIteratorTest, EvictionTileIteratorWithOcclusion) {
+  gfx::Size tile_size(102, 102);
+  gfx::Size layer_bounds(1000, 1000);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupPendingTree(pending_pile);
+  pending_layer_->CreateDefaultTilingsAndTiles();
+
+  scoped_ptr<FakePictureLayerImpl> pending_child =
+      FakePictureLayerImpl::CreateWithPile(
+          host_impl_.pending_tree(), 2, pending_pile);
+  pending_layer_->AddChild(pending_child.PassAs<LayerImpl>());
+
+  FakePictureLayerImpl* pending_child_layer =
+      static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
+  pending_child_layer->SetDrawsContent(true);
+  pending_child_layer->DoPostCommitInitializationIfNeeded();
+  pending_child_layer->CreateDefaultTilingsAndTiles();
+
+  TileManager* tile_manager = TileManagerTileIteratorTest::tile_manager();
+  EXPECT_TRUE(tile_manager);
+
+  std::vector<TileManager::PairedPictureLayer> paired_layers;
+  tile_manager->GetPairedPictureLayers(&paired_layers);
+  EXPECT_EQ(2u, paired_layers.size());
+
+  std::set<Tile*> all_tiles;
+  size_t tile_count = 0;
+  for (TileManager::RasterTileIterator raster_it(tile_manager,
+                                                 NEW_CONTENT_TAKES_PRIORITY);
+       raster_it;
+       ++raster_it) {
+    ++tile_count;
+    EXPECT_TRUE(*raster_it);
+    all_tiles.insert(*raster_it);
+  }
+  EXPECT_EQ(tile_count, all_tiles.size());
+  EXPECT_EQ(34u, tile_count);
+
+  pending_layer_->ResetAllTilesPriorities();
+
+  // Renew all of the tile priorities.
+  gfx::Rect viewport(layer_bounds);
+  pending_layer_->HighResTiling()->UpdateTilePriorities(
+      PENDING_TREE,
+      viewport,
+      1.0f,
+      1.0,
+      NULL,
+      pending_layer_->render_target(),
+      pending_layer_->draw_transform());
+  pending_layer_->LowResTiling()->UpdateTilePriorities(
+      PENDING_TREE,
+      viewport,
+      1.0f,
+      1.0,
+      NULL,
+      pending_layer_->render_target(),
+      pending_layer_->draw_transform());
+  pending_child_layer->HighResTiling()->UpdateTilePriorities(
+      PENDING_TREE,
+      viewport,
+      1.0f,
+      1.0,
+      NULL,
+      pending_child_layer->render_target(),
+      pending_child_layer->draw_transform());
+  pending_child_layer->LowResTiling()->UpdateTilePriorities(
+      PENDING_TREE,
+      viewport,
+      1.0f,
+      1.0,
+      NULL,
+      pending_child_layer->render_target(),
+      pending_child_layer->draw_transform());
+
+  // Populate all tiles directly from the tilings.
+  all_tiles.clear();
+  std::vector<Tile*> pending_high_res_tiles =
+      pending_layer_->HighResTiling()->AllTilesForTesting();
+  for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
+    all_tiles.insert(pending_high_res_tiles[i]);
+
+  std::vector<Tile*> pending_low_res_tiles =
+      pending_layer_->LowResTiling()->AllTilesForTesting();
+  for (size_t i = 0; i < pending_low_res_tiles.size(); ++i)
+    all_tiles.insert(pending_low_res_tiles[i]);
+
+  // Set all tiles on the pending_child_layer as occluded on the pending tree.
+  std::vector<Tile*> pending_child_high_res_tiles =
+      pending_child_layer->HighResTiling()->AllTilesForTesting();
+  for (size_t i = 0; i < pending_child_high_res_tiles.size(); ++i) {
+    pending_child_high_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
+    all_tiles.insert(pending_child_high_res_tiles[i]);
+  }
+
+  std::vector<Tile*> pending_child_low_res_tiles =
+      pending_child_layer->LowResTiling()->AllTilesForTesting();
+  for (size_t i = 0; i < pending_child_low_res_tiles.size(); ++i) {
+    pending_child_low_res_tiles[i]->set_is_occluded(PENDING_TREE, true);
+    all_tiles.insert(pending_child_low_res_tiles[i]);
+  }
+
+  tile_manager->InitializeTilesWithResourcesForTesting(
+      std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
+
+  // Verify occlusion is considered by EvictionTileIterator.
+  TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;

[vmpstr, 2014/07/14 18:42:20]

From my understanding, this mode would normally force active tree tiles to be
evicted first, but now we get pending tree ones because of occlusion. Is that
correct?

What I'm asking I guess is without the tile manager changes, this test fails,
right?

[jbedley, 2014/07/14 19:31:33]

By using NEW_CONTENT_TAKES_PRIORITY, only the pending tree priorities are
considered during eviction. So if there were active-tree-only tiles then they
would have the default low pending tree priorities (EVENTUALLY bin with infinite
distance from visible) and they would be evicted first.

In this test, there are two layers on the pending tree and the child layer's
tiles have all been marked as occluded on the pending tree.
Yes, without the tile manager changes this test fails. The EvictionTileIterator
alternates between the two layers so it returns alternating occluded and
unoccluded tiles. With the tile manager changes, all the occluded tiles are
returned first, as they should be.

[vmpstr, 2014/07/14 19:33:13]

Awesome, thanks.

[danakj, 2014/07/15 21:26:51]

What happens for unshared tiles in the SAME_PRIORITY_FOR_BOTH_TREES case? It
seems like they'll only be occluded if they are considered occluded in both
trees, but they are not shared, so can they ever be occluded?

[jbedley, 2014/07/16 16:09:31]

That is correct. Unshared tiles will be considered unoccluded on whatever tree
they aren't on so they will be unoccluded for SAME_PRIORITY_FOR_BOTH_TREES.

[danakj, 2014/07/16 22:30:47]

Hm, I think there's 2 problems with this SAME_PRIORITY situation.

1. If the tile is not shared, we can never evict it, which isn't right. Because
we && with an unset occlusion which means we're never occluded.

2. If the tile is shared but the tile is not visible on the other tree, we won't
have set the occlusion, so we won't be able to evict it based on occlusion in
our tree.

If you like you could file a bug about this and follow up on this in a separate
CL instead of continuing on this CL.

My thoughts on this after talking with vlad some are:

1. We could do this by being able to distinguish "unset occlusion" from "not
occluded" and "is occluded", making the occluded state an enum instead of a
bool.

but.. that's not quite enough..

2. Right now we decide to evict by doing like
- should we evict for reason A? and we && the answer from pending and active
- should we evict for reason B? and we && the answer from pending and active.

But then "should we evict for occlusion" means it has to be unoccluded on both
trees. But that's not quite the right answer.

Instead we could do
- Should we evict from the pending tree's perspective?
  (it goes off and thinks about reason A B and C).
- Should we evict from the active tree's perspective?
  (it goes off and thinks about reason A B and C).
- Then for SAME_PRIO we && the two final answers, and for !SAME_PRIO we just use
one of them.
At that point maybe the pending tree has it occluded, but the active tree has
the tile outside the viewport, with unknown occlusion, but it's far enough away
that it wants to evict too. Then we would.

WDYT?

+  size_t occluded_count = 0u;
+  Tile* last_tile = NULL;
+  for (TileManager::EvictionTileIterator it(tile_manager, tree_priority); it;
+       ++it) {
+    Tile* tile = *it;
+    if (!last_tile)
+      last_tile = tile;
+
+    bool tile_is_occluded = tile->is_occluded_for_tree_priority(tree_priority);
+
+    // The only way we will encounter an occluded tile after an unoccluded
+    // tile is if the priorty bin decreased, the tile is required for
+    // activation, or the scale changed.
+    if (tile_is_occluded) {
+      occluded_count++;
+
+      bool last_tile_is_occluded =
+          last_tile->is_occluded_for_tree_priority(tree_priority);
+      if (!last_tile_is_occluded) {
+        TilePriority::PriorityBin tile_priority_bin =
+            tile->priority_for_tree_priority(tree_priority).priority_bin;
+        TilePriority::PriorityBin last_tile_priority_bin =
+            last_tile->priority_for_tree_priority(tree_priority).priority_bin;
+
+        EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
+                    tile->required_for_activation() ||
+                    (tile->contents_scale() != last_tile->contents_scale()));
+      }
+    }
+    last_tile = tile;
+  }
+  size_t expected_occluded_count =
+      pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
+  EXPECT_EQ(expected_occluded_count, occluded_count);
+}
 }  // namespace
 }  // namespace cc