Revert "Handle direction control in compositor Animations"

cc/animation/animation.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/animation/animation.h"
 
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "base/strings/string_util.h"
@@ skipping 47 matching lines @@
                      int animation_id,
                      int group_id,
                      TargetProperty target_property)
     : curve_(curve.Pass()),
       id_(animation_id),
       group_(group_id),
       target_property_(target_property),
       run_state_(WaitingForTargetAvailability),
       iterations_(1),
       start_time_(0),
-      direction_(Normal),
+      alternates_direction_(false),
       time_offset_(0),
       needs_synchronized_start_time_(false),
       received_finished_event_(false),
       suspended_(false),
       pause_time_(0),
       total_paused_time_(0),
       is_controlling_instance_(false),
       is_impl_only_(false) {}
 
 Animation::~Animation() {
@@ skipping 87 matching lines @@
   // Returned time should always be relative to the start time and should
   // subtract all time spent paused.
   trimmed -= start_time_ + total_paused_time_;
 
   // If we're just starting or we're waiting on receiving a start time,
   // time is 'stuck' at the initial state.
   if ((run_state_ == Starting && !has_set_start_time()) ||
       needs_synchronized_start_time())
     trimmed = time_offset_;
 
-  // Return 0 if we are before the start of the animation
-  if (trimmed < 0)
+  // Zero is always the start of the animation.
+  if (trimmed <= 0)
     return 0;
 
   // Always return zero if we have no iterations.
   if (!iterations_)
     return 0;
 
   // Don't attempt to trim if we have no duration.
   if (curve_->Duration() <= 0)
     return 0;
 
-  // check if we are past active interval
-  bool is_past_total_duration =
-      (iterations_ > 0 && trimmed >= curve_->Duration() * iterations_);
+  // If less than an iteration duration, just return trimmed.
+  if (trimmed < curve_->Duration())
+    return trimmed;
+
+  // If greater than or equal to the total duration, return iteration duration.
+  if (iterations_ >= 0 && trimmed >= curve_->Duration() * iterations_) {
+    if (alternates_direction_ && !(iterations_ % 2))
+      return 0;
+    return curve_->Duration();
+  }
 
   // We need to know the current iteration if we're alternating.
-  int iteration = 0;
+  int iteration = static_cast<int>(trimmed / curve_->Duration());
 
-  // If we are past the active interval, return iteration duration.
-  if (is_past_total_duration) {
-    iteration = iterations_;
-    trimmed = curve_->Duration();
-  } else {
-    iteration = static_cast<int>(trimmed / curve_->Duration());
-    // Calculate x where trimmed = x + n * curve_->Duration() for some positive
-    // integer n.
-    trimmed = fmod(trimmed, curve_->Duration());
-  }
+  // Calculate x where trimmed = x + n * curve_->Duration() for some positive
+  // integer n.
+  trimmed = fmod(trimmed, curve_->Duration());
 
-  // check if we are running the animation in reverse direction for the current
-  // iteration
-  bool reverse = (direction_ == Reverse) ||
-                 (direction_ == Alternate && iteration % 2 == 1) ||
-                 (direction_ == AlternateReverse && iteration % 2 == 0);
-
-  // if we are running the animation in reverse direction, reverse the result
-  if (reverse)
+  // If we're alternating and on an odd iteration, reverse the direction.
+  if (alternates_direction_ && iteration % 2 == 1)
     return curve_->Duration() - trimmed;
 
   return trimmed;
 }
 
 scoped_ptr<Animation> Animation::Clone() const {
   return CloneAndInitialize(run_state_, start_time_);
 }
 
 scoped_ptr<Animation> Animation::CloneAndInitialize(RunState initial_run_state,
                                                     double start_time) const {
   scoped_ptr<Animation> to_return(
       new Animation(curve_->Clone(), id_, group_, target_property_));
   to_return->run_state_ = initial_run_state;
   to_return->iterations_ = iterations_;
   to_return->start_time_ = start_time;
   to_return->pause_time_ = pause_time_;
   to_return->total_paused_time_ = total_paused_time_;
   to_return->time_offset_ = time_offset_;
-  to_return->direction_ = direction_;
+  to_return->alternates_direction_ = alternates_direction_;
   DCHECK(!to_return->is_controlling_instance_);
   to_return->is_controlling_instance_ = true;
   return to_return.Pass();
 }
 
 void Animation::PushPropertiesTo(Animation* other) const {
   // Currently, we only push changes due to pausing and resuming animations on
   // the main thread.
   if (run_state_ == Animation::Paused ||
       other->run_state_ == Animation::Paused) {
     other->run_state_ = run_state_;
     other->pause_time_ = pause_time_;
     other->total_paused_time_ = total_paused_time_;
   }
 }
 
 }  // namespace cc