Changes sequence of docked animations when evicting windows from dock.

ash/wm/window_animations_unittest.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 "ash/wm/window_animations.h"
 
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/time/time.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/animation_container_element.h"
 
 using aura::Window;
 using ui::Layer;
 
 namespace ash {
 namespace internal {
 
 class WindowAnimationsTest : public ash::test::AshTestBase {
  public:
   WindowAnimationsTest() {}
 
   virtual void TearDown() OVERRIDE {
     AshTestBase::TearDown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowAnimationsTest);
 };
 
+// Listens to animation scheduled notifications. Remembers the transition
+// duration of the first sequence.
+class MinimizeAnimationObserver : public ui::LayerAnimationObserver {
+ public:
+  explicit MinimizeAnimationObserver(ui::LayerAnimator* animator)
+      : animator_(animator) {
+    animator_->AddObserver(this);
+    // RemoveObserver is called when the first animation is scheduled and so
+    // there should be no need for now to remove it in destructor.
+  };
+  base::TimeDelta duration() { return duration_; }
+
+ protected:
+  // ui::LayerAnimationObserver:
+  virtual void OnLayerAnimationScheduled(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {
+    duration_ = animator_->GetTransitionDuration();
+    animator_->RemoveObserver(this);
+  }
+  virtual void OnLayerAnimationEnded(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {}
+  virtual void OnLayerAnimationAborted(
+      ui::LayerAnimationSequence* sequence) OVERRIDE {}
+
+ private:
+  ui::LayerAnimator* animator_;
+  base::TimeDelta duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinimizeAnimationObserver);
+};
+
 TEST_F(WindowAnimationsTest, HideShowBrightnessGrayscaleAnimation) {
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(0));
   window->Show();
   EXPECT_TRUE(window->layer()->visible());
 
   // Hiding.
   views::corewm::SetWindowVisibilityAnimationType(
       window.get(),
       WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE);
   AnimateOnChildWindowVisibilityChanged(window.get(), false);
@@ skipping 80 matching lines @@
   // New layer animates in to the identity transform.
   EXPECT_EQ(1.0f, window->layer()->GetTargetOpacity());
   EXPECT_EQ(gfx::Transform(), window->layer()->GetTargetTransform());
 
   static_cast<gfx::AnimationContainerElement*>(old_layer->GetAnimator())->Step(
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(1));
   static_cast<gfx::AnimationContainerElement*>(window->layer()->GetAnimator())->
       Step(base::TimeTicks::Now() + base::TimeDelta::FromSeconds(1));
 }
 
+TEST_F(WindowAnimationsTest, LockAnimationDuration) {
+  ui::ScopedAnimationDurationScaleMode normal_duration_mode(
+      ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
+
+  scoped_ptr<Window> window(CreateTestWindowInShellWithId(0));
+  Layer* layer = window->layer();
+  window->SetBounds(gfx::Rect(5, 10, 320, 240));
+  window->Show();
+
+  // Test that it is possible to override transition duration when it is not
+  // locked.
+  {
+    ui::ScopedLayerAnimationSettings settings1(layer->GetAnimator());
+    settings1.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
+    {
+      ui::ScopedLayerAnimationSettings settings2(layer->GetAnimator());
+      // Duration is not locked so it gets overridden.
+      settings2.SetTransitionDuration(base::TimeDelta::FromMilliseconds(50));
+      wm::GetWindowState(window.get())->Minimize();
+      EXPECT_TRUE(layer->GetAnimator()->is_animating());
+      // Expect duration from the inner scope
+      EXPECT_EQ(50,
+                layer->GetAnimator()->GetTransitionDuration().InMilliseconds());
+    }
+    window->Show();
+    layer->GetAnimator()->StopAnimating();
+  }
+
+  // Test that it is possible to lock transition duration
+  {
+    ui::ScopedLayerAnimationSettings settings1(layer->GetAnimator());
+    settings1.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
+    // Duration is locked in outer scope.
+    settings1.LockTransitionDuration();
+    {
+      ui::ScopedLayerAnimationSettings settings2(layer->GetAnimator());
+      // Transition duration setting is ignored.
+      settings2.SetTransitionDuration(base::TimeDelta::FromMilliseconds(50));
+      wm::GetWindowState(window.get())->Minimize();
+      EXPECT_TRUE(layer->GetAnimator()->is_animating());
+      // Expect duration from the outer scope
+      EXPECT_EQ(1000,
+                layer->GetAnimator()->GetTransitionDuration().InMilliseconds());
+    }
+    window->Show();
+    layer->GetAnimator()->StopAnimating();
+  }
+
+  // Test that duration respects default.
+  {
+    // Query default duration.
+    MinimizeAnimationObserver observer(layer->GetAnimator());
+    wm::GetWindowState(window.get())->Minimize();
+    EXPECT_TRUE(layer->GetAnimator()->is_animating());
+    base::TimeDelta default_duration(observer.duration());
+    window->Show();
+    layer->GetAnimator()->StopAnimating();
+
+    ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+    settings.LockTransitionDuration();
+    // Setting transition duration is ignored since duration is locked
+    settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
+    wm::GetWindowState(window.get())->Minimize();
+    EXPECT_TRUE(layer->GetAnimator()->is_animating());
+    // Expect default duration (200ms for stock ash minimizing animation).
+    EXPECT_EQ(default_duration.InMilliseconds(),
+              layer->GetAnimator()->GetTransitionDuration().InMilliseconds());
+    window->Show();
+    layer->GetAnimator()->StopAnimating();
+  }
+}
+
 }  // namespace internal
 }  // namespace ash