cc: LayerTreeHostImpl uses element id to tick animations

cc/trees/damage_tracker_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/damage_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/base/filter_operation.h"
 #include "cc/base/filter_operations.h"
@@ skipping 81 matching lines @@
 
     for (int i = 0; i < number_of_children; ++i) {
       std::unique_ptr<LayerImpl> child =
           LayerImpl::Create(host_impl_.active_tree(), 2 + i);
       child->SetPosition(gfx::PointF(100.f, 100.f));
       child->SetBounds(gfx::Size(30, 30));
       child->SetDrawsContent(true);
       root->test_properties()->AddChild(std::move(child));
     }
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
+    host_impl_.active_tree()->SetElementIdsForTesting();
 
     return host_impl_.active_tree()->root_layer_for_testing();
   }
 
   LayerImpl* CreateTestTreeWithTwoSurfaces() {
     // This test tree has two render surfaces: one for the root, and one for
     // child1. Additionally, the root has a second child layer, and child1 has
     // two children of its own.
 
     host_impl_.active_tree()->DetachLayers();
@@ skipping 31 matching lines @@
 
     grand_child2->SetPosition(gfx::PointF(190.f, 190.f));
     grand_child2->SetBounds(gfx::Size(6, 8));
     grand_child2->SetDrawsContent(true);
 
     child1->test_properties()->AddChild(std::move(grand_child1));
     child1->test_properties()->AddChild(std::move(grand_child2));
     root->test_properties()->AddChild(std::move(child1));
     root->test_properties()->AddChild(std::move(child2));
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
+    host_impl_.active_tree()->SetElementIdsForTesting();
 
     return host_impl_.active_tree()->root_layer_for_testing();
   }
 
   LayerImpl* CreateAndSetUpTestTreeWithOneSurface(int number_of_children = 1) {
     LayerImpl* root = CreateTestTreeWithOneSurface(number_of_children);
 
     // Setup includes going past the first frame which always damages
     // everything, so that we can actually perform specific tests.
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
@@ skipping 216 matching lines @@
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // CASE 1: The layer's property changed flag takes priority over update rect.
   //
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
-  root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
-      0.5f, child->effect_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetOpacityMutated(child->element_id(), 0.5f);
   EmulateDrawingOneFrame(root);
 
   ASSERT_EQ(2u, root->GetRenderSurface()->layer_list().size());
 
   // Damage should be the entire child layer in target_surface space.
   gfx::Rect expected_rect = gfx::Rect(100, 100, 30, 30);
   gfx::Rect root_damage_rect;
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_EQ(expected_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 2: If a layer moves due to property change, it damages both the new
   //         location and the old (exposed) location. The old location is the
   //         entire old layer, not just the update_rect.
 
   // Cycle one frame of no change, just to sanity check that the next rect is
   // not because of the old damage state.
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Then, test the actual layer movement.
   ClearDamageForAllSurfaces(root);
   gfx::Transform translation;
   translation.Translate(100.f, 130.f);
-  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
-      translation, child->transform_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetTransformMutated(child->element_id(),
+                                               translation);
   EmulateDrawingOneFrame(root);
 
   // Expect damage to be the combination of the previous one and the new one.
   expected_rect.Union(gfx::Rect(200, 230, 30, 30));
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageWhenSurfaceRemoved) {
@@ skipping 37 matching lines @@
   // Sanity check that the layer actually moved to (85, 85), damaging its old
   // location and new location.
   gfx::Rect root_damage_rect;
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_EQ(gfx::Rect(85, 85, 45, 45).ToString(), root_damage_rect.ToString());
 
   // With the anchor on the layer's center, now we can test the rotation more
   // intuitively, since it applies about the layer's anchor.
   ClearDamageForAllSurfaces(root);
-  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
-      rotation, child->transform_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetTransformMutated(child->element_id(), rotation);
   EmulateDrawingOneFrame(root);
 
   // Since the child layer is square, rotation by 45 degrees about the center
   // should increase the size of the expected rect by sqrt(2), centered around
   // (100, 100). The old exposed region should be fully contained in the new
   // region.
   float expected_width = 30.f * sqrt(2.f);
   float expected_position = 100.f - 0.5f * expected_width;
   gfx::Rect expected_rect = gfx::ToEnclosingRect(gfx::RectF(
       expected_position, expected_position, expected_width, expected_width));
@@ skipping 36 matching lines @@
   gfx::RectF test_rect(child->position(), gfx::SizeF(child->bounds()));
   bool clipped = false;
   MathUtil::MapQuad(transform, gfx::QuadF(test_rect), &clipped);
   EXPECT_TRUE(clipped);
 
   // Damage the child without moving it.
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   ClearDamageForAllSurfaces(root);
-  root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
-      0.5f, child->effect_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetOpacityMutated(child->element_id(), 0.5f);
   EmulateDrawingOneFrame(root);
 
   // The expected damage should cover the entire root surface (500x500), but we
   // don't care whether the damage rect was clamped or is larger than the
   // surface for this test.
   gfx::Rect root_damage_rect;
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   gfx::Rect damage_we_care_about = gfx::Rect(gfx::Size(500, 500));
   EXPECT_TRUE(root_damage_rect.Contains(damage_we_care_about));
@@ skipping 39 matching lines @@
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkBlurImageFilter::Make(2, 2, nullptr)));
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
-      filters, child->effect_tree_index(), child->layer_tree_impl());
+  child->layer_tree_impl()->SetFilterMutated(child->element_id(), filters);
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_TRUE(child->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &child_damage_rect));
 
   // gfx::Rect(100, 100, 30, 30), expanded by 6px for the 2px blur filter.
   EXPECT_EQ(gfx::Rect(94, 94, 42, 42), root_damage_rect);
 
   // gfx::Rect(0, 0, 30, 30), expanded by 6px for the 2px blur filter.
