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

ui/wm/core/focus_controller_unittest.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 <map>
 
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/default_capture_client.h"
@@ skipping 15 matching lines @@
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace wm {
 
 class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
                                   public aura::client::FocusChangeObserver {
  public:
   FocusNotificationObserver()
-      : activation_changed_count_(0),
+      : last_activation_reason_(ActivationReason::ACTIVATION_CLIENT),
+        activation_changed_count_(0),
         focus_changed_count_(0),
         reactivation_count_(0),
         reactivation_requested_window_(NULL),
         reactivation_actual_window_(NULL) {}
   ~FocusNotificationObserver() override {}
 
   void ExpectCounts(int activation_changed_count, int focus_changed_count) {
     EXPECT_EQ(activation_changed_count, activation_changed_count_);
     EXPECT_EQ(focus_changed_count, focus_changed_count_);
   }
+  ActivationReason last_activation_reason() const {
+    return last_activation_reason_;
+  }
   int reactivation_count() const {
     return reactivation_count_;
   }
   aura::Window* reactivation_requested_window() const {
     return reactivation_requested_window_;
   }
   aura::Window* reactivation_actual_window() const {
     return reactivation_actual_window_;
   }
 
  private:
   // Overridden from aura::client::ActivationChangeObserver:
-  void OnWindowActivated(aura::Window* gained_active,
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
                          aura::Window* lost_active) override {
+    last_activation_reason_ = reason;
     ++activation_changed_count_;
   }
   void OnAttemptToReactivateWindow(aura::Window* request_active,
                                    aura::Window* actual_active) override {
     ++reactivation_count_;
     reactivation_requested_window_ = request_active;
     reactivation_actual_window_ = actual_active;
   }
 
   // Overridden from aura::client::FocusChangeObserver:
   void OnWindowFocused(aura::Window* gained_focus,
                        aura::Window* lost_focus) override {
     ++focus_changed_count_;
   }
 
+  ActivationReason last_activation_reason_;
   int activation_changed_count_;
   int focus_changed_count_;
   int reactivation_count_;
   aura::Window* reactivation_requested_window_;
   aura::Window* reactivation_actual_window_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusNotificationObserver);
 };
 
 class WindowDeleter {
@@ skipping 22 matching lines @@
   ~RecordingActivationAndFocusChangeObserver() override {
     aura::client::GetActivationClient(root_)->RemoveObserver(this);
     aura::client::GetFocusClient(root_)->RemoveObserver(this);
   }
 
   bool was_notified_with_deleted_window() const {
     return was_notified_with_deleted_window_;
   }
 
   // Overridden from aura::client::ActivationChangeObserver:
-  void OnWindowActivated(aura::Window* gained_active,
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
                          aura::Window* lost_active) override {
     if (lost_active && lost_active == deleter_->GetDeletedWindow())
       was_notified_with_deleted_window_ = true;
   }
 
   // Overridden from aura::client::FocusChangeObserver:
   void OnWindowFocused(aura::Window* gained_focus,
                        aura::Window* lost_focus) override {
     if (lost_focus && lost_focus == deleter_->GetDeletedWindow())
       was_notified_with_deleted_window_ = true;
@@ skipping 22 matching lines @@
       : root_(window->GetRootWindow()),
         window_(window),
         did_delete_(false) {
     aura::client::GetActivationClient(root_)->AddObserver(this);
   }
   ~DeleteOnLoseActivationChangeObserver() override {
     aura::client::GetActivationClient(root_)->RemoveObserver(this);
   }
 
   // Overridden from aura::client::ActivationChangeObserver:
-  void OnWindowActivated(aura::Window* gained_active,
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
                          aura::Window* lost_active) override {
     if (window_ && lost_active == window_) {
       delete lost_active;
       did_delete_ = true;
     }
   }
 
   // Overridden from WindowDeleter:
   aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
@@ skipping 124 matching lines @@
       : activated_window_(activated_window),
         shift_focus_to_(NULL) {}
   ~FocusShiftingActivationObserver() override {}
 
   void set_shift_focus_to(aura::Window* shift_focus_to) {
     shift_focus_to_ = shift_focus_to;
   }
 
  private:
   // Overridden from aura::client::ActivationChangeObserver:
-  void OnWindowActivated(aura::Window* gained_active,
+  void OnWindowActivated(ActivationReason reason,
+                         aura::Window* gained_active,
                          aura::Window* lost_active) override {
     // Shift focus to a child. This should prevent the default focusing from
     // occurring in FocusController::FocusWindow().
     if (gained_active == activated_window_) {
       aura::client::FocusClient* client =
           aura::client::GetFocusClient(gained_active);
       client->FocusWindow(shift_focus_to_);
     }
   }
 
@@ skipping 175 matching lines @@
   FocusControllerDirectTestBase() {}
 
   // Different test types shift focus in different ways.
   virtual void FocusWindowDirect(aura::Window* window) = 0;
   virtual void ActivateWindowDirect(aura::Window* window) = 0;
   virtual void DeactivateWindowDirect(aura::Window* window) = 0;
 
   // Input events do not change focus if the window can not be focused.
   virtual bool IsInputEvent() = 0;
 
+  // Returns the expected ActivationReason caused by calling the
+  // ActivatedWindowDirect(...) or DeactivateWindowDirect(...) methods.
+  virtual aura::client::ActivationChangeObserver::ActivationReason
+  GetExpectedActivationReason() const = 0;
+
   void FocusWindowById(int id) {
     aura::Window* window = root_window()->GetChildById(id);
     DCHECK(window);
     FocusWindowDirect(window);
   }
   void ActivateWindowById(int id) {
     aura::Window* window = root_window()->GetChildById(id);
     DCHECK(window);
     ActivateWindowDirect(window);
   }
@@ skipping 60 matching lines @@
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
 
     ActivateWindowById(2);
     root_observer.ExpectCounts(1, 1);
+    EXPECT_EQ(GetExpectedActivationReason(),
+              root_observer.last_activation_reason());
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
   void ReactivationEvents() override {
     ActivateWindowById(1);
     ScopedFocusNotificationObserver root_observer(root_window());
     EXPECT_EQ(0, root_observer.reactivation_count());
     root_window()->GetChildById(2)->Hide();
     // When we attempt to activate "2", which cannot be activated because it
     // is not visible, "1" will be reactivated.
@@ skipping 296 matching lines @@
  private:
   // Overridden from FocusControllerTestBase:
   void FocusWindowDirect(aura::Window* window) override { FocusWindow(window); }
   void ActivateWindowDirect(aura::Window* window) override {
     ActivateWindow(window);
   }
   void DeactivateWindowDirect(aura::Window* window) override {
     DeactivateWindow(window);
   }
   bool IsInputEvent() override { return false; }
+  // Overridden from FocusControllerDirectTestBase:
+  aura::client::ActivationChangeObserver::ActivationReason
+  GetExpectedActivationReason() const override {
+    return aura::client::ActivationChangeObserver::ActivationReason::
+        ACTIVATION_CLIENT;
+  }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
 };
 
 // Focus and Activation changes via input events.
 class FocusControllerMouseEventTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerMouseEventTest() {}
 
   // Tests that a handled mouse or gesture event does not trigger a window
@@ skipping 22 matching lines @@
   void ActivateWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.ClickLeftButton();
   }
   void DeactivateWindowDirect(aura::Window* window) override {
     aura::Window* next_activatable =
         test_focus_rules()->GetNextActivatableWindow(window);
     ui::test::EventGenerator generator(root_window(), next_activatable);
     generator.ClickLeftButton();
   }
+  // Overridden from FocusControllerDirectTestBase:
   bool IsInputEvent() override { return true; }
+  aura::client::ActivationChangeObserver::ActivationReason
+  GetExpectedActivationReason() const override {
+    return aura::client::ActivationChangeObserver::ActivationReason::
+        INPUT_EVENT;
+  }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest);
 };
 
 class FocusControllerGestureEventTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerGestureEventTest() {}
 
  private:
   // Overridden from FocusControllerTestBase:
   void FocusWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
   void ActivateWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
   void DeactivateWindowDirect(aura::Window* window) override {
     aura::Window* next_activatable =
         test_focus_rules()->GetNextActivatableWindow(window);
     ui::test::EventGenerator generator(root_window(), next_activatable);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
   bool IsInputEvent() override { return true; }
+  aura::client::ActivationChangeObserver::ActivationReason
+  GetExpectedActivationReason() const override {
+    return aura::client::ActivationChangeObserver::ActivationReason::
+        INPUT_EVENT;
+  }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest);
 };
 
 // Test base for tests where focus is implicitly set to a window as the result
 // of a disposition change to the focused window or the hierarchy that contains
 // it.
 class FocusControllerImplicitTestBase : public FocusControllerTestBase {
  protected:
   explicit FocusControllerImplicitTestBase(bool parent) : parent_(parent) {}
 
   aura::Window* GetDispositionWindow(aura::Window* window) {
     return parent_ ? window->parent() : window;
   }
 
+  // Returns the expected ActivationReason caused by calling the
+  // ActivatedWindowDirect(...) or DeactivateWindowDirect(...) methods.
+  aura::client::ActivationChangeObserver::ActivationReason
+  GetExpectedActivationReason() const {
+    return aura::client::ActivationChangeObserver::ActivationReason::
+        WINDOW_DISPOSITION_CHANGED;
+  }
+
   // Change the disposition of |window| in such a way as it will lose focus.
   virtual void ChangeWindowDisposition(aura::Window* window) = 0;
 
   // Allow each disposition change test to add additional post-disposition
   // change expectations.
   virtual void PostDispositionChangeExpectations() {}
 
   // Overridden from FocusControllerTestBase:
   void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
@@ skipping 40 matching lines @@
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
     ScopedTargetFocusNotificationObserver observer3(root_window(), 3);
     root_observer.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
     observer3.ExpectCounts(0, 0);
 
     ChangeWindowDisposition(w2);
     root_observer.ExpectCounts(1, 1);
+    EXPECT_EQ(GetExpectedActivationReason(),
+              root_observer.last_activation_reason());
     observer2.ExpectCounts(1, 1);
     observer3.ExpectCounts(1, 1);
   }
   void FocusRulesOverride() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
     EXPECT_EQ(211, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(11));
@@ skipping 250 matching lines @@
                       TransientChildWindowActivationTest);
 
 // - Verifies that the focused text input client is cleard when the window focus
 //   changes.
 ALL_FOCUS_TESTS(FocusedTextInputClient);
 
 // If a mouse event was handled, it should not activate a window.
 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
 
 }  // namespace wm