Keep dedicated layers for hiding animation

ui/views/corewm/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/views/corewm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 91 matching lines @@
   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;
 }
 
+class HidingWindowAnimationObserver;
+DEFINE_WINDOW_PROPERTY_KEY(HidingWindowAnimationObserver*,
+                           kHidingWindowAnimationObserverKey,
+                           NULL);
+
 // 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_(window),
+        layers_detached_(false) {
     window_->AddObserver(this);
+    window->SetProperty(kHidingWindowAnimationObserverKey, this);
   }
   virtual ~HidingWindowAnimationObserver() {
     STLDeleteElements(&layers_);
   }
 
+  ui::Layer* DetachAndRecreateLayers() {
+    ui::Layer* old_layer = views::corewm::RecreateWindowLayers(window_, true);
+    // Make the new layer unvisible immediately.
+    window_->layer()->SetVisible(false);
+    layers_.push_back(old_layer);
+    layers_detached_ = true;
+    return old_layer;
+  }
+
  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);
+      window_->ClearProperty(kHidingWindowAnimationObserverKey);
     }
     delete this;
   }
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     DCHECK_EQ(window, window_);
-    DCHECK(layers_.empty());
-    AcquireAllLayers(window_);
-
-    // If the Widget has views with layers, then it is necessary to take
-    // ownership of those layers too.
-    views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window_);
-    const views::Widget* const_widget = widget;
-    if (widget && const_widget->GetRootView() && widget->GetContentsView())
-      AcquireAllViewLayers(widget->GetContentsView());
+    DCHECK(layers_.empty() || layers_detached_);
+    if (!layers_detached_) {
+      AcquireAllLayers(window_);
+      // If the Widget has views with layers, then it is necessary to take
+      // ownership of those layers too.
+      views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window_);
+      const views::Widget* const_widget = widget;
+      if (widget && const_widget->GetRootView() && widget->GetContentsView())
+        AcquireAllViewLayers(widget->GetContentsView());
+    }
     window_->RemoveObserver(this);
     window_ = NULL;
   }
 
   void AcquireAllLayers(aura::Window* window) {
     ui::Layer* layer = window->AcquireLayer();
     DCHECK(layer);
     layers_.push_back(layer);
     for (aura::Window::Windows::const_iterator it = window->children().begin();
          it != window->children().end();
          ++it)
       AcquireAllLayers(*it);
   }
 
   void AcquireAllViewLayers(views::View* view) {
     for (int i = 0; i < view->child_count(); ++i)
       AcquireAllViewLayers(view->child_at(i));
     if (view->layer()) {
       ui::Layer* layer = view->RecreateLayer();
       if (layer) {
         layer->SuppressPaint();
         layers_.push_back(layer);
       }
     }
   }
 
   aura::Window* window_;
   std::vector<ui::Layer*> layers_;
+  bool layers_detached_;
 
   DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserver);
 };
 
 void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
   const Layer* root = layer;
   while (root->parent())
     root = root->parent();
   layer->GetTargetTransformRelativeTo(root, transform);
 }
@@ skipping 340 matching lines @@
 void SetWindowVisibilityAnimationVerticalPosition(aura::Window* window,
                                                   float position) {
   window->SetProperty(kWindowVisibilityAnimationVerticalPositionKey, position);
 }
 
 ui::ImplicitAnimationObserver* CreateHidingWindowAnimationObserver(
     aura::Window* window) {
   return new HidingWindowAnimationObserver(window);
 }
 
+ui::Layer* DetachHidingAnimationLayer(aura::Window* window) {
+  HidingWindowAnimationObserver* observer =
+      window->GetProperty(kHidingWindowAnimationObserverKey);
+  return observer ? observer->DetachAndRecreateLayers() : NULL;
+}
+
 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);
 }
 
@@ skipping 10 matching lines @@
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (!gfx::Animation::ShouldRenderRichAnimation() || (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled));
 }
 
 }  // namespace corewm
 }  // namespace views