Google Git
Sign in
chromium / chromium / src / 002d8b5c6ac6acf02c008f44ee3701de78b3aa00 / . / ash / wm / overview / overview_session_unittest.cc
blob: d36e43d3188874257cd65ae3d24f0e12f9a1a377 [file] [log] [blame]
// 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 "ash/wm/overview/overview_session.h"
#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "ash/accelerators/accelerator_controller_impl.h"
#include "ash/accelerators/exit_warning_handler.h"
#include "ash/accessibility/test_accessibility_controller_client.h"
#include "ash/app_list/app_list_controller_impl.h"
#include "ash/display/screen_orientation_controller.h"
#include "ash/display/screen_orientation_controller_test_api.h"
#include "ash/drag_drop/drag_drop_controller.h"
#include "ash/public/cpp/app_types.h"
#include "ash/public/cpp/ash_features.h"
#include "ash/public/cpp/fps_counter.h"
#include "ash/public/cpp/shelf_config.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/screen_util.h"
#include "ash/shelf/shelf.h"
#include "ash/shelf/shelf_view_test_api.h"
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/drag_window_resizer.h"
#include "ash/wm/overview/caption_container_view.h"
#include "ash/wm/overview/overview_constants.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/overview/overview_grid.h"
#include "ash/wm/overview/overview_grid_event_handler.h"
#include "ash/wm/overview/overview_highlight_controller.h"
#include "ash/wm/overview/overview_item.h"
#include "ash/wm/overview/overview_test_util.h"
#include "ash/wm/overview/overview_utils.h"
#include "ash/wm/overview/overview_wallpaper_controller.h"
#include "ash/wm/overview/overview_window_drag_controller.h"
#include "ash/wm/overview/rounded_label_widget.h"
#include "ash/wm/overview/rounded_rect_view.h"
#include "ash/wm/resize_shadow.h"
#include "ash/wm/resize_shadow_controller.h"
#include "ash/wm/splitview/multi_display_overview_and_split_view_test.h"
#include "ash/wm/splitview/split_view_controller.h"
#include "ash/wm/splitview/split_view_divider.h"
#include "ash/wm/splitview/split_view_drag_indicators.h"
#include "ash/wm/splitview/split_view_utils.h"
#include "ash/wm/tablet_mode/tablet_mode_browser_window_drag_delegate.h"
#include "ash/wm/tablet_mode/tablet_mode_controller.h"
#include "ash/wm/tablet_mode/tablet_mode_controller_test_api.h"
#include "ash/wm/tablet_mode/tablet_mode_window_drag_controller.h"
#include "ash/wm/window_preview_view.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "ash/wm/wm_event.h"
#include "ash/wm/workspace/workspace_window_resizer.h"
#include "base/run_loop.h"
#include "base/stl_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/metrics/user_action_tester.h"
#include "base/test/scoped_feature_list.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/client/window_types.h"
#include "ui/aura/test/test_window_delegate.h"
#include "ui/aura/window.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/hit_test.h"
#include "ui/compositor/layer_animation_sequence.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/compositor/test/draw_waiter_for_test.h"
#include "ui/display/display_layout.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/test/display_manager_test_api.h"
#include "ui/events/event_utils.h"
#include "ui/events/gesture_detection/gesture_configuration.h"
#include "ui/events/test/event_generator.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/transform.h"
#include "ui/gfx/transform_util.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/label.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/core/coordinate_conversion.h"
#include "ui/wm/core/shadow_controller.h"
#include "ui/wm/core/window_util.h"
namespace ash {
namespace {
constexpr const char kActiveWindowChangedFromOverview[] =
"WindowSelector_ActiveWindowChanged";
// Helper function to get the index of |child|, given its parent window
// |parent|.
int IndexOf(aura::Window* child, aura::Window* parent) {
aura::Window::Windows children = parent->children();
auto it = std::find(children.begin(), children.end(), child);
DCHECK(it != children.end());
return static_cast<int>(std::distance(children.begin(), it));
}
class TweenTester : public ui::LayerAnimationObserver {
public:
explicit TweenTester(aura::Window* window) : window_(window) {
window->layer()->GetAnimator()->AddObserver(this);
}
~TweenTester() override {
window_->layer()->GetAnimator()->RemoveObserver(this);
EXPECT_TRUE(will_animate_);
}
// ui::LayerAnimationObserver:
void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {}
void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {}
void OnLayerAnimationScheduled(
ui::LayerAnimationSequence* sequence) override {}
void OnAttachedToSequence(ui::LayerAnimationSequence* sequence) override {
ui::LayerAnimationObserver::OnAttachedToSequence(sequence);
if (!will_animate_) {
tween_type_ = sequence->FirstElement()->tween_type();
will_animate_ = true;
}
}
gfx::Tween::Type tween_type() const { return tween_type_; }
private:
gfx::Tween::Type tween_type_ = gfx::Tween::LINEAR;
aura::Window* window_;
bool will_animate_ = false;
DISALLOW_COPY_AND_ASSIGN(TweenTester);
};
} // namespace
// TODO(bruthig): Move all non-simple method definitions out of class
// declaration.
class OverviewSessionTest : public MultiDisplayOverviewAndSplitViewTest {
public:
OverviewSessionTest() = default;
~OverviewSessionTest() override = default;
// AshTestBase:
void SetUp() override {
MultiDisplayOverviewAndSplitViewTest::SetUp();
aura::Env::GetInstance()->set_throttle_input_on_resize_for_testing(false);
shelf_view_test_api_ = std::make_unique<ShelfViewTestAPI>(
GetPrimaryShelf()->GetShelfViewForTesting());
shelf_view_test_api_->SetAnimationDuration(
base::TimeDelta::FromMilliseconds(1));
ScopedOverviewTransformWindow::SetImmediateCloseForTests();
OverviewWallpaperController::SetDoNotChangeWallpaperForTests();
FpsCounter::SetForceReportZeroAnimationForTest(true);
ash::PresentationTimeRecorder::SetReportPresentationTimeImmediatelyForTest(
true);
}
void TearDown() override {
ash::PresentationTimeRecorder::SetReportPresentationTimeImmediatelyForTest(
false);
FpsCounter::SetForceReportZeroAnimationForTest(false);
trace_names_.clear();
MultiDisplayOverviewAndSplitViewTest::TearDown();
}
// Enters tablet mode. Needed by tests that test dragging and or splitview,
// which are tablet mode only.
void EnterTabletMode() {
// Ensure calls to SetEnabledForTest complete.
base::RunLoop().RunUntilIdle();
Shell::Get()->tablet_mode_controller()->SetEnabledForTest(true);
base::RunLoop().RunUntilIdle();
}
bool WindowsOverlapping(aura::Window* window1, aura::Window* window2) {
const gfx::Rect window1_bounds = GetTransformedTargetBounds(window1);
const gfx::Rect window2_bounds = GetTransformedTargetBounds(window2);
return window1_bounds.Intersects(window2_bounds);
}
OverviewController* overview_controller() {
return Shell::Get()->overview_controller();
}
OverviewSession* overview_session() {
return overview_controller()->overview_session_.get();
}
gfx::Rect GetTransformedBounds(aura::Window* window) {
gfx::Rect bounds_in_screen = window->layer()->bounds();
::wm::ConvertRectToScreen(window->parent(), &bounds_in_screen);
gfx::RectF bounds(bounds_in_screen);
gfx::Transform transform(gfx::TransformAboutPivot(
gfx::ToFlooredPoint(bounds.origin()), window->layer()->transform()));
transform.TransformRect(&bounds);
return gfx::ToEnclosingRect(bounds);
}
gfx::Rect GetTransformedTargetBounds(aura::Window* window) {
gfx::Rect bounds_in_screen = window->layer()->GetTargetBounds();
::wm::ConvertRectToScreen(window->parent(), &bounds_in_screen);
gfx::RectF bounds(bounds_in_screen);
gfx::Transform transform(
gfx::TransformAboutPivot(gfx::ToFlooredPoint(bounds.origin()),
window->layer()->GetTargetTransform()));
transform.TransformRect(&bounds);
return gfx::ToEnclosingRect(bounds);
}
gfx::Rect GetTransformedBoundsInRootWindow(aura::Window* window) {
gfx::RectF bounds = gfx::RectF(gfx::SizeF(window->bounds().size()));
aura::Window* root = window->GetRootWindow();
CHECK(window->layer());
CHECK(root->layer());
gfx::Transform transform;
if (!window->layer()->GetTargetTransformRelativeTo(root->layer(),
&transform)) {
return gfx::Rect();
}
transform.TransformRect(&bounds);
return gfx::ToEnclosingRect(bounds);
}
void ClickWindow(aura::Window* window) {
ui::test::EventGenerator event_generator(window->GetRootWindow(), window);
event_generator.ClickLeftButton();
}
bool InOverviewSession() {
return overview_controller()->InOverviewSession();
}
OverviewItem* GetDropTarget(int grid_index) {
return overview_session()->grid_list_[grid_index]->GetDropTarget();
}
views::ImageButton* GetCloseButton(OverviewItem* item) {
return item->GetCloseButtonForTesting();
}
views::Label* GetLabelView(OverviewItem* item) {
return item->caption_container_view_->title_label();
}
RoundedRectView* GetBackdropView(OverviewItem* item) {
return item->caption_container_view_->backdrop_view();
}
WindowPreviewView* GetPreviewView(OverviewItem* item) {
return item->caption_container_view_->preview_view();
}
// Tests that a window is contained within a given OverviewItem, and that both
// the window and its matching close button are within the same screen.
void CheckWindowAndCloseButtonInScreen(aura::Window* window,
OverviewItem* window_item) {
const gfx::Rect screen_bounds =
window_item->root_window()->GetBoundsInScreen();
EXPECT_TRUE(window_item->Contains(window));
EXPECT_TRUE(screen_bounds.Contains(GetTransformedTargetBounds(window)));
EXPECT_TRUE(screen_bounds.Contains(
GetCloseButton(window_item)->GetBoundsInScreen()));
}
void SetGridBounds(OverviewGrid* grid, const gfx::Rect& bounds) {
grid->bounds_ = bounds;
}
gfx::Rect GetGridBounds() {
if (overview_session())
return overview_session()->grid_list_[0]->bounds_;
return gfx::Rect();
}
views::Widget* item_widget(OverviewItem* item) {
return item->item_widget_.get();
}
const ScopedOverviewTransformWindow& transform_window(
OverviewItem* item) const {
return item->transform_window_;
}
void CheckOverviewEnterExitHistogram(const char* trace,
std::vector<int>&& enter_counts,
std::vector<int>&& exit_counts) {
DCHECK(!base::Contains(trace_names_, trace)) << trace;
trace_names_.push_back(trace);
{
SCOPED_TRACE(trace + std::string(".Enter"));
CheckOverviewHistogram("Ash.Overview.AnimationSmoothness.Enter",
std::move(enter_counts));
}
{
SCOPED_TRACE(trace + std::string(".Exit"));
CheckOverviewHistogram("Ash.Overview.AnimationSmoothness.Exit",
std::move(exit_counts));
}
}
static void StubForTest(ExitWarningHandler* ewh) {
ewh->stub_timer_for_test_ = true;
}
static bool is_ui_shown(ExitWarningHandler* ewh) { return !!ewh->widget_; }
private:
void CheckOverviewHistogram(const char* histogram,
std::vector<int>&& counts) {
ASSERT_EQ(3u, counts.size());
// There should be no histogram for split view.
histograms_.ExpectTotalCount(histogram + std::string(".SplitView"), 0);
histograms_.ExpectTotalCount(histogram + std::string(".ClamshellMode"),
counts[0]);
histograms_.ExpectTotalCount(
histogram + std::string(".SingleClamshellMode"), counts[1]);
histograms_.ExpectTotalCount(histogram + std::string(".TabletMode"),
counts[2]);
}
std::unique_ptr<ShelfViewTestAPI> shelf_view_test_api_;
std::vector<std::string> trace_names_;
base::HistogramTester histograms_;
DISALLOW_COPY_AND_ASSIGN(OverviewSessionTest);
};
// Tests that an a11y alert is sent on entering overview mode.
TEST_P(OverviewSessionTest, A11yAlertOnOverviewMode) {
TestAccessibilityControllerClient client;
std::unique_ptr<aura::Window> window(CreateTestWindow());
EXPECT_NE(AccessibilityAlert::WINDOW_OVERVIEW_MODE_ENTERED,
client.last_a11y_alert());
ToggleOverview();
EXPECT_EQ(AccessibilityAlert::WINDOW_OVERVIEW_MODE_ENTERED,
client.last_a11y_alert());
}
// Tests that there are no crashes when there is not enough screen space
// available to show all of the windows.
TEST_P(OverviewSessionTest, SmallDisplay) {
UpdateDisplay("3x1");
gfx::Rect bounds(0, 0, 1, 1);
std::unique_ptr<aura::Window> window1(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window4(CreateTestWindow(bounds));
window1->SetProperty(aura::client::kTopViewInset, 0);
window2->SetProperty(aura::client::kTopViewInset, 0);
window3->SetProperty(aura::client::kTopViewInset, 0);
window4->SetProperty(aura::client::kTopViewInset, 0);
ToggleOverview();
}
// Tests entering overview mode with two windows and selecting one by clicking.
TEST_P(OverviewSessionTest, Basic) {
// Overview disabled by default.
EXPECT_FALSE(InOverviewSession());
aura::Window* root_window = Shell::GetPrimaryRootWindow();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EXPECT_TRUE(WindowsOverlapping(window1.get(), window2.get()));
wm::ActivateWindow(window2.get());
EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
EXPECT_EQ(window2.get(), window_util::GetFocusedWindow());
// Hide the cursor before entering overview to test that it will be shown.
aura::client::GetCursorClient(root_window)->HideCursor();
CheckOverviewEnterExitHistogram("Init", {0, 0, 0}, {0, 0, 0});
// In overview mode the windows should no longer overlap and the overview
// focus window should be focused.
ToggleOverview();
EXPECT_EQ(overview_session()->GetOverviewFocusWindow(),
window_util::GetFocusedWindow());
EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
CheckOverviewEnterExitHistogram("Enter", {1, 0, 0}, {0, 0, 0});
// Clicking window 1 should activate it.
ClickWindow(window1.get());
EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
EXPECT_EQ(window1.get(), window_util::GetFocusedWindow());
// Cursor should have been unlocked.
EXPECT_FALSE(aura::client::GetCursorClient(root_window)->IsCursorLocked());
CheckOverviewEnterExitHistogram("Exit", {1, 0, 0}, {1, 0, 0});
}
// Tests activating minimized window.
TEST_P(OverviewSessionTest, ActivateMinimized) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
WindowState* window_state = WindowState::Get(window.get());
WMEvent minimize_event(WM_EVENT_MINIMIZE);
window_state->OnWMEvent(&minimize_event);
EXPECT_FALSE(window->IsVisible());
EXPECT_EQ(0.f, window->layer()->GetTargetOpacity());
EXPECT_EQ(WindowStateType::kMinimized,
WindowState::Get(window.get())->GetStateType());
ToggleOverview();
EXPECT_FALSE(window->IsVisible());
EXPECT_EQ(0.f, window->layer()->GetTargetOpacity());
EXPECT_EQ(WindowStateType::kMinimized, window_state->GetStateType());
WindowPreviewView* preview_view =
GetPreviewView(GetOverviewItemForWindow(window.get()));
EXPECT_TRUE(preview_view);
const gfx::Point point = preview_view->GetBoundsInScreen().CenterPoint();
GetEventGenerator()->set_current_screen_location(point);
GetEventGenerator()->ClickLeftButton();
EXPECT_FALSE(InOverviewSession());
EXPECT_TRUE(window->IsVisible());
EXPECT_EQ(1.f, window->layer()->GetTargetOpacity());
EXPECT_EQ(WindowStateType::kNormal, window_state->GetStateType());
}
// Tests that the ordering of windows is stable across different overview
// sessions even when the windows have the same bounds.
TEST_P(OverviewSessionTest, WindowsOrder) {
std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(1));
std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(2));
std::unique_ptr<aura::Window> window3(CreateTestWindowInShellWithId(3));
// The order of windows in overview mode is MRU.
WindowState::Get(window1.get())->Activate();
ToggleOverview();
const std::vector<std::unique_ptr<OverviewItem>>& overview1 =
GetOverviewItemsForRoot(0);
EXPECT_EQ(1, overview1[0]->GetWindow()->id());
EXPECT_EQ(3, overview1[1]->GetWindow()->id());
EXPECT_EQ(2, overview1[2]->GetWindow()->id());
ToggleOverview();
// Activate the second window.
WindowState::Get(window2.get())->Activate();
ToggleOverview();
const std::vector<std::unique_ptr<OverviewItem>>& overview2 =
GetOverviewItemsForRoot(0);
// The order should be MRU.
EXPECT_EQ(2, overview2[0]->GetWindow()->id());
EXPECT_EQ(1, overview2[1]->GetWindow()->id());
EXPECT_EQ(3, overview2[2]->GetWindow()->id());
ToggleOverview();
}
// Tests selecting a window by tapping on it.
TEST_P(OverviewSessionTest, BasicGesture) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window1.get());
EXPECT_EQ(window1.get(), window_util::GetFocusedWindow());
ToggleOverview();
EXPECT_EQ(overview_session()->GetOverviewFocusWindow(),
window_util::GetFocusedWindow());
GetEventGenerator()->GestureTapAt(
GetTransformedTargetBounds(window2.get()).CenterPoint());
EXPECT_EQ(window2.get(), window_util::GetFocusedWindow());
}
// Tests that the user action WindowSelector_ActiveWindowChanged is
// recorded when the mouse/touchscreen/keyboard are used to select a window
// in overview mode which is different from the previously-active window.
TEST_P(OverviewSessionTest, ActiveWindowChangedUserActionRecorded) {
base::UserActionTester user_action_tester;
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window1.get());
ToggleOverview();
// Tap on |window2| to activate it and exit overview.
GetEventGenerator()->GestureTapAt(
GetTransformedTargetBounds(window2.get()).CenterPoint());
EXPECT_EQ(
1, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// Click on |window2| to activate it and exit overview.
wm::ActivateWindow(window1.get());
ToggleOverview();
ClickWindow(window2.get());
EXPECT_EQ(
2, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// Highlight |window2| using the arrow keys. Activate it (and exit overview)
// by pressing the return key.
wm::ActivateWindow(window1.get());
ToggleOverview();
ASSERT_TRUE(HighlightOverviewWindow(window2.get()));
SendKey(ui::VKEY_RETURN);
EXPECT_EQ(
3, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
}
// Tests that the user action WindowSelector_ActiveWindowChanged is not
// recorded when the mouse/touchscreen/keyboard are used to select the
// already-active window from overview mode. Also verifies that entering and
// exiting overview without selecting a window does not record the action.
TEST_P(OverviewSessionTest, ActiveWindowChangedUserActionNotRecorded) {
base::UserActionTester user_action_tester;
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window1.get());
ToggleOverview();
// Tap on |window1| to exit overview.
GetEventGenerator()->GestureTapAt(
GetTransformedTargetBounds(window1.get()).CenterPoint());
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// |window1| remains active. Click on it to exit overview.
ASSERT_EQ(window1.get(), window_util::GetFocusedWindow());
ToggleOverview();
ClickWindow(window1.get());
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// |window1| remains active. Select using the keyboard.
ASSERT_EQ(window1.get(), window_util::GetFocusedWindow());
ToggleOverview();
ASSERT_TRUE(HighlightOverviewWindow(window1.get()));
SendKey(ui::VKEY_RETURN);
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// Entering and exiting overview without user input should not record
// the action.
ToggleOverview();
ToggleOverview();
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
}
// Tests that the user action WindowSelector_ActiveWindowChanged is not
// recorded when overview mode exits as a result of closing its only window.
TEST_P(OverviewSessionTest, ActiveWindowChangedUserActionWindowClose) {
base::UserActionTester user_action_tester;
std::unique_ptr<views::Widget> widget(CreateTestWidget(
nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(400, 400)));
ToggleOverview();
aura::Window* window = widget->GetNativeWindow();
const gfx::Point point = GetCloseButton(GetOverviewItemForWindow(window))
->GetBoundsInScreen()
.CenterPoint();
ASSERT_FALSE(widget->IsClosed());
GetEventGenerator()->set_current_screen_location(point);
GetEventGenerator()->ClickLeftButton();
ASSERT_TRUE(widget->IsClosed());
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
}
// 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_P(OverviewSessionTest, NoCrashWithDesktopTap) {
std::unique_ptr<aura::Window> window(
CreateTestWindow(gfx::Rect(200, 300, 250, 450)));
ToggleOverview();
const gfx::Rect bounds = GetTransformedBoundsInRootWindow(window.get());
GetEventGenerator()->set_current_screen_location(bounds.CenterPoint());
// Press down on the window.
const int kTouchId = 19;
GetEventGenerator()->PressTouchId(kTouchId);
// Tap on the desktop, which should not cause a crash. Overview mode should
// be disengaged.
GetEventGenerator()->GestureTapAt(GetGridBounds().CenterPoint());
EXPECT_FALSE(InOverviewSession());
GetEventGenerator()->ReleaseTouchId(kTouchId);
}
// Tests that we do not crash and a window is selected when appropriate when
// we click on a window during touch.
TEST_P(OverviewSessionTest, ClickOnWindowDuringTouch) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window2.get());
EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
ToggleOverview();
gfx::Rect window1_bounds = GetTransformedBoundsInRootWindow(window1.get());
GetEventGenerator()->set_current_screen_location(
window1_bounds.CenterPoint());
// Clicking on |window2| while touching on |window1| should not cause a
// crash, it should do nothing since overview only handles one click or touch
// at a time.
const int kTouchId = 19;
GetEventGenerator()->PressTouchId(kTouchId);
GetEventGenerator()->MoveMouseToCenterOf(window2.get());
GetEventGenerator()->ClickLeftButton();
EXPECT_TRUE(InOverviewSession());
EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
// Clicking on |window1| while touching on |window1| should not cause
// a crash, overview mode should be disengaged, and |window1| should
// be active.
GetEventGenerator()->MoveMouseToCenterOf(window1.get());
GetEventGenerator()->ClickLeftButton();
EXPECT_FALSE(InOverviewSession());
EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
GetEventGenerator()->ReleaseTouchId(kTouchId);
}
// Tests that a window does not receive located events when in overview mode.
TEST_P(OverviewSessionTest, WindowDoesNotReceiveEvents) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(400, 400)));
const gfx::Point point1 = window->bounds().CenterPoint();
ui::MouseEvent event1(ui::ET_MOUSE_PRESSED, point1, point1,
ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
aura::Window* root_window = Shell::GetPrimaryRootWindow();
ui::EventTarget* root_target = root_window;
ui::EventTargeter* targeter =
root_window->GetHost()->dispatcher()->GetDefaultEventTargeter();
// The event should target the window because we are still not in overview
// mode.
EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root_target, &event1));
ToggleOverview();
// The bounds have changed, take that into account.
const gfx::Point point2 =
GetTransformedBoundsInRootWindow(window.get()).CenterPoint();
ui::MouseEvent event2(ui::ET_MOUSE_PRESSED, point2, point2,
ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
// Now the transparent window should be intercepting this event.
EXPECT_NE(window.get(), targeter->FindTargetForEvent(root_target, &event2));
}
// Tests that clicking on the close button effectively closes the window.
TEST_P(OverviewSessionTest, CloseButton) {
std::unique_ptr<views::Widget> widget(CreateTestWidget());
std::unique_ptr<views::Widget> minimized_widget(CreateTestWidget());
minimized_widget->Minimize();
ToggleOverview();
aura::Window* window = widget->GetNativeWindow();
const gfx::Point point = GetCloseButton(GetOverviewItemForWindow(window))
->GetBoundsInScreen()
.CenterPoint();
GetEventGenerator()->set_current_screen_location(point);
EXPECT_FALSE(widget->IsClosed());
GetEventGenerator()->ClickLeftButton();
EXPECT_TRUE(widget->IsClosed());
ASSERT_TRUE(InOverviewSession());
aura::Window* minimized_window = minimized_widget->GetNativeWindow();
WindowPreviewView* preview_view =
GetPreviewView(GetOverviewItemForWindow(minimized_window));
EXPECT_TRUE(preview_view);
const gfx::Point point2 =
GetCloseButton(GetOverviewItemForWindow(minimized_window))
->GetBoundsInScreen()
.CenterPoint();
GetEventGenerator()->MoveMouseTo(point2);
EXPECT_FALSE(minimized_widget->IsClosed());
GetEventGenerator()->ClickLeftButton();
EXPECT_TRUE(minimized_widget->IsClosed());
// All minimized windows are closed, so it should exit overview mode.
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(InOverviewSession());
}
// Tests minimizing/unminimizing in overview mode.
TEST_P(OverviewSessionTest, MinimizeUnminimize) {
std::unique_ptr<views::Widget> widget(CreateTestWidget());
aura::Window* window = widget->GetNativeWindow();
ToggleOverview();
EXPECT_FALSE(GetPreviewView(GetOverviewItemForWindow(window)));
widget->Minimize();
EXPECT_TRUE(widget->IsMinimized());
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(GetPreviewView(GetOverviewItemForWindow(window)));
widget->Restore();
EXPECT_FALSE(widget->IsMinimized());
EXPECT_FALSE(GetPreviewView(GetOverviewItemForWindow(window)));
EXPECT_TRUE(InOverviewSession());
}
// Tests that clicking on the close button on a secondary display effectively
// closes the window.
TEST_P(OverviewSessionTest, CloseButtonOnMultipleDisplay) {
UpdateDisplay("600x400,600x400");
// 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. Parent the window to a window in a non-primary root window.
std::unique_ptr<aura::Window> window(
CreateTestWindow(gfx::Rect(650, 300, 250, 450)));
std::unique_ptr<views::Widget> widget(CreateTestWidget());
widget->SetBounds(gfx::Rect(650, 0, 400, 400));
aura::Window* window2 = widget->GetNativeWindow();
window2->SetProperty(aura::client::kTopViewInset, kHeaderHeightDp);
views::Widget::ReparentNativeView(window2, window->parent());
ASSERT_EQ(Shell::GetAllRootWindows()[1], window2->GetRootWindow());
ToggleOverview();
gfx::Rect bounds = GetTransformedBoundsInRootWindow(window2);
gfx::Point point(bounds.right() - 5, bounds.y() + 5);
ui::test::EventGenerator event_generator(window2->GetRootWindow(), point);
EXPECT_FALSE(widget->IsClosed());
event_generator.ClickLeftButton();
EXPECT_TRUE(widget->IsClosed());
}
// Tests entering overview mode with two windows and selecting one.
TEST_P(OverviewSessionTest, FullscreenWindow) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window1.get());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window1.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_TRUE(WindowState::Get(window1.get())->IsFullscreen());
// Enter overview and select the fullscreen window.
ToggleOverview();
CheckOverviewEnterExitHistogram("FullscreenWindowEnter1", {0, 1, 0},
{0, 0, 0});
ClickWindow(window1.get());
EXPECT_TRUE(WindowState::Get(window1.get())->IsFullscreen());
CheckOverviewEnterExitHistogram("FullscreenWindowExit1", {0, 1, 0},
{0, 1, 0});
// Entering overview and selecting another window, the previous window remains
// fullscreen.
ToggleOverview();
CheckOverviewEnterExitHistogram("FullscreenWindowEnter2", {0, 2, 0},
{0, 1, 0});
ClickWindow(window2.get());
EXPECT_TRUE(WindowState::Get(window1.get())->IsFullscreen());
CheckOverviewEnterExitHistogram("FullscreenWindowExit2", {0, 2, 0},
{1, 1, 0});
}
// Tests entering overview mode with maximized window.
TEST_P(OverviewSessionTest, MaximizedWindow) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window1.get());
const WMEvent maximize_event(WM_EVENT_MAXIMIZE);
WindowState::Get(window1.get())->OnWMEvent(&maximize_event);
EXPECT_TRUE(WindowState::Get(window1.get())->IsMaximized());
// Enter overview and select the fullscreen window.
ToggleOverview();
CheckOverviewEnterExitHistogram("MaximizedWindowEnter1", {0, 1, 0},
{0, 0, 0});
ClickWindow(window1.get());
EXPECT_TRUE(WindowState::Get(window1.get())->IsMaximized());
CheckOverviewEnterExitHistogram("MaximizedWindowExit1", {0, 1, 0}, {0, 1, 0});
ToggleOverview();
CheckOverviewEnterExitHistogram("MaximizedWindowEnter2", {0, 2, 0},
{0, 1, 0});
ClickWindow(window2.get());
EXPECT_TRUE(WindowState::Get(window1.get())->IsMaximized());
CheckOverviewEnterExitHistogram("MaximizedWindowExit2", {0, 2, 0}, {1, 1, 0});
}
// Tests that entering overview when a fullscreen window is active in maximized
// mode correctly applies the transformations to the window and correctly
// updates the window bounds on exiting overview mode: http://crbug.com/401664.
TEST_P(OverviewSessionTest, FullscreenWindowTabletMode) {
UpdateDisplay("800x600");
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateTestWindow(bounds));
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EnterTabletMode();
gfx::Rect normal_window_bounds(window1->bounds());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window1.get())->OnWMEvent(&toggle_fullscreen_event);
gfx::Rect fullscreen_window_bounds(window1->bounds());
EXPECT_NE(normal_window_bounds, fullscreen_window_bounds);
EXPECT_EQ(fullscreen_window_bounds, window2->GetTargetBounds());
const gfx::Rect fullscreen(800, 600);
const int shelf_inset = 600 - ShelfConfig::Get()->shelf_size();
const gfx::Rect normal_work_area(800, shelf_inset);
display::Screen* screen = display::Screen::GetScreen();
EXPECT_EQ(gfx::Rect(800, 600),
screen->GetDisplayNearestWindow(window1.get()).work_area());
ToggleOverview();
EXPECT_EQ(fullscreen,
screen->GetDisplayNearestWindow(window1.get()).work_area());
CheckOverviewEnterExitHistogram("FullscreenWindowTabletEnter1", {0, 0, 1},
{0, 0, 0});
// Window 2 would normally resize to normal window bounds on showing the shelf
// for overview but this is deferred until overview is exited.
EXPECT_EQ(fullscreen_window_bounds, window2->GetTargetBounds());
EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
ToggleOverview();
EXPECT_EQ(fullscreen,
screen->GetDisplayNearestWindow(window1.get()).work_area());
// Since the fullscreen window is still active, window2 will still have the
// larger bounds.
EXPECT_EQ(fullscreen_window_bounds, window2->GetTargetBounds());
CheckOverviewEnterExitHistogram("FullscreenWindowTabletExit1", {0, 0, 1},
{0, 0, 1});
// Enter overview again and select window 2. Selecting window 2 should show
// the shelf bringing window2 back to the normal bounds.
ToggleOverview();
CheckOverviewEnterExitHistogram("FullscreenWindowTabletEnter2", {0, 0, 2},
{0, 0, 1});
ClickWindow(window2.get());
// Selecting non fullscreen window should set the work area back to normal.
EXPECT_EQ(normal_work_area,
screen->GetDisplayNearestWindow(window1.get()).work_area());
EXPECT_EQ(normal_window_bounds, window2->GetTargetBounds());
CheckOverviewEnterExitHistogram("FullscreenWindowTabletExit2", {0, 0, 2},
{0, 0, 2});
ToggleOverview();
CheckOverviewEnterExitHistogram("FullscreenWindowTabletEnter3", {0, 0, 3},
{0, 0, 2});
EXPECT_EQ(normal_work_area,
screen->GetDisplayNearestWindow(window1.get()).work_area());
ClickWindow(window1.get());
// Selecting fullscreen. The work area should be updated to fullscreen as
// well.
EXPECT_EQ(fullscreen,
screen->GetDisplayNearestWindow(window1.get()).work_area());
CheckOverviewEnterExitHistogram("FullscreenWindowTabletExit3", {0, 0, 3},
{0, 0, 3});
}
TEST_P(OverviewSessionTest, SkipOverviewWindow) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
window2->SetProperty(ash::kHideInOverviewKey, true);
// Enter overview.
ToggleOverview();
EXPECT_TRUE(window1->IsVisible());
EXPECT_FALSE(window2->IsVisible());
// Exit overview.
ToggleOverview();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(window1->IsVisible());
EXPECT_TRUE(window2->IsVisible());
}
// Tests that a minimized window's visibility and layer visibility
// stay invisible (A minimized window is cloned during overview).
TEST_P(OverviewSessionTest, MinimizedWindowState) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
WindowState::Get(window1.get())->Minimize();
EXPECT_FALSE(window1->IsVisible());
EXPECT_FALSE(window1->layer()->GetTargetVisibility());
ToggleOverview();
EXPECT_FALSE(window1->IsVisible());
EXPECT_FALSE(window1->layer()->GetTargetVisibility());
ToggleOverview();
EXPECT_FALSE(window1->IsVisible());
EXPECT_FALSE(window1->layer()->GetTargetVisibility());
}
// Tests that a bounds change during overview is corrected for.
TEST_P(OverviewSessionTest, BoundsChangeDuringOverview) {
std::unique_ptr<aura::Window> window(
CreateTestWindowInShellWithDelegate(nullptr, -1, gfx::Rect(400, 400)));
// Use overview headers above the window in this test.
window->SetProperty(aura::client::kTopViewInset, 0);
ToggleOverview();
gfx::Rect overview_bounds = GetTransformedTargetBounds(window.get());
window->SetBounds(gfx::Rect(200, 0, 200, 200));
gfx::Rect new_overview_bounds = GetTransformedTargetBounds(window.get());
EXPECT_EQ(overview_bounds, new_overview_bounds);
ToggleOverview();
}
// Tests that a change to the |kTopViewInset| window property during overview is
// corrected for.
TEST_P(OverviewSessionTest, TopViewInsetChangeDuringOverview) {
std::unique_ptr<aura::Window> window = CreateTestWindow(gfx::Rect(400, 400));
window->SetProperty(aura::client::kTopViewInset, 32);
ToggleOverview();
gfx::Rect overview_bounds = GetTransformedTargetBounds(window.get());
window->SetProperty(aura::client::kTopViewInset, 0);
gfx::Rect new_overview_bounds = GetTransformedTargetBounds(window.get());
EXPECT_NE(overview_bounds, new_overview_bounds);
ToggleOverview();
}
// Tests that a newly created window aborts overview.
TEST_P(OverviewSessionTest, NewWindowCancelsOverview) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
// A window being created should exit overview mode.
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EXPECT_FALSE(InOverviewSession());
}
// Tests that a window activation exits overview mode.
TEST_P(OverviewSessionTest, ActivationCancelsOverview) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
window2->Focus();
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
// A window being activated should exit overview mode.
window1->Focus();
EXPECT_FALSE(InOverviewSession());
// window1 should be focused after exiting even though window2 was focused on
// entering overview because we exited due to an activation.
EXPECT_EQ(window1.get(), window_util::GetFocusedWindow());
}
// Tests that if a window is dragged while overview is open, the activation
// of the dragged window does not cancel overview.
TEST_P(OverviewSessionTest, ActivateDraggedWindowNotCancelOverview) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
window1->SetProperty(aura::client::kAppType,
static_cast<int>(AppType::BROWSER));
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EXPECT_FALSE(InOverviewSession());
// Start drag on |window1|.
std::unique_ptr<WindowResizer> resizer(CreateWindowResizer(
window1.get(), gfx::Point(), HTCAPTION, ::wm::WINDOW_MOVE_SOURCE_TOUCH));
EXPECT_TRUE(InOverviewSession());
resizer->Drag(gfx::Point(400, 0), 0);
EXPECT_TRUE(InOverviewSession());
wm::ActivateWindow(window1.get());
EXPECT_TRUE(InOverviewSession());
resizer->CompleteDrag();
EXPECT_FALSE(InOverviewSession());
}
// Tests that activate a non-dragged window during window drag will not cancel
// overview mode.
TEST_P(OverviewSessionTest, ActivateAnotherWindowDuringDragNotCancelOverview) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
window1->SetProperty(aura::client::kAppType,
static_cast<int>(AppType::BROWSER));
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EXPECT_FALSE(InOverviewSession());
// Start drag on |window1|.
wm::ActivateWindow(window1.get());
std::unique_ptr<WindowResizer> resizer(CreateWindowResizer(
window1.get(), gfx::Point(), HTCAPTION, ::wm::WINDOW_MOVE_SOURCE_TOUCH));
EXPECT_TRUE(InOverviewSession());
// Activate |window2| should not cancel overview mode.
wm::ActivateWindow(window2.get());
EXPECT_FALSE(WindowState::Get(window2.get())->is_dragged());
EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
EXPECT_TRUE(InOverviewSession());
}
// Tests that if an overview item is dragged, the activation of the
// corresponding window does not cancel overview.
TEST_P(OverviewSessionTest, ActivateDraggedOverviewWindowNotCancelOverview) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window(CreateTestWindow());
ToggleOverview();
OverviewItem* item = GetOverviewItemForWindow(window.get());
gfx::PointF drag_point = item->target_bounds().CenterPoint();
overview_session()->InitiateDrag(item, drag_point,
/*is_touch_dragging=*/false);
drag_point.Offset(5.f, 0.f);
overview_session()->Drag(item, drag_point);
wm::ActivateWindow(window.get());
EXPECT_TRUE(InOverviewSession());
}
// Tests that if an overview item is dragged, the activation of the window
// corresponding to another overview item does not cancel overview.
TEST_P(OverviewSessionTest,
ActivateAnotherOverviewWindowDuringOverviewDragNotCancelOverview) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
gfx::PointF drag_point = item1->target_bounds().CenterPoint();
overview_session()->InitiateDrag(item1, drag_point,
/*is_touch_dragging=*/false);
drag_point.Offset(5.f, 0.f);
overview_session()->Drag(item1, drag_point);
wm::ActivateWindow(window2.get());
EXPECT_TRUE(InOverviewSession());
}
// Tests that if an overview item is dragged, the activation of a window
// excluded from overview does not cancel overview.
TEST_P(OverviewSessionTest,
ActivateWindowExcludedFromOverviewDuringOverviewDragNotCancelOverview) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(
CreateTestWindow(gfx::Rect(), aura::client::WINDOW_TYPE_POPUP));
EXPECT_TRUE(window_util::ShouldExcludeForOverview(window2.get()));
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
gfx::PointF drag_point = item1->target_bounds().CenterPoint();
overview_session()->InitiateDrag(item1, drag_point,
/*is_touch_dragging=*/false);
drag_point.Offset(5.f, 0.f);
overview_session()->Drag(item1, drag_point);
wm::ActivateWindow(window2.get());
EXPECT_TRUE(InOverviewSession());
}
// Tests that exiting overview mode without selecting a window restores focus
// to the previously focused window.
TEST_P(OverviewSessionTest, CancelRestoresFocus) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
wm::ActivateWindow(window.get());
EXPECT_EQ(window.get(), window_util::GetFocusedWindow());
// In overview mode, the overview focus window should be focused.
ToggleOverview();
EXPECT_EQ(overview_session()->GetOverviewFocusWindow(),
window_util::GetFocusedWindow());
// If canceling overview mode, focus should be restored.
ToggleOverview();
EXPECT_EQ(window.get(), window_util::GetFocusedWindow());
}
// Tests that overview mode is exited if the last remaining window is destroyed.
TEST_P(OverviewSessionTest, LastWindowDestroyed) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
ToggleOverview();
window1.reset();
window2.reset();
EXPECT_FALSE(InOverviewSession());
}
// Tests that entering overview mode restores a window to its original
// target location.
TEST_P(OverviewSessionTest, QuickReentryRestoresInitialTransform) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(400, 400)));
gfx::Rect initial_bounds = GetTransformedBounds(window.get());
ToggleOverview();
// Quickly exit and reenter overview mode. The window should still be
// animating when we reenter. We cannot short circuit animations for this but
// we also don't have to wait for them to complete.
{
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
ToggleOverview();
ToggleOverview();
}
EXPECT_NE(initial_bounds, GetTransformedTargetBounds(window.get()));
ToggleOverview();
EXPECT_FALSE(InOverviewSession());
EXPECT_EQ(initial_bounds, GetTransformedTargetBounds(window.get()));
}
// Tests that windows with modal child windows are transformed with the modal
// child even though not activatable themselves.
TEST_P(OverviewSessionTest, ModalChild) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> child(CreateTestWindow(bounds));
child->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
::wm::AddTransientChild(window.get(), child.get());
EXPECT_EQ(window->parent(), child->parent());
ToggleOverview();
EXPECT_TRUE(window->IsVisible());
EXPECT_TRUE(child->IsVisible());
EXPECT_EQ(GetTransformedTargetBounds(child.get()),
GetTransformedTargetBounds(window.get()));
ToggleOverview();
}
// Tests that clicking a modal window's parent activates the modal window in
// overview.
TEST_P(OverviewSessionTest, ClickModalWindowParent) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(180, 180)));
std::unique_ptr<aura::Window> child(
CreateTestWindow(gfx::Rect(200, 0, 180, 180)));
child->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
::wm::AddTransientChild(window.get(), child.get());
EXPECT_FALSE(WindowsOverlapping(window.get(), child.get()));
EXPECT_EQ(window->parent(), child->parent());
ToggleOverview();
// Given that their relative positions are preserved, the windows should still
// not overlap.
EXPECT_FALSE(WindowsOverlapping(window.get(), child.get()));
ClickWindow(window.get());
EXPECT_FALSE(InOverviewSession());
// Clicking on window1 should activate child1.
EXPECT_TRUE(wm::IsActiveWindow(child.get()));
}
// Tests that windows remain on the display they are currently on in overview
// mode, and that the close buttons are on matching displays.
TEST_P(OverviewSessionTest, MultipleDisplays) {
UpdateDisplay("600x400,600x400");
aura::Window::Windows root_windows = Shell::GetAllRootWindows();
gfx::Rect bounds1(0, 0, 400, 400);
gfx::Rect bounds2(650, 0, 400, 400);
std::unique_ptr<aura::Window> window1(CreateTestWindow(bounds1));
std::unique_ptr<aura::Window> window2(CreateTestWindow(bounds1));
std::unique_ptr<aura::Window> window3(CreateTestWindow(bounds2));
std::unique_ptr<aura::Window> window4(CreateTestWindow(bounds2));
EXPECT_EQ(root_windows[0], window1->GetRootWindow());
EXPECT_EQ(root_windows[0], window2->GetRootWindow());
EXPECT_EQ(root_windows[1], window3->GetRootWindow());
EXPECT_EQ(root_windows[1], window4->GetRootWindow());
// In overview mode, each window remains in the same root window.
ToggleOverview();
EXPECT_EQ(root_windows[0], window1->GetRootWindow());
EXPECT_EQ(root_windows[0], window2->GetRootWindow());
EXPECT_EQ(root_windows[1], window3->GetRootWindow());
EXPECT_EQ(root_windows[1], window4->GetRootWindow());
// Window indices are based on top-down order. The reverse of our creation.
CheckWindowAndCloseButtonInScreen(window1.get(),
GetOverviewItemForWindow(window1.get()));
CheckWindowAndCloseButtonInScreen(window2.get(),
GetOverviewItemForWindow(window2.get()));
CheckWindowAndCloseButtonInScreen(window3.get(),
GetOverviewItemForWindow(window3.get()));
CheckWindowAndCloseButtonInScreen(window4.get(),
GetOverviewItemForWindow(window4.get()));
}
// Tests shutting down during overview.
TEST_P(OverviewSessionTest, Shutdown) {
// These windows will be deleted when the test exits and the Shell instance
// is shut down.
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
ToggleOverview();
}
// Tests adding a display during overview.
TEST_P(OverviewSessionTest, AddDisplay) {
UpdateDisplay("400x400");
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
UpdateDisplay("400x400,400x400");
EXPECT_FALSE(InOverviewSession());
}
// Tests removing a display during overview.
TEST_P(OverviewSessionTest, RemoveDisplay) {
UpdateDisplay("400x400,400x400");
std::unique_ptr<aura::Window> window1(CreateTestWindow(gfx::Rect(100, 100)));
std::unique_ptr<aura::Window> window2(
CreateTestWindow(gfx::Rect(450, 0, 100, 100)));
aura::Window::Windows root_windows = Shell::GetAllRootWindows();
EXPECT_EQ(root_windows[0], window1->GetRootWindow());
EXPECT_EQ(root_windows[1], window2->GetRootWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
UpdateDisplay("400x400");
EXPECT_FALSE(InOverviewSession());
}
// Tests removing a display during overview with NON_ZERO_DURATION animation.
TEST_P(OverviewSessionTest, RemoveDisplayWithAnimation) {
UpdateDisplay("400x400,400x400");
std::unique_ptr<aura::Window> window1(CreateTestWindow(gfx::Rect(100, 100)));
std::unique_ptr<aura::Window> window2(
CreateTestWindow(gfx::Rect(450, 0, 100, 100)));
aura::Window::Windows root_windows = Shell::GetAllRootWindows();
EXPECT_EQ(root_windows[0], window1->GetRootWindow());
EXPECT_EQ(root_windows[1], window2->GetRootWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
UpdateDisplay("400x400");
EXPECT_FALSE(InOverviewSession());
}
// Tests that dragging a window from the top of a display creates a drop target
// on that display.
TEST_P(OverviewSessionTest, DropTargetOnCorrectDisplayForDraggingFromTop) {
UpdateDisplay("600x600,600x600");
EnterTabletMode();
// DisplayConfigurationObserver enables mirror mode when tablet mode is
// enabled. Disable mirror mode to test multiple displays.
display_manager()->SetMirrorMode(display::MirrorMode::kOff, base::nullopt);
base::RunLoop().RunUntilIdle();
const aura::Window::Windows root_windows = Shell::Get()->GetAllRootWindows();
ASSERT_EQ(2u, root_windows.size());
std::unique_ptr<aura::Window> primary_screen_window =
CreateTestWindow(gfx::Rect(0, 0, 600, 600));
primary_screen_window->SetProperty(aura::client::kAppType,
static_cast<int>(AppType::BROWSER));
ASSERT_EQ(root_windows[0], primary_screen_window->GetRootWindow());
std::unique_ptr<aura::Window> secondary_screen_window =
CreateTestWindow(gfx::Rect(600, 0, 600, 600));
secondary_screen_window->SetProperty(aura::client::kAppType,
static_cast<int>(AppType::BROWSER));
ASSERT_EQ(root_windows[1], secondary_screen_window->GetRootWindow());
ASSERT_FALSE(InOverviewSession());
{
std::unique_ptr<WindowResizer> resizer =
CreateWindowResizer(primary_screen_window.get(), gfx::Point(400, 0),
HTCAPTION, ::wm::WINDOW_MOVE_SOURCE_TOUCH);
ASSERT_TRUE(InOverviewSession());
EXPECT_FALSE(GetDropTarget(1));
ASSERT_TRUE(GetDropTarget(0));
EXPECT_EQ(root_windows[0], GetDropTarget(0)->root_window());
resizer->CompleteDrag();
}
ASSERT_FALSE(InOverviewSession());
{
std::unique_ptr<WindowResizer> resizer =
CreateWindowResizer(secondary_screen_window.get(), gfx::Point(400, 0),
HTCAPTION, ::wm::WINDOW_MOVE_SOURCE_TOUCH);
ASSERT_TRUE(InOverviewSession());
EXPECT_FALSE(GetDropTarget(0));
ASSERT_TRUE(GetDropTarget(1));
EXPECT_EQ(root_windows[1], GetDropTarget(1)->root_window());
resizer->CompleteDrag();
}
ASSERT_FALSE(InOverviewSession());
}
// Tests that dragging a window from overview creates a drop target on the same
// display.
TEST_P(OverviewSessionTest, DropTargetOnCorrectDisplayForDraggingFromOverview) {
UpdateDisplay("600x600,600x600");
EnterTabletMode();
// DisplayConfigurationObserver enables mirror mode when tablet mode is
// enabled. Disable mirror mode to test multiple displays.
display_manager()->SetMirrorMode(display::MirrorMode::kOff, base::nullopt);
base::RunLoop().RunUntilIdle();
const aura::Window::Windows root_windows = Shell::Get()->GetAllRootWindows();
ASSERT_EQ(2u, root_windows.size());
std::unique_ptr<aura::Window> primary_screen_window =
CreateTestWindow(gfx::Rect(0, 0, 600, 600));
ASSERT_EQ(root_windows[0], primary_screen_window->GetRootWindow());
std::unique_ptr<aura::Window> secondary_screen_window =
CreateTestWindow(gfx::Rect(600, 0, 600, 600));
ASSERT_EQ(root_windows[1], secondary_screen_window->GetRootWindow());
ToggleOverview();
OverviewItem* primary_screen_item =
GetOverviewItemForWindow(primary_screen_window.get());
OverviewItem* secondary_screen_item =
GetOverviewItemForWindow(secondary_screen_window.get());
EXPECT_FALSE(GetDropTarget(0));
EXPECT_FALSE(GetDropTarget(1));
gfx::PointF drag_point = primary_screen_item->target_bounds().CenterPoint();
overview_session()->InitiateDrag(primary_screen_item, drag_point,
/*is_touch_dragging=*/false);
EXPECT_FALSE(GetDropTarget(0));
EXPECT_FALSE(GetDropTarget(1));
drag_point.Offset(5.f, 0.f);
overview_session()->Drag(primary_screen_item, drag_point);
EXPECT_FALSE(GetDropTarget(1));
ASSERT_TRUE(GetDropTarget(0));
EXPECT_EQ(root_windows[0], GetDropTarget(0)->root_window());
overview_session()->CompleteDrag(primary_screen_item, drag_point);
EXPECT_FALSE(GetDropTarget(0));
EXPECT_FALSE(GetDropTarget(1));
drag_point = secondary_screen_item->target_bounds().CenterPoint();
overview_session()->InitiateDrag(secondary_screen_item, drag_point,
/*is_touch_dragging=*/false);
EXPECT_FALSE(GetDropTarget(0));
EXPECT_FALSE(GetDropTarget(1));
drag_point.Offset(5.f, 0.f);
overview_session()->Drag(secondary_screen_item, drag_point);
EXPECT_FALSE(GetDropTarget(0));
ASSERT_TRUE(GetDropTarget(1));
EXPECT_EQ(root_windows[1], GetDropTarget(1)->root_window());
overview_session()->CompleteDrag(secondary_screen_item, drag_point);
EXPECT_FALSE(GetDropTarget(0));
EXPECT_FALSE(GetDropTarget(1));
}
namespace {
// A simple window delegate that returns the specified hit-test code when
// requested and applies a minimum size constraint if there is one.
class TestDragWindowDelegate : public aura::test::TestWindowDelegate {
public:
TestDragWindowDelegate() { set_window_component(HTCAPTION); }
~TestDragWindowDelegate() override = default;
private:
// aura::Test::TestWindowDelegate:
void OnWindowDestroyed(aura::Window* window) override { delete this; }
DISALLOW_COPY_AND_ASSIGN(TestDragWindowDelegate);
};
} // namespace
// Tests that toggling overview on and off does not cancel drag.
TEST_P(OverviewSessionTest, DragDropInProgress) {
std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate(
new TestDragWindowDelegate(), -1, gfx::Rect(100, 100)));
GetEventGenerator()->set_current_screen_location(
window->GetBoundsInScreen().CenterPoint());
GetEventGenerator()->PressLeftButton();
GetEventGenerator()->MoveMouseBy(10, 10);
EXPECT_EQ(gfx::Rect(10, 10, 100, 100), window->bounds());
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
GetEventGenerator()->MoveMouseBy(10, 10);
ToggleOverview();
ASSERT_FALSE(InOverviewSession());
GetEventGenerator()->MoveMouseBy(10, 10);
GetEventGenerator()->ReleaseLeftButton();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(gfx::Rect(30, 30, 100, 100), window->bounds());
}
// Tests that toggling overview on removes any resize shadows that may have been
// present.
TEST_P(OverviewSessionTest, DragWindowShadow) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(100, 100)));
wm::ActivateWindow(window.get());
Shell::Get()->resize_shadow_controller()->ShowShadow(window.get(), HTTOP);
ToggleOverview();
ResizeShadow* shadow =
Shell::Get()->resize_shadow_controller()->GetShadowForWindowForTest(
window.get());
ASSERT_TRUE(shadow);
EXPECT_FALSE(shadow->GetLayerForTest()->visible());
}
// Test that a label is created under the window on entering overview mode.
TEST_P(OverviewSessionTest, CreateLabelUnderWindow) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(300, 500)));
const base::string16 window_title = base::UTF8ToUTF16("My window");
window->SetTitle(window_title);
ToggleOverview();
OverviewItem* window_item = GetOverviewItemsForRoot(0).back().get();
views::Label* label = GetLabelView(window_item);
ASSERT_TRUE(label);
// Verify the label matches the window title.
EXPECT_EQ(window_title, label->GetText());
// Update the window title and check that the label is updated, too.
const base::string16 updated_title = base::UTF8ToUTF16("Updated title");
window->SetTitle(updated_title);
EXPECT_EQ(updated_title, label->GetText());
// Labels are located based on target_bounds, not the actual window item
// bounds.
gfx::RectF label_bounds =
gfx::RectF(label->GetWidget()->GetWindowBoundsInScreen());
label_bounds.Inset(kWindowMargin, kWindowMargin);
EXPECT_EQ(label_bounds, window_item->target_bounds());
}
// Tests that overview updates the window positions if the display orientation
// changes.
TEST_P(OverviewSessionTest, DisplayOrientationChanged) {
aura::Window* root_window = Shell::Get()->GetPrimaryRootWindow();
UpdateDisplay("600x200");
EXPECT_EQ(gfx::Rect(600, 200), root_window->bounds());
std::vector<std::unique_ptr<aura::Window>> windows;
for (int i = 0; i < 3; i++) {
windows.push_back(
std::unique_ptr<aura::Window>(CreateTestWindow(gfx::Rect(150, 150))));
}
ToggleOverview();
for (const auto& window : windows) {
EXPECT_TRUE(root_window->bounds().Contains(
GetTransformedTargetBounds(window.get())));
}
// Rotate the display, windows should be repositioned to be within the screen
// bounds.
UpdateDisplay("600x200/r");
EXPECT_EQ(gfx::Rect(200, 600), root_window->bounds());
for (const auto& window : windows) {
EXPECT_TRUE(root_window->bounds().Contains(
GetTransformedTargetBounds(window.get())));
}
}
TEST_P(OverviewSessionTest, AcceleratorInOverviewSession) {
ToggleOverview();
auto* accelerator_controller = Shell::Get()->accelerator_controller();
auto* ewh = accelerator_controller->GetExitWarningHandlerForTest();
ASSERT_TRUE(ewh);
StubForTest(ewh);
EXPECT_FALSE(is_ui_shown(ewh));
ui::test::EventGenerator event_generator(Shell::GetPrimaryRootWindow());
event_generator.PressKey(ui::VKEY_Q, ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN);
event_generator.ReleaseKey(ui::VKEY_Q,
ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN);
EXPECT_TRUE(is_ui_shown(ewh));
}
// Tests hitting the escape and back keys exits overview mode.
TEST_P(OverviewSessionTest, ExitOverviewWithKey) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
SendKey(ui::VKEY_ESCAPE);
EXPECT_FALSE(overview_controller()->InOverviewSession());
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
SendKey(ui::VKEY_BROWSER_BACK);
EXPECT_FALSE(overview_controller()->InOverviewSession());
// Tests that in tablet mode, if we snap the only overview window, we cannot
// exit overview mode.
EnterTabletMode();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
SplitViewController::Get()->SnapWindow(window.get(),
SplitViewController::LEFT);
ASSERT_TRUE(overview_controller()->InOverviewSession());
SendKey(ui::VKEY_ESCAPE);
EXPECT_TRUE(overview_controller()->InOverviewSession());
SendKey(ui::VKEY_BROWSER_BACK);
EXPECT_TRUE(overview_controller()->InOverviewSession());
}
// Regression test for clusterfuzz crash. https://crbug.com/920568
TEST_P(OverviewSessionTest, TypeThenPressEscapeTwice) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
ToggleOverview();
// Type some characters.
SendKey(ui::VKEY_A);
SendKey(ui::VKEY_B);
SendKey(ui::VKEY_C);
EXPECT_TRUE(overview_session()->GetOverviewFocusWindow());
// Pressing escape twice should not crash.
SendKey(ui::VKEY_ESCAPE);
SendKey(ui::VKEY_ESCAPE);
}
TEST_P(OverviewSessionTest, CancelOverviewOnMouseClick) {
std::unique_ptr<aura::Window> window(
CreateTestWindow(gfx::Rect(10, 10, 100, 100)));
// Move mouse to point in the background page. Sending an event here will pass
// it to the WallpaperController in both regular and overview mode.
GetEventGenerator()->MoveMouseTo(gfx::Point(0, 0));
// Clicking on the background page while not in overview should not toggle
// overview.
GetEventGenerator()->ClickLeftButton();
EXPECT_FALSE(InOverviewSession());
// Switch to overview mode. Clicking should now exit overview mode.
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// Choose a point that doesn't intersect with the window or the desks bar.
const gfx::Point point_in_background_page = GetGridBounds().CenterPoint();
GetEventGenerator()->MoveMouseTo(point_in_background_page);
GetEventGenerator()->ClickLeftButton();
EXPECT_FALSE(InOverviewSession());
}
// Tests tapping on the desktop itself to cancel overview mode.
TEST_P(OverviewSessionTest, CancelOverviewOnTap) {
std::unique_ptr<aura::Window> window(
CreateTestWindow(gfx::Rect(10, 10, 100, 100)));
// Tapping on the background page while not in overview should not toggle
// overview.
GetEventGenerator()->GestureTapAt(gfx::Point(0, 0));
EXPECT_FALSE(InOverviewSession());
// Switch to overview mode. Tapping should now exit overview mode.
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// A point that doesn't intersect with the window nor the desks bar. This
// causes events located at the point to be passed to WallpaperController, and
// not the window.
const gfx::Point point_in_background_page = GetGridBounds().CenterPoint();
GetEventGenerator()->GestureTapAt(point_in_background_page);
EXPECT_FALSE(InOverviewSession());
}
// Start dragging a window and activate overview mode. This test should not
// crash or DCHECK inside aura::Window::StackChildRelativeTo().
TEST_P(OverviewSessionTest, OverviewWhileDragging) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
std::unique_ptr<WindowResizer> resizer(CreateWindowResizer(
window.get(), gfx::Point(), HTCAPTION, ::wm::WINDOW_MOVE_SOURCE_MOUSE));
ASSERT_TRUE(resizer.get());
gfx::Point location = resizer->GetInitialLocation();
location.Offset(20, 20);
resizer->Drag(location, 0);
ToggleOverview();
resizer->RevertDrag();
}
// Verify that the overview no windows indicator appears when entering overview
// mode with no windows.
TEST_P(OverviewSessionTest, NoWindowsIndicator) {
// Verify that by entering overview mode without windows, the no items
// indicator appears.
ToggleOverview();
ASSERT_TRUE(overview_session());
ASSERT_EQ(0u, GetOverviewItemsForRoot(0).size());
EXPECT_TRUE(overview_session()->no_windows_widget_for_testing());
}
// Verify that the overview no windows indicator position is as expected.
TEST_P(OverviewSessionTest, NoWindowsIndicatorPosition) {
UpdateDisplay("400x300");
ToggleOverview();
ASSERT_TRUE(overview_session());
RoundedLabelWidget* no_windows_widget =
overview_session()->no_windows_widget_for_testing();
ASSERT_TRUE(no_windows_widget);
// Verify that originally the label is in the center of the workspace.
// Midpoint of height minus shelf.
int expected_y = (300 - ShelfConfig::Get()->shelf_size()) / 2;
EXPECT_EQ(gfx::Point(200, expected_y),
no_windows_widget->GetWindowBoundsInScreen().CenterPoint());
// Verify that after rotating the display, the label is centered in the
// workspace 300x(400-shelf).
display::Screen* screen = display::Screen::GetScreen();
const display::Display& display = screen->GetPrimaryDisplay();
display_manager()->SetDisplayRotation(
display.id(), display::Display::ROTATE_90,
display::Display::RotationSource::ACTIVE);
expected_y = (400 - ShelfConfig::Get()->shelf_size()) / 2;
EXPECT_EQ(gfx::Point(150, (400 - ShelfConfig::Get()->shelf_size()) / 2),
no_windows_widget->GetWindowBoundsInScreen().CenterPoint());
}
TEST_P(OverviewSessionTest, NoWindowsIndicatorPositionSplitview) {
UpdateDisplay("400x300");
EnterTabletMode();
std::unique_ptr<aura::Window> window(CreateTestWindow());
ToggleOverview();
ASSERT_TRUE(overview_session());
RoundedLabelWidget* no_windows_widget =
overview_session()->no_windows_widget_for_testing();
EXPECT_FALSE(no_windows_widget);
// Tests that when snapping a window to the left in splitview, the no windows
// indicator shows up in the middle of the right side of the screen.
auto* split_view_controller = SplitViewController::Get();
split_view_controller->SnapWindow(window.get(), SplitViewController::LEFT);
no_windows_widget = overview_session()->no_windows_widget_for_testing();
ASSERT_TRUE(no_windows_widget);
// There is a 8dp divider in splitview, the indicator should take that into
// account.
const int bounds_left = 200 + 4;
int expected_x = bounds_left + (400 - (bounds_left)) / 2;
const int expected_y = (300 - ShelfConfig::Get()->shelf_size()) / 2;
EXPECT_EQ(gfx::Point(expected_x, expected_y),
no_windows_widget->GetWindowBoundsInScreen().CenterPoint());
// Tests that when snapping a window to the right in splitview, the no windows
// indicator shows up in the middle of the left side of the screen.
split_view_controller->SnapWindow(window.get(), SplitViewController::RIGHT);
expected_x = /*bounds_right=*/(200 - 4) / 2;
EXPECT_EQ(gfx::Point(expected_x, expected_y),
no_windows_widget->GetWindowBoundsInScreen().CenterPoint());
}
// Tests that the no windows indicator shows properly after adding an item.
TEST_P(OverviewSessionTest, NoWindowsIndicatorAddItem) {
EnterTabletMode();
std::unique_ptr<aura::Window> window(CreateTestWindow());
ToggleOverview();
auto* split_view_controller = SplitViewController::Get();
split_view_controller->SnapWindow(window.get(), SplitViewController::LEFT);
EXPECT_TRUE(overview_session()->no_windows_widget_for_testing());
overview_session()->AddItem(window.get(), /*reposition=*/true,
/*animate=*/false);
EXPECT_FALSE(overview_session()->no_windows_widget_for_testing());
}
// Verify that when opening overview mode with multiple displays, the no items
// indicator on the primary grid if there are no windows.
TEST_P(OverviewSessionTest, NoWindowsIndicatorPositionMultiDisplay) {
UpdateDisplay("400x400,400x400,400x400");
// Enter overview mode. Verify that the no windows indicator is located on the
// primary display.
ToggleOverview();
ASSERT_TRUE(overview_session());
RoundedLabelWidget* no_windows_widget =
overview_session()->no_windows_widget_for_testing();
const int expected_y = (400 - ShelfConfig::Get()->shelf_size()) / 2;
EXPECT_EQ(gfx::Point(200, expected_y),
no_windows_widget->GetWindowBoundsInScreen().CenterPoint());
}
// Tests that we do not exit overview mode until all the grids are empty.
TEST_P(OverviewSessionTest, ExitOverviewWhenAllGridsEmpty) {
UpdateDisplay("400x400,400x400,400x400");
// Create two windows with widgets (widgets are needed to close the windows
// later in the test), one each on the first two monitors.
aura::Window::Windows root_windows = Shell::GetAllRootWindows();
std::unique_ptr<views::Widget> widget1(CreateTestWidget());
std::unique_ptr<views::Widget> widget2(CreateTestWidget());
aura::Window* window1 = widget1->GetNativeWindow();
aura::Window* window2 = widget2->GetNativeWindow();
ASSERT_TRUE(
window_util::MoveWindowToDisplay(window2, GetSecondaryDisplay().id()));
ASSERT_EQ(root_windows[0], window1->GetRootWindow());
ASSERT_EQ(root_windows[1], window2->GetRootWindow());
// Enter overview mode. Verify that the no windows indicator is not visible on
// any display.
ToggleOverview();
auto& grids = overview_session()->grid_list();
ASSERT_TRUE(overview_session());
ASSERT_EQ(3u, grids.size());
EXPECT_FALSE(overview_session()->no_windows_widget_for_testing());
OverviewItem* item1 = GetOverviewItemForWindow(window1);
OverviewItem* item2 = GetOverviewItemForWindow(window2);
ASSERT_TRUE(item1 && item2);
// Close |item2|. Verify that we are still in overview mode because |window1|
// is still open. The non primary root grids are empty however.
item2->CloseWindow();
base::RunLoop().RunUntilIdle();
ASSERT_TRUE(overview_session());
ASSERT_EQ(3u, grids.size());
EXPECT_FALSE(grids[0]->empty());
EXPECT_TRUE(grids[1]->empty());
EXPECT_TRUE(grids[2]->empty());
EXPECT_FALSE(overview_session()->no_windows_widget_for_testing());
// Close |item1|. Verify that since no windows are open, we exit overview
// mode.
item1->CloseWindow();
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(overview_session());
}
// Tests window list animation states are correctly updated.
TEST_P(OverviewSessionTest, SetWindowListAnimationStates) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window3.get())->IsFullscreen());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window3.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window3.get())->IsFullscreen());
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Enter overview.
ToggleOverview();
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window3->layer()->GetAnimator()->is_animating());
ToggleOverview();
}
// Tests window list animation states are correctly updated with selected
// window.
TEST_P(OverviewSessionTest, SetWindowListAnimationStatesWithSelectedWindow) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window3.get())->IsFullscreen());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window3.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window3.get())->IsFullscreen());
// Enter overview.
ToggleOverview();
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Click on |window3| to activate it and exit overview.
// Should only set |should_animate_when_exiting_| and
// |should_be_observed_when_exiting_| on window 3.
TweenTester tester1(window1.get());
TweenTester tester2(window2.get());
TweenTester tester3(window3.get());
ClickWindow(window3.get());
EXPECT_EQ(gfx::Tween::ZERO, tester1.tween_type());
EXPECT_EQ(gfx::Tween::ZERO, tester2.tween_type());
EXPECT_EQ(gfx::Tween::EASE_OUT, tester3.tween_type());
}
// Tests OverviewWindowAnimationObserver can handle deleted window.
TEST_P(OverviewSessionTest,
OverviewWindowAnimationObserverCanHandleDeletedWindow) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window3.get())->IsFullscreen());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window3.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window3.get())->IsFullscreen());
// Enter overview.
ToggleOverview();
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Click on |window3| to activate it and exit overview.
// Should only set |should_animate_when_exiting_| and
// |should_be_observed_when_exiting_| on window 3.
{
TweenTester tester1(window1.get());
TweenTester tester2(window2.get());
TweenTester tester3(window3.get());
ClickWindow(window3.get());
EXPECT_EQ(gfx::Tween::ZERO, tester1.tween_type());
EXPECT_EQ(gfx::Tween::ZERO, tester2.tween_type());
EXPECT_EQ(gfx::Tween::EASE_OUT, tester3.tween_type());
}
// Destroy |window1| and |window2| before |window3| finishes animation can be
// handled in OverviewWindowAnimationObserver.
window1.reset();
window2.reset();
}
// Tests can handle OverviewWindowAnimationObserver was deleted.
TEST_P(OverviewSessionTest, HandleOverviewWindowAnimationObserverWasDeleted) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window3.get())->IsFullscreen());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window3.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window3.get())->IsFullscreen());
// Enter overview.
ToggleOverview();
// Click on |window2| to activate it and exit overview. Should only set
// |should_animate_when_exiting_| and |should_be_observed_when_exiting_| on
// window 2. Because the animation duration is zero in test, the
// OverviewWindowAnimationObserver will delete itself immediately before
// |window3| is added to it.
ClickWindow(window2.get());
EXPECT_FALSE(window1->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window2->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window3->layer()->GetAnimator()->is_animating());
}
// Tests can handle |gained_active| window is not in the |overview_grid| when
// OnWindowActivated.
TEST_P(OverviewSessionTest, HandleActiveWindowNotInOverviewGrid) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window3.get())->IsFullscreen());
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window3.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_FALSE(WindowState::Get(window1.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window3.get())->IsFullscreen());
// Enter overview.
ToggleOverview();
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Create and active a new window should exit overview without error.
auto widget = CreateTestWidget();
TweenTester tester1(window1.get());
TweenTester tester2(window2.get());
TweenTester tester3(window3.get());
ClickWindow(widget->GetNativeWindow());
// |window1| and |window2| should animate.
EXPECT_EQ(gfx::Tween::EASE_OUT, tester1.tween_type());
EXPECT_EQ(gfx::Tween::EASE_OUT, tester2.tween_type());
EXPECT_EQ(gfx::Tween::ZERO, tester3.tween_type());
}
// Tests that AlwaysOnTopWindow can be handled correctly in new overview
// animations.
// Fails consistently; see https://crbug.com/812497.
TEST_P(OverviewSessionTest, DISABLED_HandleAlwaysOnTopWindow) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window4(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window5(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window6(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window7(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window8(CreateTestWindow(bounds));
window3->SetProperty(aura::client::kZOrderingKey,
ui::ZOrderLevel::kFloatingWindow);
window5->SetProperty(aura::client::kZOrderingKey,
ui::ZOrderLevel::kFloatingWindow);
// Control z order and MRU order.
wm::ActivateWindow(window8.get());
wm::ActivateWindow(window7.get()); // Will be fullscreen.
wm::ActivateWindow(window6.get()); // Will be maximized.
wm::ActivateWindow(window5.get()); // AlwaysOnTop window.
wm::ActivateWindow(window4.get());
wm::ActivateWindow(window3.get()); // AlwaysOnTop window.
wm::ActivateWindow(window2.get()); // Will be fullscreen.
wm::ActivateWindow(window1.get());
EXPECT_FALSE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window6.get())->IsFullscreen());
EXPECT_FALSE(WindowState::Get(window7.get())->IsMaximized());
const WMEvent toggle_maximize_event(WM_EVENT_TOGGLE_MAXIMIZE);
WindowState::Get(window6.get())->OnWMEvent(&toggle_maximize_event);
const WMEvent toggle_fullscreen_event(WM_EVENT_TOGGLE_FULLSCREEN);
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
EXPECT_TRUE(WindowState::Get(window2.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window7.get())->IsFullscreen());
EXPECT_TRUE(WindowState::Get(window6.get())->IsMaximized());
// Case 1: Click on |window1| to activate it and exit overview.
std::unique_ptr<ui::ScopedAnimationDurationScaleMode> test_duration_mode =
std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
ToggleOverview();
// For entering animation, only animate |window1|, |window2|, |window3| and
// |window5| because |window3| and |window5| are AlwaysOnTop windows and
// |window2| is fullscreen.
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window3->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window4->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window5->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window6->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window7->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window8->layer()->GetAnimator()->is_animating());
base::RunLoop().RunUntilIdle();
// Click on |window1| to activate it and exit overview.
// Should animate |window1|, |window2|, |window3| and |window5| because
// |window3| and |window5| are AlwaysOnTop windows and |window2| is
// fullscreen.
ClickWindow(window1.get());
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window3->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window4->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window5->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window6->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window7->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window8->layer()->GetAnimator()->is_animating());
base::RunLoop().RunUntilIdle();
// Case 2: Click on |window3| to activate it and exit overview.
// Should animate |window1|, |window2|, |window3| and |window5|.
// Reset window z-order. Need to toggle fullscreen first to workaround
// https://crbug.com/816224.
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
wm::ActivateWindow(window8.get());
wm::ActivateWindow(window7.get()); // Will be fullscreen.
wm::ActivateWindow(window6.get()); // Maximized.
wm::ActivateWindow(window5.get()); // AlwaysOnTop window.
wm::ActivateWindow(window4.get());
wm::ActivateWindow(window3.get()); // AlwaysOnTop window.
wm::ActivateWindow(window2.get()); // Will be fullscreen.
wm::ActivateWindow(window1.get());
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
// Enter overview.
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
ToggleOverview();
base::RunLoop().RunUntilIdle();
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
ClickWindow(window3.get());
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window3->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window4->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window5->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window6->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window7->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window8->layer()->GetAnimator()->is_animating());
base::RunLoop().RunUntilIdle();
// Case 3: Click on maximized |window6| to activate it and exit overview.
// Should animate |window6|, |window3| and |window5| because |window3| and
// |window5| are AlwaysOnTop windows. |window6| is maximized.
// Reset window z-order. Need to toggle fullscreen first to workaround
// https://crbug.com/816224.
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
wm::ActivateWindow(window8.get());
wm::ActivateWindow(window7.get()); // Will be fullscreen.
wm::ActivateWindow(window6.get()); // Maximized.
wm::ActivateWindow(window5.get()); // AlwaysOnTop window.
wm::ActivateWindow(window4.get());
wm::ActivateWindow(window3.get()); // AlwaysOnTop window.
wm::ActivateWindow(window2.get()); // Will be fullscreen.
wm::ActivateWindow(window1.get());
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
// Enter overview.
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
ToggleOverview();
base::RunLoop().RunUntilIdle();
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
ClickWindow(window6.get());
EXPECT_FALSE(window1->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window3->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window4->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window5->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window6->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window7->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window8->layer()->GetAnimator()->is_animating());
base::RunLoop().RunUntilIdle();
// Case 4: Click on |window8| to activate it and exit overview.
// Should animate |window8|, |window1|, |window2|, |window3| and |window5|
// because |window3| and |window5| are AlwaysOnTop windows and |window2| is
// fullscreen.
// Reset window z-order. Need to toggle fullscreen first to workaround
// https://crbug.com/816224.
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
wm::ActivateWindow(window8.get());
wm::ActivateWindow(window7.get()); // Will be fullscreen.
wm::ActivateWindow(window6.get()); // Maximized.
wm::ActivateWindow(window5.get()); // AlwaysOnTop window.
wm::ActivateWindow(window4.get());
wm::ActivateWindow(window3.get()); // AlwaysOnTop window.
wm::ActivateWindow(window2.get()); // Will be fullscreen.
wm::ActivateWindow(window1.get());
WindowState::Get(window2.get())->OnWMEvent(&toggle_fullscreen_event);
WindowState::Get(window7.get())->OnWMEvent(&toggle_fullscreen_event);
// Enter overview.
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
ToggleOverview();
base::RunLoop().RunUntilIdle();
test_duration_mode = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
ClickWindow(window8.get());
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window3->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window4->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window5->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window6->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window7->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window8->layer()->GetAnimator()->is_animating());
base::RunLoop().RunUntilIdle();
}
// Verify that the selector item can animate after the item is dragged and
// released.
TEST_P(OverviewSessionTest, WindowItemCanAnimateOnDragRelease) {
base::HistogramTester histogram_tester;
UpdateDisplay("400x400");
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EnterTabletMode();
ToggleOverview();
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
// Drag |item2| in a way so that |window2| does not get activated.
ui::test::EventGenerator* generator = GetEventGenerator();
generator->MoveMouseTo(
gfx::ToRoundedPoint(item2->target_bounds().CenterPoint()));
generator->PressLeftButton();
base::RunLoop().RunUntilIdle();
generator->MoveMouseTo(gfx::Point(200, 200));
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 1);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 0);
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
generator->ReleaseLeftButton();
EXPECT_TRUE(window2->layer()->GetAnimator()->IsAnimatingProperty(
ui::LayerAnimationElement::AnimatableProperty::TRANSFORM));
base::RunLoop().RunUntilIdle();
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 1);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 1);
}
// Verify that the overview items titlebar and close button change visibility
// when a item is being dragged.
TEST_P(OverviewSessionTest, WindowItemTitleCloseVisibilityOnDrag) {
base::HistogramTester histogram_tester;
UpdateDisplay("400x400");
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EnterTabletMode();
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
// Start the drag on |item1|. Verify the dragged item, |item1| has both the
// close button and titlebar hidden. The close button opacity however is
// opaque as its a child of the header which handles fading away the whole
// header. All other items, |item2| should only have the close button hidden.
ui::test::EventGenerator* generator = GetEventGenerator();
generator->MoveMouseTo(
gfx::ToRoundedPoint(item1->target_bounds().CenterPoint()));
generator->PressLeftButton();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0.f, item1->GetTitlebarOpacityForTesting());
EXPECT_EQ(1.f, item1->GetCloseButtonVisibilityForTesting());
EXPECT_EQ(1.f, item2->GetTitlebarOpacityForTesting());
EXPECT_EQ(0.f, item2->GetCloseButtonVisibilityForTesting());
// Drag |item1| in a way so that |window1| does not get activated (drags
// within a certain threshold count as clicks). Verify the close button and
// titlebar is visible for all items.
generator->MoveMouseTo(gfx::Point(200, 200));
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 1);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 0);
generator->ReleaseLeftButton();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1.f, item1->GetTitlebarOpacityForTesting());
EXPECT_EQ(1.f, item1->GetCloseButtonVisibilityForTesting());
EXPECT_EQ(1.f, item2->GetTitlebarOpacityForTesting());
EXPECT_EQ(1.f, item2->GetCloseButtonVisibilityForTesting());
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 1);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 1);
}
// Tests that overview widgets are stacked in the correct order.
TEST_P(OverviewSessionTest, OverviewWidgetStackingOrder) {
base::HistogramTester histogram_tester;
// Create three windows, including one minimized.
std::unique_ptr<aura::Window> minimized(CreateTestWindow());
WindowState::Get(minimized.get())->Minimize();
std::unique_ptr<aura::Window> window(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
aura::Window* parent = window->parent();
EXPECT_EQ(parent, minimized->parent());
EnterTabletMode();
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(minimized.get());
OverviewItem* item2 = GetOverviewItemForWindow(window.get());
OverviewItem* item3 = GetOverviewItemForWindow(window3.get());
views::Widget* widget1 = item_widget(item1);
views::Widget* widget2 = item_widget(item2);
views::Widget* widget3 = item_widget(item3);
// The original order of stacking is determined by the order the associated
// window was activated.
EXPECT_GT(IndexOf(widget3->GetNativeWindow(), parent),
IndexOf(widget2->GetNativeWindow(), parent));
EXPECT_GT(IndexOf(widget2->GetNativeWindow(), parent),
IndexOf(widget1->GetNativeWindow(), parent));
// Verify that the item widget is stacked below the window.
EXPECT_LT(IndexOf(widget1->GetNativeWindow(), parent),
IndexOf(minimized.get(), parent));
EXPECT_LT(IndexOf(widget2->GetNativeWindow(), parent),
IndexOf(window.get(), parent));
EXPECT_LT(IndexOf(widget3->GetNativeWindow(), parent),
IndexOf(window3.get(), parent));
// Drag the first window. Verify that it's item widget is not stacked above
// the other two.
const gfx::Point start_drag =
gfx::ToRoundedPoint(item1->target_bounds().CenterPoint());
ui::test::EventGenerator* generator = GetEventGenerator();
generator->MoveMouseTo(start_drag);
generator->PressLeftButton();
EXPECT_GT(IndexOf(widget1->GetNativeWindow(), parent),
IndexOf(widget2->GetNativeWindow(), parent));
EXPECT_GT(IndexOf(widget1->GetNativeWindow(), parent),
IndexOf(widget3->GetNativeWindow(), parent));
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 0);
// Drag to origin and then back to the start to avoid activating the window or
// entering splitview.
generator->MoveMouseTo(gfx::Point());
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 1);
generator->MoveMouseTo(start_drag);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 2);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 0);
generator->ReleaseLeftButton();
// Verify the stacking order is same as before dragging started.
EXPECT_GT(IndexOf(widget3->GetNativeWindow(), parent),
IndexOf(widget2->GetNativeWindow(), parent));
EXPECT_GT(IndexOf(widget2->GetNativeWindow(), parent),
IndexOf(widget1->GetNativeWindow(), parent));
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.TabletMode", 2);
histogram_tester.ExpectTotalCount(
"Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode", 1);
}
// Test that dragging a window from the top creates a drop target stacked at the
// bottom. Test that dropping into overview removes the drop target.
TEST_P(OverviewSessionTest, DropTargetStackedAtBottomForWindowDraggedFromTop) {
UpdateDisplay("800x600");
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
window1->SetProperty(aura::client::kAppType,
static_cast<int>(AppType::BROWSER));
std::unique_ptr<aura::Window> window2(CreateTestWindow());
aura::Window* parent = window1->parent();
ASSERT_EQ(parent, window2->parent());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
std::unique_ptr<WindowResizer> resizer =
CreateWindowResizer(window1.get(), gfx::Point(400, 0), HTCAPTION,
::wm::WINDOW_MOVE_SOURCE_TOUCH);
ASSERT_TRUE(GetDropTarget(0));
EXPECT_LT(IndexOf(GetDropTarget(0)->GetWindow(), parent),
IndexOf(window2.get(), parent));
resizer->Drag(gfx::Point(400, 500), ui::EF_NONE);
resizer->CompleteDrag();
EXPECT_FALSE(GetDropTarget(0));
}
// Test that dragging an overview item to snap creates a drop target stacked at
// the bottom. Test that ending the drag removes the drop target.
TEST_P(OverviewSessionTest, DropTargetStackedAtBottomForOverviewItem) {
EnterTabletMode();
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
aura::Window* parent = window1->parent();
ASSERT_EQ(parent, window2->parent());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
ToggleOverview();
ui::test::EventGenerator* generator = GetEventGenerator();
generator->MoveMouseTo(gfx::ToRoundedPoint(
GetOverviewItemForWindow(window1.get())->target_bounds().CenterPoint()));
generator->PressLeftButton();
generator->MoveMouseBy(5, 0);
ASSERT_TRUE(GetDropTarget(0));
EXPECT_LT(IndexOf(GetDropTarget(0)->GetWindow(), parent),
IndexOf(window2.get(), parent));
generator->ReleaseLeftButton();
EXPECT_FALSE(GetDropTarget(0));
}
// Verify that a windows which enter overview mode have a visible backdrop, if
// the window is to be letter or pillar fitted.
TEST_P(OverviewSessionTest, Backdrop) {
// Add three windows which in overview mode will be considered wide, tall and
// normal. Window |wide|, with size (400, 160) will be resized to (300, 160)
// when the 400x300 is rotated to 300x400, and should be considered a normal
// overview window after display change.
UpdateDisplay("400x300");
std::unique_ptr<aura::Window> wide(CreateTestWindow(gfx::Rect(400, 160)));
std::unique_ptr<aura::Window> tall(CreateTestWindow(gfx::Rect(100, 300)));
std::unique_ptr<aura::Window> normal(CreateTestWindow(gfx::Rect(300, 300)));
ToggleOverview();
base::RunLoop().RunUntilIdle();
OverviewItem* wide_item = GetOverviewItemForWindow(wide.get());
OverviewItem* tall_item = GetOverviewItemForWindow(tall.get());
OverviewItem* normal_item = GetOverviewItemForWindow(normal.get());
// Only very tall and very wide windows will have a backdrop. The backdrop
// only gets created if we need it once during the overview session.
ASSERT_TRUE(GetBackdropView(wide_item));
EXPECT_TRUE(GetBackdropView(wide_item)->GetVisible());
EXPECT_TRUE(GetBackdropView(tall_item));
ASSERT_TRUE(GetBackdropView(tall_item)->GetVisible());
EXPECT_FALSE(GetBackdropView(normal_item));
display::Screen* screen = display::Screen::GetScreen();
const display::Display& display = screen->GetPrimaryDisplay();
display_manager()->SetDisplayRotation(
display.id(), display::Display::ROTATE_90,
display::Display::RotationSource::ACTIVE);
// After rotation the former wide window will be a normal window and its
// backdrop will still be there but invisible.
ASSERT_TRUE(GetBackdropView(wide_item));
EXPECT_FALSE(GetBackdropView(wide_item)->GetVisible());
EXPECT_TRUE(GetBackdropView(tall_item));
ASSERT_TRUE(GetBackdropView(tall_item)->GetVisible());
EXPECT_FALSE(GetBackdropView(normal_item));
// Test that leaving overview mode cleans up properly.
ToggleOverview();
}
class OverviewSessionRoundedCornerTest : public OverviewSessionTest {
public:
OverviewSessionRoundedCornerTest() = default;
~OverviewSessionRoundedCornerTest() override = default;
bool HasRoundedCorner(OverviewItem* item) {
const ui::Layer* layer = item->transform_window_.IsMinimized()
? GetPreviewView(item)->layer()
: transform_window(item).window()->layer();
return !layer->rounded_corner_radii().IsEmpty();
}
private:
DISALLOW_COPY_AND_ASSIGN(OverviewSessionRoundedCornerTest);
};
// Test that the mask that is applied to add rounded corners in overview mode
// is removed during animations.
// TODO(https://crbug.com/1000730): Re-enable this test.
TEST_P(OverviewSessionRoundedCornerTest, DISABLED_RoundedEdgeMaskVisibility) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Test that entering overview mode normally will disable all the masks until
// the animation is complete.
EnterTabletMode();
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
EXPECT_FALSE(HasRoundedCorner(item1));
EXPECT_FALSE(HasRoundedCorner(item2));
window1->layer()->GetAnimator()->StopAnimating();
window2->layer()->GetAnimator()->StopAnimating();
// Mask is set asynchronously.
EXPECT_FALSE(HasRoundedCorner(item1));
EXPECT_FALSE(HasRoundedCorner(item2));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(HasRoundedCorner(item1));
EXPECT_TRUE(HasRoundedCorner(item2));
// Tests that entering overview mode with all windows minimized (launcher
// button pressed) will still disable all the masks until the animation is
// complete.
ToggleOverview();
WindowState::Get(window1.get())->Minimize();
WindowState::Get(window2.get())->Minimize();
ToggleOverview();
item1 = GetOverviewItemForWindow(window1.get());
item2 = GetOverviewItemForWindow(window2.get());
EXPECT_FALSE(HasRoundedCorner(item1));
EXPECT_FALSE(HasRoundedCorner(item2));
item_widget(item1)
->GetNativeWindow()
->layer()
->GetAnimator()
->StopAnimating();
item_widget(item2)
->GetNativeWindow()
->layer()
->GetAnimator()
->StopAnimating();
EXPECT_FALSE(HasRoundedCorner(item1));
EXPECT_FALSE(HasRoundedCorner(item2));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(HasRoundedCorner(item1));
EXPECT_TRUE(HasRoundedCorner(item2));
// Test that leaving overview mode cleans up properly.
ToggleOverview();
}
// Test that the mask that is applied to add rounded corners in overview mode
// is removed during drags.
TEST_P(OverviewSessionRoundedCornerTest, ShadowVisibilityDragging) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
wm::ActivateWindow(window2.get());
wm::ActivateWindow(window1.get());
EnterTabletMode();
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
// Drag the first window. Verify that the shadow was removed for the first
// window but still exists for the second window as we do not make shadow
// for a dragged window.
const gfx::Point start_drag =
gfx::ToRoundedPoint(item1->target_bounds().CenterPoint());
ui::test::EventGenerator* generator = GetEventGenerator();
generator->MoveMouseTo(start_drag);
generator->PressLeftButton();
EXPECT_FALSE(window1->layer()->GetAnimator()->is_animating());
EXPECT_FALSE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(item1->GetShadowBoundsForTesting().IsEmpty());
EXPECT_FALSE(item2->GetShadowBoundsForTesting().IsEmpty());
// Drag to horizontally and then back to the start to avoid activating the
// window, drag to close or entering splitview. Verify that the shadow is
// invisible on both items during animation.
generator->MoveMouseTo(gfx::Point(0, start_drag.y()));
// The drop target window should be created with no shadow.
OverviewItem* drop_target_item = GetDropTarget(0);
ASSERT_TRUE(drop_target_item);
EXPECT_TRUE(drop_target_item->GetShadowBoundsForTesting().IsEmpty());
generator->MoveMouseTo(start_drag);
generator->ReleaseLeftButton();
EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
EXPECT_TRUE(item1->GetShadowBoundsForTesting().IsEmpty());
EXPECT_TRUE(item2->GetShadowBoundsForTesting().IsEmpty());
// Verify that the shadow is visble again after animation is finished.
window1->layer()->GetAnimator()->StopAnimating();
window2->layer()->GetAnimator()->StopAnimating();
EXPECT_FALSE(item1->GetShadowBoundsForTesting().IsEmpty());
EXPECT_FALSE(item2->GetShadowBoundsForTesting().IsEmpty());
}
// Tests that the shadows in overview mode are placed correctly.
TEST_P(OverviewSessionTest, ShadowBounds) {
// Helper function to check if the bounds of a shadow owned by |shadow_parent|
// is contained within the bounds of |widget|.
auto contains = [](views::Widget* widget, OverviewItem* shadow_parent) {
return gfx::Rect(widget->GetNativeWindow()->bounds().size())
.Contains(shadow_parent->GetShadowBoundsForTesting());
};
// Helper function which returns the ratio of the shadow owned by
// |shadow_parent| width and height.
auto shadow_ratio = [](OverviewItem* shadow_parent) {
gfx::RectF boundsf = gfx::RectF(shadow_parent->GetShadowBoundsForTesting());
return boundsf.width() / boundsf.height();
};
// Add three windows which in overview mode will be considered wide, tall and
// normal. Set top view insets to 0 so it is easy to check the ratios of the
// shadows match the ratios of the untransformed windows.
UpdateDisplay("400x400");
std::unique_ptr<aura::Window> wide(
CreateTestWindowInShellWithDelegate(nullptr, -1, gfx::Rect(400, 100)));
std::unique_ptr<aura::Window> tall(
CreateTestWindowInShellWithDelegate(nullptr, -1, gfx::Rect(100, 400)));
std::unique_ptr<aura::Window> normal(
CreateTestWindowInShellWithDelegate(nullptr, -1, gfx::Rect(200, 200)));
wide->SetProperty(aura::client::kTopViewInset, 0);
tall->SetProperty(aura::client::kTopViewInset, 0);
normal->SetProperty(aura::client::kTopViewInset, 0);
ToggleOverview();
base::RunLoop().RunUntilIdle();
OverviewItem* wide_item = GetOverviewItemForWindow(wide.get());
OverviewItem* tall_item = GetOverviewItemForWindow(tall.get());
OverviewItem* normal_item = GetOverviewItemForWindow(normal.get());
views::Widget* wide_widget = item_widget(wide_item);
views::Widget* tall_widget = item_widget(tall_item);
views::Widget* normal_widget = item_widget(normal_item);
OverviewGrid* grid = overview_session()->grid_list()[0].get();
// Verify all the shadows are within the bounds of their respective item
// widgets when the overview windows are positioned without animations.
SetGridBounds(grid, gfx::Rect(200, 400));
grid->PositionWindows(false);
EXPECT_TRUE(contains(wide_widget, wide_item));
EXPECT_TRUE(contains(tall_widget, tall_item));
EXPECT_TRUE(contains(normal_widget, normal_item));
// Verify the shadows preserve the ratios of the original windows.
EXPECT_NEAR(shadow_ratio(wide_item), 4.f, 0.01f);
EXPECT_NEAR(shadow_ratio(tall_item), 0.25f, 0.01f);
EXPECT_NEAR(shadow_ratio(normal_item), 1.f, 0.01f);
// Verify all the shadows are within the bounds of their respective item
// widgets when the overview windows are positioned with animations.
SetGridBounds(grid, gfx::Rect(200, 400));
grid->PositionWindows(true);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(contains(wide_widget, wide_item));
EXPECT_TRUE(contains(tall_widget, tall_item));
EXPECT_TRUE(contains(normal_widget, normal_item));
EXPECT_NEAR(shadow_ratio(wide_item), 4.f, 0.01f);
EXPECT_NEAR(shadow_ratio(tall_item), 0.25f, 0.01f);
EXPECT_NEAR(shadow_ratio(normal_item), 1.f, 0.01f);
// Test that leaving overview mode cleans up properly.
ToggleOverview();
}
// Verify that attempting to drag with a secondary finger works as expected.
TEST_P(OverviewSessionTest, DraggingWithTwoFingers) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
EnterTabletMode();
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
const gfx::RectF original_bounds1 = item1->target_bounds();
const gfx::RectF original_bounds2 = item2->target_bounds();
constexpr int kTouchId1 = 1;
constexpr int kTouchId2 = 2;
// Dispatches a long press event at the event generators current location.
// Long press is one way to start dragging in splitview.
auto dispatch_long_press = [this]() {
ui::GestureEventDetails event_details(ui::ET_GESTURE_LONG_PRESS);
const gfx::Point location = GetEventGenerator()->current_screen_location();
ui::GestureEvent long_press(location.x(), location.y(), 0,
ui::EventTimeForNow(), event_details);
GetEventGenerator()->Dispatch(&long_press);
};
// Verify that the bounds of the tapped window expand when touched.
ui::test::EventGenerator* generator = GetEventGenerator();
generator->set_current_screen_location(
gfx::ToRoundedPoint(original_bounds1.CenterPoint()));
generator->PressTouchId(kTouchId1);
dispatch_long_press();
EXPECT_GT(item1->target_bounds().width(), original_bounds1.width());
EXPECT_GT(item1->target_bounds().height(), original_bounds1.height());
// Verify that attempting to touch the second window with a second finger does
// nothing to the second window. The first window remains the window to be
// dragged.
generator->set_current_screen_location(
gfx::ToRoundedPoint(original_bounds2.CenterPoint()));
generator->PressTouchId(kTouchId2);
dispatch_long_press();
EXPECT_GT(item1->target_bounds().width(), original_bounds1.width());
EXPECT_GT(item1->target_bounds().height(), original_bounds1.height());
EXPECT_EQ(item2->target_bounds(), original_bounds2);
// Verify the first window moves on drag.
gfx::PointF last_center_point = item1->target_bounds().CenterPoint();
generator->MoveTouchIdBy(kTouchId1, 40, 40);
EXPECT_NE(last_center_point, item1->target_bounds().CenterPoint());
EXPECT_EQ(original_bounds2.CenterPoint(),
item2->target_bounds().CenterPoint());
// Verify the first window moves on drag, even if we switch to a second
// finger.
last_center_point = item1->target_bounds().CenterPoint();
generator->ReleaseTouchId(kTouchId2);
generator->PressTouchId(kTouchId2);
generator->MoveTouchIdBy(kTouchId2, 40, 40);
EXPECT_NE(last_center_point, item1->target_bounds().CenterPoint());
EXPECT_EQ(original_bounds2.CenterPoint(),
item2->target_bounds().CenterPoint());
}
// Verify that shadows on windows disappear for the duration of overview mode.
TEST_P(OverviewSessionTest, ShadowDisappearsInOverview) {
std::unique_ptr<aura::Window> window(CreateTestWindow());
// Verify that the shadow is initially visible.
::wm::ShadowController* shadow_controller = Shell::Get()->shadow_controller();
EXPECT_TRUE(shadow_controller->IsShadowVisibleForWindow(window.get()));
// Verify that the shadow is invisible after entering overview mode.
ToggleOverview();
EXPECT_FALSE(shadow_controller->IsShadowVisibleForWindow(window.get()));
// Verify that the shadow is visible again after exiting overview mode.
ToggleOverview();
EXPECT_TRUE(shadow_controller->IsShadowVisibleForWindow(window.get()));
}
// Verify that PIP windows will be excluded from the overview, but not hidden.
TEST_P(OverviewSessionTest, PipWindowShownButExcludedFromOverview) {
std::unique_ptr<aura::Window> pip_window(
CreateTestWindow(gfx::Rect(200, 200)));
WindowState* window_state = WindowState::Get(pip_window.get());
const WMEvent enter_pip(WM_EVENT_PIP);
window_state->OnWMEvent(&enter_pip);
// Enter overview.
ToggleOverview();
// PIP window should be visible but not in the overview.
EXPECT_TRUE(pip_window->IsVisible());
EXPECT_FALSE(HighlightOverviewWindow(pip_window.get()));
}
// Tests the PositionWindows function works as expected.
TEST_P(OverviewSessionTest, PositionWindows) {
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
ToggleOverview();
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
OverviewItem* item3 = GetOverviewItemForWindow(window3.get());
const gfx::RectF bounds1 = item1->target_bounds();
const gfx::RectF bounds2 = item2->target_bounds();
const gfx::RectF bounds3 = item3->target_bounds();
// Verify that the bounds remain the same when calling PositionWindows again.
overview_session()->PositionWindows(/*animate=*/false);
EXPECT_EQ(bounds1, item1->target_bounds());
EXPECT_EQ(bounds2, item2->target_bounds());
EXPECT_EQ(bounds3, item3->target_bounds());
// Verify that |item2| and |item3| change bounds when calling PositionWindows
// while ignoring |item1|.
overview_session()->PositionWindows(/*animate=*/false, {item1});
EXPECT_EQ(bounds1, item1->target_bounds());
EXPECT_NE(bounds2, item2->target_bounds());
EXPECT_NE(bounds3, item3->target_bounds());
// Return the windows to their original bounds.
overview_session()->PositionWindows(/*animate=*/false);
// Verify that items that are animating before closing are ignored by
// PositionWindows.
item1->set_animating_to_close(true);
item2->set_animating_to_close(true);
overview_session()->PositionWindows(/*animate=*/false);
EXPECT_EQ(bounds1, item1->target_bounds());
EXPECT_EQ(bounds2, item2->target_bounds());
EXPECT_NE(bounds3, item3->target_bounds());
}
// Tests that overview mode is entered with kWindowDragged mode when a window is
// dragged from the top of the screen. For the purposes of this test, we use a
// browser window.
TEST_P(OverviewSessionTest, DraggingFromTopAnimation) {
EnterTabletMode();
std::unique_ptr<views::Widget> widget(CreateTestWidget(
nullptr, desks_util::GetActiveDeskContainerId(), gfx::Rect(200, 200)));
widget->GetNativeWindow()->SetProperty(aura::client::kTopViewInset, 20);
// Drag from the the top of the app to enter overview.
ui::GestureEvent event(0, 0, 0, base::TimeTicks(),
ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN));
WindowState* window_state = WindowState::Get(widget->GetNativeWindow());
window_state->CreateDragDetails(event.location(), HTCAPTION,
::wm::WINDOW_MOVE_SOURCE_TOUCH);
auto drag_controller = std::make_unique<TabletModeWindowDragController>(
window_state, std::make_unique<TabletModeBrowserWindowDragDelegate>());
ui::Event::DispatcherApi dispatch_helper(&event);
dispatch_helper.set_target(widget->GetNativeWindow());
drag_controller->Drag(event.location(), event.flags());
ASSERT_TRUE(InOverviewSession());
EXPECT_EQ(OverviewSession::EnterExitOverviewType::kImmediateEnter,
overview_session()->enter_exit_overview_type());
}
// Tests the grid bounds are as expected with different shelf auto hide
// behaviors and alignments.
TEST_P(OverviewSessionTest, GridBounds) {
UpdateDisplay("600x600");
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(200, 200)));
Shelf* shelf = GetPrimaryShelf();
shelf->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
// Test that with the bottom shelf, the grid should take up the entire display
// minus the shelf area on the bottom regardless of auto hide behavior.
const int shelf_size = ShelfConfig::Get()->shelf_size();
ToggleOverview();
EXPECT_EQ(gfx::Rect(0, 0, 600, 600 - shelf_size), GetGridBounds());
ToggleOverview();
shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
ToggleOverview();
EXPECT_EQ(gfx::Rect(0, 0, 600, 600 - shelf_size), GetGridBounds());
ToggleOverview();
// Test that with the right shelf, the grid should take up the entire display
// minus the shelf area on the right regardless of auto hide behavior.
shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
ToggleOverview();
EXPECT_EQ(gfx::Rect(0, 0, 600 - shelf_size, 600), GetGridBounds());
ToggleOverview();
shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
ToggleOverview();
EXPECT_EQ(gfx::Rect(0, 0, 600 - shelf_size, 600), GetGridBounds());
ToggleOverview();
}
// Tests that windows that have a backdrop can still be tapped normally.
// Regression test for crbug.com/938645.
TEST_P(OverviewSessionTest, SelectingWindowWithBackdrop) {
std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(500, 200)));
ToggleOverview();
OverviewItem* item = GetOverviewItemForWindow(window.get());
ASSERT_EQ(ScopedOverviewTransformWindow::GridWindowFillMode::kLetterBoxed,
item->GetWindowDimensionsType());
// Tap the target.
GetEventGenerator()->set_current_screen_location(
gfx::ToRoundedPoint(item->target_bounds().CenterPoint()));
GetEventGenerator()->ClickLeftButton();
EXPECT_FALSE(InOverviewSession());
}
TEST_P(OverviewSessionTest, ShelfAlignmentChangeWhileInOverview) {
Shelf* shelf = GetPrimaryShelf();
shelf->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
ToggleOverview();
shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
EXPECT_FALSE(InOverviewSession());
}
// TODO(sammiequon): Merge this into SplitViewOverviewSessionTest and rename
// that to TabletModeOverviewSessionTest.
class OverviewSessionNewLayoutTest : public OverviewSessionTest {
public:
OverviewSessionNewLayoutTest() = default;
~OverviewSessionNewLayoutTest() override = default;
void SetUp() override {
scoped_feature_list_.InitAndEnableFeature(features::kNewOverviewLayout);
OverviewSessionTest::SetUp();
EnterTabletMode();
}
SplitViewController* split_view_controller() {
return SplitViewController::Get();
}
protected:
void GenerateScrollSequence(const gfx::Point& start, const gfx::Point& end) {
GetEventGenerator()->GestureScrollSequence(
start, end, base::TimeDelta::FromMilliseconds(100), 1000);
}
void DispatchLongPress(OverviewItem* item) {
ui::TouchEvent long_press(
ui::ET_GESTURE_LONG_PRESS,
gfx::ToRoundedPoint(item->target_bounds().CenterPoint()),
base::TimeTicks::Now(),
ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH));
GetEventGenerator()->Dispatch(&long_press);
}
// Creates |n| test windows. They are created in reverse order, so that the
// first window in the vector is the MRU window.
std::vector<std::unique_ptr<aura::Window>> CreateTestWindows(int n) {
std::vector<std::unique_ptr<aura::Window>> windows(n);
for (int i = n - 1; i >= 0; --i)
windows[i] = CreateTestWindow();
return windows;
}
private:
base::test::ScopedFeatureList scoped_feature_list_;
DISALLOW_COPY_AND_ASSIGN(OverviewSessionNewLayoutTest);
};
// Tests that windows are in proper positions in the new overview layout.
TEST_P(OverviewSessionNewLayoutTest, CheckNewLayoutWindowPositions) {
auto windows = CreateTestWindows(6);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* item1 = GetOverviewItemForWindow(windows[0].get());
OverviewItem* item2 = GetOverviewItemForWindow(windows[1].get());
OverviewItem* item3 = GetOverviewItemForWindow(windows[2].get());
OverviewItem* item4 = GetOverviewItemForWindow(windows[3].get());
const gfx::RectF item1_bounds = item1->target_bounds();
const gfx::RectF item2_bounds = item2->target_bounds();
const gfx::RectF item3_bounds = item3->target_bounds();
const gfx::RectF item4_bounds = item4->target_bounds();
// |window1| should be in the top left position. |window2| should be directly
// below |window1|, thus sharing the same x-value but not the same y-value.
EXPECT_EQ(item1_bounds.x(), item2_bounds.x());
EXPECT_LT(item1_bounds.y(), item2_bounds.y());
// |window3| should be directly right of |window1|, thus sharing the same
// y-value, but not the same x-value.
EXPECT_LT(item1_bounds.x(), item3_bounds.x());
EXPECT_EQ(item1_bounds.y(), item3_bounds.y());
// |window4| should be directly right of |window2| and directly below
// |window3|.
EXPECT_LT(item2_bounds.x(), item4_bounds.x());
EXPECT_EQ(item2_bounds.y(), item4_bounds.y());
EXPECT_EQ(item3_bounds.x(), item4_bounds.x());
EXPECT_LT(item3_bounds.y(), item4_bounds.y());
}
TEST_P(OverviewSessionNewLayoutTest, CheckOffscreenWindows) {
auto windows = CreateTestWindows(8);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* item0 = GetOverviewItemForWindow(windows[0].get());
OverviewItem* item1 = GetOverviewItemForWindow(windows[1].get());
OverviewItem* item6 = GetOverviewItemForWindow(windows[6].get());
OverviewItem* item7 = GetOverviewItemForWindow(windows[7].get());
const gfx::RectF screen_bounds(GetGridBounds());
const gfx::RectF item0_bounds = item0->target_bounds();
const gfx::RectF item1_bounds = item1->target_bounds();
const gfx::RectF item6_bounds = item6->target_bounds();
const gfx::RectF item7_bounds = item7->target_bounds();
// |item6| should be in the same row of windows as |item0|, but offscreen
// (one screen length away).
EXPECT_FALSE(screen_bounds.Contains(item6_bounds));
EXPECT_EQ(item0_bounds.y(), item6_bounds.y());
// |item7| should be in the same row of windows as |item1|, but offscreen
// and below |item6|.
EXPECT_FALSE(screen_bounds.Contains(item7_bounds));
EXPECT_EQ(item1_bounds.y(), item7_bounds.y());
EXPECT_LT(item6_bounds.y(), item7_bounds.y());
}
// Tests to see if windows are not shifted if all already available windows
// fit on screen.
TEST_P(OverviewSessionNewLayoutTest, CheckNoOverviewItemShift) {
auto windows = CreateTestWindows(4);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* item0 = GetOverviewItemForWindow(windows[0].get());
const gfx::RectF before_shift_bounds = item0->target_bounds();
GenerateScrollSequence(gfx::Point(100, 50), gfx::Point(0, 50));
EXPECT_EQ(before_shift_bounds, item0->target_bounds());
}
// Tests to see if windows are shifted if at least one window is
// partially/completely positioned offscreen.
TEST_P(OverviewSessionNewLayoutTest, CheckOverviewItemShift) {
auto windows = CreateTestWindows(7);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* item0 = GetOverviewItemForWindow(windows[0].get());
const gfx::RectF before_shift_bounds = item0->target_bounds();
GenerateScrollSequence(gfx::Point(100, 50), gfx::Point(0, 50));
EXPECT_LT(item0->target_bounds(), before_shift_bounds);
}
// Tests to see if windows remain in bounds after scrolling extremely far.
TEST_P(OverviewSessionNewLayoutTest, CheckOverviewItemScrollingBounds) {
auto windows = CreateTestWindows(8);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// Scroll an extreme amount to see if windows on the far left are still in
// bounds. First, align the left-most window (|windows[0]|) to the left-hand
// bound and store the item's location. Then, scroll a far amount and check to
// see if the item moved at all.
OverviewItem* leftmost_window = GetOverviewItemForWindow(windows[0].get());
GenerateScrollSequence(gfx::Point(0, 50), gfx::Point(5000, 50));
const gfx::RectF left_bounds = leftmost_window->target_bounds();
GenerateScrollSequence(gfx::Point(0, 50), gfx::Point(5000, 50));
EXPECT_EQ(left_bounds, leftmost_window->target_bounds());
// Scroll an extreme amount to see if windows on the far right are still in
// bounds. First, align the right-most window (|windows[7]|) to the right-hand
// bound and store the item's location. Then, scroll a far amount and check to
// see if the item moved at all.
OverviewItem* rightmost_window = GetOverviewItemForWindow(windows[7].get());
GenerateScrollSequence(gfx::Point(5000, 50), gfx::Point(0, 50));
const gfx::RectF right_bounds = rightmost_window->target_bounds();
GenerateScrollSequence(gfx::Point(5000, 50), gfx::Point(0, 50));
EXPECT_EQ(right_bounds, rightmost_window->target_bounds());
}
// Tests the windows are stacked correctly when entering or exiting splitview
// while the new overivew layout is enabled.
TEST_P(OverviewSessionNewLayoutTest, StackingOrderSplitviewWindow) {
std::unique_ptr<aura::Window> window1 = CreateTestWindow();
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// Snap |window1| to the left and exit overview. |window2| should have higher
// z-order now, since it is the MRU window.
split_view_controller()->SnapWindow(window1.get(), SplitViewController::LEFT);
ToggleOverview();
ASSERT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
ASSERT_GT(IndexOf(window2.get(), window2->parent()),
IndexOf(window1.get(), window1->parent()));
// Test that on entering overview, |window2| is of a lower z-order, so that
// when we scroll the grid, it will be seen under |window1|.
ToggleOverview();
EXPECT_LT(IndexOf(window2.get(), window2->parent()),
IndexOf(window1.get(), window1->parent()));
// Test that on exiting overview, |window2| becomes activated, so it returns
// to being higher on the z-order than |window1|.
ToggleOverview();
EXPECT_GT(IndexOf(window2.get(), window2->parent()),
IndexOf(window1.get(), window1->parent()));
}
// Test that scrolling occurs if started on top of a window using the window's
// center-point as a start.
TEST_P(OverviewSessionNewLayoutTest, HorizontalScrollingOnOverviewItem) {
auto windows = CreateTestWindows(8);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* leftmost_window = GetOverviewItemForWindow(windows[0].get());
const gfx::Point topleft_window_center =
gfx::ToRoundedPoint(leftmost_window->target_bounds().CenterPoint());
const gfx::RectF left_bounds = leftmost_window->target_bounds();
GenerateScrollSequence(topleft_window_center, gfx::Point(-500, 50));
EXPECT_LT(leftmost_window->target_bounds(), left_bounds);
}
// A unique test class for testing flings in overview as those rely on observing
// compositor animations which require a mock time task environment.
class OverviewSessionNewLayoutFlingTest : public AshTestBase {
public:
OverviewSessionNewLayoutFlingTest()
: AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
~OverviewSessionNewLayoutFlingTest() override = default;
// AshTestBase:
void SetUp() override {
scoped_feature_list_.InitAndEnableFeature(features::kNewOverviewLayout);
AshTestBase::SetUp();
// Overview flinging is only available in tablet mode.
base::RunLoop().RunUntilIdle();
TabletModeControllerTestApi().EnterTabletMode();
base::RunLoop().RunUntilIdle();
}
private:
base::test::ScopedFeatureList scoped_feature_list_;
DISALLOW_COPY_AND_ASSIGN(OverviewSessionNewLayoutFlingTest);
};
TEST_F(OverviewSessionNewLayoutFlingTest, BasicFling) {
std::vector<std::unique_ptr<aura::Window>> windows(16);
for (int i = 15; i >= 0; --i)
windows[i] = CreateTestWindow();
ToggleOverview();
OverviewGrid* grid = GetOverviewSession()->grid_list()[0].get();
OverviewGridEventHandler* grid_event_handler = grid->grid_event_handler();
OverviewItem* item = GetOverviewItemForWindow(windows[2].get());
const gfx::Point item_center =
gfx::ToRoundedPoint(item->target_bounds().CenterPoint());
// Create a scroll sequence which results in a fling.
const gfx::Vector2d shift(-200, 0);
GetEventGenerator()->GestureScrollSequence(
item_center, item_center + shift, base::TimeDelta::FromMilliseconds(10),
10);
ui::DrawWaiterForTest::WaitForCompositingStarted(
windows[0]->GetRootWindow()->layer()->GetCompositor());
ASSERT_TRUE(grid_event_handler->IsFlingInProgressForTesting());
// Test that the scroll offset decreases as we advance the clock. Check the
// scroll offset instead of the item bounds as there is an optimization which
// does not update the item bounds of invisible elements. On some iterations,
// there may not be enough time passed to decay the velocity so the scroll
// offset will not change, but the overall change should be substantial.
constexpr int kMaxLoops = 10;
const float initial_scroll_offset = grid->scroll_offset();
float previous_scroll_offset = initial_scroll_offset;
for (int i = 0;
i < kMaxLoops && grid_event_handler->IsFlingInProgressForTesting();
++i) {
task_environment_->FastForwardBy(base::TimeDelta::FromMilliseconds(50));
float scroll_offset = grid->scroll_offset();
EXPECT_LE(scroll_offset, previous_scroll_offset);
previous_scroll_offset = scroll_offset;
}
EXPECT_LT(grid->scroll_offset(), initial_scroll_offset - 100.f);
}
// Tests that a vertical scroll sequence will close the window it is scrolled
// on.
TEST_P(OverviewSessionNewLayoutTest, VerticalScrollingOnOverviewItem) {
constexpr int kNumWidgets = 8;
std::vector<std::unique_ptr<views::Widget>> widgets(kNumWidgets);
for (int i = kNumWidgets - 1; i >= 0; --i)
widgets[i] = CreateTestWidget();
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* leftmost_window =
GetOverviewItemForWindow(widgets[0]->GetNativeWindow());
const gfx::Point topleft_window_center =
gfx::ToRoundedPoint(leftmost_window->target_bounds().CenterPoint());
const gfx::Point end_point = topleft_window_center - gfx::Vector2d(0, 300);
GenerateScrollSequence(topleft_window_center, end_point);
EXPECT_TRUE(widgets[0]->IsClosed());
}
// Test that scrolling occurs if we hit the associated keyboard shortcut.
TEST_P(OverviewSessionNewLayoutTest, CheckScrollingWithKeyboardShortcut) {
auto windows = CreateTestWindows(8);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
OverviewItem* leftmost_window = GetOverviewItemForWindow(windows[0].get());
const gfx::RectF left_bounds = leftmost_window->target_bounds();
SendKey(ui::VKEY_RIGHT, ui::EF_CONTROL_DOWN);
EXPECT_LT(leftmost_window->target_bounds(), left_bounds);
}
// Test that tapping a window in overview closes overview mode.
TEST_P(OverviewSessionNewLayoutTest, CheckWindowActivateOnTap) {
base::UserActionTester user_action_tester;
auto windows = CreateTestWindows(8);
wm::ActivateWindow(windows[1].get());
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// Tap on |windows[1]| to exit overview.
GetEventGenerator()->GestureTapAt(
GetTransformedTargetBounds(windows[1].get()).CenterPoint());
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
// |windows[1]| remains active. Click on it to exit overview.
ASSERT_EQ(windows[1].get(), window_util::GetFocusedWindow());
ToggleOverview();
ClickWindow(windows[1].get());
EXPECT_EQ(
0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
}
// Tests that windows snap through long press and drag to left or right side of
// the screen.
TEST_P(OverviewSessionNewLayoutTest, DragOverviewWindowToSnap) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateTestWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateTestWindow(bounds));
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
ASSERT_FALSE(split_view_controller()->InSplitViewMode());
// Dispatches a long press event at the |overview_item1|'s current location to
// start dragging in SplitView. Drags |overview_item1| to the left border of
// the screen. SplitView should trigger and upon completing drag,
// |overview_item1| should snap to the left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
const gfx::PointF snap_left_location =
gfx::PointF(GetGridBounds().left_center());
DispatchLongPress(overview_item1);
overview_session()->Drag(
overview_item1,
gfx::PointF(overview_item1->target_bounds().left_center()));
overview_session()->CompleteDrag(overview_item1, snap_left_location);
ASSERT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
// Dispatches a long press event at the |overview_item2|'s current location to
// start dragging in SplitView. Drags |overview_item2| to the right border of
// the screen. Upon completing drag, |overview_item2| should snap to the
// right.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
const gfx::PointF snap_right_location =
gfx::PointF(GetGridBounds().right_center());
DispatchLongPress(overview_item2);
overview_session()->Drag(
overview_item2,
gfx::PointF(overview_item2->target_bounds().right_center()));
overview_session()->CompleteDrag(overview_item2, snap_right_location);
EXPECT_FALSE(InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window2.get());
}
// Test the split view and overview functionalities in tablet mode.
class SplitViewOverviewSessionTest : public OverviewSessionTest {
public:
SplitViewOverviewSessionTest() = default;
~SplitViewOverviewSessionTest() override = default;
enum class SelectorItemLocation {
CENTER,
ORIGIN,
TOP_RIGHT,
BOTTOM_RIGHT,
BOTTOM_LEFT,
};
void SetUp() override {
OverviewSessionTest::SetUp();
EnterTabletMode();
}
SplitViewController* split_view_controller() {
return SplitViewController::Get();
}
bool IsDividerAnimating() {
return split_view_controller()->IsDividerAnimating();
}
void SkipDividerSnapAnimation() {
if (!IsDividerAnimating())
return;
split_view_controller()->StopAndShoveAnimatedDivider();
split_view_controller()->EndResizeImpl();
split_view_controller()->EndSplitViewAfterResizingIfAppropriate();
}
void EndSplitView() { split_view_controller()->EndSplitView(); }
protected:
aura::Window* CreateWindow(const gfx::Rect& bounds) {
aura::Window* window = CreateTestWindowInShellWithDelegate(
new SplitViewTestWindowDelegate, -1, bounds);
return window;
}
aura::Window* CreateWindowWithMinimumSize(const gfx::Rect& bounds,
const gfx::Size& size) {
SplitViewTestWindowDelegate* delegate = new SplitViewTestWindowDelegate();
aura::Window* window =
CreateTestWindowInShellWithDelegate(delegate, -1, bounds);
delegate->set_minimum_size(size);
return window;
}
gfx::Rect GetSplitViewLeftWindowBounds(aura::Window* window) {
return split_view_controller()->GetSnappedWindowBoundsInScreen(
window, SplitViewController::LEFT);
}
gfx::Rect GetSplitViewRightWindowBounds(aura::Window* window) {
return split_view_controller()->GetSnappedWindowBoundsInScreen(
window, SplitViewController::RIGHT);
}
gfx::Rect GetSplitViewDividerBounds(bool is_dragging) {
if (!split_view_controller()->InSplitViewMode())
return gfx::Rect();
return split_view_controller()
->split_view_divider_->GetDividerBoundsInScreen(is_dragging);
}
gfx::Rect GetWorkAreaInScreen(aura::Window* window) {
return screen_util::GetDisplayWorkAreaBoundsInScreenForActiveDeskContainer(
window);
}
// Drags a overview item |item| from its center or one of its corners
// to |end_location|. This should be used over
// DragWindowTo(OverviewItem*, gfx::Point) when testing snapping a
// window, but the windows centerpoint may be inside a snap region, thus the
// window will not snapped. This function is mostly used to test splitview so
// |long_press| is default to true. Set |long_press| to false if we do not
// want to long press after every press, which enables dragging vertically to
// close an item.
void DragWindowTo(OverviewItem* item,
const gfx::PointF& end_location,
SelectorItemLocation location,
bool long_press = true) {
gfx::PointF start_location;
switch (location) {
case SelectorItemLocation::CENTER:
start_location = item->target_bounds().CenterPoint();
break;
case SelectorItemLocation::ORIGIN:
start_location = item->target_bounds().origin();
break;
case SelectorItemLocation::TOP_RIGHT:
start_location = item->target_bounds().top_right();
break;
case SelectorItemLocation::BOTTOM_RIGHT:
start_location = item->target_bounds().bottom_right();
break;
case SelectorItemLocation::BOTTOM_LEFT:
start_location = item->target_bounds().bottom_left();
break;
default:
NOTREACHED();
break;
}
overview_session()->InitiateDrag(item, start_location,
/*is_touch_dragging=*/true);
if (long_press)
overview_session()->StartNormalDragMode(start_location);
overview_session()->Drag(item, end_location);
overview_session()->CompleteDrag(item, end_location);
}
// Drags a overview item |item| from its center point to |end_location|.
void DragWindowTo(OverviewItem* item, const gfx::PointF& end_location) {
DragWindowTo(item, end_location, SelectorItemLocation::CENTER, true);
}
// Creates a window which cannot be snapped by splitview.
std::unique_ptr<aura::Window> CreateUnsnappableWindow(
const gfx::Rect& bounds = gfx::Rect()) {
std::unique_ptr<aura::Window> window = CreateTestWindow();
window->SetProperty(aura::client::kResizeBehaviorKey,
aura::client::kResizeBehaviorNone);
return window;
}
private:
class SplitViewTestWindowDelegate : public aura::test::TestWindowDelegate {
public:
SplitViewTestWindowDelegate() = default;
~SplitViewTestWindowDelegate() override = default;
// aura::test::TestWindowDelegate:
void OnWindowDestroying(aura::Window* window) override { window->Hide(); }
void OnWindowDestroyed(aura::Window* window) override { delete this; }
};
DISALLOW_COPY_AND_ASSIGN(SplitViewOverviewSessionTest);
};
// Tests that dragging an overview item to the edge of the screen snaps the
// window. If two windows are snapped to left and right side of the screen, exit
// the overview mode.
TEST_P(SplitViewOverviewSessionTest, DragOverviewWindowToSnap) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
// Drag |window2| selector item to attempt to snap to left. Since there is
// already one left snapped window |window1|, |window1| will be put in
// overview mode.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
DragWindowTo(overview_item2, gfx::PointF(0, 0));
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window2.get());
EXPECT_TRUE(overview_controller()->overview_session()->IsWindowInOverview(
window1.get()));
// Drag |window3| selector item to snap to right.
OverviewItem* overview_item3 = GetOverviewItemForWindow(window3.get());
const gfx::PointF end_location3(GetWorkAreaInScreen(window3.get()).width(),
0.f);
DragWindowTo(overview_item3, end_location3);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window3.get());
EXPECT_FALSE(overview_controller()->InOverviewSession());
}
// Verify the correct behavior when dragging windows in overview mode.
TEST_P(SplitViewOverviewSessionTest, OverviewDragControllerBehavior) {
// TODO(sammiequon): Make this work once this feature is enabled by default
// for good.
if (base::FeatureList::IsEnabled(features::kNewOverviewLayout))
return;
aura::Env::GetInstance()->set_throttle_input_on_resize_for_testing(false);
std::unique_ptr<aura::Window> window1 = CreateTestWindow();
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* window_item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* window_item2 = GetOverviewItemForWindow(window2.get());
// Verify that if a drag is orginally horizontal, the drag behavior is drag to
// snap.
using DragBehavior = OverviewWindowDragController::DragBehavior;
ui::test::EventGenerator* generator = GetEventGenerator();
generator->set_current_screen_location(
gfx::ToRoundedPoint(window_item1->target_bounds().CenterPoint()));
generator->PressTouch();
OverviewWindowDragController* drag_controller =
overview_session()->window_drag_controller();
EXPECT_EQ(DragBehavior::kUndefined, drag_controller->current_drag_behavior());
generator->MoveTouchBy(20, 0);
EXPECT_EQ(DragBehavior::kNormalDrag,
drag_controller->current_drag_behavior());
generator->ReleaseTouch();
EXPECT_EQ(DragBehavior::kNoDrag, drag_controller->current_drag_behavior());
// Verify that if a drag is orginally vertical, the drag behavior is drag to
// close.
generator->set_current_screen_location(
gfx::ToRoundedPoint(window_item2->target_bounds().CenterPoint()));
generator->PressTouch();
drag_controller = overview_session()->window_drag_controller();
EXPECT_EQ(DragBehavior::kUndefined, drag_controller->current_drag_behavior());
// Use small increments otherwise a fling event will be fired.
for (int j = 0; j < 20; ++j)
generator->MoveTouchBy(0, 1);
EXPECT_EQ(DragBehavior::kDragToClose,
drag_controller->current_drag_behavior());
}
// Verify that if the window item has been dragged enough vertically, the window
// will be closed.
TEST_P(SplitViewOverviewSessionTest, DragToClose) {
// This test requires a widget.
std::unique_ptr<views::Widget> widget(CreateTestWidget());
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* item = GetOverviewItemForWindow(widget->GetNativeWindow());
const gfx::PointF start = item->target_bounds().CenterPoint();
ASSERT_TRUE(item);
// This drag has not covered enough distance, so the widget is not closed and
// we remain in overview mode.
overview_session()->InitiateDrag(item, start, /*is_touch_dragging=*/true);
overview_session()->Drag(item, start + gfx::Vector2dF(0, 80));
overview_session()->CompleteDrag(item, start + gfx::Vector2dF(0, 80));
ASSERT_TRUE(overview_session());
// Verify that the second drag has enough vertical distance, so the widget
// will be closed and overview mode will be exited.
overview_session()->InitiateDrag(item, start, /*is_touch_dragging=*/true);
overview_session()->Drag(item, start + gfx::Vector2dF(0, 180));
overview_session()->CompleteDrag(item, start + gfx::Vector2dF(0, 180));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(overview_session());
EXPECT_TRUE(widget->IsClosed());
}
// Verify that if the window item has been flung enough vertically, the window
// will be closed.
TEST_P(SplitViewOverviewSessionTest, FlingToClose) {
// This test requires a widget.
std::unique_ptr<views::Widget> widget(CreateTestWidget());
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
EXPECT_EQ(1u, overview_session()->grid_list()[0]->size());
OverviewItem* item = GetOverviewItemForWindow(widget->GetNativeWindow());
const gfx::PointF start = item->target_bounds().CenterPoint();
ASSERT_TRUE(item);
// Verify that items flung horizontally do not close the item.
overview_session()->InitiateDrag(item, start, /*is_touch_dragging=*/true);
overview_session()->Drag(item, start + gfx::Vector2dF(0, 50));
overview_session()->Fling(item, start, 2500, 0);
ASSERT_TRUE(overview_session());
// Verify that items flung vertically but without enough velocity do not
// close the item.
overview_session()->InitiateDrag(item, start, /*is_touch_dragging=*/true);
overview_session()->Drag(item, start + gfx::Vector2dF(0, 50));
overview_session()->Fling(item, start, 0, 1500);
ASSERT_TRUE(overview_session());
// Verify that flinging the item closes it, and since it is the last item in
// overview mode, overview mode is exited.
overview_session()->InitiateDrag(item, start, /*is_touch_dragging=*/true);
overview_session()->Drag(item, start + gfx::Vector2dF(0, 50));
overview_session()->Fling(item, start, 0, 2500);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(overview_session());
EXPECT_TRUE(widget->IsClosed());
}
// Tests that nudging occurs in the most basic case, which is we have one row
// and one item which is about to be deleted by dragging. If the item is deleted
// we still only have one row, so the other items should nudge while the item is
// being dragged.
TEST_P(SplitViewOverviewSessionTest, BasicNudging) {
// Set up three equal windows, which take up one row on the overview grid.
// When one of them is deleted we are still left with all the windows on one
// row.
std::unique_ptr<aura::Window> window1 = CreateTestWindow();
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
std::unique_ptr<aura::Window> window3 = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
OverviewItem* item3 = GetOverviewItemForWindow(window3.get());
const gfx::RectF item1_bounds = item1->target_bounds();
const gfx::RectF item2_bounds = item2->target_bounds();
const gfx::RectF item3_bounds = item3->target_bounds();
// Drag |item1| vertically. |item2| and |item3| bounds should change as they
// should be nudging towards their final bounds.
overview_session()->InitiateDrag(item1, item1_bounds.CenterPoint(),
/*is_touch_dragging=*/true);
overview_session()->Drag(item1,
item1_bounds.CenterPoint() + gfx::Vector2dF(0, 160));
EXPECT_NE(item2_bounds, item2->target_bounds());
EXPECT_NE(item3_bounds, item3->target_bounds());
// Drag |item1| back to its start drag location and release, so that it does
// not get deleted.
overview_session()->Drag(item1, item1_bounds.CenterPoint());
overview_session()->CompleteDrag(item1, item1_bounds.CenterPoint());
// Drag |item3| vertically. |item1| and |item2| bounds should change as they
// should be nudging towards their final bounds.
overview_session()->InitiateDrag(item3, item3_bounds.CenterPoint(),
/*is_touch_dragging=*/true);
overview_session()->Drag(item3,
item3_bounds.CenterPoint() + gfx::Vector2dF(0, 160));
EXPECT_NE(item1_bounds, item1->target_bounds());
EXPECT_NE(item2_bounds, item2->target_bounds());
}
// Tests that no nudging occurs when the number of rows in overview mode change
// if the item to be deleted results in the overview grid to change number of
// rows.
TEST_P(SplitViewOverviewSessionTest, NoNudgingWhenNumRowsChange) {
// Set up four equal windows, which would split into two rows in overview
// mode. Removing one window would leave us with three windows, which only
// takes a single row in overview.
std::unique_ptr<aura::Window> window1 = CreateTestWindow();
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
std::unique_ptr<aura::Window> window3 = CreateTestWindow();
std::unique_ptr<aura::Window> window4 = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* item1 = GetOverviewItemForWindow(window1.get());
OverviewItem* item2 = GetOverviewItemForWindow(window2.get());
OverviewItem* item3 = GetOverviewItemForWindow(window3.get());
OverviewItem* item4 = GetOverviewItemForWindow(window4.get());
const gfx::RectF item1_bounds = item1->target_bounds();
const gfx::RectF item2_bounds = item2->target_bounds();
const gfx::RectF item3_bounds = item3->target_bounds();
const gfx::RectF item4_bounds = item4->target_bounds();
// Drag |item1| past the drag to swipe threshold. None of the other window
// bounds should change, as none of them should be nudged.
overview_session()->InitiateDrag(item1, item1_bounds.CenterPoint(),
/*is_touch_dragging=*/true);
overview_session()->Drag(item1,
item1_bounds.CenterPoint() + gfx::Vector2dF(0, 160));
EXPECT_EQ(item2_bounds, item2->target_bounds());
EXPECT_EQ(item3_bounds, item3->target_bounds());
EXPECT_EQ(item4_bounds, item4->target_bounds());
}
// Tests that no nudging occurs when the item to be deleted results in an item
// from the previous row to drop down to the current row, thus causing the items
// to the right of the item to be shifted right, which is visually unacceptable.
TEST_P(SplitViewOverviewSessionTest, NoNudgingWhenLastItemOnPreviousRowDrops) {
// Set up five equal windows, which would split into two rows in overview
// mode. Removing one window would cause the rows to rearrange, with the third
// item dropping down from the first row to the second row. Create the windows
// backward so the the window indexs match the order seen in overview, as
// overview windows are ordered by MRU.
const int kWindows = 5;
std::unique_ptr<aura::Window> windows[kWindows];
for (int i = kWindows - 1; i >= 0; --i)
windows[i] = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* items[kWindows];
gfx::RectF item_bounds[kWindows];
for (int i = 0; i < kWindows; ++i) {
items[i] = GetOverviewItemForWindow(windows[i].get());
item_bounds[i] = items[i]->target_bounds();
}
// Drag the forth item past the drag to swipe threshold. None of the other
// window bounds should change, as none of them should be nudged, because
// deleting the fourth item will cause the third item to drop down from the
// first row to the second.
overview_session()->InitiateDrag(items[3], item_bounds[3].CenterPoint(),
/*is_touch_dragging=*/true);
overview_session()->Drag(
items[3], item_bounds[3].CenterPoint() + gfx::Vector2dF(0, 160));
EXPECT_EQ(item_bounds[0], items[0]->target_bounds());
EXPECT_EQ(item_bounds[1], items[1]->target_bounds());
EXPECT_EQ(item_bounds[2], items[2]->target_bounds());
EXPECT_EQ(item_bounds[4], items[4]->target_bounds());
// Drag the fourth item back to its start drag location and release, so that
// it does not get deleted.
overview_session()->Drag(items[3], item_bounds[3].CenterPoint());
overview_session()->CompleteDrag(items[3], item_bounds[3].CenterPoint());
// Drag the first item past the drag to swipe threshold. The second and third
// items should nudge as expected as there is no item dropping down to their
// row. The fourth and fifth items should not nudge as they are in a different
// row than the first item.
overview_session()->InitiateDrag(items[0], item_bounds[0].CenterPoint(),
/*is_touch_dragging=*/true);
overview_session()->Drag(
items[0], item_bounds[0].CenterPoint() + gfx::Vector2dF(0, 160));
EXPECT_NE(item_bounds[1], items[1]->target_bounds());
EXPECT_NE(item_bounds[2], items[2]->target_bounds());
EXPECT_EQ(item_bounds[3], items[3]->target_bounds());
EXPECT_EQ(item_bounds[4], items[4]->target_bounds());
}
// Verify the window grid size changes as expected when dragging items around in
// overview mode when split view is enabled.
TEST_P(SplitViewOverviewSessionTest,
OverviewGridSizeWhileDraggingWithSplitView) {
// Add three windows and enter overview mode.
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> window3(CreateTestWindow());
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
// Select window one and start the drag.
const int window_width =
Shell::Get()->GetPrimaryRootWindow()->GetBoundsInScreen().width();
OverviewItem* overview_item = GetOverviewItemForWindow(window1.get());
gfx::RectF overview_item_bounds = overview_item->target_bounds();
gfx::PointF start_location(overview_item_bounds.CenterPoint());
overview_session()->InitiateDrag(overview_item, start_location,
/*is_touch_dragging=*/false);
// Verify that when dragged to the left, the window grid is located where the
// right window of split view mode should be.
const gfx::PointF left(0, 0);
overview_session()->Drag(overview_item, left);
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(SplitViewController::State::kNoSnap,
split_view_controller()->state());
EXPECT_TRUE(split_view_controller()->left_window() == nullptr);
EXPECT_EQ(GetSplitViewRightWindowBounds(window1.get()), GetGridBounds());
// Verify that when dragged to the right, the window grid is located where the
// left window of split view mode should be.
const gfx::PointF right(window_width, 0);
overview_session()->Drag(overview_item, right);
EXPECT_EQ(SplitViewController::State::kNoSnap,
split_view_controller()->state());
EXPECT_TRUE(split_view_controller()->right_window() == nullptr);
EXPECT_EQ(GetSplitViewLeftWindowBounds(window1.get()), GetGridBounds());
// Verify that when dragged to the center, the window grid is has the
// dimensions of the work area.
const gfx::PointF center(window_width / 2, 0);
overview_session()->Drag(overview_item, center);
EXPECT_EQ(SplitViewController::State::kNoSnap,
split_view_controller()->state());
EXPECT_EQ(GetWorkAreaInScreen(window1.get()), GetGridBounds());
// Snap window1 to the left and initialize dragging for window2.
overview_session()->Drag(overview_item, left);
overview_session()->CompleteDrag(overview_item, left);
ASSERT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
ASSERT_EQ(window1.get(), split_view_controller()->left_window());
overview_item = GetOverviewItemForWindow(window2.get());
overview_item_bounds = overview_item->target_bounds();
start_location = overview_item_bounds.CenterPoint();
overview_session()->InitiateDrag(overview_item, start_location,
/*is_touch_dragging=*/false);
// Verify that when there is a snapped window, the window grid bounds remain
// constant despite overview items being dragged left and right.
overview_session()->Drag(overview_item, left);
EXPECT_EQ(GetSplitViewRightWindowBounds(window1.get()), GetGridBounds());
overview_session()->Drag(overview_item, right);
EXPECT_EQ(GetSplitViewRightWindowBounds(window1.get()), GetGridBounds());
overview_session()->Drag(overview_item, center);
EXPECT_EQ(GetSplitViewRightWindowBounds(window1.get()), GetGridBounds());
}
// Tests dragging a unsnappable window.
TEST_P(SplitViewOverviewSessionTest, DraggingUnsnappableAppWithSplitView) {
std::unique_ptr<aura::Window> unsnappable_window = CreateUnsnappableWindow();
// The grid bounds should be the size of the root window minus the shelf.
const gfx::Rect root_window_bounds =
Shell::Get()->GetPrimaryRootWindow()->GetBoundsInScreen();
const gfx::Rect shelf_bounds =
Shelf::ForWindow(Shell::Get()->GetPrimaryRootWindow())->GetIdealBounds();
const gfx::Rect expected_grid_bounds =
SubtractRects(root_window_bounds, shelf_bounds);
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
// Verify that after dragging the unsnappable window to the left and right,
// the window grid bounds do not change.
OverviewItem* overview_item =
GetOverviewItemForWindow(unsnappable_window.get());
overview_session()->InitiateDrag(overview_item,
overview_item->target_bounds().CenterPoint(),
/*is_touch_dragging=*/false);
overview_session()->Drag(overview_item, gfx::PointF());
EXPECT_EQ(expected_grid_bounds, GetGridBounds());
overview_session()->Drag(overview_item,
gfx::PointF(root_window_bounds.right(), 0.f));
EXPECT_EQ(expected_grid_bounds, GetGridBounds());
overview_session()->Drag(overview_item,
gfx::PointF(root_window_bounds.right() / 2.f, 0.f));
EXPECT_EQ(expected_grid_bounds, GetGridBounds());
}
// Tests that if there is only one window in the MRU window list in the overview
// mode, snapping the window to one side of the screen will not end the overview
// mode even if there is no more window left in the overview window grid.
TEST_P(SplitViewOverviewSessionTest, EmptyWindowsListNotExitOverview) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
// Test that overview mode is active in this single window case.
EXPECT_EQ(split_view_controller()->InSplitViewMode(), true);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_TRUE(overview_controller()->InOverviewSession());
// Create a new window should exit the overview mode.
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
wm::ActivateWindow(window2.get());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
// If there are only 2 snapped windows, close one of them should enter
// overview mode.
window2.reset();
EXPECT_TRUE(overview_controller()->InOverviewSession());
// If there are more than 2 windows in overview
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
std::unique_ptr<aura::Window> window4(CreateWindow(bounds));
wm::ActivateWindow(window3.get());
wm::ActivateWindow(window4.get());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
window3.reset();
EXPECT_TRUE(overview_controller()->InOverviewSession());
window4.reset();
EXPECT_TRUE(overview_controller()->InOverviewSession());
// Test that if there is only 1 snapped window, and no window in the overview
// grid, ToggleOverview() can't end overview.
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EndSplitView();
EXPECT_FALSE(SplitViewController::Get()->InSplitViewMode());
EXPECT_TRUE(overview_controller()->InOverviewSession());
// Test that ToggleOverview() can end overview if we're not in split view
// mode.
ToggleOverview();
EXPECT_FALSE(overview_controller()->InOverviewSession());
// Now enter overview and split view again. Test that exiting tablet mode can
// end split view and overview correctly.
ToggleOverview();
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_TRUE(SplitViewController::Get()->InSplitViewMode());
EXPECT_TRUE(overview_controller()->InOverviewSession());
Shell::Get()->tablet_mode_controller()->SetEnabledForTest(false);
EXPECT_FALSE(SplitViewController::Get()->InSplitViewMode());
EXPECT_FALSE(overview_controller()->InOverviewSession());
// Test that closing all windows in overview can end overview if we're not in
// split view mode.
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
window1.reset();
EXPECT_FALSE(overview_controller()->InOverviewSession());
}
// Test the overview window drag functionalities when screen rotates.
TEST_P(SplitViewOverviewSessionTest, SplitViewRotationTest) {
UpdateDisplay("807x407");
int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
display::DisplayManager* display_manager = Shell::Get()->display_manager();
display::test::ScopedSetInternalDisplayId set_internal(display_manager,
display_id);
ScreenOrientationControllerTestApi test_api(
Shell::Get()->screen_orientation_controller());
// Set the screen orientation to LANDSCAPE_PRIMARY.
test_api.SetDisplayRotation(display::Display::ROTATE_0,
display::Display::RotationSource::ACTIVE);
EXPECT_EQ(test_api.GetCurrentOrientation(),
OrientationLockType::kLandscapePrimary);
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
// Test that dragging |window1| to the left of the screen snaps it to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
// Test that dragging |window2| to the right of the screen snaps it to right.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
gfx::Rect work_area_rect = GetWorkAreaInScreen(window2.get());
gfx::PointF end_location2(work_area_rect.width(), work_area_rect.height());
DragWindowTo(overview_item2, end_location2);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window2.get());
// Test that |left_window_| was snapped to left after rotated 0 degree.
gfx::Rect left_window_bounds =
split_view_controller()->left_window()->GetBoundsInScreen();
EXPECT_EQ(left_window_bounds.x(), work_area_rect.x());
EXPECT_EQ(left_window_bounds.y(), work_area_rect.y());
EndSplitView();
// Rotate the screen by 270 degree.
test_api.SetDisplayRotation(display::Display::ROTATE_270,
display::Display::RotationSource::ACTIVE);
EXPECT_EQ(test_api.GetCurrentOrientation(),
OrientationLockType::kPortraitPrimary);
ToggleOverview();
// Test that dragging |window1| to the top of the screen snaps it to left.
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
// Test that dragging |window2| to the bottom of the screen snaps it to right.
overview_item2 = GetOverviewItemForWindow(window2.get());
work_area_rect = GetWorkAreaInScreen(window2.get());
end_location2 = gfx::PointF(work_area_rect.width(), work_area_rect.height());
DragWindowTo(overview_item2, end_location2, SelectorItemLocation::ORIGIN);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window2.get());
// Test that |left_window_| was snapped to top after rotated 270 degree.
left_window_bounds =
split_view_controller()->left_window()->GetBoundsInScreen();
EXPECT_EQ(left_window_bounds.x(), work_area_rect.x());
EXPECT_EQ(left_window_bounds.y(), work_area_rect.y());
EndSplitView();
// Rotate the screen by 180 degree.
test_api.SetDisplayRotation(display::Display::ROTATE_180,
display::Display::RotationSource::ACTIVE);
EXPECT_EQ(test_api.GetCurrentOrientation(),
OrientationLockType::kLandscapeSecondary);
ToggleOverview();
// Test that dragging |window1| to the left of the screen snaps it to right.
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kRightSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window1.get());
// Test that dragging |window2| to the right of the screen snaps it to left.
overview_item2 = GetOverviewItemForWindow(window2.get());
work_area_rect = GetWorkAreaInScreen(window2.get());
end_location2 = gfx::PointF(work_area_rect.width(), work_area_rect.height());
DragWindowTo(overview_item2, end_location2, SelectorItemLocation::ORIGIN);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window2.get());
// Test that |right_window_| was snapped to left after rotated 180 degree.
gfx::Rect right_window_bounds =
split_view_controller()->right_window()->GetBoundsInScreen();
EXPECT_EQ(right_window_bounds.x(), work_area_rect.x());
EXPECT_EQ(right_window_bounds.y(), work_area_rect.y());
EndSplitView();
// Rotate the screen by 90 degree.
test_api.SetDisplayRotation(display::Display::ROTATE_90,
display::Display::RotationSource::ACTIVE);
EXPECT_EQ(test_api.GetCurrentOrientation(),
OrientationLockType::kPortraitSecondary);
ToggleOverview();
// Test that dragging |window1| to the top of the screen snaps it to right.
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kRightSnapped);
EXPECT_EQ(split_view_controller()->right_window(), window1.get());
// Test that dragging |window2| to the bottom of the screen snaps it to left.
overview_item2 = GetOverviewItemForWindow(window2.get());
work_area_rect = GetWorkAreaInScreen(window2.get());
end_location2 = gfx::PointF(work_area_rect.width(), work_area_rect.height());
DragWindowTo(overview_item2, end_location2);
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window2.get());
// Test that |right_window_| was snapped to top after rotated 90 degree.
right_window_bounds =
split_view_controller()->right_window()->GetBoundsInScreen();
EXPECT_EQ(right_window_bounds.x(), work_area_rect.x());
EXPECT_EQ(right_window_bounds.y(), work_area_rect.y());
EndSplitView();
}
// Test that when split view mode and overview mode are both active at the same
// time, dragging the split view divider resizes the bounds of snapped window
// and the bounds of overview window grids at the same time.
TEST_P(SplitViewOverviewSessionTest, SplitViewOverviewBothActiveTest) {
UpdateDisplay("907x407");
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
ToggleOverview();
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
const gfx::Rect window1_bounds = window1->GetBoundsInScreen();
const gfx::Rect overview_grid_bounds = GetGridBounds();
const gfx::Rect divider_bounds =
GetSplitViewDividerBounds(false /* is_dragging */);
// Test that window1, divider, overview grid are aligned horizontally.
EXPECT_EQ(window1_bounds.right(), divider_bounds.x());
EXPECT_EQ(divider_bounds.right(), overview_grid_bounds.x());
const gfx::Point resize_start_location(divider_bounds.CenterPoint());
split_view_controller()->StartResize(resize_start_location);
const gfx::Point resize_end_location(300, 0);
split_view_controller()->EndResize(resize_end_location);
SkipDividerSnapAnimation();
const gfx::Rect window1_bounds_after_resize = window1->GetBoundsInScreen();
const gfx::Rect overview_grid_bounds_after_resize = GetGridBounds();
const gfx::Rect divider_bounds_after_resize =
GetSplitViewDividerBounds(false /* is_dragging */);
// Test that window1, divider, overview grid are still aligned horizontally
// after resizing.
EXPECT_EQ(window1_bounds.right(), divider_bounds.x());
EXPECT_EQ(divider_bounds.right(), overview_grid_bounds.x());
// Test that window1, divider, overview grid's bounds are changed after
// resizing.
EXPECT_NE(window1_bounds, window1_bounds_after_resize);
EXPECT_NE(overview_grid_bounds, overview_grid_bounds_after_resize);
EXPECT_NE(divider_bounds, divider_bounds_after_resize);
}
// Verify that selecting an unsnappable window while in split view works as
// intended.
TEST_P(SplitViewOverviewSessionTest, SelectUnsnappableWindowInSplitView) {
// Create one snappable and one unsnappable window.
std::unique_ptr<aura::Window> window = CreateTestWindow();
std::unique_ptr<aura::Window> unsnappable_window = CreateUnsnappableWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
// Snap the snappable window to enter split view mode.
split_view_controller()->SnapWindow(window.get(), SplitViewController::LEFT);
ASSERT_TRUE(split_view_controller()->InSplitViewMode());
// Select the unsnappable window.
OverviewItem* overview_item =
GetOverviewItemForWindow(unsnappable_window.get());
ui::test::EventGenerator* generator = GetEventGenerator();
generator->set_current_screen_location(
gfx::ToRoundedPoint(overview_item->target_bounds().CenterPoint()));
generator->ClickLeftButton();
// Verify that we are out of split view and overview mode, and that the active
// window is the unsnappable window.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_EQ(unsnappable_window.get(), window_util::GetActiveWindow());
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
ToggleOverview();
split_view_controller()->SnapWindow(window.get(), SplitViewController::LEFT);
split_view_controller()->SnapWindow(window2.get(),
SplitViewController::RIGHT);
// Split view mode should be active. Overview mode should be ended.
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
EXPECT_FALSE(overview_controller()->InOverviewSession());
ToggleOverview();
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
EXPECT_TRUE(overview_controller()->InOverviewSession());
// Now select the unsnappable window.
overview_item = GetOverviewItemForWindow(unsnappable_window.get());
generator->set_current_screen_location(
gfx::ToRoundedPoint(overview_item->target_bounds().CenterPoint()));
generator->ClickLeftButton();
// Split view mode should be ended. And the unsnappable window should be the
// active window now.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_EQ(unsnappable_window.get(), window_util::GetActiveWindow());
}
// Verify that when in overview mode, the selector items unsnappable indicator
// shows up when expected.
TEST_P(SplitViewOverviewSessionTest, OverviewUnsnappableIndicatorVisibility) {
// Create three windows; two normal and one unsnappable, so that when after
// snapping |window1| to enter split view we can test the state of each normal
// and unsnappable windows.
std::unique_ptr<aura::Window> window1(CreateTestWindow());
std::unique_ptr<aura::Window> window2(CreateTestWindow());
std::unique_ptr<aura::Window> unsnappable_window = CreateUnsnappableWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* snappable_overview_item =
GetOverviewItemForWindow(window2.get());
OverviewItem* unsnappable_overview_item =
GetOverviewItemForWindow(unsnappable_window.get());
// Note: |cannot_snap_label_view_| and its parent will be created on demand.
EXPECT_FALSE(snappable_overview_item->cannot_snap_widget_for_testing());
ASSERT_FALSE(unsnappable_overview_item->cannot_snap_widget_for_testing());
// Snap the extra snappable window to enter split view mode.
split_view_controller()->SnapWindow(window1.get(), SplitViewController::LEFT);
ASSERT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_FALSE(snappable_overview_item->cannot_snap_widget_for_testing());
ASSERT_TRUE(unsnappable_overview_item->cannot_snap_widget_for_testing());
ui::Layer* unsnappable_layer =
unsnappable_overview_item->cannot_snap_widget_for_testing()
->GetNativeWindow()
->layer();
EXPECT_EQ(1.f, unsnappable_layer->opacity());
// Exiting the splitview will hide the unsnappable label.
const gfx::Rect divider_bounds =
GetSplitViewDividerBounds(/*is_dragging=*/false);
GetEventGenerator()->set_current_screen_location(
divider_bounds.CenterPoint());
GetEventGenerator()->DragMouseTo(0, 0);
SkipDividerSnapAnimation();
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(0.f, unsnappable_layer->opacity());
}
// Verify that during "normal" dragging from overview (not drag-to-close), the
// dragged item's unsnappable indicator is temporarily suppressed.
TEST_P(SplitViewOverviewSessionTest,
OverviewUnsnappableIndicatorVisibilityWhileDragging) {
ui::GestureConfiguration* gesture_config =
ui::GestureConfiguration::GetInstance();
gesture_config->set_long_press_time_in_ms(1);
gesture_config->set_show_press_delay_in_ms(1);
std::unique_ptr<aura::Window> snapped_window = CreateTestWindow();
std::unique_ptr<aura::Window> unsnappable_window = CreateUnsnappableWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
split_view_controller()->SnapWindow(snapped_window.get(),
SplitViewController::LEFT);
ASSERT_TRUE(split_view_controller()->InSplitViewMode());
OverviewItem* unsnappable_overview_item =
GetOverviewItemForWindow(unsnappable_window.get());
ASSERT_TRUE(unsnappable_overview_item->cannot_snap_widget_for_testing());
ui::Layer* unsnappable_layer =
unsnappable_overview_item->cannot_snap_widget_for_testing()
->GetNativeWindow()
->layer();
ASSERT_EQ(1.f, unsnappable_layer->opacity());
// Test that the unsnappable label is temporarily suppressed during mouse
// dragging.
ui::test::EventGenerator* generator = GetEventGenerator();
const gfx::Point drag_starting_point = gfx::ToRoundedPoint(
unsnappable_overview_item->target_bounds().CenterPoint());
generator->set_current_screen_location(drag_starting_point);
generator->PressLeftButton();
using DragBehavior = OverviewWindowDragController::DragBehavior;
EXPECT_EQ(
DragBehavior::kUndefined,
overview_session()->window_drag_controller()->current_drag_behavior());
EXPECT_EQ(1.f, unsnappable_layer->opacity());
generator->MoveMouseBy(0, 20);
EXPECT_EQ(
DragBehavior::kNormalDrag,
overview_session()->window_drag_controller()->current_drag_behavior());
EXPECT_EQ(0.f, unsnappable_layer->opacity());
generator->ReleaseLeftButton();
EXPECT_EQ(1.f, unsnappable_layer->opacity());
// Test that the unsnappable label is temporarily suppressed during "normal"
// touch dragging (not drag-to-close).
generator->set_current_screen_location(drag_starting_point);
generator->PressTouch();
{
base::RunLoop run_loop;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, run_loop.QuitClosure(),
base::TimeDelta::FromMilliseconds(2));
run_loop.Run();
}
EXPECT_EQ(
DragBehavior::kNormalDrag,
overview_session()->window_drag_controller()->current_drag_behavior());
EXPECT_EQ(0.f, unsnappable_layer->opacity());
generator->MoveTouchBy(20, 0);
generator->ReleaseTouch();
EXPECT_EQ(1.f, unsnappable_layer->opacity());
// Test that the unsnappable label reappears if "normal" touch dragging (not
// drag-to-close) ends when the item has not been actually dragged anywhere.
// This case improves test coverage because it is handled in
// |OverviewWindowDragController::ResetGesture| instead of
// |OverviewWindowDragController::CompleteNormalDrag|.
generator->set_current_screen_location(drag_starting_point);
generator->PressTouch();
{
base::RunLoop run_loop;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, run_loop.QuitClosure(),
base::TimeDelta::FromMilliseconds(2));
run_loop.Run();
}
EXPECT_EQ(
DragBehavior::kNormalDrag,
overview_session()->window_drag_controller()->current_drag_behavior());
EXPECT_EQ(0.f, unsnappable_layer->opacity());
generator->ReleaseTouch();
EXPECT_EQ(1.f, unsnappable_layer->opacity());
// Test that the unsnappable label persists in drag-to-close mode.
generator->set_current_screen_location(drag_starting_point);
generator->PressTouch();
// Use small increments otherwise a fling event will be fired.
for (int j = 0; j < 20; ++j)
generator->MoveTouchBy(0, 1);
EXPECT_EQ(
DragBehavior::kDragToClose,
overview_session()->window_drag_controller()->current_drag_behavior());
// Drag-to-close mode affects the opacity of the whole overview item,
// including the unsnappable label.
EXPECT_EQ(unsnappable_overview_item->GetWindow()->layer()->opacity(),
unsnappable_layer->opacity());
generator->ReleaseTouch();
EXPECT_EQ(1.f, unsnappable_layer->opacity());
}
// Test that when splitview mode and overview mode are both active at the same
// time, dragging divider behaviors are correct.
TEST_P(SplitViewOverviewSessionTest, DragDividerToExitTest) {
UpdateDisplay("907x407");
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
ToggleOverview();
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
// Test that overview mode and split view mode are both active.
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Drag the divider toward closing the snapped window.
gfx::Rect divider_bounds = GetSplitViewDividerBounds(false /* is_dragging */);
split_view_controller()->StartResize(divider_bounds.CenterPoint());
split_view_controller()->EndResize(gfx::Point(0, 0));
SkipDividerSnapAnimation();
// Test that split view mode is ended. Overview mode is still active.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Now drag |window2| selector item to snap to left.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
DragWindowTo(overview_item2, gfx::PointF());
// Test that overview mode and split view mode are both active.
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Drag the divider toward closing the overview window grid.
divider_bounds = GetSplitViewDividerBounds(false /*is_dragging=*/);
const gfx::Rect display_bounds = GetWorkAreaInScreen(window2.get());
split_view_controller()->StartResize(divider_bounds.CenterPoint());
split_view_controller()->EndResize(display_bounds.bottom_right());
SkipDividerSnapAnimation();
// Test that split view mode is ended. Overview mode is also ended. |window2|
// should be activated.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_FALSE(Shell::Get()->overview_controller()->InOverviewSession());
EXPECT_EQ(window2.get(), window_util::GetActiveWindow());
}
TEST_P(SplitViewOverviewSessionTest, OverviewItemLongPressed) {
std::unique_ptr<aura::Window> window1 = CreateTestWindow();
std::unique_ptr<aura::Window> window2 = CreateTestWindow();
ToggleOverview();
ASSERT_TRUE(overview_controller()->InOverviewSession());
OverviewItem* overview_item = GetOverviewItemForWindow(window1.get());
gfx::PointF start_location(overview_item->target_bounds().CenterPoint());
const gfx::RectF original_bounds(overview_item->target_bounds());
// Verify that when a overview item receives a resetting gesture, we
// stay in overview mode and the bounds of the item are the same as they were
// before the press sequence started.
overview_session()->InitiateDrag(overview_item, start_location,
/*is_touch_dragging=*/true);
overview_session()->ResetDraggedWindowGesture();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_EQ(original_bounds, overview_item->target_bounds());
// Verify that when a overview item is tapped, we exit overview mode,
// and the current active window is the item.
overview_session()->InitiateDrag(overview_item, start_location,
/*is_touch_dragging=*/true);
overview_session()->ActivateDraggedWindow();
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_EQ(window1.get(), window_util::GetActiveWindow());
}
TEST_P(SplitViewOverviewSessionTest, SnappedWindowBoundsTest) {
const gfx::Rect bounds(400, 400);
const int kMinimumBoundSize = 100;
const gfx::Size size(kMinimumBoundSize, kMinimumBoundSize);
std::unique_ptr<aura::Window> window1(
CreateWindowWithMinimumSize(bounds, size));
std::unique_ptr<aura::Window> window2(
CreateWindowWithMinimumSize(bounds, size));
std::unique_ptr<aura::Window> window3(
CreateWindowWithMinimumSize(bounds, size));
const int screen_width =
screen_util::GetDisplayWorkAreaBoundsInParent(window1.get()).width();
ToggleOverview();
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Then drag the divider to left toward closing the snapped window.
gfx::Rect divider_bounds = GetSplitViewDividerBounds(false /*is_dragging=*/);
split_view_controller()->StartResize(divider_bounds.CenterPoint());
// Drag the divider to a point that is close enough but still have a short
// distance to the edge of the screen.
split_view_controller()->EndResize(gfx::Point(20, 20));
SkipDividerSnapAnimation();
// Test that split view mode is ended. Overview mode is still active.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Test that |window1| has the dimensions of a tablet mode maxed window, so
// that when it is placed back on the grid it will not look skinny.
EXPECT_LE(window1->bounds().x(), 0);
EXPECT_EQ(window1->bounds().width(), screen_width);
// Drag |window2| selector item to snap to right.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
const gfx::Rect work_area_rect = GetWorkAreaInScreen(window2.get());
gfx::Point end_location2 =
gfx::Point(work_area_rect.width(), work_area_rect.height());
DragWindowTo(overview_item2, gfx::PointF(end_location2));
EXPECT_EQ(SplitViewController::State::kRightSnapped,
split_view_controller()->state());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Then drag the divider to right toward closing the snapped window.
divider_bounds = GetSplitViewDividerBounds(false /* is_dragging */);
split_view_controller()->StartResize(divider_bounds.CenterPoint());
// Drag the divider to a point that is close enough but still have a short
// distance to the edge of the screen.
end_location2.Offset(-20, -20);
split_view_controller()->EndResize(end_location2);
SkipDividerSnapAnimation();
// Test that split view mode is ended. Overview mode is still active.
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(Shell::Get()->overview_controller()->InOverviewSession());
// Test that |window2| has the dimensions of a tablet mode maxed window, so
// that when it is placed back on the grid it will not look skinny.
EXPECT_GE(window2->bounds().x(), 0);
EXPECT_EQ(window2->bounds().width(), screen_width);
}
// Verify that if the split view divider is dragged all the way to the edge, the
// window being dragged gets returned to the overview list, if overview mode is
// still active.
TEST_P(SplitViewOverviewSessionTest,
DividerDraggedToEdgeReturnsWindowToOverviewList) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
ToggleOverview();
// Drag |window1| selector item to snap to left. There should be two items on
// the overview grid afterwards, |window2| and |window3|.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
ASSERT_TRUE(split_view_controller()->split_view_divider());
std::vector<aura::Window*> window_list =
overview_controller()->GetWindowsListInOverviewGridsForTest();
EXPECT_EQ(2u, window_list.size());
EXPECT_FALSE(base::Contains(window_list, window1.get()));
EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
// Drag the divider to the left edge.
const gfx::Rect divider_bounds =
GetSplitViewDividerBounds(/*is_dragging=*/false);
GetEventGenerator()->set_current_screen_location(
divider_bounds.CenterPoint());
GetEventGenerator()->DragMouseTo(0, 0);
SkipDividerSnapAnimation();
// Verify that it is still in overview mode and that |window1| is returned to
// the overview list.
EXPECT_TRUE(InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
window_list = overview_controller()->GetWindowsListInOverviewGridsForTest();
EXPECT_EQ(3u, window_list.size());
EXPECT_TRUE(base::Contains(window_list, window1.get()));
EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
}
// Verify that if the split view divider is dragged close to the edge, the grid
// bounds will be fixed to a third of the work area width and start sliding off
// the screen instead of continuing to shrink.
TEST_P(SplitViewOverviewSessionTest,
OverviewHasMinimumBoundsWhenDividerDragged) {
UpdateDisplay("600x400");
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
// Snap a window to the left and test dragging the divider towards the right
// edge of the screen.
SplitViewController::Get()->SnapWindow(window1.get(),
SplitViewController::LEFT);
OverviewGrid* grid = overview_session()->grid_list()[0].get();
ASSERT_TRUE(grid);
// Drag the divider to the right edge.
gfx::Rect divider_bounds = GetSplitViewDividerBounds(/*is_dragging=*/false);
ui::test::EventGenerator* generator = GetEventGenerator();
generator->set_current_screen_location(divider_bounds.CenterPoint());
generator->PressLeftButton();
// Tests that near the right edge, the grid bounds are fixed at 200 and are
// partially off screen to the right.
generator->MoveMouseTo(580, 0);
EXPECT_EQ(200, grid->bounds().width());
EXPECT_GT(grid->bounds().right(), 600);
generator->ReleaseLeftButton();
SkipDividerSnapAnimation();
// Releasing close to the edge will activate the left window and exit
// overview.
ASSERT_FALSE(InOverviewSession());
ToggleOverview();
// Snap a window to the right and test dragging the divider towards the left
// edge of the screen.
SplitViewController::Get()->SnapWindow(window1.get(),
SplitViewController::RIGHT);
grid = overview_session()->grid_list()[0].get();
ASSERT_TRUE(grid);
// Drag the divider to the left edge.
divider_bounds = GetSplitViewDividerBounds(/*is_dragging=*/false);
generator->set_current_screen_location(divider_bounds.CenterPoint());
generator->PressLeftButton();
generator->MoveMouseTo(20, 0);
// Tests that near the left edge, the grid bounds are fixed at 200 and are
// partially off screen to the left.
EXPECT_EQ(200, grid->bounds().width());
EXPECT_LT(grid->bounds().x(), 0);
generator->ReleaseLeftButton();
SkipDividerSnapAnimation();
}
// Test that when splitview mode is active, minimizing one of the snapped window
// will insert the minimized window back to overview mode if overview mode is
// active at the moment.
TEST_P(SplitViewOverviewSessionTest, InsertMinimizedWindowBackToOverview) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
EXPECT_TRUE(InOverviewSession());
// Minimize |window1| will put |window1| back to overview grid.
WindowState::Get(window1.get())->Minimize();
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(GetOverviewItemForWindow(window1.get()));
// Now snap both |window1| and |window2|.
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
wm::ActivateWindow(window2.get());
EXPECT_FALSE(InOverviewSession());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kBothSnapped);
EXPECT_EQ(split_view_controller()->left_window(), window1.get());
EXPECT_EQ(split_view_controller()->right_window(), window2.get());
// Minimize |window1| will open overview and put |window1| to overview grid.
WindowState::Get(window1.get())->Minimize();
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kRightSnapped);
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(GetOverviewItemForWindow(window1.get()));
// Minimize |window2| also put |window2| to overview grid.
WindowState::Get(window2.get())->Minimize();
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(GetOverviewItemForWindow(window1.get()));
EXPECT_TRUE(GetOverviewItemForWindow(window2.get()));
}
// Test that when splitview and overview are both active at the same time, if
// overview is ended due to snapping a window in splitview, the tranform of each
// window in the overview grid is restored.
TEST_P(SplitViewOverviewSessionTest, SnappedWindowAnimationObserverTest) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
// There are four ways to exit overview mode. Verify in each case the
// tranform of each window in the overview window grid has been restored.
// 1. Overview is ended by dragging a item in overview to snap to splitview.
// Drag |window1| selector item to snap to left. There should be two items on
// the overview grid afterwards, |window2| and |window3|.
ToggleOverview();
EXPECT_FALSE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window3->layer()->GetTargetTransform().IsIdentity());
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
// Drag |window2| to snap to right.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
const gfx::Rect work_area_rect =
screen_util::GetDisplayWorkAreaBoundsInScreenForActiveDeskContainer(
window2.get());
const gfx::PointF end_location2(work_area_rect.width(), 0);
DragWindowTo(overview_item2, end_location2);
EXPECT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window3->layer()->GetTargetTransform().IsIdentity());
// 2. Overview is ended by ToggleOverview() directly.
// ToggleOverview() will open overview grid in the non-default side of the
// split screen.
ToggleOverview();
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window3->layer()->GetTargetTransform().IsIdentity());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
// ToggleOverview() directly.
ToggleOverview();
EXPECT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window3->layer()->GetTargetTransform().IsIdentity());
// 3. Overview is ended by actviating an existing window.
ToggleOverview();
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window3->layer()->GetTargetTransform().IsIdentity());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
wm::ActivateWindow(window2.get());
EXPECT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window3->layer()->GetTargetTransform().IsIdentity());
// 4. Overview is ended by activating a new window.
ToggleOverview();
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_FALSE(window3->layer()->GetTargetTransform().IsIdentity());
EXPECT_EQ(SplitViewController::State::kLeftSnapped,
split_view_controller()->state());
std::unique_ptr<aura::Window> window4(CreateWindow(bounds));
wm::ActivateWindow(window4.get());
EXPECT_EQ(SplitViewController::State::kBothSnapped,
split_view_controller()->state());
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_TRUE(window1->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window2->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window3->layer()->GetTargetTransform().IsIdentity());
EXPECT_TRUE(window4->layer()->GetTargetTransform().IsIdentity());
}
// Test that when split view and overview are both active at the same time,
// double tapping on the divider can swap the window's position with the
// overview window grid's postion.
TEST_P(SplitViewOverviewSessionTest, SwapWindowAndOverviewGrid) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF());
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kLeftSnapped);
EXPECT_EQ(split_view_controller()->default_snap_position(),
SplitViewController::LEFT);
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_EQ(GetGridBounds(),
split_view_controller()->GetSnappedWindowBoundsInScreen(
window1.get(), SplitViewController::RIGHT));
split_view_controller()->SwapWindows();
EXPECT_EQ(split_view_controller()->state(),
SplitViewController::State::kRightSnapped);
EXPECT_EQ(split_view_controller()->default_snap_position(),
SplitViewController::RIGHT);
EXPECT_EQ(GetGridBounds(),
split_view_controller()->GetSnappedWindowBoundsInScreen(
window1.get(), SplitViewController::LEFT));
}
// Verify the behavior when trying to exit overview with one snapped window
// is as expected.
TEST_P(SplitViewOverviewSessionTest, ExitOverviewWithOneSnapped) {
std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(400, 400)));
// Tests that we cannot exit overview when there is one snapped window and no
// windows in overview normally.
ToggleOverview();
split_view_controller()->SnapWindow(window.get(), SplitViewController::LEFT);
ToggleOverview();
ASSERT_TRUE(InOverviewSession());
// Tests that we can exit overview if we swipe up from the shelf.
ToggleOverview(OverviewSession::EnterExitOverviewType::kSwipeFromShelf);
EXPECT_FALSE(InOverviewSession());
}
// Test that in tablet mode, pressing tab key in overview should not crash.
TEST_P(SplitViewOverviewSessionTest, NoCrashWhenPressTabKey) {
std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(400, 400)));
std::unique_ptr<aura::Window> window2(CreateWindow(gfx::Rect(400, 400)));
// In overview, there should be no crash when pressing tab key.
ToggleOverview();
EXPECT_TRUE(InOverviewSession());
SendKey(ui::VKEY_TAB);
EXPECT_TRUE(InOverviewSession());
// When splitview and overview are both active, there should be no crash when
// pressing tab key.
split_view_controller()->SnapWindow(window.get(), SplitViewController::LEFT);
EXPECT_TRUE(InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
SendKey(ui::VKEY_TAB);
EXPECT_TRUE(InOverviewSession());
}
// Tests closing a snapped window while in overview mode.
TEST_P(SplitViewOverviewSessionTest, ClosingSplitViewWindow) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
// Now close the snapped |window1|. We should remain in overview mode and the
// overview focus window should regain focus.
window1.reset();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
EXPECT_EQ(overview_session()->GetOverviewFocusWindow(),
window_util::GetFocusedWindow());
}
// Test that you cannot drag from overview during the split view divider
// animation.
TEST_P(SplitViewOverviewSessionTest,
CannotDragFromOverviewDuringSplitViewDividerAnimation) {
std::unique_ptr<aura::Window> snapped_window = CreateTestWindow();
std::unique_ptr<aura::Window> overview_window = CreateTestWindow();
ToggleOverview();
split_view_controller()->SnapWindow(snapped_window.get(),
SplitViewController::LEFT);
gfx::Point divider_drag_point =
split_view_controller()
->split_view_divider()
->GetDividerBoundsInScreen(/*is_dragging=*/false)
.CenterPoint();
split_view_controller()->StartResize(divider_drag_point);
divider_drag_point.Offset(20, 0);
split_view_controller()->Resize(divider_drag_point);
split_view_controller()->EndResize(divider_drag_point);
ASSERT_TRUE(IsDividerAnimating());
OverviewItem* overview_item = GetOverviewItemForWindow(overview_window.get());
overview_session()->InitiateDrag(overview_item,
overview_item->target_bounds().CenterPoint(),
/*is_touch_dragging=*/true);
EXPECT_FALSE(overview_item->IsDragItem());
}
// Test the split view and overview functionalities in clamshell mode. Split
// view is only active when overview is active in clamshell mode.
class SplitViewOverviewSessionInClamshellTest
: public SplitViewOverviewSessionTest {
public:
SplitViewOverviewSessionInClamshellTest() = default;
~SplitViewOverviewSessionInClamshellTest() override = default;
// AshTestBase:
void SetUp() override {
scoped_feature_list_.InitAndEnableFeature(
ash::features::kDragToSnapInClamshellMode);
OverviewSessionTest::SetUp();
Shell::Get()->tablet_mode_controller()->SetEnabledForTest(false);
DCHECK(ShouldAllowSplitView());
}
aura::Window* CreateWindowWithHitTestComponent(int hit_test_component,
const gfx::Rect& bounds) {
return CreateTestWindowInShellWithDelegate(
new TestWindowHitTestDelegate(hit_test_component), 0, bounds);
}
private:
class TestWindowHitTestDelegate : public aura::test::TestWindowDelegate {
public:
explicit TestWindowHitTestDelegate(int hit_test_component) {
set_window_component(hit_test_component);
}
~TestWindowHitTestDelegate() override = default;
private:
// aura::Test::TestWindowDelegate:
void OnWindowDestroyed(aura::Window* window) override { delete this; }
DISALLOW_COPY_AND_ASSIGN(TestWindowHitTestDelegate);
};
base::test::ScopedFeatureList scoped_feature_list_;
DISALLOW_COPY_AND_ASSIGN(SplitViewOverviewSessionInClamshellTest);
};
// Test some basic functionalities in clamshell splitview mode.
TEST_P(SplitViewOverviewSessionInClamshellTest, BasicFunctionalitiesTest) {
UpdateDisplay("600x400");
EXPECT_FALSE(Shell::Get()->tablet_mode_controller()->InTabletMode());
// 1. Test the 1 window scenario.
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
WindowState* window_state1 = WindowState::Get(window1.get());
EXPECT_FALSE(window_state1->IsSnapped());
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
// Since the only window is snapped, overview and splitview should be both
// ended.
EXPECT_EQ(window_state1->GetStateType(), WindowStateType::kLeftSnapped);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 2. Test if one window is snapped, the other windows are showing in
// overview, close all windows in overview will end overview and also
// splitview.
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(600, 300));
// SplitView and overview are both active at the moment.
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_TRUE(split_view_controller()->IsWindowInSplitView(window1.get()));
EXPECT_TRUE(overview_controller()->overview_session()->IsWindowInOverview(
window2.get()));
EXPECT_EQ(window_state1->GetStateType(), WindowStateType::kRightSnapped);
// Close |window2| will end overview and splitview.
window2.reset();
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 3. Test that snap 2 windows will end overview and splitview.
std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
ToggleOverview();
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
OverviewItem* overview_item3 = GetOverviewItemForWindow(window3.get());
DragWindowTo(overview_item3, gfx::PointF(600, 300));
EXPECT_EQ(window_state1->GetStateType(), WindowStateType::kLeftSnapped);
EXPECT_EQ(WindowState::Get(window3.get())->GetStateType(),
WindowStateType::kRightSnapped);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 4. Test if one window is snapped, the other windows are showing in
// overview, we can drag another window in overview to snap in splitview, and
// the previous snapped window will be put back into overview.
std::unique_ptr<aura::Window> window4(CreateWindow(bounds));
ToggleOverview();
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_FALSE(overview_controller()->overview_session()->IsWindowInOverview(
window1.get()));
overview_item3 = GetOverviewItemForWindow(window3.get());
DragWindowTo(overview_item3, gfx::PointF(0, 0));
EXPECT_FALSE(overview_controller()->overview_session()->IsWindowInOverview(
window3.get()));
EXPECT_TRUE(overview_controller()->overview_session()->IsWindowInOverview(
window1.get()));
EXPECT_EQ(window_state1->GetStateType(), WindowStateType::kLeftSnapped);
EXPECT_EQ(WindowState::Get(window3.get())->GetStateType(),
WindowStateType::kLeftSnapped);
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
// End overview, test that we'll not auto-snap a window to the right side of
// the screen.
EXPECT_EQ(WindowState::Get(window4.get())->GetStateType(),
WindowStateType::kDefault);
ToggleOverview();
EXPECT_EQ(WindowState::Get(window4.get())->GetStateType(),
WindowStateType::kDefault);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 5. Test if one window is snapped, the other window are showing in overview,
// activating an new window will not auto-snap the new window. Overview and
// splitview should be ended.
ToggleOverview();
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
std::unique_ptr<aura::Window> window5(CreateWindow(bounds));
EXPECT_EQ(WindowState::Get(window5.get())->GetStateType(),
WindowStateType::kDefault);
wm::ActivateWindow(window5.get());
EXPECT_EQ(WindowState::Get(window5.get())->GetStateType(),
WindowStateType::kDefault);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 6. Test if one window is snapped, the other window is showing in overview,
// close the snapped window will end split view, but overview is still active.
ToggleOverview();
const gfx::Rect overview_bounds = GetGridBounds();
overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_NE(GetGridBounds(), overview_bounds);
EXPECT_EQ(GetGridBounds(), GetSplitViewRightWindowBounds(window1.get()));
window1.reset();
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// Overview bounds will adjust from snapped bounds to fullscreen bounds.
EXPECT_EQ(GetGridBounds(), overview_bounds);
// 7. Test if split view mode is active, open the app list will end both
// overview and splitview.
overview_item3 = GetOverviewItemForWindow(window3.get());
DragWindowTo(overview_item3, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
// Open app list.
AppListControllerImpl* app_list_controller =
Shell::Get()->app_list_controller();
app_list_controller->ToggleAppList(
display::Screen::GetScreen()->GetDisplayNearestWindow(window3.get()).id(),
AppListShowSource::kSearchKey, base::TimeTicks());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
// 8. Test if splitview is active, open the app list will end overview if
// overview is active.
ToggleOverview();
// Open app list.
app_list_controller->ToggleAppList(
display::Screen::GetScreen()->GetDisplayNearestWindow(window3.get()).id(),
AppListShowSource::kSearchKey, base::TimeTicks());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
}
// Test that when overview and splitview are both active, only resize that
// happens on eligible window components will change snapped window bounds and
// overview bounds at the same time.
TEST_P(SplitViewOverviewSessionInClamshellTest, ResizeWindowTest) {
UpdateDisplay("600x400");
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(
CreateWindowWithHitTestComponent(HTRIGHT, bounds));
std::unique_ptr<aura::Window> window2(
CreateWindowWithHitTestComponent(HTLEFT, bounds));
std::unique_ptr<aura::Window> window3(
CreateWindowWithHitTestComponent(HTTOP, bounds));
std::unique_ptr<aura::Window> window4(
CreateWindowWithHitTestComponent(HTBOTTOM, bounds));
ToggleOverview();
const gfx::Rect overview_full_bounds = GetGridBounds();
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_NE(GetGridBounds(), overview_full_bounds);
EXPECT_EQ(GetGridBounds(), GetSplitViewRightWindowBounds(window1.get()));
const gfx::Rect overview_snapped_bounds = GetGridBounds();
// Resize that happens on the right edge of the left snapped window will
// resize the window and overview at the same time.
ui::test::EventGenerator generator1(Shell::GetPrimaryRootWindow(),
window1.get());
generator1.DragMouseBy(50, 50);
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
EXPECT_NE(GetGridBounds(), overview_full_bounds);
EXPECT_NE(GetGridBounds(), overview_snapped_bounds);
EXPECT_EQ(GetGridBounds(), GetSplitViewRightWindowBounds(window1.get()));
// Resize that happens on the left edge of the left snapped window will end
// overview. The same for the resize that happens on the top or bottom edge of
// the left snapped window.
OverviewItem* overview_item2 = GetOverviewItemForWindow(window2.get());
DragWindowTo(overview_item2, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
ui::test::EventGenerator generator2(Shell::GetPrimaryRootWindow(),
window2.get());
generator2.DragMouseBy(50, 50);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
ToggleOverview();
OverviewItem* overview_item3 = GetOverviewItemForWindow(window3.get());
DragWindowTo(overview_item3, gfx::PointF(0, 0));
ui::test::EventGenerator generator3(Shell::GetPrimaryRootWindow(),
window3.get());
generator3.DragMouseBy(50, 50);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
ToggleOverview();
OverviewItem* overview_item4 = GetOverviewItemForWindow(window4.get());
DragWindowTo(overview_item4, gfx::PointF(0, 0));
ui::test::EventGenerator generator4(Shell::GetPrimaryRootWindow(),
window4.get());
generator4.DragMouseBy(50, 50);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
}
// Test that when laptop splitview mode is active, moving the snapped window
// will end splitview and overview at the same time.
TEST_P(SplitViewOverviewSessionInClamshellTest, MoveWindowTest) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(
CreateWindowWithHitTestComponent(HTCAPTION, bounds));
std::unique_ptr<aura::Window> window2(
CreateWindowWithHitTestComponent(HTCAPTION, bounds));
ToggleOverview();
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
ui::test::EventGenerator generator1(Shell::GetPrimaryRootWindow(),
window1.get());
generator1.DragMouseBy(50, 50);
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
}
// Test that in clamshell splitview mode, if the snapped window is minimized,
// splitview mode and overview mode are both ended.
TEST_P(SplitViewOverviewSessionInClamshellTest, MinimizedWindowTest) {
const gfx::Rect bounds(400, 400);
std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
ToggleOverview();
// Drag |window1| selector item to snap to left.
OverviewItem* overview_item1 = GetOverviewItemForWindow(window1.get());
DragWindowTo(overview_item1, gfx::PointF(0, 0));
EXPECT_TRUE(overview_controller()->InOverviewSession());
EXPECT_TRUE(split_view_controller()->InSplitViewMode());
// Now minimize the snapped |window1|.
WindowState::Get(window1.get())->Minimize();
EXPECT_FALSE(overview_controller()->InOverviewSession());
EXPECT_FALSE(split_view_controller()->InSplitViewMode());
}
INSTANTIATE_TEST_SUITE_P(, OverviewSessionTest, testing::Bool());
INSTANTIATE_TEST_SUITE_P(, OverviewSessionRoundedCornerTest, testing::Bool());
INSTANTIATE_TEST_SUITE_P(, OverviewSessionNewLayoutTest, testing::Bool());
INSTANTIATE_TEST_SUITE_P(, SplitViewOverviewSessionTest, testing::Bool());
INSTANTIATE_TEST_SUITE_P(,
SplitViewOverviewSessionInClamshellTest,
testing::Bool());
} // namespace ash