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 <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"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/test/event_generator.h"
+#include "ui/gfx/geometry/vector2d_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/controls/label.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 {
 
+// 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;
+
 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 44 matching lines @@
     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;
   }
 
+  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.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+    widget->Init(params);
+    widget->Show();
+    ParentWindowInPrimaryRootWindow(widget->GetNativeWindow());
+    return widget.Pass();
+  }
+
   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 124 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() {}
+  virtual ~WindowSelectorSwipeToCloseDisabledTest() {}
+
+  // WindowSelectorTest:
+  virtual void SetUp() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WindowSelectorSwipeToCloseDisabledTest);
+};
+
+void WindowSelectorSwipeToCloseDisabledTest::SetUp() {
+  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 113 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)));
-
   // 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();
+  scoped_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
   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 entering overview mode with two windows and selecting one.
 TEST_F(WindowSelectorTest, FullscreenWindow) {
   gfx::Rect bounds(0, 0, 400, 400);
   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
@@ skipping 746 matching lines @@
   FilterItems("");
   EXPECT_FALSE(showing_filter_widget());
   EXPECT_FALSE(items[0]->dimmed());
   EXPECT_FALSE(items[1]->dimmed());
   EXPECT_FALSE(items[2]->dimmed());
 }
 
 // Tests selecting in the overview with dimmed and undimmed items.
 TEST_F(WindowSelectorTest, TextFilteringSelection) {
   gfx::Rect bounds(0, 0, 100, 100);
-   scoped_ptr<aura::Window> window2(CreateWindow(bounds));
-   scoped_ptr<aura::Window> window1(CreateWindow(bounds));
-   scoped_ptr<aura::Window> window0(CreateWindow(bounds));
-   base::string16 window2_title = base::UTF8ToUTF16("Rock and roll");
-   base::string16 window1_title = base::UTF8ToUTF16("Rock and");
-   base::string16 window0_title = base::UTF8ToUTF16("Rock");
-   window0->SetTitle(window0_title);
-   window1->SetTitle(window1_title);
-   window2->SetTitle(window2_title);
-   ToggleOverview();
-   SendKey(ui::VKEY_RIGHT);
-   EXPECT_TRUE(selection_widget_active());
-   EXPECT_EQ(GetSelectedWindow(), window0.get());
+  scoped_ptr<aura::Window> window2(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window1(CreateWindow(bounds));
+  scoped_ptr<aura::Window> window0(CreateWindow(bounds));
+  base::string16 window2_title = base::UTF8ToUTF16("Rock and roll");
+  base::string16 window1_title = base::UTF8ToUTF16("Rock and");
+  base::string16 window0_title = base::UTF8ToUTF16("Rock");
+  window0->SetTitle(window0_title);
+  window1->SetTitle(window1_title);
+  window2->SetTitle(window2_title);
+  ToggleOverview();
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_TRUE(selection_widget_active());
+  EXPECT_EQ(GetSelectedWindow(), window0.get());
 
-   // Dim the first item, the selection should jump to the next item.
-   std::vector<WindowSelectorItem*> items = GetWindowItemsForRoot(0);
-   FilterItems("Rock and");
-   EXPECT_EQ(GetSelectedWindow(), window1.get());
+  // Dim the first item, the selection should jump to the next item.
+  std::vector<WindowSelectorItem*> items = GetWindowItemsForRoot(0);
+  FilterItems("Rock and");
+  EXPECT_EQ(GetSelectedWindow(), window1.get());
 
-   // Cycle the selection, the dimmed window should not be selected.
-   SendKey(ui::VKEY_RIGHT);
-   EXPECT_EQ(GetSelectedWindow(), window2.get());
-   SendKey(ui::VKEY_RIGHT);
-   EXPECT_EQ(GetSelectedWindow(), window1.get());
+  // Cycle the selection, the dimmed window should not be selected.
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window2.get());
+  SendKey(ui::VKEY_RIGHT);
+  EXPECT_EQ(GetSelectedWindow(), window1.get());
 
-   // Dimming all the items should hide the selection widget.
-   FilterItems("Pop");
-   EXPECT_FALSE(selection_widget_active());
+  // Dimming all the items should hide the selection widget.
+  FilterItems("Pop");
+  EXPECT_FALSE(selection_widget_active());
 
-   // Undimming one window should automatically select it.
-   FilterItems("Rock and roll");
-   EXPECT_EQ(GetSelectedWindow(), window2.get());
+  // Undimming one window should automatically select it.
+  FilterItems("Rock and roll");
+  EXPECT_EQ(GetSelectedWindow(), window2.get());
 }
 
 // Tests clicking on the desktop itself to cancel overview mode.
 TEST_F(WindowSelectorTest, CancelOverviewOnMouseClick) {
   // Overview disabled by default.
   EXPECT_FALSE(IsSelecting());
 
   // Point and bounds selected so that they don't intersect. This causes
   // events located at the point to be passed to DesktopBackgroundController,
   // and not the window.
@@ skipping 39 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) {

[flackr, 2014/11/07 19:10:52]

I'm not sure testing the lack of a feature is something we want to be doing. For
example, when removing features we don't test that those features aren't there
anymore.

[bruthig, 2015/01/02 16:49:17]

I would argue that testing a non-existent feature/code-path is completely
different than testing a feature which is "turned off".  The main purpose of
this test isn't verifying that a window is not selected, it is to make sure that
nothing blows up.  I could make it more clear in the docs or test name as to the
real purpose.

[jonross, 2015/01/06 15:02:28]

Could you clarify in the name+description?

+  // We need a widget for the close button to work, a bare window will crash.
+  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());
+}
+
+// Test dragging a window a short distance.
+TEST_F(WindowSelectorTest, WindowTapDragShortDistance) {
+  // We need a widget for the close button to work, a bare window will crash.
+  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) {
+  // We need a widget for the close button to work, a bare window will crash.
+  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 dragging a window in a multi window SelectorItem a short distance.
+TEST_F(WindowSelectorTest, MultiWindowTapDragShortDistance) {

[flackr, 2014/11/07 19:10:52]

Is this exercising a different code path than WindowTapDragShortDistance?

[bruthig, 2015/01/02 16:49:17]

Removed.

+  scoped_ptr<views::Widget> widget1(
+      CreatePanelWindowWidget(gfx::Rect(0, 0, 300, 100)));
+  scoped_ptr<views::Widget> widget2(
+      CreatePanelWindowWidget(gfx::Rect(100, 0, 100, 100)));
+  aura::Window* window1 = widget1->GetNativeWindow();
+  wm::ActivateWindow(window1);
+  ToggleOverview();
+
+  gfx::Rect bounds1 = ToNearestRect(GetTransformedBoundsInRootWindow(window1));
+  ui::test::EventGenerator event_generator1(window1->GetRootWindow());
+
+  ASSERT_FALSE(widget1->IsClosed());
+  ASSERT_FALSE(widget2->IsClosed());
+
+  gfx::Point start(bounds1.CenterPoint());
+  gfx::Point end(start.x() - kShortDragDistance, start.y());
+  event_generator1.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_FALSE(widget1->IsClosed());
+  EXPECT_FALSE(widget2->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test dragging a window in a multi window SelectorItem a far distance.
+TEST_F(WindowSelectorTest, MultiWindowTapDragFarDistance) {
+  scoped_ptr<views::Widget> widget1(
+      CreatePanelWindowWidget(gfx::Rect(0, 0, 300, 100)));
+  scoped_ptr<views::Widget> widget2(
+      CreatePanelWindowWidget(gfx::Rect(100, 0, 100, 100)));
+  aura::Window* window1 = widget1->GetNativeWindow();
+  wm::ActivateWindow(window1);
+  ToggleOverview();
+
+  gfx::Rect bounds1 = ToNearestRect(GetTransformedBoundsInRootWindow(window1));
+  ui::test::EventGenerator event_generator1(window1->GetRootWindow());
+
+  ASSERT_FALSE(widget1->IsClosed());
+  ASSERT_FALSE(widget2->IsClosed());
+
+  gfx::Point start(bounds1.CenterPoint());
+  gfx::Point end(start.x() - kFarDragDistance, start.y());
+  event_generator1.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_TRUE(widget1->IsClosed());
+  EXPECT_FALSE(widget2->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test dragging all windows in a multi window SelectorItem a short distance.
+TEST_F(WindowSelectorTest, MultiWindowTapDragLabelShortDistance) {
+  scoped_ptr<views::Widget> widget1(
+      CreatePanelWindowWidget(gfx::Rect(0, 0, 300, 100)));
+  scoped_ptr<views::Widget> widget2(
+      CreatePanelWindowWidget(gfx::Rect(100, 0, 100, 100)));
+  aura::Window* window1 = widget1->GetNativeWindow();
+  wm::ActivateWindow(window1);
+  ToggleOverview();
+
+  gfx::Rect bounds = GetWindowItemsForRoot(0).back()->target_bounds();
+  ui::test::EventGenerator event_generator1(window1->GetRootWindow());
+
+  ASSERT_FALSE(widget1->IsClosed());
+  ASSERT_FALSE(widget2->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint().x(), bounds.y() + 3);
+  gfx::Point end(start.x() - kShortDragDistance, start.y());
+  event_generator1.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_FALSE(widget1->IsClosed());
+  EXPECT_FALSE(widget2->IsClosed());
+
+  RunAllPendingInMessageLoop();
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test dragging all windows in a multi window SelectorItem a far distance.
+TEST_F(WindowSelectorTest, MultiWindowTapDragLabelFarDistance) {

[flackr, 2014/11/07 19:10:52]

Aren't these multi window drag tests a superset of some of the above tests (the
single window tests)? i.e. can we remove some of the above tests?

[bruthig, 2015/01/02 16:49:17]

I will remove the MultiWindowTapDragShortDistance test but I think all the
others add value.  The touch events in the MultiWindowTapDragLabelShortDistance
and MultiWindowTapDragLabelFarDistance will be targeting the
WindowSelectorItem's transparent overlay whereas in the single window tests
above the event will be handled by the actual window's overlay.

+  scoped_ptr<views::Widget> widget1(
+      CreatePanelWindowWidget(gfx::Rect(0, 0, 300, 100)));
+  scoped_ptr<views::Widget> widget2(
+      CreatePanelWindowWidget(gfx::Rect(100, 0, 100, 100)));
+  aura::Window* window1 = widget1->GetNativeWindow();
+  wm::ActivateWindow(window1);
+  ToggleOverview();
+
+  gfx::Rect bounds = GetWindowItemsForRoot(0).back()->target_bounds();
+  ui::test::EventGenerator event_generator1(window1->GetRootWindow());
+
+  ASSERT_FALSE(widget1->IsClosed());
+  ASSERT_FALSE(widget2->IsClosed());
+
+  gfx::Point start(bounds.CenterPoint().x(), bounds.y() + 3);
+  gfx::Point end(start.x() - kFarDragDistance, start.y());
+  event_generator1.GestureScrollSequence(
+      start, end, base::TimeDelta::FromMilliseconds(10), 5);
+
+  EXPECT_TRUE(widget1->IsClosed());
+  EXPECT_TRUE(widget2->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
+// Test a low velocity fling.
+TEST_F(WindowSelectorTest, LowVelocityFling) {

[flackr, 2014/11/07 19:10:52]

Can probably merge this with the short distance drag as a bunch of things to try
which don't close the window.

[bruthig, 2015/01/02 16:49:17]

Unless you feel super strongly about this I would like to leave it as is.  IMO
it is much easier and better to divide tests based on the input behaviour
compared to the expected out come.  
Doing it this way also makes the tests more stand alone (which is a good
property) and if some tap+dragging behaviour changes then the developer wouldn't
need to have to fully understand what the tap+fling behaviour is in order to
update the test.
It's also a lot easier for a new developer to learn expected outcome behaviour
by looking up tests by good 'input' driven test names instead of looking up
tests by the expected outcome.

+  const float kFlingVelocity = 2000;
+  const int kSmallSwipeDistance = 25;
+
+  // We need a widget for the close button to work, a bare window will crash.
+  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() - kSmallSwipeDistance, start.y());
+  const base::TimeDelta kScrollDuration =
+      event_generator.CalculateDuration(start, end, kFlingVelocity, 10);
+  event_generator.GestureScrollSequence(start, end, kScrollDuration, 10);
+
+  EXPECT_FALSE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(IsSelecting());
+}
+
+// Test a high velocity fling.
+TEST_F(WindowSelectorTest, HighVelocityFling) {
+  const float kFlingVelocity = 10000;
+  const int kSmallSwipeDistance = 25;
+
+  // We need a widget for the close button to work, a bare window will crash.
+  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() - kSmallSwipeDistance, start.y());
+  const base::TimeDelta kScrollDuration =
+      event_generator.CalculateDuration(start, end, kFlingVelocity, 10);
+  event_generator.GestureScrollSequence(start, end, kScrollDuration, 10);
+
+  EXPECT_TRUE(widget->IsClosed());
+
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
 }  // namespace ash