cc : Delete LayerImpl::opacity

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 162 matching lines @@
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
                                false);
-  child->SetOpacity(0.f);
+  child->test_properties()->opacity = 0.f;
   ExecuteCalculateDrawProperties(parent);
   EffectTree& effect_tree =
       parent->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(child->effect_tree_index());
   const int transform_tree_size = parent->layer_tree_impl()
                                       ->property_trees()
                                       ->transform_tree.next_available_id();
   EXPECT_LT(node->data.transform_id, transform_tree_size);
 }
 
@@ skipping 309 matching lines @@
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                true);
 
   // Child is set up so that a new render surface should be created.
-  child->SetOpacity(0.5f);
+  child->test_properties()->opacity = 0.5f;
   child->SetDrawsContent(true);
 
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(25.0, 30.0);
 
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
@@ skipping 105 matching lines @@
   std::unique_ptr<LayerImpl> child_replica =
       LayerImpl::Create(host_impl()->active_tree(), 100);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                true);
 
   // Child is set up so that a new render surface should be created.
-  child->SetOpacity(0.5f);
+  child->test_properties()->opacity = 0.5f;
 
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
   gfx::Transform replica_layer_transform;
   replica_layer_transform.Scale3d(3.0, 3.0, 1.0);
@@ skipping 72 matching lines @@
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
   grand_child_of_rs2->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> replica_of_rs1 =
       LayerImpl::Create(host_impl()->active_tree(), 101);
   std::unique_ptr<LayerImpl> replica_of_rs2 =
       LayerImpl::Create(host_impl()->active_tree(), 102);
 
   // In combination with descendant draws content, opacity != 1 forces the layer
   // to have a new render surface.
-  render_surface1->SetOpacity(0.5f);
-  render_surface2->SetOpacity(0.33f);
+  render_surface1->test_properties()->opacity = 0.5f;
+  render_surface2->test_properties()->opacity = 0.33f;
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                true);
 
   // All layers in the tree are initialized with an anchor at .25 and a size of
   // (10,10).  matrix "A" is the composite layer transform used in all layers,
   // Matrix "R" is the composite replica transform used in all replica layers.
@@ skipping 543 matching lines @@
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
   child->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
-  render_surface1->SetOpacity(0.f);
+  render_surface1->test_properties()->opacity = 0.f;
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       parent, parent->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Since the layer is transparent, render_surface1->render_surface() should
   // not have gotten added anywhere.  Also, the drawable content rect should not
   // have been extended by the children.
@@ skipping 14 matching lines @@
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
-  render_surface1->SetOpacity(0.f);
+  render_surface1->test_properties()->opacity = 0.f;
   render_surface1->SetDrawsContent(true);
   child->SetDrawsContent(true);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.5f));
   render_surface1->SetBackgroundFilters(filters);
 
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         parent, parent->bounds(), &render_surface_layer_list);
@@ skipping 76 matching lines @@
   const gfx::Transform identity_matrix;
   const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
 
   child->SetBlendMode(blend_mode);
-  child->SetOpacity(0.5f);
+  child->test_properties()->opacity = 0.5f;
 
   ExecuteCalculateDrawProperties(parent);
 
   // 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());
@@ skipping 15 matching lines @@
                                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);
+  surface1->test_properties()->opacity = 0.5f;
+  not_surface->test_properties()->opacity = 0.5f;
+  surface2->test_properties()->opacity = 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());
@@ skipping 39 matching lines @@
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
 
-  child1->SetOpacity(0.5f);
-  grand_child->SetOpacity(0.5f);
-  leaf_node1->SetOpacity(0.5f);
-  leaf_node2->SetOpacity(0.5f);
+  child1->test_properties()->opacity = 0.5f;
+  grand_child->test_properties()->opacity = 0.5f;
+  leaf_node1->test_properties()->opacity = 0.5f;
+  leaf_node2->test_properties()->opacity = 0.5f;
 
   // With surfaces enabled, each layer's draw opacity is the product of layer
   // opacities on the path from the layer to its render target, not including
   // the opacity of the layer that owns the target surface (since that opacity
   // is applied by the surface).
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1.f, root->draw_opacity());
   EXPECT_EQ(1.f, parent->draw_opacity());
   EXPECT_EQ(1.f, child1->draw_opacity());
   EXPECT_EQ(1.f, child2->draw_opacity());
@@ skipping 54 matching lines @@
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
   // Make |parent| have a render surface.
-  parent->SetOpacity(0.9f);
+  parent->test_properties()->opacity = 0.9f;
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(parent, rotation_about_y_axis, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
@@ skipping 79 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
                                true, false, false);
   SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(500, 500), true, false,
                                false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
 
   child->SetMasksToBounds(true);
