Implemented swipe to close in 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 <map>
+#include <vector>
 
 #include "ash/accessibility_delegate.h"
+#include "ash/ash_switches.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/panels/panel_layout_manager.h"
 #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 "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"
@@ skipping 20 matching lines @@
   bool ShouldActivate() const override { return false; }
 };
 
 void CancelDrag(DragDropController* controller, bool* canceled) {
   if (controller->IsDragDropInProgress()) {
     *canceled = true;
     controller->DragCancel();
   }
 }
 
+// A short drag distance that will not cause an overview item to close.
+const int kShortDragDistance = 10;
+
+// A far drag distance that will cause an overview item to close.
+const int kFarDragDistance = 200;
+
+// A slow fling velocity that should not cause selctor items to close.
+const int kSlowFlingVelocity = 2000;
+
+// A fast fling velocity that should cause selector items to close.
+const int kFastFlingVelocity = 5000;
+
 }  // namespace
 
+// TODO(bruthig): Move all non-simple method definitions out of class
+// declaration.
 class WindowSelectorTest : public test::AshTestBase {
  public:
   WindowSelectorTest() {}
   ~WindowSelectorTest() override {}
 
   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* 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,
                                         &non_activatable_activation_delegate_);
     EXPECT_FALSE(ash::wm::CanActivateWindow(window));
     return window;
   }
 
+  // Creates a Widget containing a Window with the given |bounds|. This should
+  // be used when the test requires a Widget. For example any test that will
+  // cause a window to be closed via
+  // views::Widget::GetWidgetForNativeView(window)->Close().
+  scoped_ptr<views::Widget> CreateWindowWidget(const gfx::Rect& bounds) {
+    scoped_ptr<views::Widget> widget(new views::Widget);
+    views::Widget::InitParams params;
+    params.bounds = bounds;
+    params.type = views::Widget::InitParams::TYPE_WINDOW;
+    params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+    widget->Init(params);
+    widget->Show();
+    ParentWindowInPrimaryRootWindow(widget->GetNativeWindow());
+    return widget.Pass();
+  }
+
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         nullptr, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
     test::TestShelfDelegate::instance()->AddShelfItem(window);
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     return window;
   }
 
-  views::Widget* CreatePanelWindowWidget(const gfx::Rect& bounds) {
-    views::Widget* widget = new views::Widget;
-    views::Widget::InitParams params;
-    params.bounds = bounds;
-    params.type = views::Widget::InitParams::TYPE_PANEL;
-    params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-    widget->Init(params);
-    widget->Show();
-    ParentWindowInPrimaryRootWindow(widget->GetNativeWindow());
-    return widget;
-  }
-
   bool WindowsOverlapping(aura::Window* window1, aura::Window* window2) {
     gfx::RectF window1_bounds = GetTransformedTargetBounds(window1);
     gfx::RectF window2_bounds = GetTransformedTargetBounds(window2);
     return window1_bounds.Intersects(window2_bounds);
   }
 
   void ToggleOverview() {
     ash::Shell::GetInstance()->window_selector_controller()->ToggleOverview();
   }
 
@@ skipping 117 matching lines @@
   }
 
  private:
   aura::test::TestWindowDelegate delegate_;
   NonActivatableActivationDelegate non_activatable_activation_delegate_;
   scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorTest);
 };
 
