Hook up the FocusController behind a flag.

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_client.h"
 #include "ui/aura/root_window.h"
@@ skipping 120 matching lines @@
   FocusControllerTestBase() {}
 
   // Overridden from aura::test::AuraTestBase:
   virtual void SetUp() OVERRIDE {
     // FocusController registers itself as an Env observer so it can catch all
     // window initializations, including the root_window()'s, so we create it
     // before allowing the base setup.
     test_focus_rules_ = new TestFocusRules;
     focus_controller_.reset(new FocusController(test_focus_rules_));
     aura::test::AuraTestBase::SetUp();
-    root_window()->AddPreTargetHandler(focus_controller());
-    aura::client::SetActivationClient(root_window(), focus_controller());
+    root_window()->AddPreTargetHandler(focus_controller_.get());
+    aura::client::SetFocusClient(root_window(), focus_controller_.get());
+    aura::client::SetActivationClient(root_window(), focus_controller_.get());
 
     // Hierarchy used by all tests:
     // root_window
     //       +-- w1
     //       |    +-- w11
     //       |    +-- w12
     //       +-- w2
     //       |    +-- w21
     //       |         +-- w211
     //       +-- w3
@@ skipping 13 matching lines @@
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 21,
         gfx::Rect(5, 5, 10, 10), w2);
     aura::test::CreateTestWindowWithDelegate(
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 211,
         gfx::Rect(1, 1, 5, 5), w21);
     aura::test::CreateTestWindowWithDelegate(
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3,
         gfx::Rect(125, 125, 50, 50), root_window());
   }
   virtual void TearDown() OVERRIDE {
-    root_window()->RemovePreTargetHandler(focus_controller());
+    root_window()->RemovePreTargetHandler(focus_controller_.get());
     aura::test::AuraTestBase::TearDown();
     test_focus_rules_ = NULL;  // Owned by FocusController.
     focus_controller_.reset();
   }
 
-  FocusController* focus_controller() { return focus_controller_.get(); }
-  aura::Window* focused_window() { return focus_controller_->focused_window(); }
-  int focused_window_id() {
-      return focused_window() ? focused_window()->id() : -1;
+  void FocusWindow(aura::Window* window) {
+    aura::client::GetFocusClient(root_window())->FocusWindow(window, NULL);
   }
-
+  aura::Window* GetFocusedWindow() {
+    return aura::client::GetFocusClient(root_window())->GetFocusedWindow();
+  }
+  int GetFocusedWindowId() {
+    return GetFocusedWindow()->id();
+  }
   void ActivateWindow(aura::Window* window) {
     aura::client::GetActivationClient(root_window())->ActivateWindow(window);
   }
   void DeactivateWindow(aura::Window* window) {
     aura::client::GetActivationClient(root_window())->DeactivateWindow(window);
   }
   aura::Window* GetActiveWindow() {
     return aura::client::GetActivationClient(root_window())->GetActiveWindow();
   }
   int GetActiveWindowId() {
@@ skipping 49 matching lines @@
     FocusWindowDirect(window);
   }
   void ActivateWindowById(int id) {
     aura::Window* window = root_window()->GetChildById(id);
     DCHECK(window);
     ActivateWindowDirect(window);
   }
 
   // Overridden from FocusControllerTestBase:
   virtual void BasicFocus() OVERRIDE {
-    EXPECT_EQ(NULL, focused_window());
+    EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(1);
-    EXPECT_EQ(1, focused_window_id());
+    EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(2);
-    EXPECT_EQ(2, focused_window_id());
+    EXPECT_EQ(2, GetFocusedWindowId());
   }
   virtual void BasicActivation() OVERRIDE {
     EXPECT_EQ(NULL, GetActiveWindow());
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
     DeactivateWindow(GetActiveWindow());
     EXPECT_EQ(1, GetActiveWindowId());
   }
@@ skipping 49 matching lines @@
     FocusEventsTestHandler handler_root(root_window());
     ExpectActivationEvents(&handler_root, 0, 0);
     ActivateWindowById(2);
     ExpectActivationEvents(&handler_root, 1, 1);
     ActivateWindowById(2);
     ExpectActivationEvents(&handler_root, 1, 1);
   }
   virtual void ShiftFocusWithinActiveWindow() OVERRIDE {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
-    EXPECT_EQ(1, focused_window_id());
+    EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(11);
-    EXPECT_EQ(11, focused_window_id());
+    EXPECT_EQ(11, GetFocusedWindowId());
     FocusWindowById(12);
-    EXPECT_EQ(12, focused_window_id());
+    EXPECT_EQ(12, GetFocusedWindowId());
   }
   virtual void ShiftFocusToChildOfInactiveWindow() OVERRIDE {
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
-    EXPECT_EQ(2, focused_window_id());
+    EXPECT_EQ(2, GetFocusedWindowId());
     FocusWindowById(11);
     EXPECT_EQ(1, GetActiveWindowId());
-    EXPECT_EQ(11, focused_window_id());
+    EXPECT_EQ(11, GetFocusedWindowId());
   }
   virtual void FocusRulesOverride() OVERRIDE {
-    EXPECT_EQ(NULL, focused_window());
+    EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(11);
-    EXPECT_EQ(11, focused_window_id());
+    EXPECT_EQ(11, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(211));
     FocusWindowById(12);
-    EXPECT_EQ(211, focused_window_id());
+    EXPECT_EQ(211, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
     FocusWindowById(12);
-    EXPECT_EQ(12, focused_window_id());
+    EXPECT_EQ(12, GetFocusedWindowId());
   }
   virtual void ActivationRulesOverride() OVERRIDE {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
-    EXPECT_EQ(1, focused_window_id());
+    EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w3 = root_window()->GetChildById(3);
     test_focus_rules()->set_focus_restriction(w3);
 
     ActivateWindowById(2);
     // FocusRules restricts focus and activation to 3.
     EXPECT_EQ(3, GetActiveWindowId());
-    EXPECT_EQ(3, focused_window_id());
+    EXPECT_EQ(3, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
-    EXPECT_EQ(2, focused_window_id());
+    EXPECT_EQ(2, GetFocusedWindowId());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase);
 };
 
 // Focus and Activation changes via aura::client::ActivationClient API.
 class FocusControllerApiTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerApiTest() {}
 
  private:
   // Overridden from FocusControllerTestBase:
   virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
-    focus_controller()->FocusWindow(window);
+    FocusWindow(window);
   }
   virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
     ActivateWindow(window);
   }
   virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
     DeactivateWindow(window);
   }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
 };
