cc : Delete code not used outside tests related to impl-only animations

cc/animation/element_animations.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/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 124 matching lines @@
   // and only after the animations are deleted on the main thread
   // this insures we will never push an animation twice.
   RemoveAnimationsCompletedOnMainThread(element_animations_impl.get());
 
   PushPropertiesToImplThread(element_animations_impl.get());
   element_animations_impl->UpdateActivation(NORMAL_ACTIVATION);
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::AddAnimation(std::unique_ptr<Animation> animation) {
+  DCHECK(!animation->is_impl_only() ||
+         animation->target_property() == TargetProperty::SCROLL_OFFSET);
   bool added_transform_animation =
       animation->target_property() == TargetProperty::TRANSFORM;
   bool added_opacity_animation =
       animation->target_property() == TargetProperty::OPACITY;
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
   if (added_transform_animation)
     UpdateClientAnimationState(TargetProperty::TRANSFORM);
   if (added_opacity_animation)
     UpdateClientAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
   if (!has_element_in_active_list() && !has_element_in_pending_list())
     return;
 
   if (needs_to_start_animations_)
     StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
   UpdateClientAnimationState(TargetProperty::OPACITY);
   UpdateClientAnimationState(TargetProperty::TRANSFORM);
 }
 
-void ElementAnimations::AccumulatePropertyUpdates(
-    base::TimeTicks monotonic_time,
-    AnimationEvents* events) {
-  if (!events)
-    return;
-
-  for (size_t i = 0; i < animations_.size(); ++i) {
-    Animation* animation = animations_[i].get();
-    if (!animation->is_impl_only())
-      continue;
-
-    if (!animation->InEffect(monotonic_time))
-      continue;
-
-    base::TimeDelta trimmed =
-        animation->TrimTimeToCurrentIteration(monotonic_time);
-    switch (animation->target_property()) {
-      case TargetProperty::OPACITY: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
-                             animation->group(), TargetProperty::OPACITY,
-                             monotonic_time);
-        const FloatAnimationCurve* float_animation_curve =
-            animation->curve()->ToFloatAnimationCurve();
-        event.opacity = float_animation_curve->GetValue(trimmed);
-        event.is_impl_only = true;
-        events->events_.push_back(event);
-        break;
-      }
-
-      case TargetProperty::TRANSFORM: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
-                             animation->group(), TargetProperty::TRANSFORM,
-                             monotonic_time);
-        const TransformAnimationCurve* transform_animation_curve =
-            animation->curve()->ToTransformAnimationCurve();
-        event.transform = transform_animation_curve->GetValue(trimmed);
-        event.is_impl_only = true;
-        events->events_.push_back(event);
-        break;
-      }
-
-      case TargetProperty::FILTER: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
-                             animation->group(), TargetProperty::FILTER,
-                             monotonic_time);
-        const FilterAnimationCurve* filter_animation_curve =
-            animation->curve()->ToFilterAnimationCurve();
-        event.filters = filter_animation_curve->GetValue(trimmed);
-        event.is_impl_only = true;
-        events->events_.push_back(event);
-        break;
-      }
-
-      case TargetProperty::BACKGROUND_COLOR: {
-        break;
-      }
-
-      case TargetProperty::SCROLL_OFFSET: {
-        // Impl-side changes to scroll offset are already sent back to the
-        // main thread (e.g. for user-driven scrolling), so a PROPERTY_UPDATE
-        // isn't needed.
-        break;
-      }
-    }
-  }
-}
-
 void ElementAnimations::UpdateState(bool start_ready_animations,
                                     AnimationEvents* events) {
   if (!has_element_in_active_list())
     return;
 
   // Animate hasn't been called, this happens if an element has been added
   // between the Commit and Draw phases.
   if (last_tick_time_ == base::TimeTicks())
     return;
 
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (needs_to_start_animations_ && start_ready_animations) {
     StartAnimations(last_tick_time_);
     PromoteStartedAnimations(last_tick_time_, events);
   }
 
-  AccumulatePropertyUpdates(last_tick_time_, events);
-
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::ActivateAnimations() {
   bool changed_transform_animation = false;
   bool changed_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
         animations_[i]->affects_pending_elements()) {
       if (animations_[i]->target_property() == TargetProperty::TRANSFORM)
@@ skipping 1226 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc