Changes sequence of docked animations when evicting windows from dock.

ui/compositor/scoped_layer_animation_settings.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/scoped_layer_animation_settings.h"
 
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 63 matching lines @@
     Layer* base_layer_;
     // child layers
     std::vector<Layer*> inverse_layers_;
 };
 
 
 // ScoperLayerAnimationSettings ------------------------------------------------
 ScopedLayerAnimationSettings::ScopedLayerAnimationSettings(
     LayerAnimator* animator)
     : animator_(animator),
-      old_transition_duration_(animator->transition_duration_),
+      old_is_transition_duration_locked_(
+          animator->is_transition_duration_locked_),
+      old_transition_duration_(animator->GetTransitionDuration()),
       old_tween_type_(animator->tween_type()),
       old_preemption_strategy_(animator->preemption_strategy()),
       inverse_observer_(new InvertingObserver()) {
   SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
 }
 
 ScopedLayerAnimationSettings::~ScopedLayerAnimationSettings() {
-  animator_->transition_duration_ = old_transition_duration_;
+  animator_->is_transition_duration_locked_ =
+      old_is_transition_duration_locked_;
+  animator_->SetTransitionDuration(old_transition_duration_);
   animator_->set_tween_type(old_tween_type_);
   animator_->set_preemption_strategy(old_preemption_strategy_);
 
   for (std::set<ImplicitAnimationObserver*>::const_iterator i =
        observers_.begin(); i != observers_.end(); ++i) {
     animator_->observers_.RemoveObserver(*i);
     (*i)->SetActive(true);
   }
 
   if (inverse_observer_->layer()) {
     animator_->observers_.RemoveObserver(inverse_observer_.get());
   }
 }
 
 void ScopedLayerAnimationSettings::AddObserver(
     ImplicitAnimationObserver* observer) {
   observers_.insert(observer);
   animator_->AddObserver(observer);
 }
 
 void ScopedLayerAnimationSettings::SetTransitionDuration(
     base::TimeDelta duration) {
-  animator_->transition_duration_ = duration;
+  animator_->SetTransitionDuration(duration);
+}
+
+void ScopedLayerAnimationSettings::LockTransitionDuration() {
+  animator_->is_transition_duration_locked_ = true;
 }
 
 base::TimeDelta ScopedLayerAnimationSettings::GetTransitionDuration() const {
-  return animator_->transition_duration_;
+  return animator_->GetTransitionDuration();
 }
 
 void ScopedLayerAnimationSettings::SetTweenType(gfx::Tween::Type tween_type) {
   animator_->set_tween_type(tween_type);
 }
 
 gfx::Tween::Type ScopedLayerAnimationSettings::GetTweenType() const {
   return animator_->tween_type();
 }
 
@@ skipping 15 matching lines @@
   }
   inverse_observer_->SetLayer(base);
 }
 
 void ScopedLayerAnimationSettings::AddInverselyAnimatedLayer(
     Layer* inverse_layer) {
   inverse_observer_->AddInverselyAnimatedLayer(inverse_layer);
 }
 
 }  // namespace ui