Removes AshTestBase::SupportsHostWindowResize

ash/wm/dock/docked_window_layout_manager_unittest.cc

 // Copyright (c) 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/common/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
@@ skipping 190 matching lines @@
 
   // Location at start of the drag in |window->parent()|'s coordinates.
   gfx::Point initial_location_in_parent_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedWindowLayoutManagerTest);
 };
 
 // Tests that a created window is successfully added to the dock
 // layout manager.
 TEST_P(DockedWindowLayoutManagerTest, AddOneWindow) {
-  if (!SupportsHostWindowResize())
-    return;
-
   gfx::Rect bounds(0, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and docked at the right edge.
   // Its width should shrink or grow to ideal width.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->bounds().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Tests that a docked window's bounds cannot be changed programmatically.
 TEST_P(DockedWindowLayoutManagerTest, DockedWindowBoundsDontChange) {
-  if (!SupportsHostWindowResize())
-    return;
-
   gfx::Rect bounds(0, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and docked at the right edge.
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   bounds = window->GetBoundsInScreen();
   window->SetBounds(gfx::Rect(210, 210, 210, 210));
   EXPECT_EQ(bounds.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 // Tests that with a window docked on the left the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingLeft) {
-  if (!SupportsHostWindowResize())
-    return;
-
   gfx::Rect bounds(0, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->bounds().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager =
@@ skipping 28 matching lines @@
       window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
           ",48 150x300",
       window2->bounds().ToString());
 }
 
 // Tests that with a window docked on the right the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingRight) {
-  if (!SupportsHostWindowResize())
-    return;
-
   gfx::Rect bounds(0, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager =
@@ skipping 27 matching lines @@
   EXPECT_EQ(base::IntToString(desktop_area.width() - window2->bounds().width() -
                               docked_width(manager) - min_dock_gap()) +
                 ",48 256x512",
             window2->bounds().ToString());
 }
 
 // Tests that with a window docked on the right the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 // Test case for the secondary screen.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingRightSecondScreen) {
-  if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
+  if (!SupportsMultipleDisplays())
     return;
 
   // Create a dual screen layout.
   UpdateDisplay("600x600,600x600");
 
   gfx::Rect bounds(600, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   // Drag pointer to the right edge of the second screen.
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
@@ skipping 35 matching lines @@
   EXPECT_EQ("600,32 231x320", window1->GetBoundsInScreen().ToString());
   EXPECT_EQ(
       base::IntToString(600 + desktop_area.width() - window2->bounds().width() -
                         docked_width(manager) - min_dock_gap()) +
           ",48 256x512",
       window2->GetBoundsInScreen().ToString());
 }
 
 // Adds two windows and tests that the gaps are evenly distributed.
 TEST_P(DockedWindowLayoutManagerTest, AddTwoWindows) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
 
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Test that the gaps differ at most by a single pixel.
   gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(w1.get())
                             .work_area();
   int gap1 = w1->GetBoundsInScreen().y();
   int gap2 = w2->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   int gap3 = work_area.bottom() - w2->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_EQ(0, gap3);
 }
 
 // Adds two non-overlapping windows and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsDragging) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
 
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
@@ skipping 12 matching lines @@
   int gap1 = w2->GetBoundsInScreen().y() - work_area.y();
   int gap2 = w1->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap3 = work_area.bottom() - w1->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_EQ(0, gap3);
 }
 
 // Adds three overlapping windows and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsDragging) {
-  if (!SupportsHostWindowResize())
-    return;
   UpdateDisplay("600x1000");
 
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 500);
   std::unique_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 310)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 600);
 
   // All windows should be attached and snapped to the right side of the screen.
@@ skipping 41 matching lines @@
   gap3 = w3->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_NEAR(gap3, min_dock_gap(), 1);
   EXPECT_EQ(0, gap4);
 }
 
 // Adds three windows in bottom display and tests layout after a drag.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsDraggingSecondScreen) {
-  if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
+  if (!SupportsMultipleDisplays())
     return;
 
   // Create two screen vertical layout.
   UpdateDisplay("600x1000,600x1000");
   // Layout the secondary display to the bottom of the primary.
   ASSERT_GT(display::Screen::GetScreen()->GetNumDisplays(), 1);
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::BOTTOM, 0));
 
   std::unique_ptr<aura::Window> w1(
@@ skipping 51 matching lines @@
   gap3 = w3->GetBoundsInScreen().y() - w1->GetBoundsInScreen().bottom();
   gap4 = work_area.bottom() - w3->GetBoundsInScreen().bottom();
   EXPECT_EQ(0, gap1);
   EXPECT_NEAR(gap2, min_dock_gap(), 1);
   EXPECT_NEAR(gap3, min_dock_gap(), 1);
   EXPECT_EQ(0, gap4);
 }
 
 // Tests that a second window added to the dock is resized to match.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsWidthNew) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 280, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // The first window should get resized to ideal width.
   EXPECT_EQ(ideal_width(), w1->bounds().width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
   // The second window should get resized to the existing dock.
   EXPECT_EQ(ideal_width(), w2->bounds().width());
 }
 
 // Tests that a first non-resizable window added to the dock is not resized.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsWidthNonResizableFirst) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   w1->SetProperty(aura::client::kCanResizeKey, false);
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 280, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // The first window should not get resized.
   EXPECT_EQ(201, w1->bounds().width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
   // The second window should get resized to the first window's width.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
 }
 
 // Tests that a second non-resizable window added to the dock is not resized.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsWidthNonResizableSecond) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 280, 202)));
   w2->SetProperty(aura::client::kCanResizeKey, false);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // The first window should get resized to ideal width.
   EXPECT_EQ(ideal_width(), w1->bounds().width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
   // The second window should not get resized.
   EXPECT_EQ(280, w2->bounds().width());
 
   // The first window should get resized again - to match the second window.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
 }
 
 // Test that restrictions on minimum and maximum width of windows are honored.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsWidthRestrictions) {
