Removes AshTestBase::SupportsHostWindowResize

ash/wm/dock/docked_window_resizer_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_resizer.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shelf/shelf_types.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
@@ skipping 223 matching lines @@
   aura::test::TestWindowDelegate delegate_;
 
   // Location at start of the drag in |window->parent()|'s coordinates.
   gfx::Point initial_location_in_parent_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedWindowResizerTest);
 };
 
 // Verifies a window can be dragged and attached to the dock.
 TEST_P(DockedWindowResizerTest, AttachRightPrecise) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock
 // even if pointer overshoots the screen edge by a few pixels (sticky edge)
 TEST_P(DockedWindowResizerTest, AttachRightOvershoot) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), +4);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and then if a pointer is not quite reaching
 // the screen edge the window does not get docked and stays in the desktop.
 TEST_P(DockedWindowResizerTest, AttachRightUndershoot) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   // Grabbing at 70px ensures that at least 30% of the window is in screen,
   // otherwise the window would be adjusted in
   // WorkspaceLayoutManager::AdjustWindowBoundsWhenAdded.
   const int kGrabOffsetX = 70;
   const int kUndershootBy = 1;
   DragVerticallyAndRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(),
                                   -kUndershootBy, test_panels() ? -100 : 20,
                                   kGrabOffsetX, 5);
 
   // The window right should be past the screen edge but not docked.
   // Initial touch point is 70px to the right which helps to find where the edge
   // should be.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right() +
                 window->bounds().width() - kGrabOffsetX - kUndershootBy - 1,
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock.
 TEST_P(DockedWindowResizerTest, AttachLeftPrecise) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 0);
 
   // The window should be docked at the left edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock
 // even if pointer overshoots the screen edge by a few pixels (sticky edge)
 TEST_P(DockedWindowResizerTest, AttachLeftOvershoot) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), -4);
 
   // The window should be docked at the left edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and then if a pointer is not quite reaching
 // the screen edge the window does not get docked and stays in the desktop.
 TEST_P(DockedWindowResizerTest, AttachLeftUndershoot) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   gfx::Rect initial_bounds(window->bounds());
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 1);
 
   // The window should be crossing the screen edge but not docked.
   int expected_x = initial_bounds.x() - initial_location_in_parent().x() + 1;
   EXPECT_EQ(expected_x, window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Dock on the right side, change shelf alignment, check that windows move to
 // the opposite side.
 TEST_P(DockedWindowResizerTest, AttachRightChangeShelf) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // set launcher shelf to be aligned on the right
@@ skipping 13 matching lines @@
   // set launcher shelf to be aligned at the bottom
   GetPrimaryShelf()->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
   // The window should stay in the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Dock on the right side, try to undock, then drag more to really undock
 TEST_P(DockedWindowResizerTest, AttachTryDetach) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, ideal_width() + 10, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   // Its width should shrink to ideal width.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
@@ skipping 23 matching lines @@
   // The window should be floating on the desktop again and moved to the left.
   EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Dock on the right side, and undock by dragging the right edge of the window
 // header. This test is useful because both the position of the dragged window
 // and the position of the mouse are used in determining whether a window should
 // be undocked.
 TEST_P(DockedWindowResizerTest, AttachTryDetachDragRightEdgeOfHeader) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, ideal_width() + 10, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   // Its width should shrink to ideal width.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
@@ skipping 20 matching lines @@
   // Release the mouse and the window should be no longer attached to the dock.
   DragEnd();
 
   // The window should be floating on the desktop again and moved to the left.
   EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Minimize a docked window, then restore it and check that it is still docked.
 TEST_P(DockedWindowResizerTest, AttachMinimizeRestore) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   // Minimize the window, it should be hidden.
   window_state->Minimize();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_TRUE(window_state->IsMinimized());
   // Restore the window; window should be visible.
   window_state->Restore();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(window_state->IsDocked());
 }
 
 // Maximize a docked window and check that it is maximized and no longer docked.
 TEST_P(DockedWindowResizerTest, AttachMaximize) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   // Maximize the window, it should get undocked and maximized in a desktop.
   window_state->Maximize();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(window_state->IsMaximized());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Dock two windows, undock one, check that the other one is still docked.
 TEST_P(DockedWindowResizerTest, AttachTwoWindows) {
-  if (!SupportsHostWindowResize())
-    return;
   UpdateDisplay("600x600");
 
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 50);
 
   // Docking second window should not minimize the first.
   wm::WindowState* window_state1 = wm::GetWindowState(w1.get());
   EXPECT_FALSE(window_state1->IsMinimized());
