Keep dedicated layers for hiding animation

ui/views/corewm/focus_controller.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/focus_controller.h"
 
 #include "base/auto_reset.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/events/event.h"
 #include "ui/views/corewm/focus_rules.h"
+#include "ui/views/corewm/window_animations.h"
 #include "ui/views/corewm/window_util.h"
 
 namespace views {
 namespace corewm {
 namespace {
 
 // When a modal window is activated, we bring its entire transient parent chain
 // to the front. This function must be called before the modal transient is
 // stacked at the top to ensure correct stacking order.
 void StackTransientParentsBelowModalWindow(aura::Window* window) {
@@ skipping 13 matching lines @@
   // the same parent.
   const aura::Window::Windows& window_transients(
       GetTransientChildren(relative_to));
   for (aura::Window::Windows::const_iterator i = window_transients.begin();
        i != window_transients.end(); ++i) {
     aura::Window* transient = *i;
     if (transient->parent() == relative_to->parent())
       relative_to = transient;
   }
   if (window != relative_to) {
-    window->layer()->parent()->StackAbove(window->layer(),
-                                          relative_to->layer());
+    ui::Layer* hiding_layer = DetachHidingAnimationLayer(window);
+    if (hiding_layer) {
+      window->layer()->parent()->StackAbove(hiding_layer,
+                                            relative_to->layer());
+    }
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, public:
 
 FocusController::FocusController(FocusRules* rules)
     : active_window_(NULL),
@@ skipping 147 matching lines @@
 // FocusController, aura::WindowObserver implementation:
 
 void FocusController::OnWindowVisibilityChanged(aura::Window* window,
                                                 bool visible) {
   if (!visible) {
     WindowLostFocusFromDispositionChange(window, window->parent());
     // Despite the focus change, we need to keep the window being hidden
     // stacked above the new window so it stays open on top as it animates away.
     aura::Window* next_window = GetActiveWindow();
     if (next_window && next_window->parent() == window->parent())
       StackWindowLayerAbove(window, next_window);

[sky, 2014/03/05 15:49:05]

Is it possible to remove this code entirely and instead change the hiding code
to acquire the layers immediately for the animation?

[oshima, 2014/03/05 17:14:22]

Only down side is that it will always bring the window's layer to front even if
the window wasn't active (in which case, we may not care).

Scott, we talked about if this is really necessary for desktop aura. If
desktop_aura do not need this behavior, I can move this logic to ash. (I can do
this if the window has hide animation observer when the window is deactivated).

WDYT?

   }
 }
 
 void FocusController::OnWindowDestroying(aura::Window* window) {
   WindowLostFocusFromDispositionChange(window, window->parent());
 }
 
 void FocusController::OnWindowHierarchyChanging(
     const HierarchyChangeParams& params) {
   if (params.receiver == active_window_ &&
@@ skipping 141 matching lines @@
 void FocusController::WindowFocusedFromInputEvent(aura::Window* window) {
   // Only focus |window| if it or any of its parents can be focused. Otherwise
   // FocusWindow() will focus the topmost window, which may not be the
   // currently focused one.
   if (rules_->CanFocusWindow(GetToplevelWindow(window)))
     FocusWindow(window);
 }
 
 }  // namespace corewm
 }  // namespace views