CC: Add fill mode to 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 48 matching lines @@
                      int group_id,
                      TargetProperty target_property)
     : curve_(curve.Pass()),
       id_(animation_id),
       group_(group_id),
       target_property_(target_property),
       run_state_(WaitingForTargetAvailability),
       iterations_(1),
       direction_(Normal),
       playback_rate_(1),
+      fill_mode_(FillModeNone),
       needs_synchronized_start_time_(false),
       received_finished_event_(false),
       suspended_(false),
       is_controlling_instance_(false),
       is_impl_only_(false),
       affects_active_observers_(true),
       affects_pending_observers_(true) {
 }
 
 Animation::~Animation() {
@@ skipping 72 matching lines @@
 
   if (playback_rate_ == 0)
     return false;
 
   return run_state_ == Running && iterations_ >= 0 &&
          iterations_ * curve_->Duration() / std::abs(playback_rate_) <=
              (monotonic_time + time_offset_ - start_time_ - total_paused_time_)
                  .InSecondsF();
 }
 
-double Animation::TrimTimeToCurrentIteration(
-    base::TimeTicks monotonic_time) const {
+bool Animation::NoEffectBeforeAnimation(base::TimeTicks monotonic_time) const {

[dstockwell, 2014/09/18 00:14:29]

This method name is a little strange, perhaps just InEffect(time) (and negating
at the call site)

[samli, 2014/09/18 00:59:55]

Done.

+  return ConvertToActiveTime(monotonic_time) < 0 &&
+         (fill_mode_ == FillModeNone || fill_mode_ == FillModeForwards);
+}
+
+double Animation::ConvertToActiveTime(base::TimeTicks monotonic_time) const {
   base::TimeTicks trimmed = monotonic_time + time_offset_;
 
-  // Zero playback rate not supported
-  DCHECK(playback_rate_);
-
   // If we're paused, time is 'stuck' at the pause time.
   if (run_state_ == Paused)
     trimmed = pause_time_;
 
   // Returned time should always be relative to the start time and should
   // subtract all time spent paused.
   trimmed -= (start_time_ - base::TimeTicks()) + 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 = base::TimeTicks() + time_offset_;
 
-  double active_time = (trimmed - base::TimeTicks()).InSecondsF();
+  return (trimmed - base::TimeTicks()).InSecondsF();
+}
+
+double Animation::TrimTimeToCurrentIteration(
+    base::TimeTicks monotonic_time) const {
+  // Zero playback rate not supported
+  DCHECK(playback_rate_);
+
+  double active_time = ConvertToActiveTime(monotonic_time);
 
   // Return 0 if we are before the start of the animation
   if (active_time < 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.
@@ skipping 56 matching lines @@
   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->playback_rate_ = playback_rate_;
+  to_return->fill_mode_ = fill_mode_;
   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