@@ skipping 21 matching lines @@
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The window should be floating on the desktop again and moved to the left.
   EXPECT_EQ(left_edge - 32, w2->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
 }
 
 // Create two windows, dock one and change shelf to auto-hide.
 TEST_P(DockedWindowResizerTest, AttachOneAutoHideShelf) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
 
   // w1 should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   std::unique_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegateAndType(
       NULL, ui::wm::WINDOW_TYPE_NORMAL, 0, gfx::Rect(20, 20, 150, 20)));
@@ skipping 19 matching lines @@
                   .work_area();
   // Docked window should be centered vertically in the work area.
   EXPECT_EQ(work_area.CenterPoint().y(), w1->bounds().CenterPoint().y());
   // Docked background should extend to the bottom of work area.
   EXPECT_EQ(work_area.bottom(), manager->docked_bounds().bottom());
 }
 
 // Dock one window, try to dock another window on the opposite side (should not
 // dock).
 TEST_P(DockedWindowResizerTest, AttachOnTwoSides) {
-  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, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   gfx::Rect initial_bounds(w2->bounds());
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w2.get(), 50);
 
   // The first window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be near the left edge but not snapped.
   // Normal window will get side-maximized while panels will not.
   int expected_x = test_panels()
                        ? (initial_bounds.x() - initial_location_in_parent().x())
                        : 0;
   EXPECT_EQ(expected_x, w2->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
 }
 
 // Tests that reverting a drag restores docked state if a window was docked.
 TEST_P(DockedWindowResizerTest, RevertDragRestoresAttachment) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be docked at the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Drag the window out but revert the drag
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
   DragMove(-50, 0);
   DragRevert();
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Detach window.
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
   DragMove(-50, 0);
   DragEnd();
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Tests that reverting drag restores undocked state if a window was not docked.
 TEST_P(DockedWindowResizerTest, RevertDockedDragRevertsAttachment) {
-  if (!SupportsHostWindowResize())
-    return;
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(window.get()));
   int previous_container_id = window->parent()->id();
   // Drag the window out but revert the drag
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
   DragMove(-50 - window->bounds().x(), 50 - window->bounds().y());
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragRevert();
@@ skipping 76 matching lines @@
   DragEnd();
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 }
 
 // Dock two windows, undock one.
 // Test the docked windows area size and default container resizing.
 TEST_P(DockedWindowResizerTest, AttachTwoWindowsDetachOne) {
-  if (!SupportsHostWindowResize())
-    return;
   UpdateDisplay("600x600");
 
   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, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
@@ skipping 49 matching lines @@
   EXPECT_EQ(left_edge + drag_x, w2->bounds().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to remaining single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 }
 
 // Dock one of the windows. Maximize other testing desktop resizing.
 TEST_P(DockedWindowResizerTest, AttachWindowMaximizeOther) {
-  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, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
@@ skipping 74 matching lines @@
             w2->bounds().width());
 
   // Unmaximize the second window.
   w2_state->Restore();
   // Its bounds should get restored.
   EXPECT_EQ(restored_bounds, w2->bounds());
 }
 
 // Dock one window. Test the sticky behavior near screen or desktop edge.
 TEST_P(DockedWindowResizerTest, AttachOneTestSticky) {
-  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, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w1.get(), 20);
   // A window should be docked at the left edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().x(),
             w1->GetBoundsInScreen().x());
@@ skipping 72 matching lines @@
             docked_width(manager));
   // Desktop work area should now shrink by dock width.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
                 docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 }
 
 // Dock two windows, resize one.
 // Test the docked windows area size and remaining desktop resizing.
 TEST_P(DockedWindowResizerTest, ResizeOneOfTwoWindows) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   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, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
@@ skipping 119 matching lines @@
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Desktop work area should be inset.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width() -
                 docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
 }
 
 // Dock a window, resize it and test that undocking it restores the pre-docked
 // size.
 TEST_P(DockedWindowResizerTest, ResizingKeepsSize) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   const gfx::Size original_size(201, 201);
   std::unique_ptr<aura::Window> w1(
       CreateTestWindow(gfx::Rect(gfx::Point(), original_size)));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // Window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
