More unittests passing with new focus controller.

ui/views/corewm/base_focus_rules.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/base_focus_rules.h"
 
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
@@ skipping 51 matching lines @@
   // The window must be visible.
   if (!IsWindowConsideredVisibleForActivation(window))
     return false;
 
   // The window's activation delegate must allow this window to be activated.
   if (aura::client::GetActivationDelegate(window) &&
       !aura::client::GetActivationDelegate(window)->ShouldActivate()) {
     return false;
   }
 
+  // A window must be focusable to be activatable. We don't call
+  // CanFocusWindow() from here because it will call back to us via
+  // GetActivatableWindow().
+  if (!window->CanFocus())
+    return false;
+
   // The window cannot be blocked by a modal transient.
   return !GetModalTransient(window);
 }
 
 bool BaseFocusRules::CanFocusWindow(aura::Window* window) const {
   // It is possible to focus a NULL window, it is equivalent to clearing focus.
   if (!window)
     return true;
 
   // The focused window is always inside the active window, so windows that
@@ skipping 17 matching lines @@
   return NULL;
 }
 
 aura::Window* BaseFocusRules::GetActivatableWindow(aura::Window* window) const {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
     if (CanActivateWindow(child))
       return child;
 
+    // CanActivateWindow() above will return false if |child| is blocked by a
+    // modal transient. In this case the modal is or contains the activatable
+    // window. We recurse because the modal may itself be blocked by a modal
+    // transient.
+    aura::Window* modal_transient = GetModalTransient(child);
+    if (modal_transient)
+      return GetActivatableWindow(modal_transient);
+
     if (child->transient_parent())
       return GetActivatableWindow(child->transient_parent());
 
     parent = parent->parent();
     child = child->parent();
   }
   return NULL;
 }
 
 aura::Window* BaseFocusRules::GetFocusableWindow(aura::Window* window) const {
   if (CanFocusWindow(window))
     return window;
 
   // |window| may be in a hierarchy that is non-activatable, in which case we
   // need to cut over to the activatable hierarchy.
   aura::Window* activatable = GetActivatableWindow(window);
-  if (!activatable)
-    return GetFocusedWindow(window);
+  if (!activatable) {
+    // There may not be a related activatable hierarchy to cut over to, in which
+    // case we try an unrelated one.
+    aura::Window* toplevel = GetToplevelWindow(window);
+    if (toplevel)
+      activatable = GetNextActivatableWindow(toplevel);
+    if (!activatable)
+      return NULL;
+  }
 
   if (!activatable->Contains(window)) {
     // If there's already a child window focused in the activatable hierarchy,
     // just use that (i.e. don't shift focus), otherwise we need to at least cut
     // over to the activatable hierarchy.
     aura::Window* focused = GetFocusedWindow(activatable);
     return activatable->Contains(focused) ? focused : activatable;
   }
 
   while (window && !CanFocusWindow(window))
@@ skipping 32 matching lines @@
 
   // Focus cycling is currently very primitive: we just climb the tree.
   // If need be, we could add the ability to look at siblings, descend etc.
   // For test coverage, see FocusControllerImplicitTestBase subclasses in
   // focus_controller_unittest.cc.
   return GetFocusableWindow(ignore->parent());
 }
 
 }  // namespace corewm
 }  // namespace views