@@ skipping 29 matching lines @@
       SkBlurImageFilter::Make(2, 2, nullptr)));
 
   // Setting the filter will damage the whole surface.
   gfx::Transform transform;
   transform.RotateAboutYAxis(60);
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   child->test_properties()->transform = transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
-      filters, child->effect_tree_index(), child->layer_tree_impl());
+  child->layer_tree_impl()->SetFilterMutated(child->element_id(), filters);
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_TRUE(child->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &child_damage_rect));
 
   // Blur outset is 6px for a 2px blur.
   int blur_outset = 6;
   int rotated_outset_left = blur_outset / 2;
   int expected_rotated_width = (30 + 2 * blur_outset) / 2;
@@ skipping 34 matching lines @@
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(3.f));
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   int device_scale_factor = 2;
   EmulateDrawingOneFrame(root, device_scale_factor);
-  child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
-      filters, child->effect_tree_index(), child->layer_tree_impl());
+  child->layer_tree_impl()->SetFilterMutated(child->element_id(), filters);
   EmulateDrawingOneFrame(root, device_scale_factor);
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_TRUE(child->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &child_damage_rect));
 
   // Blur outset is 9px for a 3px blur, scaled up by DSF.
   int blur_outset = 9 * device_scale_factor;
   gfx::Rect original_rect(100, 100, 100, 100);
   gfx::Rect expected_child_damage_rect(60, 60);
@@ skipping 279 matching lines @@
   child2->test_properties()->force_render_surface = true;
   grand_child1->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   // CASE 1: Damage to a descendant surface should propagate properly to
   //         ancestor surface.
   ClearDamageForAllSurfaces(root);
-  root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
-      0.5f, grand_child1->effect_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetOpacityMutated(grand_child1->element_id(), 0.5f);
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &child_damage_rect));
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(300, 300, 6, 8).ToString(), root_damage_rect.ToString());
 
   // CASE 2: Same as previous case, but with additional damage elsewhere that
   //         should be properly unioned.
   // - child1 surface damage in root surface space:
   //   gfx::Rect(300, 300, 6, 8);
   // - child2 damage in root surface space:
   //   gfx::Rect(11, 11, 18, 18);
   ClearDamageForAllSurfaces(root);
-  root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
-      0.7f, grand_child1->effect_tree_index(), root->layer_tree_impl());
-  root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
-      0.7f, child2->effect_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetOpacityMutated(grand_child1->element_id(), 0.7f);
+  root->layer_tree_impl()->SetOpacityMutated(child2->element_id(), 0.7f);
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &child_damage_rect));
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(11, 11, 295, 297).ToString(),
             root_damage_rect.ToString());
 }
@@ skipping 48 matching lines @@
   // transforming it, while the root surface would be damaged appropriately.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   ClearDamageForAllSurfaces(root);
   gfx::Transform translation;
   translation.Translate(-50.f, -50.f);
-  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
-      translation, child1->transform_tree_index(), root->layer_tree_impl());
+  root->layer_tree_impl()->SetTransformMutated(child1->element_id(),
+                                               translation);
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &child_damage_rect));
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
 
   // The new surface bounds should be damaged entirely.
   EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(),
             child_damage_rect.ToString());
@@ skipping 585 matching lines @@
   ASSERT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &damage_rect));
   EXPECT_TRUE(damage_rect.Contains(root->GetRenderSurface()->content_rect()));
   EXPECT_TRUE(damage_rect.Contains(
       gfx::ToEnclosingRect(child1->GetRenderSurface()->DrawableContentRect())));
   EXPECT_EQ(damage_rect, root->GetRenderSurface()->GetDamageRect());
 }
 
 }  // namespace
 }  // namespace cc