Move occlusion info to TilePriority.

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 2791 matching lines @@
 
   // No occlusion.
   int unoccluded_tile_count = 0;
   for (PictureLayerImpl::LayerRasterTileIterator it =
            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
        it;
        ++it) {
     Tile* tile = *it;
 
     // Occluded tiles should not be iterated over.
-    EXPECT_FALSE(tile->is_occluded());
+    EXPECT_FALSE(tile->priority(PENDING_TREE).is_occluded);
 
     // Some tiles may not be visible (i.e. outside the viewport). The rest are
     // visible and at least partially unoccluded, verified by the above expect.
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
   }
   EXPECT_EQ(unoccluded_tile_count, 25 + 4);
 
   // Partial occlusion.
   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);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   unoccluded_tile_count = 0;
   for (PictureLayerImpl::LayerRasterTileIterator it =
            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
        it;
        ++it) {
     Tile* tile = *it;
 
-    EXPECT_FALSE(tile->is_occluded());
+    EXPECT_FALSE(tile->priority(PENDING_TREE).is_occluded);
 
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
   }
   EXPECT_EQ(unoccluded_tile_count, 20 + 2);
 
   // Full occlusion.
   layer1->SetPosition(gfx::Point(0, 0));
 
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   unoccluded_tile_count = 0;
   for (PictureLayerImpl::LayerRasterTileIterator it =
            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
        it;
        ++it) {
     Tile* tile = *it;
 
-    EXPECT_FALSE(tile->is_occluded());
+    EXPECT_FALSE(tile->priority(PENDING_TREE).is_occluded);
 
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
   }
   EXPECT_EQ(unoccluded_tile_count, 0);
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest,
@@ skipping 23 matching lines @@
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
       // Fully occluded tiles are not required for activation.
-      if (tile->is_occluded()) {
+      if (tile->priority(PENDING_TREE).is_occluded) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
   }
   EXPECT_EQ(occluded_tile_count, 0);
 
   // Partial occlusion.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
   LayerImpl* layer1 = pending_layer_->children()[0];
@@ skipping 12 matching lines @@
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
-      if (tile->is_occluded()) {
+      if (tile->priority(PENDING_TREE).is_occluded) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
   }
   EXPECT_EQ(occluded_tile_count, 30 + 5 + 2);
 
   // Full occlusion.
   layer1->SetPosition(gfx::PointF(0, 0));
 
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   occluded_tile_count = 0;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
 
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
-      if (tile->is_occluded()) {
+      if (tile->priority(PENDING_TREE).is_occluded) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
   }
   EXPECT_EQ(occluded_tile_count, 100 + 25 + 4);
 }
+
+TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
+  gfx::Size tile_size(102, 102);
+  gfx::Size layer_bounds(1000, 1000);
+  gfx::Size viewport_size(1000, 1000);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupTrees(pending_pile, active_pile);
+
+  // Fully occlude the active layer.
+  active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
+  LayerImpl* layer1 = active_layer_->children()[0];
+  layer1->SetBounds(layer_bounds);
+  layer1->SetContentBounds(layer_bounds);
+  layer1->SetDrawsContent(true);
+  layer1->SetContentsOpaque(true);
+
+  host_impl_.SetViewportSize(viewport_size);
+
+  host_impl_.pending_tree()->UpdateDrawProperties();
+  host_impl_.active_tree()->UpdateDrawProperties();
+
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+
+    for (PictureLayerTiling::CoverageIterator iter(
+             tiling,
+             pending_layer_->contents_scale_x(),
+             gfx::Rect(layer_bounds));
+         iter;
+         ++iter) {
+      if (!*iter)
+        continue;
+      const Tile* tile = *iter;

[danakj, 2014/06/17 22:29:41]

can you show with EXPECT checks that these Tile* are not shared with the active
tree so that you can demonstrate these two loops are doing different things?

[jbedley, 2014/06/18 23:00:39]

Actually both loops were doing the same thing because all the tiles were shared
before. I've modified the test so that we get both shared and unshared tiles
now. We also get various combinations of tiles being occluded on different
trees.

+
+      EXPECT_FALSE(tile->priority(PENDING_TREE).is_occluded);
+      EXPECT_TRUE(tile->priority(ACTIVE_TREE).is_occluded);
+    }
+  }
+
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
+
+    for (PictureLayerTiling::CoverageIterator iter(
+             tiling,
+             active_layer_->contents_scale_x(),
+             gfx::Rect(layer_bounds));
+         iter;
+         ++iter) {
+      if (!*iter)
+        continue;
+      const Tile* tile = *iter;
+
+      EXPECT_FALSE(tile->priority(PENDING_TREE).is_occluded);
+      EXPECT_TRUE(tile->priority(ACTIVE_TREE).is_occluded);
+    }
+  }
+}
 }  // namespace
 }  // namespace cc