CC Animation: Expose TargetProperty enum to be aliased in Blink Platform.

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"
@@ skipping 101 matching lines @@
     SetNeedsCommit();
   animations_.clear();
 }
 
 void AnimationPlayer::UnbindElementAnimations() {
   element_animations_ = nullptr;
   DCHECK(animations_.empty());
 }
 
 void AnimationPlayer::AddAnimation(scoped_ptr<Animation> animation) {
-  DCHECK(animation->target_property() != Animation::SCROLL_OFFSET ||
+  DCHECK(animation->target_property() != TargetProperty::SCROLL_OFFSET ||
          (animation_host_ && animation_host_->SupportsScrollAnimations()));
 
   if (element_animations_) {
     element_animations_->layer_animation_controller()->AddAnimation(
         std::move(animation));
     SetNeedsCommit();
   } else {
     animations_.push_back(std::move(animation));
   }
 }
@@ skipping 20 matching lines @@
   }
 }
 
 void AnimationPlayer::AbortAnimation(int animation_id) {
   DCHECK(element_animations_);
   element_animations_->layer_animation_controller()->AbortAnimation(
       animation_id);
   SetNeedsCommit();
 }
 
-void AnimationPlayer::AbortAnimations(
-    Animation::TargetProperty target_property) {
+void AnimationPlayer::AbortAnimations(TargetProperty::Type target_property) {
   if (element_animations_) {
     element_animations_->layer_animation_controller()->AbortAnimations(
         target_property);
     SetNeedsCommit();
   } else {
     auto animations_to_remove = std::remove_if(
         animations_.begin(), animations_.end(),
         [target_property](const scoped_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())
       player_impl->DetachLayer();
     if (layer_id_)
       player_impl->AttachLayer(layer_id_);
   }
 }
 
 void AnimationPlayer::NotifyAnimationStarted(
     base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
+    TargetProperty::Type target_property,
     int group) {
   if (layer_animation_delegate_)
     layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
                                                       target_property, group);
 }
 
 void AnimationPlayer::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
+    TargetProperty::Type target_property,
     int group) {
   if (layer_animation_delegate_)
     layer_animation_delegate_->NotifyAnimationFinished(monotonic_time,
                                                        target_property, group);
 }
 
 void AnimationPlayer::NotifyAnimationAborted(
     base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
+    TargetProperty::Type target_property,
     int group) {
   if (layer_animation_delegate_)
     layer_animation_delegate_->NotifyAnimationAborted(monotonic_time,
                                                       target_property, group);
 }
 
 void AnimationPlayer::SetNeedsCommit() {
   DCHECK(animation_host_);
   animation_host_->SetNeedsCommit();
   animation_host_->SetNeedsRebuildPropertyTrees();
 }
 
 }  // namespace cc