Aura: Add non-browser windows into the list of "Alt + Tab" cycle list.

ash/wm/activation_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 "ash/wm/activation_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_modality_controller.h"
 #include "ash/wm/window_util.h"
@@ skipping 37 matching lines @@
 // Returns true if children of |window| can be activated.
 // These are the only containers in which windows can receive focus.
 bool SupportsChildActivation(aura::Window* window) {
   for (size_t i = 0; i < arraysize(kWindowContainerIds); i++) {
     if (window->id() == kWindowContainerIds[i])
       return true;
   }
   return false;
 }
 
+bool HasModalTransientChild(aura::Window* window) {
+  aura::Window::Windows::const_iterator it;
+  for (it = window->transient_children().begin();
+       it != window->transient_children().end();
+       ++it) {
+    if ((*it)->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_WINDOW)
+      return true;
+  }
+  return false;
+}
+
 // Returns true if |window| can be activated or deactivated.
 // A window manager typically defines some notion of "top level window" that
 // supports activation/deactivation.
-bool CanActivateWindow(aura::Window* window, const aura::Event* event) {
+bool CanActivateWindowWithEvent(aura::Window* window,
+                                const aura::Event* event) {
   return window &&
       window->IsVisible() &&
       (!aura::client::GetActivationDelegate(window) ||
         aura::client::GetActivationDelegate(window)->ShouldActivate(event)) &&
       SupportsChildActivation(window->parent());
 }
 
 // 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.
@@ skipping 25 matching lines @@
   aura::Env::GetInstance()->RemoveObserver(this);
 }
 
 // static
 aura::Window* ActivationController::GetActivatableWindow(
     aura::Window* window,
     const aura::Event* event) {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
-    if (CanActivateWindow(child, event))
+    if (CanActivateWindowWithEvent(child, event))
       return child;
     // If |child| isn't activatable, but has transient parent, trace
     // that path instead.
     if (child->transient_parent())
       return GetActivatableWindow(child->transient_parent(), event);
     parent = parent->parent();
     child = child->parent();
   }
   return NULL;
 }
 
+bool ActivationController::CanActivateWindow(aura::Window* window) const {
+  return CanActivateWindowWithEvent(window, NULL) &&
+         !HasModalTransientChild(window);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::client::ActivationClient implementation:
 
 void ActivationController::ActivateWindow(aura::Window* window) {
   ActivateWindowWithEvent(window, NULL);
 }
 
 void ActivationController::DeactivateWindow(aura::Window* window) {
   if (window)
     ActivateNextWindow(window);
 }
 
 aura::Window* ActivationController::GetActiveWindow() {
   return Shell::GetRootWindow()->GetProperty(
       aura::client::kRootWindowActiveWindowKey);
 }
 
 bool ActivationController::OnWillFocusWindow(aura::Window* window,
                                              const aura::Event* event) {
-  return CanActivateWindow(GetActivatableWindow(window, event), event);
+  return CanActivateWindowWithEvent(GetActivatableWindow(window, event), event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::WindowObserver implementation:
 
 void ActivationController::OnWindowVisibilityChanged(aura::Window* window,
                                                      bool visible) {
   if (!visible) {
     aura::Window* next_window = ActivateNextWindow(window);
     if (next_window && next_window->parent() == window->parent()) {
@@ skipping 46 matching lines @@
   if (updating_activation_)
     return;
 
   AutoReset<bool> in_activate_window(&updating_activation_, true);
   // Nothing may actually have changed.
   aura::Window* old_active = GetActiveWindow();
   if (old_active == window)
     return;
   // The stacking client may impose rules on what window configurations can be
   // activated or deactivated.
-  if (window && !CanActivateWindow(window, event))
+  if (window && !CanActivateWindowWithEvent(window, event))
     return;
   // If the screen is locked, just bring the window to top so that
   // it will be activated when the lock window is destroyed.
   if (window && !window->CanReceiveEvents()) {
     StackTransientParentsBelowModalWindow(window);
     window->parent()->StackChildAtTop(window);
     return;
   }
   if (window &&
       !window->Contains(window->GetFocusManager()->GetFocusedWindow())) {
@@ skipping 49 matching lines @@
   return window;
 }
 
 aura::Window* ActivationController::GetTopmostWindowToActivateInContainer(
     aura::Window* container,
     aura::Window* ignore) const {
   for (aura::Window::Windows::const_reverse_iterator i =
            container->children().rbegin();
        i != container->children().rend();
        ++i) {
-    if (*i != ignore && CanActivateWindow(*i, NULL))
+    if (*i != ignore && CanActivateWindowWithEvent(*i, NULL))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace ash