FocusController needs to restack windows upon activation (but not focus).

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/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/views/corewm/focus_change_event.h"
 #include "ui/views/corewm/focus_rules.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) {
+  if (window->GetProperty(aura::client::kModalKey) != ui::MODAL_TYPE_WINDOW)
+    return;
+
+  aura::Window* transient_parent = window->transient_parent();
+  while (transient_parent) {
+    transient_parent->parent()->StackChildAtTop(transient_parent);
+    transient_parent = transient_parent->transient_parent();
+  }
+}
+
 // Updates focused window state and dispatches changing/changed events.
 void DispatchEventsAndUpdateState(ui::EventDispatcher* dispatcher,
                                   int changing_event_type,
                                   int changed_event_type,
                                   aura::Window** state,
                                   aura::Window* new_state,
+                                  bool restack,
                                   ui::EventTarget** event_dispatch_target) {
   int result = ui::ER_UNHANDLED;
   {
     base::AutoReset<ui::EventTarget*> reset(event_dispatch_target, *state);
     FocusChangeEvent changing_event(changing_event_type);
     result = dispatcher->ProcessEvent(*state, &changing_event);
   }
   DCHECK(!(result & ui::ER_CONSUMED))
       << "Focus and Activation events cannot be consumed";
 
   *state = new_state;
 
+  if (restack && new_state) {
+    StackTransientParentsBelowModalWindow(new_state);
+    new_state->parent()->StackChildAtTop(new_state);
+  }
+
   {
     base::AutoReset<ui::EventTarget*> reset(event_dispatch_target, *state);
     FocusChangeEvent changed_event(changed_event_type);
     dispatcher->ProcessEvent(*state, &changed_event);
   }
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 132 matching lines @@
     return;
   DCHECK(rules_->CanFocusWindow(window));
   if (window)
     DCHECK_EQ(window, rules_->GetFocusableWindow(window));
   DispatchEventsAndUpdateState(
       this,
       FocusChangeEvent::focus_changing_event_type(),
       FocusChangeEvent::focus_changed_event_type(),
       &focused_window_,
       window,
+      /* restack */ false,
       &event_dispatch_target_);
 }
 
 void FocusController::SetActiveWindow(aura::Window* window) {
   if (window == active_window_)
     return;
   DCHECK(rules_->CanActivateWindow(window));
   if (window)
     DCHECK_EQ(window, rules_->GetActivatableWindow(window));
   DispatchEventsAndUpdateState(
       this,
       FocusChangeEvent::activation_changing_event_type(),
       FocusChangeEvent::activation_changed_event_type(),
       &active_window_,
       window,
+      /* restack */ true,
       &event_dispatch_target_);
 }
 
 void FocusController::WindowLostFocusFromDispositionChange(
     aura::Window* window) {
   // TODO(beng): See if this function can be replaced by a call to
   //             FocusWindow().
   // Activation adjustments are handled first in the event of a disposition
   // changed. If an activation change is necessary, focus is reset as part of
   // that process so there's no point in updating focus independently.
   if (window->Contains(active_window_)) {
     aura::Window* next_activatable = rules_->GetNextActivatableWindow(window);
     SetActiveWindow(next_activatable);
     SetFocusedWindow(next_activatable);
   } else if (window->Contains(focused_window_)) {
     // Active window isn't changing, but focused window might be.
     SetFocusedWindow(rules_->GetNextFocusableWindow(window));
   }
 }
 
 void FocusController::WindowFocusedFromInputEvent(aura::Window* window) {
   FocusWindow(window);
 }
 
 }  // namespace corewm
 }  // namespace views