CC Animation: Start replacing int layer_id with ElementId element_id.

cc/animation/animation_player.cc

 // Copyright 2015 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/animation/animation_player.h"
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 
 namespace cc {
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
   return make_scoped_refptr(new AnimationPlayer(id));
 }
 
 AnimationPlayer::AnimationPlayer(int id)
     : animation_host_(),
       animation_timeline_(),
       element_animations_(),
       layer_animation_delegate_(),
       id_(id),
-      layer_id_(0) {
+      element_id_(0) {
   DCHECK(id_);
 }
 
 AnimationPlayer::~AnimationPlayer() {
   DCHECK(!animation_timeline_);
   DCHECK(!element_animations_);
 }
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
   scoped_refptr<AnimationPlayer> player = AnimationPlayer::Create(id());
   return player;
 }
 
 void AnimationPlayer::SetAnimationHost(AnimationHost* animation_host) {
   animation_host_ = animation_host;
 }
 
 void AnimationPlayer::SetAnimationTimeline(AnimationTimeline* timeline) {
   if (animation_timeline_ == timeline)
     return;
 
   // We need to unregister player to manage ElementAnimations and observers
   // properly.
-  if (layer_id_ && element_animations_)
+  if (element_id_ && element_animations_)
     UnregisterPlayer();
 
   animation_timeline_ = timeline;
 
   // Register player only if layer AND host attached.
-  if (layer_id_ && animation_host_)
+  if (element_id_ && animation_host_)
     RegisterPlayer();
 }
 
-void AnimationPlayer::AttachLayer(int layer_id) {
-  DCHECK_EQ(layer_id_, 0);
-  DCHECK(layer_id);
+void AnimationPlayer::AttachLayer(ElementId element_id) {
+  DCHECK_EQ(element_id_, 0);
+  DCHECK(element_id);
 
-  layer_id_ = layer_id;
+  element_id_ = element_id;
 
   // Register player only if layer AND host attached.
   if (animation_host_)
     RegisterPlayer();
 }
 
 void AnimationPlayer::DetachLayer() {
-  DCHECK(layer_id_);
+  DCHECK(element_id_);
 
   if (animation_host_)
     UnregisterPlayer();
 
-  layer_id_ = 0;
+  element_id_ = 0;
 }
 
 void AnimationPlayer::RegisterPlayer() {
-  DCHECK(layer_id_);
+  DCHECK(element_id_);
   DCHECK(animation_host_);
   DCHECK(!element_animations_);
 
   // Create ElementAnimations or re-use existing.
-  animation_host_->RegisterPlayerForLayer(layer_id_, this);
+  animation_host_->RegisterPlayerForLayer(element_id_, this);
   // Get local reference to shared ElementAnimations.
   BindElementAnimations();
 }
 
 void AnimationPlayer::UnregisterPlayer() {
-  DCHECK(layer_id_);
+  DCHECK(element_id_);
   DCHECK(animation_host_);
   DCHECK(element_animations_);
 
   UnbindElementAnimations();
   // Destroy ElementAnimations or release it if it's still needed.
-  animation_host_->UnregisterPlayerForLayer(layer_id_, this);
+  animation_host_->UnregisterPlayerForLayer(element_id_, this);
 }
 
 void AnimationPlayer::BindElementAnimations() {
   DCHECK(!element_animations_);
   element_animations_ =
-      animation_host_->GetElementAnimationsForLayerId(layer_id_);
+      animation_host_->GetElementAnimationsForLayerId(element_id_);
   DCHECK(element_animations_);
 
   // Pass all accumulated animations to ElementAnimations.
   for (auto& animation : animations_) {
     element_animations_->AddAnimation(std::move(animation));
   }
   if (!animations_.empty())
     SetNeedsCommit();
   animations_.clear();
 }
@@ skipping 51 matching lines @@
     auto animations_to_remove = std::remove_if(
         animations_.begin(), animations_.end(),
         [target_property](const std::unique_ptr<Animation>& animation) {
           return animation->target_property() == target_property;
         });
     animations_.erase(animations_to_remove, animations_.end());
   }
 }
 
 void AnimationPlayer::PushPropertiesTo(AnimationPlayer* player_impl) {
-  if (layer_id_ != player_impl->layer_id()) {
-    if (player_impl->layer_id())
+  if (element_id_ != player_impl->element_id()) {
+    if (player_impl->element_id())
       player_impl->DetachLayer();
-    if (layer_id_)
-      player_impl->AttachLayer(layer_id_);
+    if (element_id_)
+      player_impl->AttachLayer(element_id_);
   }
 }
 
 void AnimationPlayer::NotifyAnimationStarted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   if (layer_animation_delegate_)
     layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
                                                       target_property, group);
@@ skipping 30 matching lines @@
   }
 }
 
 void AnimationPlayer::SetNeedsCommit() {
   DCHECK(animation_host_);
   animation_host_->SetNeedsCommit();
   animation_host_->SetNeedsRebuildPropertyTrees();
 }
 
 }  // namespace cc