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) {
+  ui::ScopedAnimationDurationScaleMode long_duration(

[James Cook, 2013/12/02 18:33:51]

Did you mean normal_duration? Or is this long relative to something else?

[varkha, 2013/12/02 20:18:09]

I was meaning to do something else and ended up leaving it intact but did not
rename the variable back. Nice catch. I think we want to leave the animation
timing at "NORMAL" for this test.

+      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();
+  }
+
+  // Listens to animation scheduled notifications. Remembers the transition
+  // duration of the first sequence.
+  class MinimizeAnimationObserver : public ui::LayerAnimationObserver {

[James Cook, 2013/12/02 18:33:51]

optional nit: It's unusual to see classes declared in the middle of functions in
Chrome. There's no style guide entry about it, so you're welcome to keep it
here, it just seemed a bit odd to me as a reader.

[varkha, 2013/12/02 20:18:09]

Done.

+   public:
+    MinimizeAnimationObserver(ui::LayerAnimator* animator)

[James Cook, 2013/12/02 18:33:51]

nit: explicit

[varkha, 2013/12/02 20:18:09]

Done.

+        : animator_(animator) {
+      animator_->AddObserver(this);
+    };
+    virtual ~MinimizeAnimationObserver() {
+      animator_->RemoveObserver(this);
+    };
+    base::TimeDelta duration() { return duration_; }
+
+   protected:
+    // ui::LayerAnimationObserver:
+    virtual void OnLayerAnimationScheduled(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {
+      duration_ = animator_->GetTransitionDuration();
+      animator_->RemoveObserver(this);

[James Cook, 2013/12/02 18:33:51]

Do you need to remove the observer in two places?

[varkha, 2013/12/02 20:18:09]

I wanted to add an assert about !HasObserver in the destructor but we don't have
that method here. RemoveObserver is safe here to be called more than once so
there is no harm either way. I will remove the call in destructor and add a
comment instead.

+    }
+    virtual void OnLayerAnimationEnded(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {}
+    virtual void OnLayerAnimationAborted(
+        ui::LayerAnimationSequence* sequence) OVERRIDE {}
+
+   private:
+    ui::LayerAnimator* animator_;
+    base::TimeDelta duration_;
+  };
+
+  // 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