Thread ui opacity animations

ui/compositor/layer_animator.cc

 // 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.
 
 #include "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "cc/animation_id_provider.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 
 #define SAFE_INVOKE_VOID(function, running_anim, ...) \
     if (running_anim.is_sequence_alive()) \
       function(running_anim.sequence(), ##__VA_ARGS__)
@@ skipping 175 matching lines @@
   }
 
   // Starting a zero duration pause that affects all the animated properties
   // will prevent any of the sequences from animating until there are no
   // running animations that affect any of these properties, as well as
   // handle preemption strategy.
   StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreatePauseElement(animated_properties,
                                                 base::TimeDelta())));
 
+  bool wait_for_group_start = false;
+  for (iter = animations.begin(); iter != animations.end(); ++iter)
+    wait_for_group_start |= (*iter)->IsFirstElementThreaded();
+
+  int group_id = cc::AnimationIdProvider::NextGroupId();
+
   // These animations (provided they don't animate any common properties) will
   // now animate together if trivially scheduled.
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
+    (*iter)->set_animation_group_id(group_id);
+    (*iter)->set_waiting_for_group_start(wait_for_group_start);
     ScheduleAnimation(*iter);
   }
 
   adding_animations_ = false;
   UpdateAnimationState();
 }
 
 
 void LayerAnimator::ScheduleTogether(
     const std::vector<LayerAnimationSequence*>& animations) {
   scoped_refptr<LayerAnimator> retain(this);
 
   // Collect all the affected properties.
   LayerAnimationElement::AnimatableProperties animated_properties;
   std::vector<LayerAnimationSequence*>::const_iterator iter;
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     animated_properties.insert((*iter)->properties().begin(),
                                (*iter)->properties().end());
   }
 
   // Scheduling a zero duration pause that affects all the animated properties
   // will prevent any of the sequences from animating until there are no
   // running animations that affect any of these properties.
   ScheduleAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreatePauseElement(animated_properties,
                                                 base::TimeDelta())));
 
+  bool wait_for_group_start = false;
+  for (iter = animations.begin(); iter != animations.end(); ++iter)
+    wait_for_group_start |= (*iter)->IsFirstElementThreaded();
+
+  int group_id = cc::AnimationIdProvider::NextGroupId();
+
   // These animations (provided they don't animate any common properties) will
   // now animate together if trivially scheduled.
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
+    (*iter)->set_animation_group_id(group_id);
+    (*iter)->set_waiting_for_group_start(wait_for_group_start);
     ScheduleAnimation(*iter);
   }
 
   UpdateAnimationState();
 }
 
 void LayerAnimator::SchedulePauseForProperties(
     base::TimeDelta duration,
     LayerAnimationElement::AnimatableProperty property,
     ...) {
@@ skipping 44 matching lines @@
 
 void LayerAnimator::RemoveObserver(LayerAnimationObserver* observer) {
   observers_.RemoveObserver(observer);
   // Remove the observer from all sequences as well.
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     (*queue_iter)->RemoveObserver(observer);
   }
 }
 
+void LayerAnimator::OnThreadedAnimationStarted(
+    const cc::AnimationEvent& event) {
+  LayerAnimationElement::AnimatableProperty property =
+    LayerAnimationElement::ToAnimatableProperty(event.targetProperty);
+
+  RunningAnimation* running = GetRunningAnimation(property);
+  if (!running)
+    return;
+  DCHECK(running->is_sequence_alive());
+
+  if (running->sequence()->animation_group_id() != event.groupId)
+    return;
+
+  running->sequence()->OnThreadedAnimationStarted(event);
+  if (!running->sequence()->waiting_for_group_start())
+    return;
+
+  base::TimeTicks start_time = base::TimeTicks::FromInternalValue(
+      event.monotonicTime * base::Time::kMicrosecondsPerSecond);
+
+  running->sequence()->set_waiting_for_group_start(false);
+
+  // The call to GetRunningAnimation made above already purged deleted
+  // animations, so we are guaranteed that all the animations we iterate
+  // over now are alive.
+  for (RunningAnimations::iterator iter = running_animations_.begin();
+       iter != running_animations_.end(); ++iter) {
+    // Ensure that each sequence is only Started once, regardless of the
+    // number of sequences in the group that have threaded first elements.
+    if (((*iter).sequence()->animation_group_id() == event.groupId) &&
+        !(*iter).sequence()->IsFirstElementThreaded() &&
+        (*iter).sequence()->waiting_for_group_start()) {
+      (*iter).sequence()->set_start_time(start_time);
+      (*iter).sequence()->set_waiting_for_group_start(false);
+      (*iter).sequence()->Start(delegate());
+    }
+  }
+}
+
 // LayerAnimator protected -----------------------------------------------------
 
 void LayerAnimator::ProgressAnimation(LayerAnimationSequence* sequence,
                                       base::TimeTicks now) {
-  if (!delegate())
+  if (!delegate() || sequence->waiting_for_group_start())
     return;
 
   sequence->Progress(now, delegate());
 }
 
 void LayerAnimator::ProgressAnimationToEnd(LayerAnimationSequence* sequence) {
   if (!delegate())
     return;
 
   sequence->ProgressToEnd(delegate());
@@ skipping 75 matching lines @@
   else if (!should_start && is_started_)
     GetAnimationContainer()->Stop(this);
 
   is_started_ = should_start;
 }
 
 LayerAnimationSequence* LayerAnimator::RemoveAnimation(
     LayerAnimationSequence* sequence) {
   linked_ptr<LayerAnimationSequence> to_return;
 
+  bool is_running = false;
+
   // First remove from running animations
   for (RunningAnimations::iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
     if ((*iter).sequence() == sequence) {
       running_animations_.erase(iter);
+      is_running = true;
       break;
     }
   }
 
   // Then remove from the queue
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     if ((*queue_iter) == sequence) {
       to_return = *queue_iter;
       animation_queue_.erase(queue_iter);
       break;
     }
   }
 
