1 files changed, 57 insertions, 20 deletions

diff --git a/chromium/cc/animation/layer_animation_controller.h b/chromium/cc/animation/layer_animation_controller.h
index 564a5933e7f..72f4c46a9cc 100644
--- a/chromium/cc/animation/layer_animation_controller.h
+++ b/chromium/cc/animation/layer_animation_controller.h
@@ -40,7 +40,7 @@ class CC_EXPORT LayerAnimationController
   int id() const { return id_; }
 
   void AddAnimation(scoped_ptr<Animation> animation);
-  void PauseAnimation(int animation_id, double time_offset);
+  void PauseAnimation(int animation_id, base::TimeDelta time_offset);
   void RemoveAnimation(int animation_id);
   void RemoveAnimation(int animation_id,
                        Animation::TargetProperty target_property);
@@ -52,13 +52,18 @@ class CC_EXPORT LayerAnimationController
   virtual void PushAnimationUpdatesTo(
       LayerAnimationController* controller_impl);
 
-  void Animate(double monotonic_time);
-  void AccumulatePropertyUpdates(double monotonic_time,
+  void Animate(base::TimeTicks monotonic_time);
+  void AccumulatePropertyUpdates(base::TimeTicks monotonic_time,
                                  AnimationEventsVector* events);
 
   void UpdateState(bool start_ready_animations,
                    AnimationEventsVector* events);
 
+  // Make animations affect active observers if and only if they affect
+  // pending observers. Any animations that no longer affect any observers
+  // are deleted.
+  void ActivateAnimations();
+
   // Returns the active animation in the given group, animating the given
   // property, if such an animation exists.
   Animation* GetAnimation(int group_id,
@@ -73,7 +78,7 @@ class CC_EXPORT LayerAnimationController
   bool HasActiveAnimation() const;
 
   // Returns true if there are any animations at all to process.
-  bool has_any_animation() const { return !active_animations_.empty(); }
+  bool has_any_animation() const { return !animations_.empty(); }
 
   // Returns true if there is an animation currently animating the given
   // property, or if there is an animation scheduled to animate this property in
@@ -83,10 +88,8 @@ class CC_EXPORT LayerAnimationController
   void SetAnimationRegistrar(AnimationRegistrar* registrar);
   AnimationRegistrar* animation_registrar() { return registrar_; }
 
-  void NotifyAnimationStarted(const AnimationEvent& event,
-                              double wall_clock_time);
-  void NotifyAnimationFinished(const AnimationEvent& event,
-                               double wall_clock_time);
+  void NotifyAnimationStarted(const AnimationEvent& event);
+  void NotifyAnimationFinished(const AnimationEvent& event);
   void NotifyAnimationAborted(const AnimationEvent& event);
   void NotifyAnimationPropertyUpdate(const AnimationEvent& event);
 
@@ -109,7 +112,29 @@ class CC_EXPORT LayerAnimationController
     layer_animation_delegate_ = delegate;
   }
 
-  bool AnimatedBoundsForBox(const gfx::BoxF& box, gfx::BoxF* bounds);
+  bool HasFilterAnimationThatInflatesBounds() const;
+  bool HasTransformAnimationThatInflatesBounds() const;
+  bool HasAnimationThatInflatesBounds() const {
+    return HasTransformAnimationThatInflatesBounds() ||
+           HasFilterAnimationThatInflatesBounds();
+  }
+
+  bool FilterAnimationBoundsForBox(const gfx::BoxF& box,
+                                   gfx::BoxF* bounds) const;
+  bool TransformAnimationBoundsForBox(const gfx::BoxF& box,
+                                      gfx::BoxF* bounds) const;
+
+  bool HasAnimationThatAffectsScale() const;
+
+  bool HasOnlyTranslationTransforms() const;
+
+  // Sets |max_scale| to the maximum scale along any dimension during active
+  // animations. Returns false if the maximum scale cannot be computed.
+  bool MaximumScale(float* max_scale) const;
+
+  bool needs_to_start_animations_for_testing() {
+    return needs_to_start_animations_;
+  }
 
  protected:
   friend class base::RefCounted<LayerAnimationController>;
@@ -127,15 +152,15 @@ class CC_EXPORT LayerAnimationController
   void PushPropertiesToImplThread(
       LayerAnimationController* controller_impl) const;
 
-  void StartAnimations(double monotonic_time);
-  void PromoteStartedAnimations(double monotonic_time,
+  void StartAnimations(base::TimeTicks monotonic_time);
+  void PromoteStartedAnimations(base::TimeTicks monotonic_time,
                                 AnimationEventsVector* events);
-  void MarkFinishedAnimations(double monotonic_time);
-  void MarkAnimationsForDeletion(double monotonic_time,
+  void MarkFinishedAnimations(base::TimeTicks monotonic_time);
+  void MarkAnimationsForDeletion(base::TimeTicks monotonic_time,
                                  AnimationEventsVector* events);
   void PurgeAnimationsMarkedForDeletion();
 
-  void TickAnimations(double monotonic_time);
+  void TickAnimations(base::TimeTicks monotonic_time);
 
   enum UpdateActivationType {
     NormalActivation,
@@ -143,10 +168,18 @@ class CC_EXPORT LayerAnimationController
   };
   void UpdateActivation(UpdateActivationType type);
 
-  void NotifyObserversOpacityAnimated(float opacity);
-  void NotifyObserversTransformAnimated(const gfx::Transform& transform);
-  void NotifyObserversFilterAnimated(const FilterOperations& filter);
-  void NotifyObserversScrollOffsetAnimated(gfx::Vector2dF scroll_offset);
+  void NotifyObserversOpacityAnimated(float opacity,
+                                      bool notify_active_observers,
+                                      bool notify_pending_observers);
+  void NotifyObserversTransformAnimated(const gfx::Transform& transform,
+                                        bool notify_active_observers,
+                                        bool notify_pending_observers);
+  void NotifyObserversFilterAnimated(const FilterOperations& filter,
+                                     bool notify_active_observers,
+                                     bool notify_pending_observers);
+  void NotifyObserversScrollOffsetAnimated(const gfx::Vector2dF& scroll_offset,
+                                           bool notify_active_observers,
+                                           bool notify_pending_observers);
 
   void NotifyObserversAnimationWaitingForDeletion();
 
@@ -155,12 +188,12 @@ class CC_EXPORT LayerAnimationController
 
   AnimationRegistrar* registrar_;
   int id_;
-  ScopedPtrVector<Animation> active_animations_;
+  ScopedPtrVector<Animation> animations_;
 
   // This is used to ensure that we don't spam the registrar.
   bool is_active_;
 
-  double last_tick_time_;
+  base::TimeTicks last_tick_time_;
 
   ObserverList<LayerAnimationValueObserver> value_observers_;
   ObserverList<LayerAnimationEventObserver> event_observers_;
@@ -169,6 +202,10 @@ class CC_EXPORT LayerAnimationController
 
   AnimationDelegate* layer_animation_delegate_;
 
+  // Only try to start animations when new animations are added or when the
+  // previous attempt at starting animations failed to start all animations.
+  bool needs_to_start_animations_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };