Keep dedicated layers for hiding animation

ui/wm/core/window_animations.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/wm/core/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "ui/aura/client/animation_host.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/compositor_observer.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"
+#include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector2d.h"
 #include "ui/gfx/vector3d_f.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_core_switches.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationType)
 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationTransition)
 DECLARE_WINDOW_PROPERTY_TYPE(float)
 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(WM_CORE_EXPORT, bool)
 
-using aura::Window;
-using base::TimeDelta;
-using ui::Layer;
-
 namespace wm {
 namespace {
 const float kWindowAnimation_Vertical_TranslateY = 15.f;
 }  // namespace
 
 DEFINE_WINDOW_PROPERTY_KEY(int,
                            kWindowVisibilityAnimationTypeKey,
                            WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 DEFINE_WINDOW_PROPERTY_KEY(int, kWindowVisibilityAnimationDurationKey, 0);
 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationTransition,
                            kWindowVisibilityAnimationTransitionKey,
                            ANIMATE_BOTH);
 DEFINE_WINDOW_PROPERTY_KEY(float,
                            kWindowVisibilityAnimationVerticalPositionKey,
                            kWindowAnimation_Vertical_TranslateY);
 
+// An AnimationObserer which has two roles:
+// 1) Notifies AnimationHost at the end of hiding animation.
+// 2) Detaches the window's layers for hiding animation and deletes
+// them upon completion of the animation. This is necessary to a)
+// ensure that the animation continues in the event of the window being
+// deleted, and b) to ensure that the animation is visible even if the
+// window gets restacked below other windows when focus or activation
+// changes.
+class HidingWindowAnimationObserver : public ui::ImplicitAnimationObserver,
+                                      public aura::WindowObserver {
+ public:
+  HidingWindowAnimationObserver(aura::Window* window,
+                                ui::ScopedLayerAnimationSettings* settings);
+  virtual ~HidingWindowAnimationObserver() {}
+
+  // ui::ImplicitAnimationObserver:
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
+
+  // aura::WindowObserver:
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
+
+  // Detach the current layers and create new layers for |window_|.
+  // Stack the original layers above |window_| and its transient
+  // children.  If the window has transient children, the original
+  // layers will be moved above the top most transient child so that
+  // activation change does not put the window above the animating
+  // layer.
+  void DetachAndRecreateLayers();
+
+ private:
+  aura::Window* window_;
+
+  // The owner of detached layers.
+  scoped_ptr<ui::LayerTreeOwner> layer_owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserver);
+};
+
 namespace {
 
 const int kDefaultAnimationDurationForMenuMS = 150;
 
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
 const float kWindowAnimation_TranslateFactor = 0.5f;
 const float kWindowAnimation_ScaleFactor = .95f;
 
 const int kWindowAnimation_Rotate_DurationMS = 180;
 const int kWindowAnimation_Rotate_OpacityDurationPercent = 90;
 const float kWindowAnimation_Rotate_TranslateY = -20.f;
 const float kWindowAnimation_Rotate_PerspectiveDepth = 500.f;
 const float kWindowAnimation_Rotate_DegreesX = 5.f;
 const float kWindowAnimation_Rotate_ScaleFactor = .99f;
 
 const float kWindowAnimation_Bounce_Scale = 1.02f;
 const int kWindowAnimation_Bounce_DurationMS = 180;
 const int kWindowAnimation_Bounce_GrowShrinkDurationPercent = 40;
 
 base::TimeDelta GetWindowVisibilityAnimationDuration(
     const aura::Window& window) {
   int duration =
       window.GetProperty(kWindowVisibilityAnimationDurationKey);
   if (duration == 0 && window.type() == ui::wm::WINDOW_TYPE_MENU) {
     return base::TimeDelta::FromMilliseconds(
         kDefaultAnimationDurationForMenuMS);
   }
-  return TimeDelta::FromInternalValue(duration);
+  return base::TimeDelta::FromInternalValue(duration);
 }
 
 // Gets/sets the WindowVisibilityAnimationType associated with a window.
 // TODO(beng): redundant/fold into method on public api?
 int GetWindowVisibilityAnimationType(aura::Window* window) {
   int type = window->GetProperty(kWindowVisibilityAnimationTypeKey);
   if (type == WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT) {
     return (window->type() == ui::wm::WINDOW_TYPE_MENU ||
             window->type() == ui::wm::WINDOW_TYPE_TOOLTIP)
                ? WINDOW_VISIBILITY_ANIMATION_TYPE_FADE
                : WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
   }
   return type;
 }
 
-// Observes a hide animation.
-// A window can be hidden for a variety of reasons. Sometimes, Hide() will be
-// called and life is simple. Sometimes, the window is actually bound to a
-// views::Widget and that Widget is closed, and life is a little more
-// complicated. When a Widget is closed the aura::Window* is actually not
-// destroyed immediately - it is actually just immediately hidden and then
-// destroyed when the stack unwinds. To handle this case, we start the hide
-// animation immediately when the window is hidden, then when the window is
-// subsequently destroyed this object acquires ownership of the window's layer,
-// so that it can continue animating it until the animation completes.
-// Regardless of whether or not the window is destroyed, this object deletes
-// itself when the animation completes.
-class HidingWindowAnimationObserver : public ui::ImplicitAnimationObserver,
-                                      public aura::WindowObserver {
- public:
-  explicit HidingWindowAnimationObserver(aura::Window* window)
-      : window_(window) {
-    window_->AddObserver(this);
-  }
-  virtual ~HidingWindowAnimationObserver() {
-    STLDeleteElements(&layers_);
-  }
-
- private:
-  // Overridden from ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
-    // Window may have been destroyed by this point.
-    if (window_) {
-      aura::client::AnimationHost* animation_host =
-          aura::client::GetAnimationHost(window_);
-      if (animation_host)
-        animation_host->OnWindowHidingAnimationCompleted();
-      window_->RemoveObserver(this);
-    }
-    delete this;
-  }
-
-  // Overridden from aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
-    DCHECK_EQ(window, window_);
-    DCHECK(layers_.empty());
-    AcquireAllLayers(window_->layer());
-    window_->RemoveObserver(this);
-    window_ = NULL;
-  }
-
-  void AcquireAllLayers(ui::Layer* layer) {
-    if (layer->owner()) {
-      ui::Layer* released = layer->owner()->AcquireLayer();
-      DCHECK_EQ(layer, released);
-      layers_.push_back(released);
-    }
-    std::vector<Layer*>::const_iterator it = layer->children().begin();
-    for (; it != layer->children().end(); ++it)
-      AcquireAllLayers(*it);
-  }
-
-  aura::Window* window_;
-  std::vector<ui::Layer*> layers_;
-
-  DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserver);
-};
-
 void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
-  const Layer* root = layer;
+  const ui::Layer* root = layer;
   while (root->parent())
     root = root->parent();
   layer->GetTargetTransformRelativeTo(root, transform);
 }
 
 gfx::Rect GetLayerWorldBoundsAfterTransform(ui::Layer* layer,
                                             const gfx::Transform& transform) {
   gfx::Transform in_world = transform;
   GetTransformRelativeToRoot(layer, &in_world);
 
@@ skipping 34 matching lines @@
 
   animation_host->SetHostTransitionOffsets(top_left_delta, bottom_right_delta);
 }
 
 // Shows a window using an animation, animating its opacity from 0.f to 1.f,
 // its visibility to true, and its transform from |start_transform| to
 // |end_transform|.
 void AnimateShowWindowCommon(aura::Window* window,
                              const gfx::Transform& start_transform,
                              const gfx::Transform& end_transform) {
-  window->layer()->set_delegate(window);
-
   AugmentWindowSize(window, end_transform);
 
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(start_transform);
   window->layer()->SetVisible(true);
 
   {
     // Property sets within this scope will be implicitly animated.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
     if (duration.ToInternalValue() > 0)
       settings.SetTransitionDuration(duration);
 
     window->layer()->SetTransform(end_transform);
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
   }
 }
 
 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 // its visibility to false, and its transform to |end_transform|.
 void AnimateHideWindowCommon(aura::Window* window,
                              const gfx::Transform& end_transform) {
   AugmentWindowSize(window, end_transform);
-  window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.AddObserver(new HidingWindowAnimationObserver(window));
-
+  ScopedHidingAnimationSettings hiding_settings(window);
   base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
   if (duration.ToInternalValue() > 0)
-    settings.SetTransitionDuration(duration);
+    hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
 
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(end_transform);
   window->layer()->SetVisible(false);
 }
 
 static gfx::Transform GetScaleForWindow(aura::Window* window) {
   gfx::Rect bounds = window->bounds();
   gfx::Transform scale = gfx::GetScaleTransform(
       gfx::Point(kWindowAnimation_TranslateFactor * bounds.width(),
@@ skipping 56 matching lines @@
                   kWindowAnimation_Bounce_GrowShrinkDurationPercent / 100)));
   transition->set_tween_type(grow ? gfx::Tween::EASE_OUT : gfx::Tween::EASE_IN);
   return transition.release();
 }
 
 void AnimateBounce(aura::Window* window) {
   ui::ScopedLayerAnimationSettings scoped_settings(
       window->layer()->GetAnimator());
   scoped_settings.SetPreemptionStrategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-  window->layer()->set_delegate(window);
   scoped_ptr<ui::LayerAnimationSequence> sequence(
       new ui::LayerAnimationSequence);
   sequence->AddElement(CreateGrowShrinkElement(window, true));
   sequence->AddElement(ui::LayerAnimationElement::CreatePauseElement(
       ui::LayerAnimationElement::BOUNDS,
       base::TimeDelta::FromMilliseconds(
         kWindowAnimation_Bounce_DurationMS *
             (100 - 2 * kWindowAnimation_Bounce_GrowShrinkDurationPercent) /
             100)));
   sequence->AddElement(CreateGrowShrinkElement(window, false));
   window->layer()->GetAnimator()->StartAnimation(sequence.release());
 }
 
 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
-  window->layer()->set_delegate(window);
   if (show)
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kWindowAnimation_Rotate_DurationMS);
 
+  HidingWindowAnimationObserver* observer = NULL;
+
   if (!show) {
-    new HidingWindowAnimationObserver(window);
+    // TODO(oshima): Fix observer leak.
+    observer = new HidingWindowAnimationObserver(window, NULL);
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
         ui::LayerAnimationElement::OPACITY);
   }
   scoped_ptr<ui::LayerAnimationElement> opacity(
       ui::LayerAnimationElement::CreateOpacityElement(
           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
   opacity->set_tween_type(gfx::Tween::EASE_IN_OUT);
   window->layer()->GetAnimator()->ScheduleAnimation(
@@ skipping 27 matching lines @@
   translation->SetChild(scale_about_pivot.release());
   rotation->SetChild(translation.release());
   rotation->SetReversed(show);
 
   scoped_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           rotation.release(), duration));
 
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(transition.release()));
+  if (observer)
+    observer->DetachAndRecreateLayers();
 }
 
 void AnimateShowWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, true);
 }
 
 void AnimateHideWindow_Rotate(aura::Window* window) {
   AddLayerAnimationsForRotate(window, false);
 }
 
 bool AnimateShowWindow(aura::Window* window) {
   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
       // Since hide animation may have changed opacity and transform,
       // reset them to show the window.
-      window->layer()->set_delegate(window);
       window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
       window->layer()->SetTransform(gfx::Transform());
     }
     return false;
   }
 
   switch (GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
       AnimateShowWindow_Drop(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
       AnimateShowWindow_Vertical(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
       AnimateShowWindow_Fade(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
       AnimateShowWindow_Rotate(window);
       return true;
     default:
       return false;
   }
 }
 
 bool AnimateHideWindow(aura::Window* window) {
   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
       // Since show animation may have changed opacity and transform,
       // reset them, though the change should be hidden.
-      window->layer()->set_delegate(NULL);
       window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
       window->layer()->SetTransform(gfx::Transform());
     }
     return false;
   }
 
   switch (GetWindowVisibilityAnimationType(window)) {
     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
       AnimateHideWindow_Drop(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
       AnimateHideWindow_Vertical(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
       AnimateHideWindow_Fade(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
       AnimateHideWindow_Rotate(window);
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
+// HidingWindowAnimationObserver
+
+HidingWindowAnimationObserver::HidingWindowAnimationObserver(
+    aura::Window* window,
+    ui::ScopedLayerAnimationSettings* settings)
+    : window_(window) {
+  window->AddObserver(this);
+  if (settings)
+    settings->AddObserver(this);
+}
+
+void HidingWindowAnimationObserver::OnImplicitAnimationsCompleted() {
+  // Window may have been destroyed by this point.
+  if (window_) {
+    aura::client::AnimationHost* animation_host =
+        aura::client::GetAnimationHost(window_);
+    if (animation_host)
+      animation_host->OnWindowHidingAnimationCompleted();
+    window_->RemoveObserver(this);
+  }
+  delete this;
+}
+
+void HidingWindowAnimationObserver::OnWindowDestroying(aura::Window* window) {
+  DCHECK_EQ(window, window_);
+  window_->RemoveObserver(this);
+  window_ = NULL;
+}
+
+void HidingWindowAnimationObserver::DetachAndRecreateLayers() {
+  layer_owner_ = RecreateLayers(window_);
+  if (window_->parent()) {
+    const aura::Window::Windows& transient_children =
+        GetTransientChildren(window_);
+    aura::Window::Windows::const_iterator iter =
+        std::find(window_->parent()->children().begin(),
+                  window_->parent()->children().end(),
+                  window_);
+    DCHECK(iter != window_->parent()->children().end());
+    aura::Window* topmost_transient_child = NULL;
+    for (++iter; iter != window_->parent()->children().end(); ++iter) {
+      if (std::find(transient_children.begin(),
+                    transient_children.end(),
+                    *iter) !=
+          transient_children.end()) {
+        topmost_transient_child = *iter;
+      }
+    }
+    if (topmost_transient_child) {
+      window_->parent()->layer()->StackAbove(
+          layer_owner_->root(), topmost_transient_child->layer());
+    }
+  }
+
+  // TODO(sky): The recreated layer should have the target visibility of
+  // the original layer.
+  // Make the new layer invisible immediately.
+  window_->layer()->SetVisible(false);
+  window_->layer()->SetOpacity(0);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ScopedHidingAnimationSettings
+
+ScopedHidingAnimationSettings::ScopedHidingAnimationSettings(
+    aura::Window* window)
+    : layer_animation_settings_(window->layer()->GetAnimator()),
+      observer_(new HidingWindowAnimationObserver(
+          window, &layer_animation_settings_)) {
+}
+
+ScopedHidingAnimationSettings::~ScopedHidingAnimationSettings() {
+  observer_->DetachAndRecreateLayers();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // External interface
 
 void SetWindowVisibilityAnimationType(aura::Window* window, int type) {
   window->SetProperty(kWindowVisibilityAnimationTypeKey, type);
 }
 
 int GetWindowVisibilityAnimationType(aura::Window* window) {
   return window->GetProperty(kWindowVisibilityAnimationTypeKey);
 }
 
 void SetWindowVisibilityAnimationTransition(
     aura::Window* window,
     WindowVisibilityAnimationTransition transition) {
   window->SetProperty(kWindowVisibilityAnimationTransitionKey, transition);
 }
 
 bool HasWindowVisibilityAnimationTransition(
     aura::Window* window,
     WindowVisibilityAnimationTransition transition) {
   WindowVisibilityAnimationTransition prop = window->GetProperty(
       kWindowVisibilityAnimationTransitionKey);
   return (prop & transition) != 0;
 }
 
 void SetWindowVisibilityAnimationDuration(aura::Window* window,
-                                          const TimeDelta& duration) {
+                                          const base::TimeDelta& duration) {
   window->SetProperty(kWindowVisibilityAnimationDurationKey,
                       static_cast<int>(duration.ToInternalValue()));
 }
 
 base::TimeDelta GetWindowVisibilityAnimationDuration(
     const aura::Window& window) {
   return base::TimeDelta::FromInternalValue(
       window.GetProperty(kWindowVisibilityAnimationDurationKey));
 }
 
 void SetWindowVisibilityAnimationVerticalPosition(aura::Window* window,
                                                   float position) {
   window->SetProperty(kWindowVisibilityAnimationVerticalPositionKey, position);
 }
 
-ui::ImplicitAnimationObserver* CreateHidingWindowAnimationObserver(
-    aura::Window* window) {
-  return new HidingWindowAnimationObserver(window);
-}
-
 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
   if (WindowAnimationsDisabled(window))
     return false;
   if (visible)
     return AnimateShowWindow(window);
   // Don't start hiding the window again if it's already being hidden.
   return window->layer()->GetTargetOpacity() != 0.0f &&
       AnimateHideWindow(window);
 }
 
 bool AnimateWindow(aura::Window* window, WindowAnimationType type) {
   switch (type) {
   case WINDOW_ANIMATION_TYPE_BOUNCE:
     AnimateBounce(window);
     return true;
   default:
     NOTREACHED();
     return false;
   }
 }
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled));
 }
 
 }  // namespace wm