+  if (!to_return.get() ||
+      !to_return->waiting_for_group_start() ||
+      !to_return->IsFirstElementThreaded())
+    return to_return.release();
+
+  // The removed sequence may have been responsible for making other sequences
+  // wait for a group start. If no other sequences in the group have a
+  // threaded first element, the group no longer needs the additional wait.
+  bool is_wait_still_needed = false;
+  int group_id = to_return->animation_group_id();
+  for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
+       queue_iter != animation_queue_.end(); ++queue_iter) {
+    if (((*queue_iter)->animation_group_id() == group_id) &&
+        (*queue_iter)->IsFirstElementThreaded()) {
+      is_wait_still_needed = true;
+      break;
+    }
+  }
+
+  if (is_wait_still_needed)
+    return to_return.release();
+
+  for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
+       queue_iter != animation_queue_.end(); ++queue_iter) {
+    if ((*queue_iter)->animation_group_id() == group_id &&
+        (*queue_iter)->waiting_for_group_start()) {
+      (*queue_iter)->set_waiting_for_group_start(false);
+      if (is_running) {
+        (*queue_iter)->set_start_time(last_step_time_);
+        (*queue_iter)->Start(delegate());
+      }
+    }
+  }
   return to_return.release();
 }
 
 void LayerAnimator::FinishAnimation(
     LayerAnimationSequence* sequence, bool abort) {
   scoped_refptr<LayerAnimator> retain(this);
   scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequence));
   if (abort)
-    sequence->Abort();
+    sequence->Abort(delegate());
   else
     ProgressAnimationToEnd(sequence);
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::FinishAnyAnimationWithZeroDuration() {
   scoped_refptr<LayerAnimator> retain(this);
   // Special case: if we've started a 0 duration animation, just finish it now
   // and get rid of it. We need to make a copy because Progress may indirectly
@@ skipping 55 matching lines @@
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     if (running_animations_copy[i].sequence()->HasCommonProperty(
             sequence->properties())) {
       scoped_ptr<LayerAnimationSequence> removed(
           SAFE_INVOKE_PTR(RemoveAnimation, running_animations_copy[i]));
       if (abort)
-        running_animations_copy[i].sequence()->Abort();
+        running_animations_copy[i].sequence()->Abort(delegate());
       else
         SAFE_INVOKE_VOID(ProgressAnimationToEnd, running_animations_copy[i]);
     }
   }
 
   // Same for the queued animations that haven't been started. Again, we'll
   // need to operate on a copy.
   std::vector<base::WeakPtr<LayerAnimationSequence> > sequences;
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter)
     sequences.push_back((*queue_iter)->AsWeakPtr());
 
   for (size_t i = 0; i < sequences.size(); ++i) {
     if (!sequences[i] || !HasAnimation(sequences[i]))
       continue;
 
     if (sequences[i]->HasCommonProperty(sequence->properties())) {
       scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequences[i]));
       if (abort)
-        sequences[i]->Abort();
+        sequences[i]->Abort(delegate());
       else
         ProgressAnimationToEnd(sequences[i]);
     }
   }
 }
 
 void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
       sequence->AsWeakPtr();
@@ skipping 141 matching lines @@
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
   base::TimeTicks start_time;
   if (is_animating() || adding_animations_)
     start_time = last_step_time_;
   else if (GetAnimationContainer()->is_running())
     start_time = GetAnimationContainer()->last_tick_time();
   else
     start_time = base::TimeTicks::Now();
 
-  sequence->set_start_time(start_time);
+  if (!sequence->animation_group_id())
+    sequence->set_animation_group_id(cc::AnimationIdProvider::NextGroupId());
+  if (!sequence->waiting_for_group_start() ||
+      sequence->IsFirstElementThreaded()) {
+    sequence->set_start_time(start_time);
+    sequence->Start(delegate());
+  }
   running_animations_.push_back(
       RunningAnimation(sequence->AsWeakPtr()));
 
   // Need to keep a reference to the animation.
   AddToQueueIfNotPresent(sequence);
 
   // Ensure that animations get stepped at their start time.
   Step(start_time);
 
   return true;
@@ skipping 28 matching lines @@
   // Abort should never affect the set of running animations, but just in case
   // clients are badly behaved, we will use a copy of the running animations.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     scoped_ptr<LayerAnimationSequence> removed(
         RemoveAnimation(running_animations_copy[i].sequence()));
     if (removed.get())
-      removed->Abort();
+      removed->Abort(delegate());
   }
   // This *should* have cleared the list of running animations.
   DCHECK(running_animations_.empty());
   running_animations_.clear();
   animation_queue_.clear();
   UpdateAnimationState();
 }
 
 void LayerAnimator::PurgeDeletedAnimations() {
   for (size_t i = 0; i < running_animations_.size();) {
     if (!running_animations_[i].is_sequence_alive())
       running_animations_.erase(running_animations_.begin() + i);
     else
       i++;
   }
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui