More unittests passing with new focus controller.

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/focus_change_observer.h"
@@ skipping 20 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, public:
 
 FocusController::FocusController(FocusRules* rules)
     : active_window_(NULL),
       focused_window_(NULL),
+      updating_focus_(false),
       rules_(rules),
       ALLOW_THIS_IN_INITIALIZER_LIST(observer_manager_(this)) {
   DCHECK(rules);
   aura::Env::GetInstance()->AddObserver(this);
 }
 
 FocusController::~FocusController() {
   aura::Env::GetInstance()->RemoveObserver(this);
 }
 
@@ skipping 49 matching lines @@
   focus_observers_.AddObserver(observer);
 }
 
 void FocusController::RemoveObserver(
     aura::client::FocusChangeObserver* observer) {
   focus_observers_.RemoveObserver(observer);
 }
 
 void FocusController::FocusWindow(aura::Window* window,
                                   const ui::Event* event) {
+  if (updating_focus_)
+    return;
+
+  if (window &&
+      (window->Contains(focused_window_) || window->Contains(active_window_))) {
+    return;
+  }
+
   // Focusing a window also activates its containing activatable window. Note
   // that the rules could redirect activation activation and/or focus.
   aura::Window* focusable = rules_->GetFocusableWindow(window);
   aura::Window* activatable =
       focusable ? rules_->GetActivatableWindow(focusable) : NULL;
+
+  // We need valid focusable/activatable windows in the event we're not clearing
+  // focus. "Clearing focus" is inferred by whether or not |window| passed to
+  // this function is non-NULL.
+  if (window && (!focusable || !activatable))
+    return;
+  DCHECK((focusable && activatable) || !window);
   SetActiveWindow(activatable);
-  if (focusable && activatable)
-    DCHECK(GetActiveWindow()->Contains(focusable));
+  if (active_window_)
+    DCHECK(active_window_->Contains(focusable));
   SetFocusedWindow(focusable);
 }
 
 aura::Window* FocusController::GetFocusedWindow() {
   return focused_window_;
 }
 
 void FocusController::OnWindowHiddenInRootWindow(
     aura::Window* window,
     aura::RootWindow* root_window,
@@ skipping 60 matching lines @@
 }
 
 void FocusController::OnWindowInitialized(aura::Window* window) {
   observer_manager_.Add(window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, private:
 
 void FocusController::SetFocusedWindow(aura::Window* window) {
-  if (window == focused_window_)
+  if (updating_focus_ || window == focused_window_)
     return;
   DCHECK(rules_->CanFocusWindow(window));
   if (window)
     DCHECK_EQ(window, rules_->GetFocusableWindow(window));
 
+  base::AutoReset<bool> updating_focus(&updating_focus_, true);
   aura::Window* lost_focus = focused_window_;
   focused_window_ = window;
 
   FOR_EACH_OBSERVER(aura::client::FocusChangeObserver,
                     focus_observers_,
                     OnWindowFocused(focused_window_, lost_focus));
   aura::client::FocusChangeObserver* observer =
       aura::client::GetFocusChangeObserver(lost_focus);
   if (observer)
     observer->OnWindowFocused(focused_window_, lost_focus);
   observer = aura::client::GetFocusChangeObserver(focused_window_);
   if (observer)
     observer->OnWindowFocused(focused_window_, lost_focus);
 }
 
 void FocusController::SetActiveWindow(aura::Window* window) {
-  if (window == active_window_)
+  if (updating_focus_ || window == active_window_)
     return;
+
   DCHECK(rules_->CanActivateWindow(window));
   if (window)
     DCHECK_EQ(window, rules_->GetActivatableWindow(window));
 
+  base::AutoReset<bool> updating_focus(&updating_focus_, true);
   aura::Window* lost_activation = active_window_;
   active_window_ = window;
   if (active_window_) {
     StackTransientParentsBelowModalWindow(active_window_);
     active_window_->parent()->StackChildAtTop(active_window_);
   }
 
   FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
                     activation_observers_,
                     OnWindowActivated(active_window_, lost_activation));
   aura::client::ActivationChangeObserver* observer =
       aura::client::GetActivationChangeObserver(lost_activation);
   if (observer)
     observer->OnWindowActivated(active_window_, lost_activation);
   observer = aura::client::GetActivationChangeObserver(active_window_);
   if (observer)
     observer->OnWindowActivated(active_window_, lost_activation);
 }
 
 void FocusController::WindowLostFocusFromDispositionChange(
     aura::Window* window) {
+  // A window's modality state will interfere with focus restoration during its
+  // destruction.
+  window->ClearProperty(aura::client::kModalKey);
   // 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_)) {
+  if (window == 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, NULL);
 }
 
 }  // namespace corewm
 }  // namespace views