cc : Fix occlusion tracking bug for contributing surface

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface_impl.h"
+#include "cc/layers/texture_layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/proto/begin_main_frame_and_commit_state.pb.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
@@ skipping 3638 matching lines @@
   EXPECT_FALSE(root->layer_tree_impl()
                    ->property_trees()
                    ->transform_tree.Node(grand_child->transform_tree_index())
                    ->ancestors_are_invertible);
 
   // CalcDrawProps skips a subtree when a layer's screen space transform is
   // uninvertible
   EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
+TEST_F(LayerTreeHostCommonTest, OcclusionBySiblingOfTarget) {
+  FakeImplTaskRunnerProvider task_runner_provider;
+  TestSharedBitmapManager shared_bitmap_manager;
+  TestTaskGraphRunner task_graph_runner;
+  std::unique_ptr<OutputSurface> output_surface = FakeOutputSurface::Create3d();
+  FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
+                                  &task_graph_runner);
+
+  std::unique_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl.active_tree(), 1);
+  std::unique_ptr<LayerImpl> child =
+      LayerImpl::Create(host_impl.active_tree(), 2);
+  std::unique_ptr<TextureLayerImpl> surface =
+      TextureLayerImpl::Create(host_impl.active_tree(), 3);
+  std::unique_ptr<TextureLayerImpl> surface_child =
+      TextureLayerImpl::Create(host_impl.active_tree(), 4);
+  std::unique_ptr<TextureLayerImpl> surface_sibling =
+      TextureLayerImpl::Create(host_impl.active_tree(), 5);
+  std::unique_ptr<TextureLayerImpl> surface_child_mask =
+      TextureLayerImpl::Create(host_impl.active_tree(), 6);
+
+  surface->SetDrawsContent(true);
+  surface_child->SetDrawsContent(true);
+  surface_sibling->SetDrawsContent(true);
+  surface_child_mask->SetDrawsContent(true);
+  surface->SetContentsOpaque(true);
+  surface_child->SetContentsOpaque(true);
+  surface_sibling->SetContentsOpaque(true);
+  surface_child_mask->SetContentsOpaque(true);
+
+  surface->test_properties()->opacity = 0.5f;
+  surface_child->test_properties()->opacity = 0.6f;
+
+  gfx::Transform identity_matrix;
+  gfx::Transform translate;
+  translate.Translate(20.f, 20.f);
+
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1000, 1000), true,
+                               false, true);
+  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(300, 300), false, true,
+                               false);
+  SetLayerPropertiesForTesting(surface.get(), translate, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(300, 300), false, true,
+                               true);
+  SetLayerPropertiesForTesting(surface_child.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(300, 300), false, false, true);
+  SetLayerPropertiesForTesting(surface_sibling.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(200, 200), false, false, false);
+
+  LayerImpl* surface_ptr = surface.get();
+  LayerImpl* surface_child_ptr = surface_child.get();
+  LayerImpl* surface_child_mask_ptr = surface_child_mask.get();
+
+  host_impl.SetViewportSize(root->bounds());
+
+  surface_child->test_properties()->SetMaskLayer(std::move(surface_child_mask));
+  surface->test_properties()->AddChild(std::move(surface_child));
+  child->test_properties()->AddChild(std::move(surface));
+  child->test_properties()->AddChild(std::move(surface_sibling));
+  root->test_properties()->AddChild(std::move(child));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
+  host_impl.SetVisible(true);
+  host_impl.InitializeRenderer(output_surface.get());
+  host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
+  bool update_lcd_text = false;
+  host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      surface_ptr->render_surface()->draw_transform(), translate);
+  // surface_sibling draws into the root render surface and occludes
+  // surface_child's contents.
+  Occlusion actual_occlusion =
+      surface_child_ptr->render_surface()->occlusion_in_content_space();
+  Occlusion expected_occlusion(translate, SimpleEnclosedRegion(gfx::Rect()),
+                               SimpleEnclosedRegion(gfx::Rect(200, 200)));
+  EXPECT_TRUE(expected_occlusion.IsEqual(actual_occlusion));
+
+  // Mask layer should have the same occlusion.
+  actual_occlusion =
+      surface_child_mask_ptr->draw_properties().occlusion_in_content_space;
+  EXPECT_TRUE(expected_occlusion.IsEqual(actual_occlusion));
+}
+
 TEST_F(LayerTreeHostCommonTest,
        OcclusionForLayerWithUninvertibleDrawTransform) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   std::unique_ptr<OutputSurface> output_surface = FakeOutputSurface::Create3d();
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
+
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.active_tree(), 2);
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.active_tree(), 3);
   std::unique_ptr<LayerImpl> occluding_child =
       LayerImpl::Create(host_impl.active_tree(), 4);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
@@ skipping 6728 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc