Use element id's for animations

cc/trees/layer_tree_host_unittest_animation.cc

 // Copyright 2012 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.h"
 
 #include <stdint.h>
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_host.h"
@@ skipping 26 matching lines @@
         player_child_id_(AnimationIdProvider::NextPlayerId()) {
     timeline_ = AnimationTimeline::Create(timeline_id_);
     player_ = AnimationPlayer::Create(player_id_);
     player_child_ = AnimationPlayer::Create(player_child_id_);
 
     player_->set_animation_delegate(this);
   }
 
   void AttachPlayersToTimeline() {
     layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
+    layer_tree_host()->SetElementIdsForTesting();
     timeline_->AttachPlayer(player_.get());
     timeline_->AttachPlayer(player_child_.get());
   }
 
  protected:
   scoped_refptr<AnimationTimeline> timeline_;
   scoped_refptr<AnimationPlayer> player_;
   scoped_refptr<AnimationPlayer> player_child_;
 
   const int timeline_id_;
@@ skipping 81 matching lines @@
 // Add a layer animation and confirm that
 // LayerTreeHostImpl::UpdateAnimationState does get called.
 class LayerTreeHostAnimationTestAddAnimation
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : update_animation_state_was_called_(false) {}
 
   void BeginTest() override {
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     PostAddInstantAnimationToMainThreadPlayer(player_.get());
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
     EXPECT_FALSE(has_unfinished_animation);
     update_animation_state_was_called_ = true;
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
@@ skipping 20 matching lines @@
 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 // after a while, we do eventually force a draw.
 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
       : started_animating_(false) {}
 
   void BeginTest() override {
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     started_animating_ = true;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (started_animating_)
@@ skipping 17 matching lines @@
 
 // Ensures that animations eventually get deleted.
 class LayerTreeHostAnimationTestAnimationsGetDeleted
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationsGetDeleted()
       : started_animating_(false) {}
 
   void BeginTest() override {
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     bool have_animations = !host_impl->animation_host()
                                 ->active_element_animations_for_testing()
                                 .empty();
     if (!started_animating_ && have_animations) {
       started_animating_ = true;
@@ skipping 25 matching lines @@
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(picture_->id());
+    player_child_->AttachElement(picture_->element_id());
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThreadPlayer(player_child_.get());
   }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     // TODO(ajuma): This test only checks the active tree. Add checks for
     // pending tree too.
@@ skipping 45 matching lines @@
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
 
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
     player_child_->set_animation_delegate(this);
-    player_child_->AttachElement(picture_->id());
+    player_child_->AttachElement(picture_->element_id());
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThreadPlayer(player_child_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
     Animation* animation = player_child_->element_animations()->GetAnimation(
@@ skipping 33 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes);
 
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override {
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     PostAddInstantAnimationToMainThreadPlayer(player_.get());
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                int group) override {
     Animation* animation =
         player_->element_animations()->GetAnimation(TargetProperty::OPACITY);
     if (animation)
       player_->element_animations()->RemoveAnimation(animation->id());
@@ skipping 15 matching lines @@
       : update_check_layer_() {}
 
   void SetupTree() override {
     update_check_layer_ = FakePictureLayer::Create(&client_);
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     client_.set_bounds(update_check_layer_->bounds());
     LayerTreeHostAnimationTest::SetupTree();
 
     AttachPlayersToTimeline();
-    player_->AttachElement(update_check_layer_->id());
+    player_->AttachElement(update_check_layer_->element_id());
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThreadPlayer(player_.get());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     scoped_refptr<AnimationTimeline> timeline_impl =
         host_impl->animation_host()->GetTimelineById(timeline_id_);
     scoped_refptr<AnimationPlayer> player_impl =
@@ skipping 27 matching lines @@
 class LayerTreeHostAnimationTestLayerAddedWithAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       AttachPlayersToTimeline();
 
       scoped_refptr<Layer> layer = Layer::Create();
-      player_->AttachElement(layer->id());
+      layer->SetElementId(ElementId(42lu));
+      player_->AttachElement(layer->element_id());
       player_->set_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       std::unique_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve());
       std::unique_ptr<Animation> animation(
           Animation::Create(std::move(curve), 1, 1, TargetProperty::OPACITY));
       player_->AddAnimation(std::move(animation));
 
       // We add the animation *before* attaching the layer to the tree.
       layer_tree_host()->root_layer()->AddChild(layer);
@@ skipping 130 matching lines @@
 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     : public LayerTreeHostAnimationTest {
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(picture_->id());
+    player_child_->AttachElement(picture_->element_id());
     player_child_->set_animation_delegate(this);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
     LayerTreeHostAnimationTest::InitializeSettings(settings);
   }
 
@@ skipping 68 matching lines @@
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(1000, 1000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(scroll_layer_->id());
+    player_child_->AttachElement(scroll_layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         std::unique_ptr<ScrollOffsetAnimationCurve> curve(
             ScrollOffsetAnimationCurve::Create(
                 gfx::ScrollOffset(500.f, 550.f),
@@ skipping 36 matching lines @@
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(scroll_layer_->id());
+    player_child_->AttachElement(scroll_layer_->element_id());
     // Allows NotifyAnimationTakeover to get called.
     player_child_->set_animation_delegate(this);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Add an update after the first commit to trigger the animation takeover
       // path.
       layer_tree_host()
           ->animation_host()
           ->scroll_offset_animations()
-          .AddTakeoverUpdate(scroll_layer_->id());
+          .AddTakeoverUpdate(scroll_layer_->element_id());
       EXPECT_TRUE(layer_tree_host()
                       ->animation_host()
                       ->scroll_offset_animations()
                       .HasUpdatesForTesting());
     }
   }
 
   void WillCommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 0) {
       host_impl->animation_host()->ImplOnlyScrollAnimationCreate(
-          scroll_layer_->id(), gfx::ScrollOffset(650.f, 750.f),
+          scroll_layer_->element_id(), gfx::ScrollOffset(650.f, 750.f),
           gfx::ScrollOffset(10, 20));
     }
   }
 
   void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                double animation_start_time,
                                std::unique_ptr<AnimationCurve> curve) override {
     EndTest();
   }
@@ skipping 17 matching lines @@
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
     scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(scroll_layer_->id());
+    player_child_->AttachElement(scroll_layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Add an update after the first commit to trigger the animation update
       // path.
       layer_tree_host()
           ->animation_host()
           ->scroll_offset_animations()
-          .AddAdjustmentUpdate(scroll_layer_->id(),
+          .AddAdjustmentUpdate(scroll_layer_->element_id(),
                                gfx::Vector2dF(100.f, 100.f));
       EXPECT_TRUE(layer_tree_host()
                       ->animation_host()
                       ->scroll_offset_animations()
                       .HasUpdatesForTesting());
     } else if (layer_tree_host()->source_frame_number() == 2) {
       // Verify that the update queue is cleared after the update is applied.
       EXPECT_FALSE(layer_tree_host()
                        ->animation_host()
                        ->scroll_offset_animations()
                        .HasUpdatesForTesting());
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     // Note that the frame number gets incremented after BeginCommitOnThread but
     // before WillCommitCompleteOnThread and CommitCompleteOnThread.
     if (host_impl->sync_tree()->source_frame_number() == 0) {
       // This happens after the impl-only animation is added in
       // WillCommitCompleteOnThread.
       Animation* animation =
           host_impl->animation_host()
-              ->GetElementAnimationsForElementId(scroll_layer_->id())
+              ->GetElementAnimationsForElementId(scroll_layer_->element_id())
               ->GetAnimation(TargetProperty::SCROLL_OFFSET);
       ScrollOffsetAnimationCurve* curve =
           animation->curve()->ToScrollOffsetAnimationCurve();
 
       // Verifiy the initial and target position before the scroll offset
       // update from MT.
       EXPECT_EQ(Animation::RunState::RUNNING, animation->run_state());
       EXPECT_EQ(gfx::ScrollOffset(10.f, 20.f),
                 curve->GetValue(base::TimeDelta()));
       EXPECT_EQ(gfx::ScrollOffset(650.f, 750.f), curve->target_value());
     }
   }
 
   void WillCommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 0) {
       host_impl->animation_host()->ImplOnlyScrollAnimationCreate(
-          scroll_layer_->id(), gfx::ScrollOffset(650.f, 750.f),
+          scroll_layer_->element_id(), gfx::ScrollOffset(650.f, 750.f),
           gfx::ScrollOffset(10, 20));
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->sync_tree()->source_frame_number() == 1) {
       Animation* animation =
           host_impl->animation_host()
-              ->GetElementAnimationsForElementId(scroll_layer_->id())
+              ->GetElementAnimationsForElementId(scroll_layer_->element_id())
               ->GetAnimation(TargetProperty::SCROLL_OFFSET);
       ScrollOffsetAnimationCurve* curve =
           animation->curve()->ToScrollOffsetAnimationCurve();
       // Verifiy the initial and target position after the scroll offset
       // update from MT
       EXPECT_EQ(Animation::RunState::STARTING, animation->run_state());
       EXPECT_EQ(gfx::ScrollOffset(110.f, 120.f),
                 curve->GetValue(base::TimeDelta()));
       EXPECT_EQ(gfx::ScrollOffset(750.f, 850.f), curve->target_value());
 
@@ skipping 31 matching lines @@
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     std::unique_ptr<ScrollOffsetAnimationCurve> curve(
         ScrollOffsetAnimationCurve::Create(gfx::ScrollOffset(6500.f, 7500.f),
                                            EaseInOutTimingFunction::Create()));
     std::unique_ptr<Animation> animation(Animation::Create(
         std::move(curve), 1, 0, TargetProperty::SCROLL_OFFSET));
     animation->set_needs_synchronized_start_time(true);
 
     AttachPlayersToTimeline();
-    player_child_->AttachElement(scroll_layer_->id());
+    player_child_->AttachElement(scroll_layer_->element_id());
     player_child_->AddAnimation(std::move(animation));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
@@ skipping 87 matching lines @@
   LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers()
       : frame_count_with_pending_tree_(0) {}
 
   void BeginTest() override {
     AttachPlayersToTimeline();
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
-      player_->AttachElement(layer_tree_host()->root_layer()->id());
+      player_->AttachElement(layer_tree_host()->root_layer()->element_id());
       AddAnimatedTransformToPlayer(player_.get(), 4, 1, 1);
     } else if (layer_tree_host()->source_frame_number() == 2) {
       AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, 0.5f, true);
 
       scoped_refptr<Layer> layer = Layer::Create();
       layer_tree_host()->root_layer()->AddChild(layer);
+
+      layer_tree_host()->SetElementIdsForTesting();
       layer->SetBounds(gfx::Size(4, 4));
 
-      player_child_->AttachElement(layer->id());
+      player_child_->AttachElement(layer->element_id());
       player_child_->set_animation_delegate(this);
       AddOpacityTransitionToPlayer(player_child_.get(), 1, 0.f, 0.5f, true);
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 67 matching lines @@
 
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(2, 2));
     client_.set_bounds(layer_->bounds());
     // Transform the layer to 4,4 to start.
     gfx::Transform start_transform;
     start_transform.Translate(4.0, 4.0);
     layer_->SetTransform(start_transform);
 
     layer_tree_host()->root_layer()->AddChild(layer_);
-    player_->AttachElement(layer_->id());
+    layer_tree_host()->SetElementIdsForTesting();
+
+    player_->AttachElement(layer_->element_id());
 
     AttachPlayersToTimeline();
   }
 
   void BeginTest() override {
     // Add a translate from 6,7 to 8,9.
     TransformOperations start;
     start.AppendTranslate(6.f, 7.f, 0.f);
     TransformOperations end;
     end.AppendTranslate(8.f, 9.f, 0.f);
@@ skipping 49 matching lines @@
 // the animation should resume.
 class LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = Layer::Create();
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
 
+    layer_tree_host()->SetElementIdsForTesting();
+
     layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
     timeline_->AttachPlayer(player_.get());
-    player_->AttachElement(layer_->id());
+    player_->AttachElement(layer_->element_id());
     DCHECK(player_->element_animations());
 
     AddOpacityTransitionToPlayer(player_.get(), 10000.0, 0.1f, 0.9f, true);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
@@ skipping 61 matching lines @@
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = Layer::Create();
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
-    player_child_->AttachElement(layer_->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
+    player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // First frame: add an animation to the root layer.
         AddAnimatedTransformToPlayer(player_.get(), 0.1, 5, 5);
         break;
       case 2:
         // Second frame: add an animation to the content layer. The root layer
         // animation has caused us to animate already during this frame.
         AddOpacityTransitionToPlayer(player_child_.get(), 0.1, 5, 5, false);
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     // After both animations have started, verify that they have valid
     // start times.
     if (host_impl->active_tree()->source_frame_number() < 2)
       return;
     AnimationHost::ElementToAnimationsMap element_animations_copy =
         host_impl->animation_host()->active_element_animations_for_testing();
     EXPECT_EQ(2u, element_animations_copy.size());
     for (auto& it : element_animations_copy) {
-      int id = it.first;
-      if (id == host_impl->RootLayer()->id()) {
+      ElementId id = it.first;
+      if (id == host_impl->RootLayer()->element_id()) {
         Animation* anim = it.second->GetAnimation(TargetProperty::TRANSFORM);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
-      } else if (id == layer_->id()) {
+      } else if (id == layer_->element_id()) {
         Animation* anim = it.second->GetAnimation(TargetProperty::OPACITY);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
       }
       EndTest();
     }
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
 
 class LayerTreeHostAnimationTestRemoveAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
-    player_child_->AttachElement(layer_->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
+    player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         AddAnimatedTransformToPlayer(player_child_.get(), 1.0, 5, 5);
         break;
       case 2:
@@ skipping 57 matching lines @@
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_->id());
+    player_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
         break;
       case 2:
@@ skipping 61 matching lines @@
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
-    player_child_->AttachElement(layer_->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
+    player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1)
       AddAnimatedTransformToPlayer(player_child_.get(), 0.04, 5, 5);
   }
 
   void WillCommit() override {
@@ skipping 52 matching lines @@
       : called_animation_started_(false), called_animation_finished_(false) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
-    player_->AttachElement(picture_->id());
+    player_->AttachElement(picture_->element_id());
     player_->set_animation_delegate(this);
   }
 
   void BeginTest() override {
     PostAddLongAnimationToMainThreadPlayer(player_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {
@@ skipping 29 matching lines @@
 // if we destroy ElementAnimations.
 class LayerTreeHostAnimationTestSetPotentiallyAnimatingOnLacDestruction
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     prev_screen_space_transform_is_animating_ = true;
     screen_space_transform_animation_stopped_ = false;
 
     LayerTreeHostAnimationTest::SetupTree();
     AttachPlayersToTimeline();
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
     AddAnimatedTransformToPlayer(player_.get(), 1.0, 5, 5);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->pending_tree()->source_frame_number() <= 1) {
       EXPECT_TRUE(host_impl->pending_tree()
                       ->root_layer()
                       ->screen_space_transform_is_animating());
@@ skipping 63 matching lines @@
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
     layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
-    player_->AttachElement(layer_tree_host()->root_layer()->id());
-    player_child_->AttachElement(layer_->id());
+    player_->AttachElement(layer_tree_host()->root_layer()->element_id());
+    player_child_->AttachElement(layer_->element_id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1 ||
         layer_tree_host()->source_frame_number() == 2)
       PostSetNeedsCommitToMainThread();
   }
 
@@ skipping 16 matching lines @@
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
 
 }  // namespace
 }  // namespace cc