Add user action for changing the active window in Ash overview mode

ash/wm/overview/window_selector_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <vector>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
@@ skipping 17 matching lines @@
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/user_action_tester.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.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_event_dispatcher.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_delegate.h"
 
 namespace ash {
 namespace {
 
+const char kActiveWindowChanged[] = "WindowSelector_ActiveWindowChanged";
+
 class NonActivatableActivationDelegate
     : public aura::client::ActivationDelegate {
  public:
   bool ShouldActivate() const override { return false; }
 };
 
 void CancelDrag(DragDropController* controller, bool* canceled) {
   if (controller->IsDragDropInProgress()) {
     *canceled = true;
     controller->DragCancel();
@@ skipping 11 matching lines @@
 
   void SetUp() override {
     test::AshTestBase::SetUp();
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
         test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).shelf_view()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
+  aura::Window* CreateWindowWithType(const gfx::Rect& bounds,
+                                     ui::wm::WindowType type) {
+    return CreateTestWindowInShellWithDelegateAndType(&delegate_, type, -1,
+                                                      bounds);
+  }
+
   aura::Window* CreateWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds);
   }
 
   aura::Window* CreateWindowWithId(const gfx::Rect& bounds, int id) {
     return CreateTestWindowInShellWithDelegate(&delegate_, id, bounds);
   }
   aura::Window* CreateNonActivatableWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateWindow(bounds);
     aura::client::SetActivationDelegate(window,
@@ skipping 110 matching lines @@
     return ws->grid_list_[ws->selected_grid_index_]->is_selecting();
   }
 
   bool showing_filter_widget() {
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     return ws->text_filter_widget_->GetNativeWindow()->layer()->
         GetTargetTransform().IsIdentity();
   }
 
+  aura::Window* initially_active_window() {
+    return ash::Shell::GetInstance()
+        ->window_selector_controller()
+        ->initially_active_window_;
+  }
+
   views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
     return &(window->close_button_widget_);
   }
 
   views::LabelButton* GetLabelButtonView(ash::WindowSelectorItem* window) {
     return window->window_label_button_view_;
   }
 
   // Tests that a window is contained within a given WindowSelectorItem, and
   // that both the window and its matching close button are within the same
@@ skipping 135 matching lines @@
   EXPECT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
   generator.GestureTapAt(gfx::ToEnclosingRect(
       GetTransformedTargetBounds(window2.get())).CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
+// Tests that the user action defined by |kActiveWindowChanged| is recorded
+// when a normal window is active upon entering overview mode and a different
+// normal window is active upon exiting overview mode.
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionChanged) {
+  base::UserActionTester user_action_tester;
+  gfx::Rect bounds(0, 0, 400, 400);
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  wm::ActivateWindow(window1.get());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  ToggleOverview();
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window2.get());
+  generator.GestureTapAt(
+      gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
+          .CenterPoint());
+  ASSERT_EQ(window2.get(), GetFocusedWindow());
+  EXPECT_EQ(1, user_action_tester.GetActionCount(kActiveWindowChanged));
+}
+
+// Tests that the user action defined by |kActiveWindowChanged| is not recorded
+// when the window that is active upon entering overview mode remains
+// active upon exiting overview mode.
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionNoChange) {
+  base::UserActionTester user_action_tester;
+  gfx::Rect bounds(0, 0, 400, 400);
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  wm::ActivateWindow(window1.get());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  ToggleOverview();
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window1.get());
+  generator.GestureTapAt(
+      gfx::ToEnclosingRect(GetTransformedTargetBounds(window1.get()))
+          .CenterPoint());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  EXPECT_EQ(0, user_action_tester.GetActionCount(kActiveWindowChanged));
+}
+
+// Tests that the user action defined by |kActiveWindowChanged| is not recorded
+// when the window that is active upon entering overview mode is a popup, even
+// a normal window is active upon exiting overview mode.
+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionPopupWindow) {
+  base::UserActionTester user_action_tester;
+  gfx::Rect bounds(0, 0, 400, 400);
+  scoped_ptr<aura::Window> window1(
+      CreateWindowWithType(bounds, ui::wm::WINDOW_TYPE_POPUP));
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  wm::ActivateWindow(window1.get());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  ToggleOverview();
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window2.get());
+  generator.GestureTapAt(
+      gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
+          .CenterPoint());
+  ASSERT_EQ(window2.get(), GetFocusedWindow());
+  EXPECT_EQ(0, user_action_tester.GetActionCount(kActiveWindowChanged));
+}
+
+// Tests that the user action defined by |kActiveWindowChanged| is not recorded
+// when the oply open window is closed while in overview mode.

[bruthig, 2015/05/12 17:37:38]

Sp? "oply"

[tdanderson, 2015/05/14 01:36:32]

Done.

+TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionWindowClose) {
+  base::UserActionTester user_action_tester;
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
+  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() - 1);
+  ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
+
+  ASSERT_FALSE(widget->IsClosed());
+  event_generator.ClickLeftButton();
+  ASSERT_TRUE(widget->IsClosed());
+  EXPECT_EQ(0, user_action_tester.GetActionCount(kActiveWindowChanged));
+}
+
+// Tests that if a normal window is active upon entering overview mode, the
+// member |initially_active_window_| should be set to this window while
+// overview mode is active and cleared upon exiting overview mode.
+TEST_F(WindowSelectorTest, InitiallyActiveWindowSetInOverviewMode) {
+  gfx::Rect bounds(0, 0, 400, 400);
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+  wm::ActivateWindow(window1.get());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+  EXPECT_EQ(window1.get(), initially_active_window());
+  ToggleOverview();
+  ASSERT_FALSE(IsSelecting());
+  EXPECT_EQ(nullptr, initially_active_window());
+}
+
+// Tests that if a popup window is active upon entering overview mode, the
+// member |initially_active_window_| should not be set upon entering overview
+// mode.
+TEST_F(WindowSelectorTest, InitiallyActiveWindowNotSetForPopup) {
+  gfx::Rect bounds(0, 0, 400, 400);
+  scoped_ptr<aura::Window> window1(
+      CreateWindowWithType(bounds, ui::wm::WINDOW_TYPE_POPUP));
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  wm::ActivateWindow(window1.get());
+  ASSERT_EQ(window1.get(), GetFocusedWindow());
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+  EXPECT_EQ(nullptr, initially_active_window());
+}
+
 // Tests that we do not crash and overview mode remains engaged if the desktop
 // is tapped while a finger is already down over a window.
 TEST_F(WindowSelectorTest, NoCrashWithDesktopTap) {
   scoped_ptr<aura::Window> window(CreateWindow(gfx::Rect(200, 300, 250, 450)));
 
   ToggleOverview();
 
   gfx::Rect bounds =
       gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window.get()));
   ui::test::EventGenerator event_generator(window->GetRootWindow(),
@@ skipping 871 matching lines @@
   // Switch to overview mode.
   ToggleOverview();
   ASSERT_TRUE(IsSelecting());
 
   // Tap should now exit overview mode.
   generator.GestureTapAt(point_in_background_page);
   EXPECT_FALSE(IsSelecting());
 }
 
 }  // namespace ash