+class WindowSelectorSwipeToCloseDisabledTest : public WindowSelectorTest {
+ public:
+  WindowSelectorSwipeToCloseDisabledTest() {}
+  ~WindowSelectorSwipeToCloseDisabledTest() override {}
+
+  // WindowSelectorTest:
+  void SetUp() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WindowSelectorSwipeToCloseDisabledTest);
+};
+
+void WindowSelectorSwipeToCloseDisabledTest::SetUp() {
+  base::CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kAshDisableSwipeToCloseInOverviewMode);
+  WindowSelectorTest::SetUp();
+}
+
 // Tests that an a11y alert is sent on entering overview mode.
 TEST_F(WindowSelectorTest, A11yAlertOnOverviewMode) {
   gfx::Rect bounds(0, 0, 400, 400);
   AccessibilityDelegate* delegate =
       ash::Shell::GetInstance()->accessibility_delegate();
   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
   EXPECT_NE(delegate->GetLastAccessibilityAlert(),
             ui::A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
   ToggleOverview();
   EXPECT_EQ(delegate->GetLastAccessibilityAlert(),
@@ skipping 49 matching lines @@
   generator.GestureTapAt(gfx::ToEnclosingRect(
       GetTransformedTargetBounds(window2.get())).CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
 // 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)));
 
-  // We need a widget for the close button to work, a bare window will crash.
-  scoped_ptr<views::Widget> widget(new views::Widget);
-  views::Widget::InitParams params;
-  params.bounds = gfx::Rect(0, 0, 400, 400);
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  params.parent = window->parent();
-  widget->Init(params);
-  widget->Show();
-
   ToggleOverview();
 
   gfx::Rect bounds =
       gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window.get()));
   ui::test::EventGenerator event_generator(window->GetRootWindow(),
                                            bounds.CenterPoint());
 
   // Press down on the window.
   const int kTouchId = 19;
   event_generator.PressTouchId(kTouchId);
@@ skipping 74 matching lines @@
   ui::MouseEvent event2(ui::ET_MOUSE_PRESSED, point2, point2,
                         ui::EF_NONE, ui::EF_NONE);
 
   // Now the transparent window should be intercepting this event.
   EXPECT_NE(window, static_cast<aura::Window*>(
         targeter->FindTargetForEvent(root_target, &event2)));
 }
 
 // Tests that clicking on the close button effectively closes the window.
 TEST_F(WindowSelectorTest, CloseButton) {
-  scoped_ptr<aura::Window> window1(CreateWindow(gfx::Rect(200, 300, 250, 450)));
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
-  // We need a widget for the close button to work, a bare window will crash.
-  scoped_ptr<views::Widget> widget(new views::Widget);
-  views::Widget::InitParams params;
-  params.bounds = gfx::Rect(0, 0, 400, 400);
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  params.parent = window1->parent();
-  widget->Init(params);
-  widget->Show();
   ToggleOverview();
 
-  aura::Window* window2 = widget->GetNativeWindow();
-  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window2);
+  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(window2->GetRootWindow(), point);
+  ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
 
   EXPECT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests that clicking on the close button on a secondary display effectively
 // closes the window.
 TEST_F(WindowSelectorTest, CloseButtonOnMultipleDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 
   scoped_ptr<aura::Window> window1(CreateWindow(gfx::Rect(650, 300, 250, 450)));
 
-  // We need a widget for the close button to work, a bare window will crash.
+  // We need a widget for the close button to work because windows are closed
+  // via the widget. We also use the widget to determine if the window has been
+  // closed or not. We explicity create the widget so that the window can be
+  // parented to a non-primary root window.
   scoped_ptr<views::Widget> widget(new views::Widget);
   views::Widget::InitParams params;
   params.bounds = gfx::Rect(650, 0, 400, 400);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = window1->parent();
   widget->Init(params);
   widget->Show();
 
   ASSERT_EQ(root_windows[1], window1->GetRootWindow());
 
@@ skipping 764 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());
 }
 
+// Verify swipe to close doesn't work when swipe to close is disabled.
+TEST_F(WindowSelectorSwipeToCloseDisabledTest, WindowTapDragFarDistance) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::Rect bounds = ToNearestRect(GetTransformedBoundsInRootWindow(window));
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint());
+  gfx::Point end(start.x() - kFarDragDistance, start.y());
+  event_generator.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_FALSE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Verify the window moves and fades as it is dragged.
+TEST_F(WindowSelectorTest, VerifyWindowBehaviourDuringTapDrag) {
+  scoped_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 400, 400)));
+
+  ToggleOverview();
+
+  gfx::Rect bounds = ToNearestRect(GetTransformedBoundsInRootWindow(
+      window.get()));
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  const gfx::Point drag_start_point(bounds.CenterPoint());
+  const gfx::Point drag_left_point(drag_start_point.x() - kFarDragDistance,
+                                   drag_start_point.y());
+  const gfx::Point drag_right_point(drag_start_point.x() + kFarDragDistance,
+                                    drag_start_point.y());
+
+  const int drag_left_delta_x = drag_start_point.x() - drag_left_point.x();
+  const int drag_right_delta_x = drag_start_point.x() - drag_right_point.x();
+
+  const gfx::Rect original_bounds = window->GetBoundsInScreen();
+
+  ASSERT_EQ(1.0f, window->layer()->opacity());
+
+  event_generator.set_current_location(drag_start_point);
+  event_generator.PressTouch();
+
+  EXPECT_EQ(1.0f, window->layer()->opacity());
+
+  event_generator.MoveTouch(drag_left_point);
+
+  EXPECT_EQ(original_bounds.x() - drag_left_delta_x,
+            window->GetBoundsInScreen().x());

