Revert of cc : Don't draw animating layers which are transparent but raster them.

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>
@@ skipping 4408 matching lines @@
 
   AddOpacityTransitionToElementWithPlayer(child_element_id, timeline, 10.0,
                                           0.0f, 1.0f, false);
 
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
-  // We should have one render surface and one layer. The child
-  // layer should not be included as its transparent.
+  // We should have one render surface and two layers. The child
+  // layer should be included even though it is transparent.
   ASSERT_EQ(1u, render_surface_list.size());
-  ASSERT_EQ(1, GetRenderSurface(root_layer)->num_contributors());
+  ASSERT_EQ(2, GetRenderSurface(root_layer)->num_contributors());
 
-  // If the root itself is hidden, the child should not be drawn and should not
-  // raster even if it has an animating opacity.
+  // If the root itself is hidden, the child should not be drawn even if it has
+  // an animating opacity.
   root_layer->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   RenderSurfaceList render_surface_list2;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs2(
       root_layer, root_layer->bounds(), &render_surface_list2);
   inputs2.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs2);
 
   LayerImpl* child_ptr = root_layer->layer_tree_impl()->LayerById(2);
-  EXPECT_FALSE(child_ptr->contributes_to_drawn_render_surface());
-  EXPECT_FALSE(child_ptr->raster_even_if_not_in_rsll());
+  EffectTree& tree =
+      root_layer->layer_tree_impl()->property_trees()->effect_tree;
+  EffectNode* node = tree.Node(child_ptr->effect_tree_index());
+  EXPECT_FALSE(node->is_drawn);
 
-  // The child layer should not be drawn as its transparent but should raster
-  // as its opacity is animating.
+  // A layer should be drawn and it should contribute to drawn surface when
+  // it has animating opacity even if it has opacity 0.
   root_layer->test_properties()->opacity = 1.0f;
   child_ptr->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   RenderSurfaceList render_surface_list3;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs3(
       root_layer, root_layer->bounds(), &render_surface_list3);
   inputs3.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs3);
 
   child_ptr = root_layer->layer_tree_impl()->LayerById(2);
-  EXPECT_FALSE(child_ptr->contributes_to_drawn_render_surface());
-  EXPECT_TRUE(child_ptr->raster_even_if_not_in_rsll());
+  tree = root_layer->layer_tree_impl()->property_trees()->effect_tree;
+  node = tree.Node(child_ptr->effect_tree_index());
+  EXPECT_TRUE(node->is_drawn);
+  EXPECT_TRUE(tree.ContributesToDrawnSurface(child_ptr->effect_tree_index()));
 
-  // The child layer should not be drawn as its transparent but should raster
-  // as its opacity is animating even after activation.
+  // But if the opacity of the layer remains 0 after activation, it should not
+  // be drawn.
   host_impl.ActivateSyncTree();
   LayerImpl* active_root = host_impl.active_tree()->LayerById(root_layer->id());
   LayerImpl* active_child = host_impl.active_tree()->LayerById(child_ptr->id());
 
+  EffectTree& active_effect_tree =
+      host_impl.active_tree()->property_trees()->effect_tree;
+  EXPECT_TRUE(active_effect_tree.needs_update());
+
   ExecuteCalculateDrawProperties(active_root);
 
-  EXPECT_FALSE(active_child->contributes_to_drawn_render_surface());
-  EXPECT_TRUE(active_child->raster_even_if_not_in_rsll());
+  node = active_effect_tree.Node(active_child->effect_tree_index());
+  EXPECT_FALSE(node->is_drawn);
+  EXPECT_FALSE(active_effect_tree.ContributesToDrawnSurface(
+      active_child->effect_tree_index()));
 }
 
 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
 class LCDTextTest : public LayerTreeHostCommonTestBase,
                     public testing::TestWithParam<LCDTextTestParam> {
  public:
   LCDTextTest()
       : LayerTreeHostCommonTestBase(LCDTextTestLayerTreeSettings()),
         host_impl_(LCDTextTestLayerTreeSettings(),
                    &task_runner_provider_,
@@ skipping 5671 matching lines @@
 
   // Check child layer draw properties.
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   EXPECT_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_EQ(gfx::Rect(10, 10), child->clip_rect());
   EXPECT_EQ(gfx::Rect(10, 10), child->drawable_content_rect());
 }
 
 }  // namespace
 }  // namespace cc