Added an ActivationReason parameter to ActivationChangeObserver::OnWindowActivated(...).

ui/wm/core/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/wm/core/focus_controller.h"
 
 #include "base/auto_reset.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
@@ skipping 85 matching lines @@
     aura::client::FocusChangeObserver* observer) {
   focus_observers_.AddObserver(observer);
 }
 
 void FocusController::RemoveObserver(
     aura::client::FocusChangeObserver* observer) {
   focus_observers_.RemoveObserver(observer);
 }
 
 void FocusController::FocusWindow(aura::Window* window) {
-  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);
-
-  // 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(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);
-  }
+  FocusAndActivateWindow(aura::client::ActivationChangeObserver::
+                             ActivationReason::ACTIVATION_CLIENT,
+                         window);
 }
 
 void FocusController::ResetFocusWithinActiveWindow(aura::Window* window) {
   DCHECK(window);
   if (!active_window_)
     return;
   if (!active_window_->Contains(window))
     return;
   SetFocusedWindow(window);
 }
@@ skipping 58 matching lines @@
       params.target->Contains(params.receiver) && (!params.new_parent ||
       aura::client::GetFocusClient(params.new_parent) !=
           aura::client::GetFocusClient(params.receiver))) {
     WindowLostFocusFromDispositionChange(params.receiver, params.old_parent);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, private:
 
+void FocusController::FocusAndActivateWindow(
+    aura::client::ActivationChangeObserver::ActivationReason reason,
+    aura::Window* window) {
+  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);
+
+  // 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(reason, 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);
+  }
+}
+
 void FocusController::SetFocusedWindow(aura::Window* 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_;
 
@@ skipping 35 matching lines @@
     observer->OnWindowFocused(
         focused_window_,
         window_tracker.Contains(lost_focus) ? lost_focus : NULL);
   }
 
   // Ensure that the text input client is reset when the window loses the focus.
   if (!window)
     text_input_focus_manager->FocusTextInputClient(NULL);
 }
 
-void FocusController::SetActiveWindow(aura::Window* requested_window,
-                                      aura::Window* window) {
+void FocusController::SetActiveWindow(
+    aura::client::ActivationChangeObserver::ActivationReason reason,
+    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_));
     }
@@ skipping 20 matching lines @@
     observer_manager_.Add(active_window_);
   if (active_window_) {
     StackTransientParentsBelowModalWindow(active_window_);
     active_window_->parent()->StackChildAtTop(active_window_);
   }
 
   aura::client::ActivationChangeObserver* observer = NULL;
   if (window_tracker.Contains(lost_activation)) {
     observer = aura::client::GetActivationChangeObserver(lost_activation);
     if (observer)
-      observer->OnWindowActivated(active_window_, lost_activation);
+      observer->OnWindowActivated(reason, active_window_, lost_activation);
   }
   observer = aura::client::GetActivationChangeObserver(active_window_);
   if (observer) {
     observer->OnWindowActivated(
-        active_window_,
+        reason, active_window_,
         window_tracker.Contains(lost_activation) ? lost_activation : NULL);
   }
-  FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
-                    activation_observers_,
-                    OnWindowActivated(active_window_,
-                                      window_tracker.Contains(lost_activation) ?
-                                      lost_activation : NULL));
+  FOR_EACH_OBSERVER(
+      aura::client::ActivationChangeObserver, activation_observers_,
+      OnWindowActivated(
+          reason, active_window_,
+          window_tracker.Contains(lost_activation) ? lost_activation : NULL));
 }
 
 void FocusController::WindowLostFocusFromDispositionChange(
     aura::Window* window,
     aura::Window* next) {
   // 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(NULL, next_activatable);
+    SetActiveWindow(aura::client::ActivationChangeObserver::ActivationReason::
+                        WINDOW_DISPOSITION_CHANGED,
+                    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);
+  if (rules_->CanFocusWindow(GetToplevelWindow(window))) {
+    FocusAndActivateWindow(
+        aura::client::ActivationChangeObserver::ActivationReason::INPUT_EVENT,
+        window);
+  }
 }
 
 }  // namespace wm