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

ui/views/corewm/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/views/corewm/focus_controller.h"
 
 #include <map>
 
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/activation_client.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/events/event_handler.h"
 #include "ui/views/corewm/base_focus_rules.h"
 
 namespace views {
 namespace corewm {
 
 class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
                                   public aura::client::FocusChangeObserver {
  public:
   FocusNotificationObserver()
       : activation_changed_count_(0),
-        focus_changed_count_(0) {}
+        focus_changed_count_(0),
+        reactivation_count_(0),
+        reactivation_requested_window_(NULL),
+        reactivation_actual_window_(NULL) {}
   virtual ~FocusNotificationObserver() {}
 
   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_);
   }
-
+  int GetReactivationCount() {

[sky, 2013/04/24 14:14:53]

methods like this are typically named in unix_hacker_style. So, this should be
reactivation_count() (and const). Same with 45/48.

[sschmitz, 2013/04/24 15:42:04]

Done.

+    return reactivation_count_;
+  }
+  aura::Window* GetReactivationRequestedWindow() {
+    return reactivation_requested_window_;
+  }
+  aura::Window* GetReactivationActualWindow() {
+    return reactivation_actual_window_;
+  }
 
  private:
   // Overridden from aura::client::ActivationChangeObserver:
   virtual void OnWindowActivated(aura::Window* gained_active,
                                  aura::Window* lost_active) OVERRIDE {
     ++activation_changed_count_;
   }
+  virtual 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:
   virtual void OnWindowFocused(aura::Window* gained_focus,
                                aura::Window* lost_focus) OVERRIDE {
     ++focus_changed_count_;
   }
 
   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 ScopedFocusNotificationObserver : public FocusNotificationObserver {
  public:
   ScopedFocusNotificationObserver(aura::RootWindow* root_window)
       : root_window_(root_window) {
     aura::client::GetActivationClient(root_window_)->AddObserver(this);
     aura::client::GetFocusClient(root_window_)->AddObserver(this);
@@ skipping 198 matching lines @@
   }
 
   TestFocusRules* test_focus_rules() { return test_focus_rules_; }
 
   // Test functions.
   virtual void BasicFocus() = 0;
   virtual void BasicActivation() = 0;
   virtual void FocusEvents() = 0;
   virtual void DuplicateFocusEvents() {}
   virtual void ActivationEvents() = 0;
+  virtual void ReactivationEvents() {}
   virtual void DuplicateActivationEvents() {}
   virtual void ShiftFocusWithinActiveWindow() {}
   virtual void ShiftFocusToChildOfInactiveWindow() {}
   virtual void ShiftFocusToParentOfFocusedWindow() {}
   virtual void FocusRulesOverride() = 0;
   virtual void ActivationRulesOverride() = 0;
   virtual void ShiftFocusOnActivation() {}
   virtual void ShiftFocusOnActivationDueToHide() {}
   virtual void NoShiftActiveOnActivation() {}
   virtual void NoFocusChangeOnClickOnCaptureWindow() {}
@@ skipping 94 matching lines @@
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
 
     ActivateWindowById(2);
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
+  virtual void ReactivationEvents() OVERRIDE {
+    ActivateWindowById(1);
+    ScopedFocusNotificationObserver root_observer(root_window());
+    EXPECT_EQ(0, root_observer.GetReactivationCount());
+    root_window()->GetChildById(2)->Hide();
+    // When we attempt to activate "2", which cannot be activated because it
+    // is not visible, "1" will be reactivated.
+    ActivateWindowById(2);
+    EXPECT_EQ(1, root_observer.GetReactivationCount());
+    EXPECT_EQ(root_window()->GetChildById(2),
+              root_observer.GetReactivationRequestedWindow());
+    EXPECT_EQ(root_window()->GetChildById(1),
+              root_observer.GetReactivationActualWindow());
+  }
   virtual void DuplicateActivationEvents() OVERRIDE {
     // Activating an existing active window should not resend activation events.
     ActivateWindowById(1);
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
@@ skipping 524 matching lines @@
 ALL_FOCUS_TESTS(FocusEvents);
 
 // - Focuses or activates a window multiple times, verifies that events are only
 //   dispatched when focus/activation actually changes.
 DIRECT_FOCUS_CHANGE_TESTS(DuplicateFocusEvents);
 DIRECT_FOCUS_CHANGE_TESTS(DuplicateActivationEvents);
 
 // - Activates a window, verifies that activation events were dispatched.
 TARGET_FOCUS_TESTS(ActivationEvents);
 
+// - Attempts to active a hidden window, verifies that current window is
+//   attempted to be reactivated and the appropriate event dispatched.
+FOCUS_CONTROLLER_TEST(FocusControllerApiTest, ReactivationEvents);
+
 // - Input events/API calls shift focus between focusable windows within the
 //   active window.
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusWithinActiveWindow);
 
 // - Input events/API calls to a child window of an inactive window shifts
 //   activation to the activatable parent and focuses the child.
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToChildOfInactiveWindow);
 
 // - Input events/API calls to focus the parent of the focused window do not
 //   shift focus away from the child.
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToParentOfFocusedWindow);
 
 // - Verifies that FocusRules determine what can be focused.
 ALL_FOCUS_TESTS(FocusRulesOverride);
 
 // - Verifies that FocusRules determine what can be activated.
 TARGET_FOCUS_TESTS(ActivationRulesOverride);
 
 // - Verifies that attempts to change focus or activation from a focus or
 //   activation change observer are ignored.
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivation);
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusOnActivationDueToHide);
 DIRECT_FOCUS_CHANGE_TESTS(NoShiftActiveOnActivation);
 
 // Clicking on a window which has capture should not result in a focus change.
 DIRECT_FOCUS_CHANGE_TESTS(NoFocusChangeOnClickOnCaptureWindow);
 
 }  // namespace corewm
 }  // namespace views