[flackr, 2015/02/12 18:52:43]

I didn't realize the window get bounds routines included the transform, perhaps
we don't need the "GetTransformed(Target)?BoundsInRootWindow" helper methods
which have been added in a few places?

+  EXPECT_EQ(original_bounds.y(), window->GetBoundsInScreen().y());
+
+  EXPECT_GT(0.5f, window->layer()->opacity());

[flackr, 2015/02/12 18:52:43]

nit: I think with comparison EXPECT operators we reverse the order to put them
in natural english order as it gives a more natural error on failure. i.e. this
should be EXECT_LT(window->layer()->opacity(), 0.5f);

[bruthig, 2015/02/12 20:34:16]

Done.

+
+  event_generator.MoveTouch(drag_start_point);
+
+  EXPECT_EQ(original_bounds.x(), window->GetBoundsInScreen().x());
+  EXPECT_EQ(original_bounds.y(), window->GetBoundsInScreen().y());
+  EXPECT_EQ(1.0f, window->layer()->opacity());
+
+  event_generator.MoveTouch(drag_right_point);
+
+  EXPECT_EQ(original_bounds.x() - drag_right_delta_x,
+            window->GetBoundsInScreen().x());
+  EXPECT_EQ(original_bounds.y(), window->GetBoundsInScreen().y());
+
+  EXPECT_GT(0.5f, window->layer()->opacity());
+
+  RunAllPendingInMessageLoop();

[flackr, 2015/02/12 18:52:43]

This should happen implicitly when control leaves the test and it shuts down.

[bruthig, 2015/02/12 20:34:16]

Done.

+}
+
+// Test dragging a window a short distance.
+TEST_F(WindowSelectorTest, WindowTapDragShortDistance) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::Rect bounds = ToNearestRect(GetTransformedBoundsInRootWindow(window));
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint());
+  gfx::Point end(start.x() - kShortDragDistance, start.y());
+  event_generator.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_FALSE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test dragging a window a far distance.
+TEST_F(WindowSelectorTest, WindowTapDragFarDistance) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::Rect bounds = ToNearestRect(GetTransformedBoundsInRootWindow(window));
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint());
+  gfx::Point end(start.x() - kFarDragDistance, start.y());
+  event_generator.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_TRUE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
+// Test a slow velocity fling.
+TEST_F(WindowSelectorTest, SlowVelocityFling) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint().x(), bounds.CenterPoint().y());
+  gfx::Point end(start.x() - kShortDragDistance, start.y());
+  const base::TimeDelta kScrollDuration =
+      event_generator.CalculateScrollDurationForFlingVelocity(
+          start, end, kSlowFlingVelocity, 10);
+  event_generator.GestureScrollSequence(start, end, kScrollDuration, 10);
+
+  EXPECT_FALSE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test a fast velocity fling.
+TEST_F(WindowSelectorTest, FastVelocityFling) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint().x(), bounds.CenterPoint().y());
+  gfx::Point end(start.x() - kShortDragDistance, start.y());
+  const base::TimeDelta kScrollDuration =
+      event_generator.CalculateScrollDurationForFlingVelocity(
+          start, end, kFastFlingVelocity, 10);
+  event_generator.GestureScrollSequence(start, end, kScrollDuration, 10);
+
+  EXPECT_TRUE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
+// Test a fast velocity fling.
+TEST_F(WindowSelectorTest, SlowVelocityFlingAtAFarDistance) {
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+
+  ToggleOverview();
+  ASSERT_TRUE(IsSelecting());
+
+  aura::Window* window = widget->GetNativeWindow();
+  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
+  ui::test::EventGenerator event_generator(window->GetRootWindow());
+
+  ASSERT_FALSE(widget->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint().x(), bounds.CenterPoint().y());
+  gfx::Point end(start.x() - kFarDragDistance, start.y());
+  const base::TimeDelta kScrollDuration =
+      event_generator.CalculateScrollDurationForFlingVelocity(
+          start, end, kSlowFlingVelocity, 10);
+  event_generator.GestureScrollSequence(start, end, kScrollDuration, 10);
+
+  EXPECT_TRUE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
 }  // namespace ash