cc:: Remove RenderSurfaceImpl::TargetEffectTreeIndex

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 <set>
@@ skipping 1373 matching lines @@
   // Since the child layer has a blend mode other than normal, it should get
   // its own render surface. Also, layer's draw_properties should contain the
   // default blend mode, since the render surface becomes responsible for
   // applying the blend mode.
   ASSERT_TRUE(child->render_surface());
   EXPECT_EQ(1.0f, child->draw_opacity());
   EXPECT_EQ(0.5f, child->render_surface()->draw_opacity());
   EXPECT_EQ(SkXfermode::kSrcOver_Mode, child->draw_blend_mode());
 }
 
+TEST_F(LayerTreeHostCommonTest, RenderSurfaceDrawOpacity) {
+  LayerImpl* root = root_layer();
+  LayerImpl* surface1 = AddChildToRoot<LayerImpl>();
+  LayerImpl* not_surface = AddChild<LayerImpl>(surface1);
+  LayerImpl* surface2 = AddChild<LayerImpl>(not_surface);
+
+  const gfx::Transform identity_matrix;
+  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               true);
+  SetLayerPropertiesForTesting(surface1, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               true);
+  SetLayerPropertiesForTesting(not_surface, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               false);
+  SetLayerPropertiesForTesting(surface2, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false,
+                               true);
+  surface1->SetDrawsContent(true);
+  surface2->SetDrawsContent(true);
+
+  surface1->SetOpacity(0.5f);
+  not_surface->SetOpacity(0.5f);
+  surface2->SetOpacity(0.5f);
+
+  ExecuteCalculateDrawProperties(root);
+
+  ASSERT_TRUE(surface1->render_surface());
+  ASSERT_FALSE(not_surface->render_surface());
+  ASSERT_TRUE(surface2->render_surface());
+  EXPECT_EQ(0.5f, surface1->render_surface()->draw_opacity());
+  // surface2's draw opacity should include the opacity of not-surface and
+  // itself, but not the opacity of surface1.
+  EXPECT_EQ(0.25f, surface2->render_surface()->draw_opacity());
+}
+
 TEST_F(LayerTreeHostCommonTest, DrawOpacityWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, a layer's draw opacity is
   // the product of all ancestor layer opacties and the layer's own opacity.
   // (Rendering will still be incorrect in situations where we really do need
   // surfaces to apply opacity, such as when we have overlapping layers with an
   // ancestor whose opacity is <1.)
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
@@ skipping 8268 matching lines @@
   proto::ScrollAndScaleSet proto;
   scroll_and_scale_set.ToProtobuf(&proto);
   ScrollAndScaleSet new_scroll_and_scale_set;
   new_scroll_and_scale_set.FromProtobuf(proto);
 
   EXPECT_TRUE(scroll_and_scale_set.EqualsForTesting(new_scroll_and_scale_set));
 }
 
 }  // namespace
 }  // namespace cc