Add support for inverse transform animations.

ui/compositor/layer_animation_element.h

 // Copyright (c) 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <set>
 
 #include "base/time/time.h"
@@ skipping 39 matching lines @@
     bool visibility;
     float brightness;
     float grayscale;
     SkColor color;
   };
 
   typedef std::set<AnimatableProperty> AnimatableProperties;
 
   LayerAnimationElement(const AnimatableProperties& properties,
                         base::TimeDelta duration);
+
   virtual ~LayerAnimationElement();
 
   // Creates an element that transitions to the given transform. The caller owns
   // the return value.
   static LayerAnimationElement* CreateTransformElement(
       const gfx::Transform& transform,
       base::TimeDelta duration);
 
+  // Creates an element that counters a transition to the given transform.
+  // This element maintains the invariant uninverted_transition->at(t) *
+  // this->at(t) == base_transform * this->at(t_start) for any t. The caller
+  // owns the return value.
+  static LayerAnimationElement* CreateInverseTransformElement(
+      const gfx::Transform& base_transform,
+      const LayerAnimationElement* uninverted_transition);
+
   // Creates an element that transitions to another in a way determined by an
   // interpolated transform. The element accepts ownership of the interpolated
   // transform. NB: at every step, the interpolated transform clobbers the
   // existing transform. That is, it does not interpolate between the existing
   // transform and the last value the interpolated transform will assume. It is
   // therefore important that the value of the interpolated at time 0 matches
   // the current transform.
   static LayerAnimationElement* CreateInterpolatedTransformElement(
       InterpolatedTransform* interpolated_transform,
       base::TimeDelta duration);
@@ skipping 93 matching lines @@
   Tween::Type tween_type() const { return tween_type_; }
   void set_tween_type(Tween::Type tween_type) { tween_type_ = tween_type; }
 
   // Each LayerAnimationElement has a unique animation_id. Elements belonging
   // to sequences that are supposed to start together have the same
   // animation_group_id.
   int animation_id() const { return animation_id_; }
   int animation_group_id() const { return animation_group_id_; }
   void set_animation_group_id(int id) { animation_group_id_ = id; }
 
+  base::TimeDelta duration() const { return duration_; }
+
   // The fraction of the animation that has been completed after the last
   // call made to {Progress, ProgressToEnd}.
   double last_progressed_fraction() const { return last_progressed_fraction_; }
 
  protected:
   // Called once each time the animation element is run before any call to
   // OnProgress.
   virtual void OnStart(LayerAnimationDelegate* delegate) = 0;
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) = 0;
   virtual void OnGetTarget(TargetValue* target) const = 0;
   virtual void OnAbort(LayerAnimationDelegate* delegate) = 0;
 
-  base::TimeDelta duration() const { return duration_; }
-
   // Actually start the animation, dispatching to another thread if needed.
   virtual void RequestEffectiveStart(LayerAnimationDelegate* delegate);
 
+  LayerAnimationElement(const LayerAnimationElement& element);
+
  private:
   // For debugging purposes, we sometimes alter the duration we actually use.
   // For example, during tests we often set duration = 0, and it is sometimes
   // useful to slow animations down to see them more clearly.
   base::TimeDelta GetEffectiveDuration(const base::TimeDelta& delta);
 
   bool first_frame_;
   const AnimatableProperties properties_;
   base::TimeTicks requested_start_time_;
 
   // When the animation actually started, taking into account queueing delays.
   base::TimeTicks effective_start_time_;
   const base::TimeDelta duration_;
   Tween::Type tween_type_;
 
   const int animation_id_;
   int animation_group_id_;
 
   double last_progressed_fraction_;
 
-  DISALLOW_COPY_AND_ASSIGN(LayerAnimationElement);
+  DISALLOW_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_