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:
@@ skipping 100 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) {

[varkha, 2013/11/28 21:50:43]

I thought a test for the new ability would be useful too.

+  ui::ScopedAnimationDurationScaleMode long_duration(
+      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();
+  }
+
+  // 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.SetTransitionDurationLocked(true);
+    {
+      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();
+  }
+
+  // Test that it is possible to unlock transition duration
+  {
+    ui::ScopedLayerAnimationSettings settings1(layer->GetAnimator());
+    settings1.SetTransitionDuration(base::TimeDelta::FromMilliseconds(1000));
+    settings1.SetTransitionDurationLocked(true);
+    {
+      ui::ScopedLayerAnimationSettings settings2(layer->GetAnimator());
+      // Duration is unlocked in inner scope.
+      settings2.SetTransitionDurationLocked(false);
+      // Transition duration is properly set.
+      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();
+  }
+
+  // Observer class to query default animation duration when animation starts.
+  class MinimizeAnimationObserver : public ui::LayerAnimationObserver {
+   public:
+    MinimizeAnimationObserver(ui::LayerAnimator* animator)
+        : animator_(animator) {};
+    base::TimeDelta duration() { return duration_; }
+
+   protected:
+    // ui::LayerAnimationObserver:
+    virtual void OnLayerAnimationEnded(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {}
+    virtual void OnLayerAnimationAborted(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {}
+    virtual void OnLayerAnimationScheduled(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {
+      duration_ = animator_->GetTransitionDuration();
+    }
+
+   private:
+    ui::LayerAnimator* animator_;
+    base::TimeDelta duration_;
+    DISALLOW_COPY_AND_ASSIGN(MinimizeAnimationObserver);
+  };
+
+  // Test that duration respects default.
+  {
+    MinimizeAnimationObserver observer(layer->GetAnimator());
+    layer->GetAnimator()->AddObserver(&observer);
+    wm::GetWindowState(window.get())->Minimize();
+    layer->GetAnimator()->RemoveObserver(&observer);
+    EXPECT_TRUE(layer->GetAnimator()->is_animating());
+    base::TimeDelta default_duration(observer.duration());
+    LOG(INFO) << "default " << default_duration.InMilliseconds();
+    layer->GetAnimator()->StopAnimating();
+    window->Show();
+
+    ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+    settings.SetTransitionDurationLocked(true);
+    // 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());
+  }
+}
+
 }  // namespace internal
 }  // namespace ash