Shuffles and renames ash/common/wm classes

ash/wm/overview/window_selector_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
+#include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.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/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/shelf_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
-#include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 170 matching lines @@
 
   const std::vector<WindowSelectorItem*>& GetWindowItemsForRoot(int index) {
     return ash::Shell::GetInstance()->window_selector_controller()->
         window_selector_->grid_list_[index]->window_list_.get();
   }
 
   WindowSelectorItem* GetWindowItemForWindow(int grid_index,
                                              aura::Window* window) {
     const std::vector<WindowSelectorItem*>& windows =
         GetWindowItemsForRoot(grid_index);
-    auto iter =
-        std::find_if(windows.cbegin(), windows.cend(),
-                     [window](const WindowSelectorItem* item) {
-                       return item->Contains(wm::WmWindowAura::Get(window));
-                     });
+    auto iter = std::find_if(windows.cbegin(), windows.cend(),
+                             [window](const WindowSelectorItem* item) {
+                               return item->Contains(WmWindowAura::Get(window));
+                             });
     if (iter == windows.end())
       return nullptr;
     return *iter;
   }
 
   // Selects |window| in the active overview session by cycling through all
   // windows in overview until it is found. Returns true if |window| was found,
   // false otherwise.
   bool SelectWindow(const aura::Window* window) {
     if (GetSelectedWindow() == nullptr)
       SendKey(ui::VKEY_TAB);
     const aura::Window* start_window = GetSelectedWindow();
     if (start_window == window)
       return true;
     do {
       SendKey(ui::VKEY_TAB);
     } while (GetSelectedWindow() != window &&
              GetSelectedWindow() != start_window);
     return GetSelectedWindow() == window;
   }
 
   const aura::Window* GetSelectedWindow() {
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     WindowSelectorItem* item =
         ws->grid_list_[ws->selected_grid_index_]->SelectedWindow();
     if (!item)
       return nullptr;
-    return wm::WmWindowAura::GetAuraWindow(item->GetWindow());
+    return WmWindowAura::GetAuraWindow(item->GetWindow());
   }
 
   bool selection_widget_active() {
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     return ws->grid_list_[ws->selected_grid_index_]->is_selecting();
   }
 
   bool showing_filter_widget() {
     WindowSelector* ws = ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get();
     return ws->text_filter_widget_->GetNativeWindow()->layer()->
         GetTargetTransform().IsIdentity();
   }
 
   views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
     return &(window->close_button_widget_);
   }
 
   views::LabelButton* GetLabelButtonView(ash::WindowSelectorItem* window) {
     return window->window_label_button_view_;
   }
 
   // Tests that a window is contained within a given WindowSelectorItem, and
   // that both the window and its matching close button are within the same
   // screen.
   void IsWindowAndCloseButtonInScreen(aura::Window* window,
                                       WindowSelectorItem* window_item) {
     aura::Window* root_window =
-        wm::WmWindowAura::GetAuraWindow(window_item->root_window());
-    EXPECT_TRUE(window_item->Contains(wm::WmWindowAura::Get(window)));
+        WmWindowAura::GetAuraWindow(window_item->root_window());
+    EXPECT_TRUE(window_item->Contains(WmWindowAura::Get(window)));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(window))));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         ToEnclosingRect(GetTransformedTargetBounds(
             GetCloseButton(window_item)->GetNativeView()))));
   }
 
   void FilterItems(const base::StringPiece& pattern) {
     ash::Shell::GetInstance()->
         window_selector_controller()->window_selector_.get()->
@@ skipping 119 matching lines @@
 
 // Tests that the ordering of windows is near the windows' original positions.
 TEST_F(WindowSelectorTest, MinimizeMovement) {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect left_bounds(0, 0, root_window->bounds().width() / 2,
                         root_window->bounds().height());
   gfx::Rect right_bounds(root_window->bounds().width() / 2, 0,
                          root_window->bounds().width() / 2,
                          root_window->bounds().height());
   std::unique_ptr<aura::Window> left_window(CreateWindow(left_bounds));
-  wm::WmWindow* left_window_wm = wm::WmWindowAura::Get(left_window.get());
+  WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
-  wm::WmWindow* right_window_wm = wm::WmWindowAura::Get(right_window.get());
+  WmWindow* right_window_wm = WmWindowAura::Get(right_window.get());
 
   // The window should stay on the same side of the screen regardless of which
   // one was active on entering overview mode.
   wm::GetWindowState(left_window.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
   EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
   EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
   ToggleOverview();
 
@@ skipping 19 matching lines @@
 // on a second display.
 TEST_F(WindowSelectorTest, MinimizeMovementSecondDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   // Verify the same works on the second display
   UpdateDisplay("400x400,400x400");
   gfx::Rect left_bounds(400, 0, 200, 400);
   gfx::Rect right_bounds(600, 0, 200, 400);
   std::unique_ptr<aura::Window> left_window(CreateWindow(left_bounds));
-  wm::WmWindow* left_window_wm = wm::WmWindowAura::Get(left_window.get());
+  WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
-  wm::WmWindow* right_window_wm = wm::WmWindowAura::Get(right_window.get());
+  WmWindow* right_window_wm = WmWindowAura::Get(right_window.get());
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows[1], left_window->GetRootWindow());
   EXPECT_EQ(root_windows[1], right_window->GetRootWindow());
 
   wm::GetWindowState(left_window.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
   EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
   EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
@@ skipping 815 matching lines @@
 TEST_F(WindowSelectorTest, BasicTabKeyNavigation) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ToggleOverview();
 
   const std::vector<WindowSelectorItem*>& overview_windows =
       GetWindowItemsForRoot(0);
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_windows[1]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_windows[1]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
 }
 
 // Tests traversing some windows in overview mode with the arrow keys in every
 // possible direction.
 TEST_F(WindowSelectorTest, BasicArrowKeyNavigation) {
   if (!SupportsHostWindowResize())
     return;
   const size_t test_windows = 9;
   UpdateDisplay("800x600");
   ScopedVector<aura::Window> windows;
@@ skipping 57 matching lines @@
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds1));
 
   ToggleOverview();
 
   const std::vector<WindowSelectorItem*>& overview_root1 =
       GetWindowItemsForRoot(0);
   const std::vector<WindowSelectorItem*>& overview_root2 =
       GetWindowItemsForRoot(1);
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_root1[0]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_root1[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_root1[1]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_root1[1]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_root2[0]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_root2[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            wm::WmWindowAura::GetAuraWindow(overview_root2[1]->GetWindow()));
+            WmWindowAura::GetAuraWindow(overview_root2[1]->GetWindow()));
 }
 
 // Tests first monitor when display order doesn't match left to right screen
 // positions.
 TEST_F(WindowSelectorTest, MultiMonitorReversedOrder) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("400x400,400x400");
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
@@ skipping 87 matching lines @@
   ASSERT_TRUE(SelectWindow(window2.get()));
   SendKey(ui::VKEY_RETURN);
   EXPECT_FALSE(IsSelecting());
   EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
 }
 
 // Tests that overview mode hides the callout widget.
 TEST_F(WindowSelectorTest, WindowOverviewHidesCalloutWidgets) {
   std::unique_ptr<aura::Window> panel1(
       CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
-  wm::WmWindow* wm_panel1 = wm::WmWindowAura::Get(panel1.get());
+  WmWindow* wm_panel1 = WmWindowAura::Get(panel1.get());
   std::unique_ptr<aura::Window> panel2(
       CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
-  wm::WmWindow* wm_panel2 = wm::WmWindowAura::Get(panel2.get());
+  WmWindow* wm_panel2 = WmWindowAura::Get(panel2.get());
   PanelLayoutManager* panel_manager = PanelLayoutManager::Get(wm_panel1);
 
   // By default, panel callout widgets are visible.
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel1)->IsVisible());
   EXPECT_TRUE(panel_manager->GetCalloutWidgetForPanel(wm_panel2)->IsVisible());
 
   // Toggling the overview should hide the callout widgets.
   ToggleOverview();
   EXPECT_FALSE(panel_manager->GetCalloutWidgetForPanel(wm_panel1)->IsVisible());
   EXPECT_FALSE(panel_manager->GetCalloutWidgetForPanel(wm_panel2)->IsVisible());
@@ skipping 214 matching lines @@
             bounds.y());
   EXPECT_LE(transformed_rect.bottom(), bounds.bottom());
   EXPECT_NEAR(transformed_rect.x() - bounds.x(),
               bounds.right() - transformed_rect.right(), 1);
   EXPECT_NEAR(
       transformed_rect.y() + (int)(scale * inset) - header_height - bounds.y(),
       bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 }  // namespace ash