-  if (!SupportsHostWindowResize())
-    return;
-
   aura::test::TestWindowDelegate delegate1;
   delegate1.set_maximum_size(gfx::Size(240, 0));
   std::unique_ptr<aura::Window> w1(
       CreateTestWindowWithDelegate(gfx::Rect(0, 0, 201, 201), &delegate1));
   aura::test::TestWindowDelegate delegate2;
   delegate2.set_minimum_size(gfx::Size(260, 0));
   std::unique_ptr<aura::Window> w2(
       CreateTestWindowWithDelegate(gfx::Rect(0, 0, 280, 202), &delegate2));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // The first window should get resized to its maximum width.
   EXPECT_EQ(240, w1->bounds().width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 300);
   // The second window should get resized to its minimum width.
   EXPECT_EQ(260, w2->bounds().width());
 
   // The first window should be centered relative to the second.
   EXPECT_EQ(w1->bounds().CenterPoint().x(), w2->bounds().CenterPoint().x());
 }
 
 // Test that restrictions on minimum width of windows are honored.
 TEST_P(DockedWindowLayoutManagerTest, WidthMoreThanMax) {
-  if (!SupportsHostWindowResize())
-    return;
-
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(400, 0));
   std::unique_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(gfx::Rect(0, 0, 400, 201), &delegate));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, window.get(), 20);
 
   // Secondary drag ensures that we are testing the minimum size restriction
   // and not just failure to get past the tiling step in SnapSizer.
   ASSERT_NO_FATAL_FAILURE(
       DragStartAtOffsetFromwindowOrigin(window.get(), 25, 5));
   DragMove(150, 0);
   DragEnd();
 
   // The window should not get docked even though it is dragged past the edge.
   EXPECT_NE(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_NE(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Docks three windows and tests that the very first window gets minimized.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsMinimize) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 200);
   std::unique_ptr<aura::Window> w3(CreateTestWindow(gfx::Rect(0, 0, 220, 204)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w3.get(), 300);
 
   // The last two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
@@ skipping 13 matching lines @@
   // The other two windows should be still docked.
   EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMinimized());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsDocked());
   EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMinimized());
   EXPECT_TRUE(wm::GetWindowState(w3.get())->IsDocked());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 }
 
 // Docks up to three windows and tests that they split vertical space.
 TEST_P(DockedWindowLayoutManagerTest, ThreeWindowsSplitHeightEvenly) {
-  if (!SupportsHostWindowResize())
-    return;
-
   UpdateDisplay("600x1000");
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 202)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 200);
 
   // The two windows should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
@@ skipping 23 matching lines @@
   EXPECT_NEAR(w1->GetBoundsInScreen().height(),
               w2->GetBoundsInScreen().height(), 1);
   EXPECT_NEAR(w2->GetBoundsInScreen().height(),
               w3->GetBoundsInScreen().height(), 1);
   EXPECT_NEAR(work_area.height() / 3, w1->GetBoundsInScreen().height(),
               min_dock_gap() * 2);
 }
 
 // Docks two windows and tests that restrictions on vertical size are honored.
 TEST_P(DockedWindowLayoutManagerTest, TwoWindowsHeightRestrictions) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // The first window is fixed height.
   aura::test::TestWindowDelegate delegate1;
   delegate1.set_minimum_size(gfx::Size(0, 300));
   delegate1.set_maximum_size(gfx::Size(0, 300));
   std::unique_ptr<aura::Window> w1(
       CreateTestWindowWithDelegate(gfx::Rect(0, 0, 201, 300), &delegate1));
   // The second window has maximum height.
   aura::test::TestWindowDelegate delegate2;
   delegate2.set_maximum_size(gfx::Size(0, 100));
   std::unique_ptr<aura::Window> w2(
@@ skipping 19 matching lines @@
   gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(w1.get())
                             .work_area();
   EXPECT_GT(w1->GetBoundsInScreen().height(), work_area.height() / 2 + 10);
   EXPECT_LT(w2->GetBoundsInScreen().height(), work_area.height() / 2 - 10);
 }
 
 // Tests that a docked window is moved to primary display when secondary display
 // is disconnected and that it stays docked and properly positioned.
 TEST_P(DockedWindowLayoutManagerTest, DisplayDisconnectionMovesDocked) {
-  if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
+  if (!SupportsMultipleDisplays())
     return;
 
   // Create a dual screen layout.
   UpdateDisplay("600x700,800x600");
 
   gfx::Rect bounds(600, 0, 201, 201);
   std::unique_ptr<aura::Window> window(CreateTestWindow(bounds));
   // Drag pointer to the right edge of the second screen.
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(work_area.height(), window->GetBoundsInScreen().height());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 
 }  // namespace ash