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

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 924 matching lines @@
       return;
     node->data.opacity = EffectiveOpacity();
     effect_tree.set_needs_update(true);
   }
 }
 
 void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() {
   if (scrollable())
     UpdatePropertyTreeScrollOffset();
 
-  if (HasAnyAnimationTargetingProperty(Animation::OPACITY))
+  if (HasAnyAnimationTargetingProperty(AnimationTargetProperty::OPACITY))
     UpdatePropertyTreeOpacity();
 
-  if (HasAnyAnimationTargetingProperty(Animation::TRANSFORM)) {
+  if (HasAnyAnimationTargetingProperty(AnimationTargetProperty::TRANSFORM)) {
     UpdatePropertyTreeTransform();
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
@@ skipping 198 matching lines @@
   filters_ = filters;
   NoteLayerPropertyChangedForSubtree();
 }
 
 bool LayerImpl::FilterIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::FILTER, observer_type)
+                   AnimationTargetProperty::FILTER, observer_type)
              : layer_tree_impl_->IsAnimatingFilterProperty(this);
 }
 
 bool LayerImpl::HasPotentiallyRunningFilterAnimation() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsPotentiallyAnimatingProperty(
-                   Animation::FILTER, observer_type)
+                   AnimationTargetProperty::FILTER, observer_type)
              : layer_tree_impl_->HasPotentiallyRunningFilterAnimation(this);
 }
 
 bool LayerImpl::FilterIsAnimatingOnImplOnly() const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->FilterIsAnimatingOnImplOnly(this);
 
-  Animation* filter_animation =
-      layer_animation_controller_->GetAnimation(Animation::FILTER);
+  Animation* filter_animation = layer_animation_controller_->GetAnimation(
+      AnimationTargetProperty::FILTER);
   return filter_animation && filter_animation->is_impl_only();
 }
 
 void LayerImpl::SetBackgroundFilters(
     const FilterOperations& filters) {
   if (background_filters_ == filters)
     return;
 
   background_filters_ = filters;
   NoteLayerPropertyChanged();
@@ skipping 24 matching lines @@
 float LayerImpl::EffectiveOpacity() const {
   return hide_layer_and_subtree_ ? 0.f : opacity_;
 }
 
 bool LayerImpl::OpacityIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::OPACITY, observer_type)
+                   AnimationTargetProperty::OPACITY, observer_type)
              : layer_tree_impl_->IsAnimatingOpacityProperty(this);
 }
 
 bool LayerImpl::HasPotentiallyRunningOpacityAnimation() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsPotentiallyAnimatingProperty(
-                   Animation::OPACITY, observer_type)
+                   AnimationTargetProperty::OPACITY, observer_type)
              : layer_tree_impl_->HasPotentiallyRunningOpacityAnimation(this);
 }
 
 bool LayerImpl::OpacityIsAnimatingOnImplOnly() const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->OpacityIsAnimatingOnImplOnly(this);
 
-  Animation* opacity_animation =
-      layer_animation_controller_->GetAnimation(Animation::OPACITY);
+  Animation* opacity_animation = layer_animation_controller_->GetAnimation(
+      AnimationTargetProperty::OPACITY);
   return opacity_animation && opacity_animation->is_impl_only();
 }
 
 void LayerImpl::SetElementId(uint64_t element_id) {
   if (element_id == element_id_)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerImpl::SetElementId", "id", element_id);
 
@@ skipping 84 matching lines @@
   transform_is_invertible_ = transform_is_invertible;
   NoteLayerPropertyChangedForSubtree();
 }
 
 bool LayerImpl::TransformIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::TRANSFORM, observer_type)
+                   AnimationTargetProperty::TRANSFORM, observer_type)
              : layer_tree_impl_->IsAnimatingTransformProperty(this);
 }
 
 bool LayerImpl::HasPotentiallyRunningTransformAnimation() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsPotentiallyAnimatingProperty(
-                   Animation::TRANSFORM, observer_type)
+                   AnimationTargetProperty::TRANSFORM, observer_type)
              : layer_tree_impl_->HasPotentiallyRunningTransformAnimation(this);
 }
 
 bool LayerImpl::TransformIsAnimatingOnImplOnly() const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->TransformIsAnimatingOnImplOnly(this);
 
-  Animation* transform_animation =
-      layer_animation_controller_->GetAnimation(Animation::TRANSFORM);
+  Animation* transform_animation = layer_animation_controller_->GetAnimation(
+      AnimationTargetProperty::TRANSFORM);
   return transform_animation && transform_animation->is_impl_only();
 }
 
 bool LayerImpl::HasOnlyTranslationTransforms() const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->HasOnlyTranslationTransforms(this);
 
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
@@ skipping 23 matching lines @@
     return layer_tree_impl_->AnimationStartScale(this, start_scale);
 
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_->AnimationStartScale(observer_type,
                                                           start_scale);
 }
 
 bool LayerImpl::HasAnyAnimationTargetingProperty(
-    Animation::TargetProperty property) const {
+    AnimationTargetProperty property) const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->HasAnyAnimationTargetingProperty(this, property);
 
   return !!layer_animation_controller_->GetAnimation(property);
 }
 
 bool LayerImpl::HasFilterAnimationThatInflatesBounds() const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->HasFilterAnimationThatInflatesBounds(this);
 
@@ skipping 340 matching lines @@
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 void LayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 int LayerImpl::NumDescendantsThatDrawContent() const {
   return num_descendants_that_draw_content_;
 }
 
-void LayerImpl::NotifyAnimationFinished(
-    base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
-    int group) {
-  if (target_property == Animation::SCROLL_OFFSET)
+void LayerImpl::NotifyAnimationFinished(base::TimeTicks monotonic_time,
+                                        AnimationTargetProperty target_property,
+                                        int group) {
+  if (target_property == AnimationTargetProperty::SCROLL_OFFSET)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 void LayerImpl::SetHasRenderSurface(bool should_have_render_surface) {
   if (!!render_surface() == should_have_render_surface)
     return;
 
   SetNeedsPushProperties();
   if (should_have_render_surface) {
     render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
@@ skipping 78 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc