Thread ui transform 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"
@@ skipping 571 matching lines @@
     LayerAnimationSequence* sequence, bool abort) {
   // For all the running animations, if they animate the same property,
   // progress them to the end and remove them. Note, Aborting or Progressing
   // animations may affect the collection of running animations, so we need to
   // operate on a copy.
   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(
+    if (running_animations_copy[i].sequence()->HasConflictingProperty(
             sequence->properties())) {
       scoped_ptr<LayerAnimationSequence> removed(
           SAFE_INVOKE_PTR(RemoveAnimation, running_animations_copy[i]));
       if (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())) {
+    if (sequences[i]->HasConflictingProperty(sequence->properties())) {
       scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequences[i]));
       if (abort)
         sequences[i]->Abort(delegate());
       else
         ProgressAnimationToEnd(sequences[i]);
     }
   }
 }
 
 void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
@@ skipping 97 matching lines @@
     // 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(animated)) {
+      if (!sequences[i]->HasConflictingProperty(animated)) {
         StartSequenceImmediately(sequences[i].get());
         started_sequence = true;
         break;
       }
 
       // Animation couldn't be started. Add its properties to the collection so
       // that we don't start a conflicting animation. For example, if our queue
       // has the elements { {T,B}, {B} } (that is, an element that animates both
       // the transform and the bounds followed by an element that animates the
       // bounds), and we're currently animating the transform, we can't start
       // the first element because it animates the transform, too. We cannot
       // start the second element, either, because the first element animates
       // bounds too, and needs to go first.
       animated.insert(sequences[i]->properties().begin(),
                       sequences[i]->properties().end());
     }
 
     // If we started a sequence, try again. We may be able to start several.
   } while (started_sequence);
 }
 
 bool LayerAnimator::StartSequenceImmediately(LayerAnimationSequence* sequence) {
   PurgeDeletedAnimations();
 
   // Ensure that no one is animating one of the sequence's properties already.
   for (RunningAnimations::const_iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
-    if ((*iter).sequence()->HasCommonProperty(sequence->properties()))
+    if ((*iter).sequence()->HasConflictingProperty(sequence->properties()))
       return false;
   }
 
   // All clear, actually start the sequence. Note: base::TimeTicks::Now has
   // a resolution that can be as bad as 15ms. If this causes glitches in the
   // animations, this can be switched to HighResNow() (animation uses Now()
   // internally).
   // All LayerAnimators share the same AnimationContainer. Use the
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
@@ skipping 79 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui