Consider occluded tiles during eviction with occluded as Tile property.

cc/layers/picture_layer_impl_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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 3186 matching lines @@
         EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
 
         // Unshared tiles are occluded on the active tree iff they lie beneath
         // the occluding layer.
         EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
                   scaled_content_rect.x() >= occluding_layer_position.x());
       }
     }
   }
 }
+
+TEST_F(OcclusionTrackingPictureLayerImplTest,
+       OccludedTilesConsideredDuringEviction) {
+  gfx::Size tile_size(102, 102);
+  gfx::Size layer_bounds(1000, 1000);
+  gfx::Size viewport_size(500, 500);
+  gfx::Point occluding_layer_position(310, 0);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupPendingTree(pending_pile);
+  pending_layer_->set_fixed_tile_size(tile_size);
+
+  ASSERT_TRUE(pending_layer_->CanHaveTilings());
+
+  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+
+  std::vector<PictureLayerTiling*> tilings;
+  tilings.push_back(pending_layer_->AddTiling(low_res_factor));
+  tilings.push_back(pending_layer_->AddTiling(0.3f));
+  tilings.push_back(pending_layer_->AddTiling(0.7f));
+  tilings.push_back(pending_layer_->AddTiling(1.0f));
+  tilings.push_back(pending_layer_->AddTiling(2.0f));
+
+  pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
+  LayerImpl* layer1 = pending_layer_->children()[0];
+  layer1->SetBounds(layer_bounds);
+  layer1->SetContentBounds(layer_bounds);
+  layer1->SetDrawsContent(true);
+
+  // No occlusion.
+  layer1->SetContentsOpaque(false);
+
+  host_impl_.SetViewportSize(viewport_size);
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  std::vector<Tile*> all_tiles;
+  for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
+           tilings.begin();
+       tiling_iterator != tilings.end();
+       ++tiling_iterator) {
+    std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
+    std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
+  }
+
+  host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
+
+  int occluded_tile_count = 0;
+  Tile* last_tile = NULL;
+  for (PictureLayerImpl::LayerEvictionTileIterator it =
+           PictureLayerImpl::LayerEvictionTileIterator(
+               pending_layer_, NEW_CONTENT_TAKES_PRIORITY);

[danakj, 2014/07/09 17:38:40]

what about the SAME_PRIORITY_FOR_BOTH_TREES case? if a tile is not shared would
it just default to being unoccluded always?

should we be testing all 3 priorities?

[jbedley, 2014/07/11 00:19:38]

I added all 6 cases to the test (pending or active layer for 3 priorities).

+       it;
+       ++it) {
+    Tile* tile = *it;
+    if (!last_tile)
+      last_tile = tile;
+
+    EXPECT_TRUE(tile);
+
+    if (tile->is_occluded(PENDING_TREE)) {
+      occluded_tile_count++;
+      // Occluded tiles should be evicted first within each tiling.
+      if (!last_tile->is_occluded(PENDING_TREE))
+        EXPECT_NE(tile->contents_scale(), last_tile->contents_scale());
+    }
+
+    last_tile = tile;
+  }
+  EXPECT_EQ(occluded_tile_count, 0);
+
+  // Partial occlusion.
+  layer1->SetContentsOpaque(true);
+  layer1->SetPosition(occluding_layer_position);
+
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  occluded_tile_count = 0;
+  last_tile = NULL;
+  for (PictureLayerImpl::LayerEvictionTileIterator it =
+           PictureLayerImpl::LayerEvictionTileIterator(
+               pending_layer_, NEW_CONTENT_TAKES_PRIORITY);
+       it;
+       ++it) {
+    Tile* tile = *it;
+    if (!last_tile)
+      last_tile = tile;
+
+    EXPECT_TRUE(tile);
+
+    if (tile->is_occluded(PENDING_TREE)) {

[danakj, 2014/07/09 17:38:40]

Hm, this verifies that we don't evict an occluded tile after a non-occluded one,
but it's pretty indirect in verifying that we do evict all occluded tiles first
(as opposed to not evicting any of them and then this loop passes, but maybe the
43 check doesn't).

Can you change this test a bit to be more direct, like.. My first thought is

1. Verify that at scale T there are N occluded tiles.
2. Verify that for each tile I we evict at scale T, the tile is occluded iff I <
N.

Then you can hard-code the N if you like but it's more obvious where it's coming
from and the test verifies it's what you think it is by doing step 1.

wdyt?

[jbedley, 2014/07/11 00:19:38]

Done.
It won't necessarily be that the occluded tiles at a certain scale will be the
first N tiles iterated over at that scale. For example, an EVENTUALLY tile would
be evicted before an occluded NOW tile.

I modified it to verify that occlusion is considered at the proper time (after
bin, requirement for activation, and resolution). Another way could be to only
count the NOW tiles that aren't required for activation and make sure that the
occluded tiles are the first N of those. Do you have a preference?

+      occluded_tile_count++;
+      if (!last_tile->is_occluded(PENDING_TREE))
+        EXPECT_NE(tile->contents_scale(), last_tile->contents_scale());
+    }
+
+    last_tile = tile;
+  }
+  EXPECT_EQ(occluded_tile_count, 43);
+
+  // Back to no occlusion.
+  layer1->SetContentsOpaque(false);
+
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  occluded_tile_count = 0;
+  last_tile = NULL;
+  for (PictureLayerImpl::LayerEvictionTileIterator it =
+           PictureLayerImpl::LayerEvictionTileIterator(
+               pending_layer_, NEW_CONTENT_TAKES_PRIORITY);
+       it;
+       ++it) {
+    Tile* tile = *it;
+    if (!last_tile)
+      last_tile = tile;
+
+    EXPECT_TRUE(tile);
+
+    if (tile->is_occluded(PENDING_TREE)) {
+      occluded_tile_count++;
+      if (!last_tile->is_occluded(PENDING_TREE))
+        EXPECT_NE(tile->contents_scale(), last_tile->contents_scale());
+    }
+
+    last_tile = tile;
+  }
+  EXPECT_EQ(occluded_tile_count, 0);
+}
 }  // namespace
 }  // namespace cc