Trying to activate a window in a workspace other than the current is ignored while a system modal d…

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"
@@ skipping 133 matching lines @@
   // 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);
 
   // Activation change observers may change the focused window. If this happens
   // we must not adjust the focus below since this will clobber that change.
   aura::Window* last_focused_window = focused_window_;
   if (!updating_activation_)
-    SetActiveWindow(activatable);
+    SetActiveWindow(window, activatable);
 
   // If the window's ActivationChangeObserver shifted focus to a valid window,
   // we don't want to focus the window we thought would be focused by default.
   bool activation_changed_focus = last_focused_window != focused_window_;
   if (!updating_focus_ && (!activation_changed_focus || !focused_window_)) {
     if (active_window_ && focusable)
       DCHECK(active_window_->Contains(focusable));
     SetFocusedWindow(focusable);
   }
 }
@@ skipping 107 matching lines @@
                     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 (updating_activation_ || window == active_window_)
+void FocusController::SetActiveWindow(aura::Window* requested_window,
+                                      aura::Window* window) {
+  if (updating_activation_)
     return;
 
+  if (window == active_window_) {
+    if (requested_window) {
+      FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
+                        activation_observers_,
+                        OnAttemptToReactivateWindow(requested_window,
+                                                    active_window_));
+    }
+    return;
+  }
+
   DCHECK(rules_->CanActivateWindow(window));
   if (window)
     DCHECK_EQ(window, rules_->GetActivatableWindow(window));
 
   base::AutoReset<bool> updating_activation(&updating_activation_, true);
   aura::Window* lost_activation = active_window_;
   if (active_window_ && observer_manager_.IsObserving(active_window_) &&
       focused_window_ != active_window_) {
     observer_manager_.Remove(active_window_);
   }
@@ skipping 23 matching lines @@
   // 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 == active_window_) {
     aura::Window* next_activatable = rules_->GetNextActivatableWindow(window);
-    SetActiveWindow(next_activatable);
+    SetActiveWindow(NULL, next_activatable);
     if (!(active_window_ && active_window_->Contains(focused_window_)))
       SetFocusedWindow(next_activatable);
   } else if (window->Contains(focused_window_)) {
     // Active window isn't changing, but focused window might be.
     SetFocusedWindow(rules_->GetFocusableWindow(next));
   }
 }
 
 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