Keep dedicated layers for hiding animation

ui/wm/core/window_animations.h

 // 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.
 
 #ifndef UI_WM_CORE_WINDOW_ANIMATIONS_H_
 #define UI_WM_CORE_WINDOW_ANIMATIONS_H_
 
 #include <vector>
 
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/wm/core/wm_core_export.h"
 
 namespace aura {
 class Window;
 }
 namespace base {
 class TimeDelta;
 }
 namespace gfx {
 class Rect;
@@ skipping 54 matching lines @@
     aura::Window* window,
     const base::TimeDelta& duration);
 
 WM_CORE_EXPORT base::TimeDelta GetWindowVisibilityAnimationDuration(
     const aura::Window& window);
 
 WM_CORE_EXPORT void SetWindowVisibilityAnimationVerticalPosition(
     aura::Window* window,
     float position);
 
-// Creates an ImplicitAnimationObserver that takes ownership of the layers
-// associated with a Window so that the animation can continue after the Window
-// has been destroyed.
-// The returned object deletes itself when the animations are done.
-WM_CORE_EXPORT ui::ImplicitAnimationObserver*
-    CreateHidingWindowAnimationObserver(aura::Window* window);
+// A wrapper of ui::ScopedLayerAnimationSettings for hiding animations.
+// Use this to ensure that the animation is visible even after
+// the window is deleted, instead of directly using
+// ui::ScopedLayerAnimationSettings.
+class WM_CORE_EXPORT ScopedHidingAnimationSettings {
+ public:
+  explicit ScopedHidingAnimationSettings(aura::Window* window);
+  ~ScopedHidingAnimationSettings();
+
+  // Returns the wrapped ScopedLayeAnimationSettings instance.
+  ui::ScopedLayerAnimationSettings* layer_animation_settings() {
+    return &layer_animation_settings_;
+  }
+
+  // When set to true, this recreates layers for the window and and puts
+  // the original (and animating) layers on top of |window_| and
+  // its transient children so that these layers stay above new
+  // focused window. This is typically used when closing a focusable
+  // toplevel window.
+  // Note that this is effective only if |window| has focus when
+  // applying the animation.
+  void set_ensure_visible_after_focus_lost(
+      bool ensure_visible_after_focus_loste) {
+    ensure_visibility_after_focus_lost_ = ensure_visible_after_focus_lost;
+  }
+
+ private:
+  aura::Window* window_;
+  bool ensure_visibility_after_focus_lost_;
+  ui::ScopedLayerAnimationSettings layer_animation_settings_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedHidingAnimationSettings);
+};
 
 // Returns false if the |window| didn't animate.
 WM_CORE_EXPORT bool AnimateOnChildWindowVisibilityChanged(aura::Window* window,
                                                           bool visible);
 WM_CORE_EXPORT bool AnimateWindow(aura::Window* window,
                                   WindowAnimationType type);
 
 // Returns true if window animations are disabled for |window|. Window
 // animations are enabled by default. If |window| is NULL, this just checks
 // if the global flag disabling window animations is present.
 WM_CORE_EXPORT bool WindowAnimationsDisabled(aura::Window* window);
 
 }  // namespace corewm
 }  // namespace views
 
 #endif  // UI_WM_CORE_WINDOW_ANIMATIONS_H_