CC Animation: Erase ElementAnimations::ObserverType.

cc/animation/animation_host.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_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
+#include "cc/trees/mutator_host_client.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 
 class AnimationHost::ScrollOffsetAnimations : public AnimationDelegate {
  public:
   explicit ScrollOffsetAnimations(AnimationHost* animation_host)
       : animation_host_(animation_host),
         scroll_offset_timeline_(
@@ skipping 398 matching lines @@
   }
 }
 
 bool AnimationHost::ScrollOffsetAnimationWasInterrupted(int layer_id) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->scroll_offset_animation_was_interrupted()
              : false;
 }
 
-static ElementAnimations::ObserverType ObserverTypeFromTreeType(
-    LayerTreeType tree_type) {
-  return tree_type == LayerTreeType::ACTIVE
-             ? ElementAnimations::ObserverType::ACTIVE
-             : ElementAnimations::ObserverType::PENDING;
-}
-
 bool AnimationHost::IsAnimatingFilterProperty(int layer_id,
                                               LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::FILTER, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::FILTER, tree_type)
              : false;
 }
 
 bool AnimationHost::IsAnimatingOpacityProperty(int layer_id,
                                                LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::OPACITY, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::OPACITY, tree_type)
              : false;
 }
 
 bool AnimationHost::IsAnimatingTransformProperty(
     int layer_id,
     LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::TRANSFORM,
-                   ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::TRANSFORM, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningFilterAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::FILTER, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::FILTER, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningOpacityAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::OPACITY, ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::OPACITY, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningTransformAnimation(
     int layer_id,
     LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::TRANSFORM,
-                   ObserverTypeFromTreeType(tree_type))
+                   TargetProperty::TRANSFORM, tree_type)
              : false;
 }
 
 bool AnimationHost::HasAnyAnimationTargetingProperty(
     int layer_id,
     TargetProperty::Type property) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   if (!element_animations)
     return false;
 
@@ skipping 79 matching lines @@
   return element_animations
              ? element_animations->TransformAnimationBoundsForBox(box, bounds)
              : true;
 }
 
 bool AnimationHost::HasOnlyTranslationTransforms(
     int layer_id,
     LayerTreeType tree_type) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
-             ? element_animations->HasOnlyTranslationTransforms(
-                   ObserverTypeFromTreeType(tree_type))
+             ? element_animations->HasOnlyTranslationTransforms(tree_type)
              : true;
 }
 
 bool AnimationHost::AnimationsPreserveAxisAlignment(int layer_id) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
              ? element_animations->AnimationsPreserveAxisAlignment()
              : true;
 }
 
 bool AnimationHost::MaximumTargetScale(int layer_id,
                                        LayerTreeType tree_type,
                                        float* max_scale) const {
   *max_scale = 0.f;
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
-             ? element_animations->MaximumTargetScale(
-                   ObserverTypeFromTreeType(tree_type), max_scale)
+             ? element_animations->MaximumTargetScale(tree_type, max_scale)
              : true;
 }
 
 bool AnimationHost::AnimationStartScale(int layer_id,
                                         LayerTreeType tree_type,
                                         float* start_scale) const {
   *start_scale = 0.f;
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations
-             ? element_animations->AnimationStartScale(
-                   ObserverTypeFromTreeType(tree_type), start_scale)
+             ? element_animations->AnimationStartScale(tree_type, start_scale)
              : true;
 }
 
 bool AnimationHost::HasAnyAnimation(int layer_id) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
   return element_animations ? element_animations->has_any_animation() : false;
 }
 
 bool AnimationHost::HasActiveAnimationForTesting(int layer_id) const {
   auto element_animations = GetElementAnimationsForLayerId(layer_id);
@@ skipping 59 matching lines @@
 const AnimationHost::LayerToElementAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
   return layer_to_element_animations_map_;
 }
 
 void AnimationHost::OnAnimationWaitingForDeletion() {
   animation_waiting_for_deletion_ = true;
 }
 
 }  // namespace cc