-  child->SetOpacity(0.4f);
-  grand_child->SetOpacity(0.5f);
-  great_grand_child->SetOpacity(0.4f);
+  child->test_properties()->opacity = 0.4f;
+  grand_child->test_properties()->opacity = 0.5f;
+  great_grand_child->test_properties()->opacity = 0.4f;
 
   ExecuteCalculateDrawProperties(parent);
 
   ASSERT_EQ(2U, render_surface_layer_list_impl()->size());
   EXPECT_EQ(parent->id(), render_surface_layer_list_impl()->at(0)->id());
   EXPECT_EQ(child->id(), render_surface_layer_list_impl()->at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
   // When a render surface has a clip rect, it is used to clip the content rect
@@ skipping 25 matching lines @@
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(200.f, 200.f), gfx::Size(10, 10),
                                true, false, true);
   SetLayerPropertiesForTesting(leaf_node, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   parent->SetMasksToBounds(true);
-  child->SetOpacity(0.4f);
-  grand_child->SetOpacity(0.4f);
+  child->test_properties()->opacity = 0.4f;
+  grand_child->test_properties()->opacity = 0.4f;
 
   ExecuteCalculateDrawProperties(parent);
 
   // We should cull child and grand_child from the
   // render_surface_layer_list.
   ASSERT_EQ(1U, render_surface_layer_list_impl()->size());
   EXPECT_EQ(parent->id(), render_surface_layer_list_impl()->at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {
@@ skipping 372 matching lines @@
                                gfx::PointF(15.f, 15.f), gfx::Size(10, 10), true,
                                false, false);
   SetLayerPropertiesForTesting(grand_child4, identity_matrix, gfx::Point3F(),
                                gfx::PointF(45.f, 45.f), gfx::Size(10, 10), true,
                                false, false);
 
   child->SetMasksToBounds(true);
   grand_child3->SetMasksToBounds(true);
 
   // Force child to be a render surface.
-  child->SetOpacity(0.4f);
+  child->test_properties()->opacity = 0.4f;
 
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_EQ(gfx::Rect(5, 5, 10, 10), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
   EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
@@ skipping 52 matching lines @@
                                false);
   SetLayerPropertiesForTesting(leaf_node4, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   child->SetMasksToBounds(true);
   grand_child3->SetMasksToBounds(true);
   grand_child4->SetMasksToBounds(true);
 
   // Force everyone to be a render surface.
-  child->SetOpacity(0.4f);
-  grand_child1->SetOpacity(0.5f);
-  grand_child2->SetOpacity(0.5f);
-  grand_child3->SetOpacity(0.5f);
-  grand_child4->SetOpacity(0.5f);
+  child->test_properties()->opacity = 0.4f;
+  grand_child1->test_properties()->opacity = 0.5f;
+  grand_child2->test_properties()->opacity = 0.5f;
+  grand_child3->test_properties()->opacity = 0.5f;
+  grand_child4->test_properties()->opacity = 0.5f;
 
   ExecuteCalculateDrawProperties(parent);
 
   ASSERT_TRUE(grand_child1->render_surface());
   ASSERT_TRUE(grand_child2->render_surface());
   ASSERT_TRUE(grand_child3->render_surface());
 
   // Surfaces are clipped by their parent, but un-affected by the owning layer's
   // masksToBounds.
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
@@ skipping 1973 matching lines @@
   back_facing_child_of_front_facing_surface->SetDrawsContent(true);
   front_facing_child_of_back_facing_surface->SetDrawsContent(true);
   back_facing_child_of_back_facing_surface->SetDrawsContent(true);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
   // Having a descendant and opacity will force these to have render surfaces.
-  front_facing_surface->SetOpacity(0.5f);
-  back_facing_surface->SetOpacity(0.5f);
+  front_facing_surface->test_properties()->opacity = 0.5f;
+  back_facing_surface->test_properties()->opacity = 0.5f;
 
   // Nothing preserves 3d. According to current W3C CSS gfx::Transforms spec,
   // these layers should blindly use their own local transforms to determine
   // back-face culling.
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(front_facing_child, identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(back_facing_child, backface_matrix,
@@ skipping 749 matching lines @@
   grand_child->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
-  child->SetOpacity(0.5f);
+  child->test_properties()->opacity = 0.5f;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_FALSE(child->has_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(host()->settings(), &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   child->SetDrawsContent(true);
-  child->SetOpacity(0.0f);
+  child->test_properties()->opacity = 0.0f;
 
   const int child_id = child->id();
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.pending_tree()->SetRootLayer(std::move(root));
   host_impl.pending_tree()->BuildPropertyTreesForTesting();
   // Add opacity animation.
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddOpacityTransitionToLayerWithPlayer(child_id, timeline, 10.0, 0.0f, 1.0f,
                                         false);
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // 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_layer_list.size());
   ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());
 
   // If the root itself is hidden, the child should not be drawn even if it has
   // an animating opacity.
-  root_layer->SetOpacity(0.0f);
+  root_layer->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   LayerImplList render_surface_layer_list2;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs2(
       root_layer, root_layer->bounds(), &render_surface_layer_list2);
   inputs2.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs2);
 
   LayerImpl* child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(child_ptr->effect_tree_index());
   EXPECT_FALSE(node->data.is_drawn);
 
   // 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->SetOpacity(1.0f);
-  child_ptr->SetOpacity(0.0f);
+  root_layer->test_properties()->opacity = 1.0f;
+  child_ptr->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   LayerImplList render_surface_layer_list3;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs3(
       root_layer, root_layer->bounds(), &render_surface_layer_list3);
   inputs3.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs3);
 
   child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   tree = root_layer->layer_tree_impl()->property_trees()->effect_tree;
   node = tree.Node(child_ptr->effect_tree_index());
@@ skipping 155 matching lines @@
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
 
   // Case 7: Translucent.
   child_->SetTransform(identity_matrix);
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  child_->SetOpacity(0.5f);
+  child_->test_properties()->opacity = 0.5f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
 
   // Case 8: Sanity check: restore transform and opacity.
   child_->SetTransform(identity_matrix);
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  child_->SetOpacity(1.f);
+  child_->test_properties()->opacity = 1.f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 
   // Case 9: Non-opaque content.
   child_->SetContentsOpaque(false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
@@ skipping 15 matching lines @@
   bool expect_not_lcd_text = layers_always_allowed_lcd_text_;
 
   // Sanity check: Make sure can_use_lcd_text_ is set on each node.
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 
   // Add opacity animation.
-  child_->SetOpacity(0.9f);
+  child_->test_properties()->opacity = 0.9f;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   AddOpacityTransitionToLayerWithPlayer(child_->id(), timeline(), 10.0, 0.9f,
                                         0.1f, false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
                                  layers_always_allowed_lcd_text_);
   // Text LCD should be adjusted while animation is active.
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
 }
@@ skipping 3401 matching lines @@
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->SetTransform(identity);
 
   child_ptr->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->hide_layer_and_subtree = false;
 
-  child_ptr->SetOpacity(0.f);
+  child_ptr->OnOpacityAnimated(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetOpacity(1.f);
+  child_ptr->test_properties()->opacity = 1.f;
 
   root_ptr->SetTransform(singular);
   // Force transform tree to have a node for child, so that ancestor's
   // invertible transform can be tested.
   child_ptr->SetTransform(rotate);
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   root_ptr->SetTransform(identity);
   child_ptr->SetTransform(identity);
 
-  root_ptr->SetOpacity(0.f);
-  child_ptr->SetOpacity(0.7f);
+  root_ptr->test_properties()->opacity = 0.f;
+  child_ptr->test_properties()->opacity = 0.7f;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  root_ptr->SetOpacity(1.f);
+  root_ptr->test_properties()->opacity = 1.f;
 
-  child_ptr->SetOpacity(0.f);
+  child_ptr->test_properties()->opacity = 0.f;
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   std::vector<std::unique_ptr<CopyOutputRequest>> requests;
   requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
   grandchild_ptr->PassCopyRequests(&requests);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   requests.clear();
   grandchild_ptr->PassCopyRequests(&requests);
-  child_ptr->SetOpacity(1.f);
+  child_ptr->test_properties()->opacity = 1.f;
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetHasRenderSurface(true);
   child_ptr->test_properties()->double_sided = true;
   child_ptr->SetTransform(rotate_back_and_translate);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   child_ptr->SetTransform(identity);
@@ skipping 138 matching lines @@
       FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 0.3f, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::OPACITY));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl.active_tree()->animation_host()->RegisterPlayerForElement(
       root_ptr->id(), player.get());
   host_impl.active_tree()
       ->animation_host()
       ->GetElementAnimationsForElementId(root_ptr->id())
       ->AddAnimation(std::move(animation));
-  root_ptr->SetOpacity(0);
+  root_ptr->test_properties()->opacity = 0.f;
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
@@ skipping 26 matching lines @@
   gfx::Transform rotate;
   child->test_properties()->double_sided = false;
   rotate.RotateAboutXAxis(180.f);
   child->SetTransform(rotate);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->test_properties()->double_sided = true;
   child->SetTransform(identity);
 
-  child->SetOpacity(0.f);
+  child->test_properties()->opacity = 0.f;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
   // PreCalculateMetaInformation happens when its required.
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> parent = Layer::Create();
@@ skipping 477 matching lines @@
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   gfx::Transform translation;
   translation.Translate(10, 10);
   SetLayerPropertiesForTesting(test_layer, translation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
 
   render_surface->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
-  test_layer->SetOpacity(0);
+  test_layer->test_properties()->opacity = 0.f;
   test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(translation, test_layer->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipChildVisibleRect) {
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
@@ skipping 630 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