Use element id's for animations

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 2535 matching lines @@
       grand_child_of_root, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(
       grand_child_of_rs1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(
       grand_child_of_rs2, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
 
   parent->layer_tree_impl()->BuildPropertyTreesForTesting();
+  SetElementIdsForTesting();
 
   // Put an animated opacity on the render surface.
-  AddOpacityTransitionToLayerWithPlayer(render_surface1->id(), timeline_impl(),
-                                        10.0, 1.f, 0.f, false);
+  AddOpacityTransitionToElementWithPlayer(
+      render_surface1->element_id(), timeline_impl(), 10.0, 1.f, 0.f, false);
 
   // Also put an animated opacity on a layer without descendants.
-  AddOpacityTransitionToLayerWithPlayer(grand_child_of_root->id(),
-                                        timeline_impl(), 10.0, 1.f, 0.f, false);
+  AddOpacityTransitionToElementWithPlayer(grand_child_of_root->element_id(),
+                                          timeline_impl(), 10.0, 1.f, 0.f,
+                                          false);
 
   // Put a transform animation on the render surface.
-  AddAnimatedTransformToLayerWithPlayer(render_surface2->id(), timeline_impl(),
-                                        10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(render_surface2->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
 
   // Also put transform animations on grand_child_of_root, and
   // grand_child_of_rs2
-  AddAnimatedTransformToLayerWithPlayer(grand_child_of_root->id(),
-                                        timeline_impl(), 10.0, 30, 0);
-  AddAnimatedTransformToLayerWithPlayer(grand_child_of_rs2->id(),
-                                        timeline_impl(), 10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(grand_child_of_root->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(grand_child_of_rs2->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
 
   parent->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(parent);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(parent->render_surface());
   ASSERT_FALSE(child_of_root->render_surface());
   ASSERT_FALSE(grand_child_of_root->render_surface());
 
@@ skipping 98 matching lines @@
                                gfx::Size(10, 10), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(great_grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
+  SetElementIdsForTesting();
+
   // Add a transform animation with a start delay to |grand_child|.
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 0, 1,
       TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  AddAnimationToLayerWithPlayer(grand_child->id(), timeline_impl(),
-                                std::move(animation));
+  AddAnimationToElementWithPlayer(grand_child->element_id(), timeline_impl(),
+                                  std::move(animation));
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_FALSE(parent->screen_space_transform_is_animating());
   EXPECT_FALSE(child->screen_space_transform_is_animating());
 
   EXPECT_FALSE(grand_child->TransformIsAnimating());
   EXPECT_TRUE(grand_child->HasPotentiallyRunningTransformAnimation());
   EXPECT_TRUE(grand_child->screen_space_transform_is_animating());
   EXPECT_TRUE(great_grand_child->screen_space_transform_is_animating());
 }
@@ skipping 1700 matching lines @@
   child2->SetDrawsContent(true);
   animating_surface->SetDrawsContent(true);
   child_of_animating_surface->SetDrawsContent(true);
   animating_child->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);
 
+  SetElementIdsForTesting();
+
   // Animate the transform on the render surface.
-  AddAnimatedTransformToLayerWithPlayer(animating_surface->id(),
-                                        timeline_impl(), 10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(animating_surface->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
   // This is just an animating layer, not a surface.
-  AddAnimatedTransformToLayerWithPlayer(animating_child->id(), timeline_impl(),
-                                        10.0, 30, 0);
+  AddAnimatedTransformToElementWithPlayer(animating_child->element_id(),
+                                          timeline_impl(), 10.0, 30, 0);
 
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child, backface_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animating_surface, backface_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(child_of_animating_surface, backface_matrix,
                                gfx::Point3F(), gfx::PointF(),
@@ skipping 591 matching lines @@
                                false);
   child->SetDrawsContent(true);
   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);
+  host_impl.pending_tree()->SetElementIdsForTesting();
 
-  AddOpacityTransitionToLayerWithPlayer(child_id, timeline, 10.0, 0.0f, 1.0f,
-                                        false);
+  ElementId child_element_id =
+      host_impl.pending_tree()->LayerById(child_id)->element_id();
+
+  AddOpacityTransitionToElementWithPlayer(child_element_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());
@@ skipping 83 matching lines @@
 
     // Stash raw pointers to look at later.
     root_ = root_ptr.get();
     child_ = child_ptr.get();
     grand_child_ = grand_child_ptr.get();
 
     child_->AddChild(std::move(grand_child_ptr));
     root_->AddChild(std::move(child_ptr));
     host_impl_.active_tree()->SetRootLayer(std::move(root_ptr));
 
+    host_impl_.active_tree()->SetElementIdsForTesting();
+
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
     gfx::Transform identity_matrix;
     SetLayerPropertiesForTesting(root_, identity_matrix, gfx::Point3F(),
@@ skipping 132 matching lines @@
   // 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_->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);
+  SetElementIdsForTesting();
+
+  AddOpacityTransitionToElementWithPlayer(child_->element_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());
 }
 
 TEST_P(LCDTextTest, CanUseLCDTextWithAnimationContentsOpaque) {
   bool expect_lcd_text = can_use_lcd_text_ || layers_always_allowed_lcd_text_;
   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());
+  SetElementIdsForTesting();
 
   // Mark contents non-opaque within the first animation frame.
   child_->SetContentsOpaque(false);
-  AddOpacityTransitionToLayerWithPlayer(child_->id(), timeline(), 10.0, 0.9f,
-                                        0.1f, false);
+  AddOpacityTransitionToElementWithPlayer(child_->element_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_);
   // LCD text should be disabled for non-opaque layers even during animations.
   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
@@ skipping 1745 matching lines @@
   SetLayerPropertiesForTesting(scroller, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
 
   gfx::Transform end_scale;
   end_scale.Scale(2.f, 2.f);
   TransformOperations start_operations;
   start_operations.AppendMatrix(start_scale);
   TransformOperations end_operations;
   end_operations.AppendMatrix(end_scale);
-  AddAnimatedTransformToLayerWithPlayer(animated_layer->id(), timeline_impl(),
-                                        1.0, start_operations, end_operations);
+  SetElementIdsForTesting();
+
+  AddAnimatedTransformToElementWithPlayer(animated_layer->element_id(),
+                                          timeline_impl(), 1.0,
+                                          start_operations, end_operations);
   gfx::Vector2dF scroll_delta(5.f, 9.f);
   SetScrollOffsetDelta(scroller, scroll_delta);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f);
   EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation,
                       scroller->DrawTransform().To2dTranslation());
 }
 
@@ skipping 82 matching lines @@
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   TransformOperations translation;
   translation.AppendTranslate(1.f, 2.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline;
   timeline = AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), translation);
+  host_impl.active_tree()->SetElementIdsForTesting();
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(),
+                                          translation);
 
   // No layers have scale-affecting animations.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 4.f, 3.f);
 
-  AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // Only |child| has a scale-affecting animation.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(5.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       5.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(1.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       1.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AddAnimatedTransformToLayerWithPlayer(grand_parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(grand_parent_raw->element_id(),
+                                          timeline, 1.0, TransformOperations(),
+                                          scale);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |child| have scale-affecting animations.
   EXPECT_EQ(
       5.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(5.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   // We don't support combining animated scales from two nodes; 0.f means
   // that the maximum scale could not be computed.
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       1.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(1.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
   EXPECT_EQ(
       5.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       1.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AbortAnimationsOnLayerWithPlayer(grand_parent_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
-  AbortAnimationsOnLayerWithPlayer(parent_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
-  AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(grand_parent_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(parent_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
-  AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
-                                        TransformOperations(), perspective);
+  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
+                                          1.0, TransformOperations(),
+                                          perspective);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a scale-affecting animation but computing the maximum of this
   // animation is not supported.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(
       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
 
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
-  AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                   TargetProperty::TRANSFORM);
+  AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
+                                     TargetProperty::TRANSFORM);
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent_raw->SetTransform(scale_matrix);
   parent_raw->SetTransform(scale_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
-  AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
+  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(10.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(10.f,
@@ skipping 382 matching lines @@
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->AddChild(std::move(child1));
   root->AddChild(std::move(child2));
   root->test_properties()->force_render_surface = true;
   root->SetDrawsContent(true);
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
+  host_impl.active_tree()->SetElementIdsForTesting();
+
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
@@ skipping 10 matching lines @@
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  AddAnimatedTransformToLayerWithPlayer(child2_layer->id(), timeline, 1.0,
-                                        TransformOperations(), scale);
-
   SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
   child2_layer->SetDrawsContent(true);
 
+  AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
+                                          1.0, TransformOperations(), scale);
+
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(3.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(3.f, child1_layer->mask_layer()->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(5.f, child2_layer->GetIdealContentsScale());
 
   EXPECT_FLOAT_EQ(
       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
@@ skipping 247 matching lines @@
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
+  host()->SetElementIdsForTesting();
+
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetMasksToBounds(true);
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetOpacity(0.f);
 
-  AddOpacityTransitionToLayerWithPlayer(animated->id(), timeline(), 10.0, 0.f,
-                                        1.f, false);
+  SetElementIdsForTesting();

[ajuma, 2016/06/01 23:53:42]

This adds ids to the the LTHI's active tree, right? This test only has a
main-thread tree and sets ids for it above, so is this call needed?

[Ian Vollick, 2016/06/02 19:03:11]

Nope, removed.

+  AddOpacityTransitionToElementWithPlayer(animated->element_id(), timeline(),
+                                          10.0, 0.f, 1.f, false);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_FALSE(animated->visible_layer_rect_for_testing().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> clip = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
   surface->AddChild(descendant_of_animation);
 
   clip->SetMasksToBounds(true);
   surface->SetForceRenderSurfaceForTesting(true);
 
   host()->SetRootLayer(root);
 
+  host()->SetElementIdsForTesting();
+
   gfx::Transform uninvertible_matrix;
   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
 
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(clip.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(animated.get(), uninvertible_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(120, 120), true, false);
   SetLayerPropertiesForTesting(surface.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(descendant_of_animation.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(200, 200), true, false);
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
-  AddAnimatedTransformToLayerWithPlayer(animated->id(), timeline(), 10.0,
-                                        start_transform_operations,
-                                        end_transform_operations);
+  SetElementIdsForTesting();
+  AddAnimatedTransformToElementWithPlayer(animated->element_id(), timeline(),
+                                          10.0, start_transform_operations,
+                                          end_transform_operations);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   // The animated layer has a singular transform and maps to a non-empty rect in
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect_for_testing());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(2, 2),
@@ skipping 26 matching lines @@
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
 
-  AddAnimatedFilterToLayerWithPlayer(child->id(), timeline_impl(), 10.0, 0.1f,
-                                     0.2f);
+  SetElementIdsForTesting();
+  AddAnimatedFilterToElementWithPlayer(child->element_id(), timeline_impl(),
+                                       10.0, 0.1f, 0.2f);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->filters().IsEmpty());
   EXPECT_TRUE(child->filters().IsEmpty());
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
@@ skipping 10 matching lines @@
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
 
+  SetElementIdsForTesting();
+
   std::unique_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(0.1f));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(0.3f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   curve->AddKeyframe(FilterKeyframe::Create(
       base::TimeDelta::FromMilliseconds(100), end_filters, nullptr));
   std::unique_ptr<Animation> animation =
       Animation::Create(std::move(curve), 0, 1, TargetProperty::FILTER);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
 
-  AddAnimationToLayerWithPlayer(child->id(), timeline_impl(),
-                                std::move(animation));
+  AddAnimationToElementWithPlayer(child->element_id(), timeline_impl(),
+                                  std::move(animation));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->filters().IsEmpty());
   EXPECT_TRUE(child->filters().IsEmpty());
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
@@ skipping 341 matching lines @@
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(greatgrandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   root->AddChild(child);
   child->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
 
   host()->SetRootLayer(root);
 
+  host()->SetElementIdsForTesting();
+
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
   grandchild->set_visible_layer_rect(gfx::Rect());
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
 
   child->SetTransform(singular);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
   child->SetTransform(identity);
 
   child->SetHideLayerAndSubtree(true);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
   child->SetHideLayerAndSubtree(false);
 
   gfx::Transform zero_z_scale;
   zero_z_scale.Scale3d(1, 1, 0);
   child->SetTransform(zero_z_scale);
 
+  SetElementIdsForTesting();

[ajuma, 2016/06/01 23:53:42]

Is this needed? (this test only has Layers, not LayerImpls)

[Ian Vollick, 2016/06/02 19:03:11]

Whoops, removed. I clearly added the host()->SetElementIdsForTesting above and
failed to remove this.

+
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)),
       animation_id, 1, TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  AddAnimationToLayerWithPlayer(child->id(), timeline(), std::move(animation));
+  AddAnimationToElementWithPlayer(child->element_id(), timeline(),
+                                  std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
   grandchild->set_visible_layer_rect(gfx::Rect());
 
-  RemoveAnimationFromLayerWithExistingPlayer(child->id(), timeline(),
-                                             animation_id);
+  RemoveAnimationFromElementWithExistingPlayer(child->element_id(), timeline(),
+                                               animation_id);
   child->SetTransform(identity);
   child->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
 
   // 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.
   grandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
   greatgrandchild->set_visible_layer_rect(gfx::Rect());
 
   // Add an opacity animation with a start delay.
   animation_id = 1;
   animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  AddAnimationToLayerWithExistingPlayer(child->id(), timeline(),
-                                        std::move(animation));
+  AddAnimationToElementWithExistingPlayer(child->element_id(), timeline(),
+                                          std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
@@ skipping 24 matching lines @@
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->AddChild(std::move(grandchild));
   root->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
+  host_impl.active_tree()->SetElementIdsForTesting();
+
   // Check the non-skipped case.
   // ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   // EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
 
@@ skipping 75 matching lines @@
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_ptr<Animation> transform_animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl.active_tree()->animation_host()->RegisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(root_ptr->id())
+      ->GetElementAnimationsForElementId(root_ptr->element_id())
       ->AddAnimation(std::move(transform_animation));
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetScrollClipLayer(root_ptr->id());
   root_ptr->SetTransform(singular);
   child_ptr->SetTransform(singular);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
-      root_ptr->id(), player.get());
+      root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform identity;
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
+  SetElementIdsForTesting();
 
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
   singular.matrix().set(0, 1, 1);
 
   child->SetTransform(singular);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_ptr<Animation> transform_animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl()->active_tree()->animation_host()->RegisterPlayerForElement(
-      grand_child->id(), player.get());
+      grand_child->element_id(), player.get());
   host_impl()
       ->active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(grand_child->id())
+      ->GetElementAnimationsForElementId(grand_child->element_id())
       ->AddAnimation(std::move(transform_animation));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), grand_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 
   host_impl()->active_tree()->animation_host()->UnregisterPlayerForElement(
-      grand_child->id(), player.get());
+      grand_child->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingPendingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   gfx::Transform identity;
@@ skipping 22 matching lines @@
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->AddChild(std::move(grandchild));
   root->AddChild(std::move(child));
 
   host_impl.pending_tree()->SetRootLayer(std::move(root));
+  host_impl.pending_tree()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   std::unique_ptr<TimingFunction> func = EaseTimingFunction::Create();
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta(), 0.9f, std::move(func)));
   curve->AddKeyframe(
       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());
+      root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
-      ->GetElementAnimationsForElementId(root_ptr->id())
+      ->GetElementAnimationsForElementId(root_ptr->element_id())
       ->AddAnimation(std::move(animation));
   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());
+      root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
@@ skipping 830 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimationsTrackingTest) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
+  host()->SetElementIdsForTesting();
+
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetOpacity(0.f);
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
-  player->AttachElement(animated->id());
+
+  player->AttachElement(animated->element_id());
 
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
       animation_id, 1, TargetProperty::OPACITY);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
-  AddAnimationToLayerWithExistingPlayer(animated->id(), timeline(),
-                                        std::move(animation));
+  AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
+                                          std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EffectTree& tree = root->layer_tree_host()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(animated->effect_tree_index());
   EXPECT_FALSE(node->data.is_currently_animating_opacity);
   EXPECT_TRUE(node->data.has_potential_opacity_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
   root->layer_tree_host()->AnimateLayers(
@@ skipping 10 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationsTrackingTest) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
+  host()->SetElementIdsForTesting();
+
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetForceRenderSurfaceForTesting(true);
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
-  player->AttachElement(animated->id());
+  player->AttachElement(animated->element_id());
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_ptr<Animation> animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
-  AddAnimationToLayerWithExistingPlayer(animated->id(), timeline(),
-                                        std::move(animation));
+  AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
+                                          std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   TransformTree& tree =
       root->layer_tree_host()->property_trees()->transform_tree;
   TransformNode* node = tree.Node(animated->transform_tree_index());
   EXPECT_FALSE(node->data.is_currently_animating);
   EXPECT_TRUE(node->data.has_potential_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
@@ skipping 235 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