Move the concept of Activation to the Shell.

ui/aura_shell/root_window_event_filter_unittest.cc

 // Copyright (c) 2011 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/aura_shell/root_window_event_filter.h"
 
+#include "ui/aura/client/activation_delegate.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/cursor.h"
 #include "ui/aura/event.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_windows.h"
 #include "ui/aura/test/test_event_filter.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_stacking_client.h"
+#include "ui/aura_shell/activation_controller.h"
 #include "ui/aura_shell/shell_window_ids.h"
+#include "ui/aura_shell/test/test_activation_delegate.h"
+#include "ui/aura_shell/window_util.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/screen.h"
 
 namespace aura_shell {
 namespace test {
 
 class RootWindowEventFilterTest : public aura::test::AuraTestBase {
  public:
   RootWindowEventFilterTest() {
     aura::RootWindow::GetInstance()->SetEventFilter(
         new internal::RootWindowEventFilter);
 
     aura::test::TestStackingClient* stacking_client =
         static_cast<aura::test::TestStackingClient*>(
             aura::RootWindow::GetInstance()->stacking_client());
     stacking_client->default_container()->set_id(
         internal::kShellWindowId_DefaultContainer);
+    activation_controller_.reset(new internal::ActivationController);
+    activation_controller_->set_default_container_for_test(
+        stacking_client->default_container());
   }
   virtual ~RootWindowEventFilterTest() {
     aura::RootWindow::GetInstance()->SetEventFilter(NULL);
   }
 
  private:
+  scoped_ptr<internal::ActivationController> activation_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(RootWindowEventFilterTest);
 };
 
 class HitTestWindowDelegate : public aura::test::TestWindowDelegate {
  public:
   HitTestWindowDelegate()
       : hittest_code_(HTNOWHERE) {
   }
   virtual ~HitTestWindowDelegate() {}
   void set_hittest_code(int hittest_code) { hittest_code_ = hittest_code; }
@@ skipping 67 matching lines @@
   w12->RemoveChild(w122.get());
   EXPECT_EQ(NULL, w122->GetFocusManager());
   EXPECT_EQ(NULL, w12->GetFocusManager()->GetFocusedWindow());
   EXPECT_FALSE(root_window->DispatchKeyEvent(&keyev));
 }
 
 // Various assertion testing for activating windows.
 TEST_F(RootWindowEventFilterTest, ActivateOnMouse) {
   aura::RootWindow* root_window = aura::RootWindow::GetInstance();
 
-  aura::test::ActivateWindowDelegate d1;
+  TestActivationDelegate d1;
+  aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &d1, 1, gfx::Rect(10, 10, 50, 50), NULL));
-  aura::test::ActivateWindowDelegate d2;
+      &wd, 1, gfx::Rect(10, 10, 50, 50), NULL));
+  d1.SetWindow(w1.get());
+  TestActivationDelegate d2;
   scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &d2, 2, gfx::Rect(70, 70, 50, 50), NULL));
+      &wd, 2, gfx::Rect(70, 70, 50, 50), NULL));
+  d2.SetWindow(w2.get());
+
   aura::internal::FocusManager* focus_manager = w1->GetFocusManager();
 
   d1.Clear();
   d2.Clear();
 
   // Activate window1.
-  root_window->SetActiveWindow(w1.get(), NULL);
-  EXPECT_EQ(w1.get(), root_window->active_window());
+  aura_shell::ActivateWindow(w1.get());
+  EXPECT_TRUE(IsActiveWindow(w1.get()));
   EXPECT_EQ(w1.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(1, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
   d1.Clear();
 
-  // Click on window2.
-  gfx::Point press_point = w2->bounds().CenterPoint();
-  aura::Window::ConvertPointToWindow(w2->parent(), root_window, &press_point);
-  aura::test::EventGenerator generator(press_point);
-  generator.ClickLeftButton();
+  {
+    // Click on window2.
+    gfx::Point press_point = w2->bounds().CenterPoint();
+    aura::Window::ConvertPointToWindow(w2->parent(), root_window, &press_point);
+    aura::test::EventGenerator generator(press_point);
+    generator.ClickLeftButton();
 
-  // Window2 should have become active.
-  EXPECT_EQ(w2.get(), root_window->active_window());
-  EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
-  EXPECT_EQ(0, d1.activated_count());
-  EXPECT_EQ(1, d1.lost_active_count());
-  EXPECT_EQ(1, d2.activated_count());
-  EXPECT_EQ(0, d2.lost_active_count());
-  d1.Clear();
-  d2.Clear();
+    // Window2 should have become active.
+    EXPECT_TRUE(IsActiveWindow(w2.get()));
+    EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
+    EXPECT_EQ(0, d1.activated_count());
+    EXPECT_EQ(1, d1.lost_active_count());
+    EXPECT_EQ(1, d2.activated_count());
+    EXPECT_EQ(0, d2.lost_active_count());
+    d1.Clear();
+    d2.Clear();
+  }
 
-  // Click back on window1, but set it up so w1 doesn't activate on click.
-  press_point = w1->bounds().CenterPoint();
-  aura::Window::ConvertPointToWindow(w1->parent(), root_window, &press_point);
-  d1.set_activate(false);
-  generator.ClickLeftButton();
+  {
+    // Click back on window1, but set it up so w1 doesn't activate on click.
+    gfx::Point press_point = w1->bounds().CenterPoint();
+    aura::Window::ConvertPointToWindow(w1->parent(), root_window, &press_point);
+    aura::test::EventGenerator generator(press_point);
+    d1.set_activate(false);
+    generator.ClickLeftButton();
 
-  // Window2 should still be active and focused.
-  EXPECT_EQ(w2.get(), root_window->active_window());
-  EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
-  EXPECT_EQ(0, d1.activated_count());
-  EXPECT_EQ(0, d1.lost_active_count());
-  EXPECT_EQ(0, d2.activated_count());
-  EXPECT_EQ(0, d2.lost_active_count());
-  d1.Clear();
-  d2.Clear();
+    // Window2 should still be active and focused.
+    EXPECT_TRUE(IsActiveWindow(w2.get()));
+    EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
+    EXPECT_EQ(0, d1.activated_count());
+    EXPECT_EQ(0, d1.lost_active_count());
+    EXPECT_EQ(0, d2.activated_count());
+    EXPECT_EQ(0, d2.lost_active_count());
+    d1.Clear();
+    d2.Clear();
+  }
 
   // Destroy window2, this should make window1 active.
   d1.set_activate(true);
   w2.reset();
   EXPECT_EQ(0, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
-  EXPECT_EQ(w1.get(), root_window->active_window());
+  EXPECT_TRUE(IsActiveWindow(w1.get()));
   EXPECT_EQ(w1.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(1, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
 }
 
 // Essentially the same as ActivateOnMouse, but for touch events.
 TEST_F(RootWindowEventFilterTest, ActivateOnTouch) {
   aura::RootWindow* root_window = aura::RootWindow::GetInstance();
 
-  aura::test::ActivateWindowDelegate d1;
+  TestActivationDelegate d1;
+  aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate(
-      &d1, -1, gfx::Rect(10, 10, 50, 50), NULL));
-  aura::test::ActivateWindowDelegate d2;
+      &wd, -1, gfx::Rect(10, 10, 50, 50), NULL));
+  d1.SetWindow(w1.get());
+  TestActivationDelegate d2;
   scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate(
-      &d2, -2, gfx::Rect(70, 70, 50, 50), NULL));
+      &wd, -2, gfx::Rect(70, 70, 50, 50), NULL));
+  d2.SetWindow(w2.get());
+
   aura::internal::FocusManager* focus_manager = w1->GetFocusManager();
 
   d1.Clear();
   d2.Clear();
 
   // Activate window1.
-  root_window->SetActiveWindow(w1.get(), NULL);
-  EXPECT_EQ(w1.get(), root_window->active_window());
+  aura_shell::ActivateWindow(w1.get());
+  EXPECT_TRUE(IsActiveWindow(w1.get()));
   EXPECT_EQ(w1.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(1, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
   d1.Clear();
 
   // Touch window2.
   gfx::Point press_point = w2->bounds().CenterPoint();
   aura::Window::ConvertPointToWindow(w2->parent(), root_window, &press_point);
   aura::TouchEvent touchev1(ui::ET_TOUCH_PRESSED, press_point, 0);
   root_window->DispatchTouchEvent(&touchev1);
 
   // Window2 should have become active.
-  EXPECT_EQ(w2.get(), root_window->active_window());
+  EXPECT_TRUE(IsActiveWindow(w2.get()));
   EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(0, d1.activated_count());
   EXPECT_EQ(1, d1.lost_active_count());
   EXPECT_EQ(1, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
   d1.Clear();
   d2.Clear();
 
   // Touch window1, but set it up so w1 doesn't activate on touch.
   press_point = w1->bounds().CenterPoint();
   aura::Window::ConvertPointToWindow(w1->parent(), root_window, &press_point);
   d1.set_activate(false);
   aura::TouchEvent touchev2(ui::ET_TOUCH_PRESSED, press_point, 0);
   root_window->DispatchTouchEvent(&touchev2);
 
   // Window2 should still be active and focused.
-  EXPECT_EQ(w2.get(), root_window->active_window());
+  EXPECT_TRUE(IsActiveWindow(w2.get()));
   EXPECT_EQ(w2.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(0, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
   EXPECT_EQ(0, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
   d1.Clear();
   d2.Clear();
 
   // Destroy window2, this should make window1 active.
   d1.set_activate(true);
   w2.reset();
   EXPECT_EQ(0, d2.activated_count());
   EXPECT_EQ(0, d2.lost_active_count());
-  EXPECT_EQ(w1.get(), root_window->active_window());
+  EXPECT_TRUE(IsActiveWindow(w1.get()));
   EXPECT_EQ(w1.get(), focus_manager->GetFocusedWindow());
   EXPECT_EQ(1, d1.activated_count());
   EXPECT_EQ(0, d1.lost_active_count());
 }
 
 TEST_F(RootWindowEventFilterTest, MouseEventCursors) {
   aura::RootWindow* root_window = aura::RootWindow::GetInstance();
 
   // Create a window.
   const int kWindowLeft = 123;
@@ skipping 61 matching lines @@
   gfx::Size size = root_window->GetHostSize();
   EXPECT_EQ(gfx::Rect(size),
             gfx::Screen::GetMonitorAreaNearestPoint(gfx::Point()));
 
   // Rotate it clock-wise 90 degrees.
   ui::Transform transform;
   transform.SetRotate(90.0f);
   transform.ConcatTranslate(size.width(), 0);
   root_window->SetTransform(transform);
 
-  aura::test::ActivateWindowDelegate d1;
+  TestActivationDelegate d1;
+  aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(0, 10, 50, 50), NULL));
+      CreateTestWindowWithDelegate(&wd, 1, gfx::Rect(0, 10, 50, 50), NULL));
+  d1.SetWindow(w1.get());
   w1->Show();
 
   gfx::Point miss_point(5, 5);
   transform.TransformPoint(miss_point);
   aura::MouseEvent mouseev1(ui::ET_MOUSE_PRESSED,
                             miss_point,
                             ui::EF_LEFT_BUTTON_DOWN);
   root_window->DispatchMouseEvent(&mouseev1);
   EXPECT_FALSE(w1->GetFocusManager()->GetFocusedWindow());
   aura::MouseEvent mouseup(ui::ET_MOUSE_RELEASED,
                            miss_point,
                            ui::EF_LEFT_BUTTON_DOWN);
   root_window->DispatchMouseEvent(&mouseup);
 
   gfx::Point hit_point(5, 15);
   transform.TransformPoint(hit_point);
   aura::MouseEvent mouseev2(ui::ET_MOUSE_PRESSED,
                             hit_point,
                             ui::EF_LEFT_BUTTON_DOWN);
   root_window->DispatchMouseEvent(&mouseev2);
-  EXPECT_EQ(w1.get(), root_window->active_window());
+  EXPECT_TRUE(IsActiveWindow(w1.get()));
   EXPECT_EQ(w1.get(), w1->GetFocusManager()->GetFocusedWindow());
 }
 
 TEST_F(RootWindowEventFilterTest, AdditionalFilters) {
   aura::RootWindow* root_window = aura::RootWindow::GetInstance();
 
   // Creates a window and make it active
   scoped_ptr<aura::Window> w1(aura::test::CreateTestWindow(
       SK_ColorWHITE, -1, gfx::Rect(0, 0, 100, 100), NULL));
-  root_window->SetActiveWindow(w1.get(), NULL);
+  aura_shell::ActivateWindow(w1.get());
 
   // Creates two addition filters
   scoped_ptr<aura::test::TestEventFilter> f1(
       new aura::test::TestEventFilter(NULL));
   scoped_ptr<aura::test::TestEventFilter> f2(
       new aura::test::TestEventFilter(NULL));
 
   // Adds them to root window event filter.
   internal::RootWindowEventFilter* root_window_filter =
       static_cast<internal::RootWindowEventFilter*>(
@@ skipping 45 matching lines @@
   EXPECT_EQ(0, f1->key_event_count());
   EXPECT_EQ(0, f1->mouse_event_count());
   EXPECT_EQ(1, f2->key_event_count());
   EXPECT_EQ(1, f2->mouse_event_count());
 
   root_window_filter->RemoveFilter(f2.get());
 }
 
 }  // namespace test
 }  // namespace aura_shell