Keep dedicated layers for hiding animation

ash/wm/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 "ash/wm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 137 matching lines @@
 
   // Reset the transform to identity when the minimize animation is completed.
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
               gfx::Transform(),
               base::TimeDelta())));
 }
 
 void AnimateShowWindow_Minimize(aura::Window* window) {
-  window->layer()->set_delegate(window);
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kLayerAnimationsForMinimizeDurationMS);
   settings.SetTransitionDuration(duration);
   AddLayerAnimationsForMinimize(window, true);
 
   // Now that the window has been restored, we need to clear its animation style
   // to default so that normal animation applies.
   ::wm::SetWindowVisibilityAnimationType(
       window, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 }
 
 void AnimateHideWindow_Minimize(aura::Window* window) {
-  window->layer()->set_delegate(NULL);
-
   // Property sets within this scope will be implicitly animated.
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+  ::wm::ScopedHidingAnimationSettings hiding_settings(window);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
       kLayerAnimationsForMinimizeDurationMS);
-  settings.SetTransitionDuration(duration);
-  settings.AddObserver(
-      ::wm::CreateHidingWindowAnimationObserver(window));
+  hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
   window->layer()->SetVisible(false);
 
   AddLayerAnimationsForMinimize(window, false);
 }
 
 void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
                                                      bool show) {
-  window->layer()->set_delegate(window);
-
   float start_value, end_value;
   if (show) {
     start_value = kWindowAnimation_HideBrightnessGrayscale;
     end_value = kWindowAnimation_ShowBrightnessGrayscale;
   } else {
     start_value = kWindowAnimation_ShowBrightnessGrayscale;
     end_value = kWindowAnimation_HideBrightnessGrayscale;
   }
 
   window->layer()->SetLayerBrightness(start_value);
   window->layer()->SetLayerGrayscale(start_value);
   if (show) {
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
     window->layer()->SetVisible(true);
   }
 
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
 
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.SetTransitionDuration(duration);
-  if (!show) {
-    settings.AddObserver(
-        ::wm::CreateHidingWindowAnimationObserver(window));
-  }
-
-  window->layer()->GetAnimator()->
-      ScheduleTogether(
-          CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
-  if (!show) {
+  if (show) {
+    ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+    window->layer()->GetAnimator()->
+        ScheduleTogether(
+            CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
+  } else {
+    ::wm::ScopedHidingAnimationSettings hiding_settings(window);
+    window->layer()->GetAnimator()->
+        ScheduleTogether(
+            CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
     window->layer()->SetVisible(false);
   }
 }
 
 void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
   AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
 }
 
 void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
@@ skipping 267 matching lines @@
   }
 
   // Assume the shelf is overflowed, zoom off to the bottom right of the
   // work area.
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
   return gfx::Rect(work_area.right(), work_area.bottom(), 0, 0);
 }
 
 }  // namespace ash