Shuffles and renames ash/common/wm classes

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/ash_switches.h"
+#include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
-#include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
@@ skipping 40 matching lines @@
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         &delegate_,
         window_type_,
         0,
         bounds);
     if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) {
       test::TestShelfDelegate* shelf_delegate =
           test::TestShelfDelegate::instance();
       shelf_delegate->AddShelfItem(window);
       PanelLayoutManager* manager =
-          PanelLayoutManager::Get(wm::WmWindowAura::Get(window));
+          PanelLayoutManager::Get(WmWindowAura::Get(window));
       manager->Relayout();
     }
     return window;
   }
 
   aura::Window* CreateModalWindow(const gfx::Rect& bounds) {
     aura::Window* window = new aura::Window(&delegate_);
     window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
@@ skipping 12 matching lines @@
       window->SetBounds(gfx::Rect(origin, bounds.size()));
       aura::client::ParentWindowWithContext(window, root, bounds);
     }
     return window;
   }
 
   static WindowResizer* CreateSomeWindowResizer(
       aura::Window* window,
       const gfx::Point& point_in_parent,
       int window_component) {
-    return CreateWindowResizer(wm::WmWindowAura::Get(window), point_in_parent,
+    return CreateWindowResizer(WmWindowAura::Get(window), point_in_parent,
                                window_component,
                                aura::client::WINDOW_MOVE_SOURCE_MOUSE)
         .release();
   }
 
   void DragStart(aura::Window* window) {
     DragStartAtOffsetFromWindowOrigin(window, 0, 0);
   }
 
   void DragStartAtOffsetFromWindowOrigin(aura::Window* window,
@@ skipping 468 matching lines @@
   std::unique_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegateAndType(
       NULL, ui::wm::WINDOW_TYPE_NORMAL, 0, gfx::Rect(20, 20, 150, 20)));
   wm::GetWindowState(w2.get())->Maximize();
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized());
 
   gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(w1.get())
                             .work_area();
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
 
   // 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());
 
   // Turn on shelf auto-hide.
   Shelf::ForPrimaryDisplay()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   work_area = display::Screen::GetScreen()
@@ skipping 57 matching lines @@
   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(wm::WmWindowAura::Get(window.get()));
+      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();
   EXPECT_EQ(previous_container_id, window->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
 
   // Drag a window to the left so that it overlaps the screen edge.
@@ skipping 97 matching lines @@
   // 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());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100);
   // Both windows should now be docked at the right edge.
   EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock width should be set to a wider window.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
@@ skipping 51 matching lines @@
   // 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());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 25, 5));
   DragMove(w2->GetRootWindow()->bounds().width()
            -w2->bounds().width()
            -(w2->bounds().width()/2 + 20)
            -w2->bounds().x(),
            50 - w2->bounds().y());
   DragEnd();
@@ skipping 78 matching lines @@
   // 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());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   // The first window should be docked.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().x(),
             w1->GetBoundsInScreen().x());
   // Dock width should be set to that of a single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Position second window in the desktop 20px to the right of the docked w1.
   DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT,
@@ skipping 79 matching lines @@
   // 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());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100);
   // Both windows should now be docked at the right edge.
   EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock width should be set to a wider window.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
@@ skipping 123 matching lines @@
   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());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Resize the window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
                                                               0, 20,
                                                               HTLEFT));
   DragMove(-kResizeSpan1, 0);
@@ skipping 33 matching lines @@
   // 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 =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Resize the window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(
       w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   // Normally alignment would be reset to "NONE" during the drag when there is
@@ skipping 39 matching lines @@
   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());
   // Dock width should be set to ideal width.
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(ideal_width(), docked_width(manager));
 
   // Resize the first window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
                                                               0, 20,
                                                               HTLEFT));
   DragMove(-kResizeSpan1, 0);
@@ skipping 48 matching lines @@
   // 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());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Detach and drag down to shelf.
   ASSERT_NO_FATAL_FAILURE(DragStart(w1.get()));
   DragMove(-40, 0);
   // Alignment is set to "NONE" when drag starts.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
@@ skipping 108 matching lines @@
     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 =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(w1.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   EXPECT_TRUE(window_state->IsDocked());
   EXPECT_FALSE(window_state->IsSnapped());
 
   // Side snap at right edge.
   const wm::WMEvent snap_right(wm::WM_EVENT_SNAP_RIGHT);
   window_state->OnWMEvent(&snap_right);
   // The window should be snapped at the right edge and the dock should close.
   gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()));
@@ skipping 38 matching lines @@
   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());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(wm::WmWindowAura::Get(window.get()));
+      DockedWindowLayoutManager::Get(WmWindowAura::Get(window.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(window->bounds().width(), docked_width(manager));
   EXPECT_TRUE(window_state->IsDocked());
 
   // Maximize the window while in a real drag. In particular,
   // ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowStateTypeChanged()
   // must be called in order for the maximized window's size to be correct.
   delegate()->set_window_component(HTCAPTION);
   ui::test::EventGenerator& generator = GetEventGenerator();
   generator.MoveMouseTo(window->GetBoundsInScreen().origin());
@@ skipping 11 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