@@ skipping 32 matching lines @@
   EXPECT_EQ(ideal_width(), w1->bounds().width());
 
   // Undock again by dragging left.
   DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT, w1.get(), 100, 20);
   // Size should be restored to what it was originally.
   EXPECT_EQ(original_size.ToString(), w1->bounds().size().ToString());
 }
 
 // Dock a window, resize it and test that it stays docked.
 TEST_P(DockedWindowResizerTest, ResizingKeepsDockedState) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // Window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
@@ skipping 35 matching lines @@
   // The window should stay docked.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // The dock should stay as wide as w1 is now (a bit less than before).
   EXPECT_EQ(previous_width - kResizeSpan2, w1->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 }
 
 // Dock two windows, resize one. Test the docked windows area size.
 TEST_P(DockedWindowResizerTest, ResizeTwoWindows) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   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, 201)));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100);
   // Both windows should now be docked at the right edge.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
@@ skipping 44 matching lines @@
   DragEnd();
   // Making w1 wider should make both windows wider since w2 no longer remembers
   // user width.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 }
 
 // Tests that dragging a window down to shelf attaches a panel but does not
 // attach a regular window.
 TEST_P(DockedWindowResizerTest, DragToShelf) {
-  if (!SupportsHostWindowResize())
-    return;
-
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
@@ skipping 24 matching lines @@
     EXPECT_TRUE(wm::GetWindowState(w1.get())->panel_attached());
   } else {
     // The window should not be touching the shelf.
     EXPECT_EQ(shelf_y - kDistanceFromShelf, w1->bounds().bottom());
   }
 }
 
 // Tests that docking and undocking a |window| with a transient child properly
 // maintains the parent of that transient child to be the same as the |window|.
 TEST_P(DockedWindowResizerTest, DragWindowWithTransientChild) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Create a window with a transient child.
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   std::unique_ptr<aura::Window> child(
       CreateTestWindowInShellWithDelegateAndType(
           NULL, ui::wm::WINDOW_TYPE_NORMAL, 0, gfx::Rect(20, 20, 150, 20)));
   ::wm::AddTransientChild(window.get(), child.get());
   if (window->parent() != child->parent())
     window->parent()->AddChild(child.get());
   EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get()));
@@ skipping 20 matching lines @@
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(kShellWindowId_DefaultContainer, child->parent()->id());
   // The child should not have moved.
   EXPECT_EQ(gfx::Point(20 + 500, 20 + 20).ToString(),
             child->GetBoundsInScreen().origin().ToString());
 }
 
 // Tests that reparenting windows during the drag does not affect system modal
 // windows that are transient children of the dragged windows.
 TEST_P(DockedWindowResizerTest, DragWindowWithModalTransientChild) {
-  if (!SupportsHostWindowResize())
-    return;
-
   // Create a window.
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   gfx::Rect bounds(window->bounds());
 
   // Start dragging the window.
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
   gfx::Vector2d move_vector(40, test_panels() ? -60 : 60);
   DragMove(move_vector.x(), move_vector.y());
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
@@ skipping 19 matching lines @@
   EXPECT_EQ(kShellWindowId_SystemModalContainer, child->parent()->id());
   // The |child| should not have moved.
   EXPECT_EQ(gfx::Point(20, 20).ToString(),
             child->GetBoundsInScreen().origin().ToString());
   // The |child| should still be a transient child of |window|.
   EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get()));
 }
 
 // Tests that side snapping a window undocks it, closes the dock and then snaps.
 TEST_P(DockedWindowResizerTest, SideSnapDocked) {
-  if (!SupportsHostWindowResize() || test_panels())
+  if (test_panels())
     return;
 
   std::unique_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   wm::WindowState* window_state = wm::GetWindowState(w1.get());
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
@@ skipping 36 matching lines @@
   EXPECT_EQ(work_area.height(), w1->bounds().height());
   EXPECT_EQ(work_area.x(), w1->bounds().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id());
   EXPECT_FALSE(window_state->IsDocked());
   EXPECT_TRUE(window_state->IsSnapped());
 }
 
 // Tests that a window is undocked if the window is maximized via a keyboard
 // accelerator during a drag.
 TEST_P(DockedWindowResizerTest, MaximizedDuringDrag) {
-  if (!SupportsHostWindowResize() || test_panels())
+  if (test_panels())
     return;
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, ideal_width(), 201)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());
 
   // Dock the window to the right edge.
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, window.get(), 20);
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
@@ skipping 24 matching lines @@
   EXPECT_TRUE(window_state->IsMaximized());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowResizerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 
 }  // namespace ash