@@ skipping 56 matching lines @@
 
   aura::Window* GetDispositionWindow(aura::Window* window) {
     return parent_ ? window->parent() : window;
   }
 
   // Change the disposition of |window| in such a way as it will lose focus.
   virtual void ChangeWindowDisposition(aura::Window* window) = 0;
 
   // Overridden from FocusControllerTestBase:
   virtual void BasicFocus() OVERRIDE {
-    EXPECT_EQ(NULL, focused_window());
+    EXPECT_EQ(NULL, GetFocusedWindow());
 
     aura::Window* w211 = root_window()->GetChildById(211);
-    focus_controller()->FocusWindow(w211);
-    EXPECT_EQ(211, focused_window_id());
+    FocusWindow(w211);
+    EXPECT_EQ(211, GetFocusedWindowId());
 
     ChangeWindowDisposition(w211);
     // BasicFocusRules passes focus to the parent.
-    EXPECT_EQ(parent_ ? 2 : 21, focused_window_id());
+    EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId());
   }
   virtual void BasicActivation() OVERRIDE {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     EXPECT_EQ(NULL, GetActiveWindow());
 
     aura::Window* w2 = root_window()->GetChildById(2);
     ActivateWindow(w2);
     EXPECT_EQ(2, GetActiveWindowId());
 
     ChangeWindowDisposition(w2);
     EXPECT_EQ(3, GetActiveWindowId());
   }
   virtual void FocusEvents() OVERRIDE {
     aura::Window* w211 = root_window()->GetChildById(211);
-    focus_controller()->FocusWindow(w211);
+    FocusWindow(w211);
 
     FocusEventsTestHandler handler(root_window()->GetChildById(211));
     EXPECT_EQ(0, handler.GetCountForEventType(
         FocusChangeEvent::focus_changing_event_type()));
     EXPECT_EQ(0, handler.GetCountForEventType(
         FocusChangeEvent::focus_changed_event_type()));
     ChangeWindowDisposition(w211);
     EXPECT_EQ(1, handler.GetCountForEventType(
         FocusChangeEvent::focus_changing_event_type()));
     EXPECT_EQ(1, handler.GetCountForEventType(
@@ skipping 12 matching lines @@
     ExpectActivationEvents(&handler_root, 0, 0);
     ExpectActivationEvents(&handler_2, 0, 0);
     ExpectActivationEvents(&handler_3, 0, 0);
 
     ChangeWindowDisposition(w2);
     ExpectActivationEvents(&handler_root, 1, 1);
     ExpectActivationEvents(&handler_2, 1, 0);
     ExpectActivationEvents(&handler_3, 0, 1);
   }
   virtual void FocusRulesOverride() OVERRIDE {
-    EXPECT_EQ(NULL, focused_window());
+    EXPECT_EQ(NULL, GetFocusedWindow());
     aura::Window* w211 = root_window()->GetChildById(211);
-    focus_controller()->FocusWindow(w211);
-    EXPECT_EQ(211, focused_window_id());
+    FocusWindow(w211);
+    EXPECT_EQ(211, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(11));
     ChangeWindowDisposition(w211);
     // Normally, focus would shift to the parent (w21) but the override shifts
     // it to 11.
-    EXPECT_EQ(11, focused_window_id());
+    EXPECT_EQ(11, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
   }
   virtual void ActivationRulesOverride() OVERRIDE {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     aura::Window* w1 = root_window()->GetChildById(1);
     ActivateWindow(w1);
 
     EXPECT_EQ(1, GetActiveWindowId());
-    EXPECT_EQ(1, focused_window_id());
+    EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w3 = root_window()->GetChildById(3);
     test_focus_rules()->set_focus_restriction(w3);
 
     // Normally, activation/focus would move to w2, but since we have a focus
     // restriction, it should move to w3 instead.
     ChangeWindowDisposition(w1);
     EXPECT_EQ(3, GetActiveWindowId());
-    EXPECT_EQ(3, focused_window_id());
+    EXPECT_EQ(3, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
     ActivateWindow(root_window()->GetChildById(2));
     EXPECT_EQ(2, GetActiveWindowId());
-    EXPECT_EQ(2, focused_window_id());
+    EXPECT_EQ(2, GetFocusedWindowId());
   }
 
  private:
   // When true, the disposition change occurs to the parent of the window
   // instead of to the window. This verifies that changes occurring in the
   // hierarchy that contains the window affect the window's focus.
   bool parent_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerImplicitTestBase);
 };
@@ skipping 157 matching lines @@
 DIRECT_FOCUS_CHANGE_TESTS(ShiftFocusToChildOfInactiveWindow);
 
 // - Verifies that FocusRules determine what can be focused.
 ALL_FOCUS_TESTS(FocusRulesOverride);
 
 // - Verifies that FocusRules determine what can be activated.
 TARGET_FOCUS_TESTS(ActivationRulesOverride);
 
 }  // namespace corewm
 }  // namespace views