chromeos: Renames WmWindowAura to WmWindow

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/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/system/tray/system_tray.h"
 #include "ash/common/test/test_shelf_delegate.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_grid.h"
 #include "ash/common/wm/overview/window_selector.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/overview/window_selector_item.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/common/wm/workspace/workspace_window_resizer.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
+#include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_app_list_view_presenter_impl.h"
@@ skipping 123 matching lines @@
     WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget.get());
     window->SetIntProperty(WmWindowProperty::TOP_VIEW_INSET, kHeaderHeight);
     ParentWindowInPrimaryRootWindow(widget->GetNativeWindow());
     return widget;
   }
 
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         nullptr, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
     window->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
-    test::TestShelfDelegate::instance()->AddShelfItem(
-        WmWindowAura::Get(window));
+    test::TestShelfDelegate::instance()->AddShelfItem(WmWindow::Get(window));
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     return window;
   }
 
   bool WindowsOverlapping(aura::Window* window1, aura::Window* window2) {
     gfx::Rect window1_bounds = GetTransformedTargetBounds(window1);
     gfx::Rect window2_bounds = GetTransformedTargetBounds(window2);
     return window1_bounds.Intersects(window2_bounds);
   }
 
   WindowSelectorController* window_selector_controller() {
     return WmShell::Get()->window_selector_controller();
   }
 
   WindowSelector* window_selector() {
     return window_selector_controller()->window_selector_.get();
   }
 
   void ToggleOverview() { window_selector_controller()->ToggleOverview(); }
 
   aura::Window* GetOverviewWindowForMinimizedState(int index,
                                                    aura::Window* window) {
     WindowSelectorItem* selector = GetWindowItemForWindow(index, window);
-    return WmWindowAura::GetAuraWindow(
+    return WmWindow::GetAuraWindow(
         selector->GetOverviewWindowForMinimizedStateForTest());
   }
 
   gfx::Rect GetTransformedBounds(aura::Window* window) {
     gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(
         window->parent(), window->layer()->bounds()));
     gfx::Transform transform(gfx::TransformAboutPivot(
         gfx::ToFlooredPoint(bounds.origin()), window->layer()->transform()));
     transform.TransformRect(&bounds);
     return gfx::ToEnclosingRect(bounds);
@@ skipping 52 matching lines @@
   const std::vector<WindowSelectorItem*>& GetWindowItemsForRoot(int index) {
     return 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(WmWindowAura::Get(window));
+                               return item->Contains(WmWindow::Get(window));
                              });
     if (iter == windows.end())
       return nullptr;
     return *iter;
   }
 
   gfx::SlideAnimation* GetBackgroundViewAnimationForWindow(
       int grid_index,
       aura::Window* window) {
     return GetWindowItemForWindow(grid_index, window)
@@ skipping 15 matching lines @@
              GetSelectedWindow() != start_window);
     return GetSelectedWindow() == window;
   }
 
   const aura::Window* GetSelectedWindow() {
     WindowSelector* ws = window_selector();
     WindowSelectorItem* item =
         ws->grid_list_[ws->selected_grid_index_]->SelectedWindow();
     if (!item)
       return nullptr;
-    return WmWindowAura::GetAuraWindow(item->GetWindow());
+    return WmWindow::GetAuraWindow(item->GetWindow());
   }
 
   bool selection_widget_active() {
     WindowSelector* ws = window_selector();
     return ws->grid_list_[ws->selected_grid_index_]->is_selecting();
   }
 
   bool showing_filter_widget() {
     return window_selector()
         ->text_filter_widget_->GetNativeWindow()
         ->layer()
         ->GetTargetTransform()
         .IsIdentity();
   }
 
   views::Widget* GetCloseButton(WindowSelectorItem* window) {
     return window->close_button_->GetWidget();
   }
 
   views::LabelButton* GetLabelButtonView(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 =
-        WmWindowAura::GetAuraWindow(window_item->root_window());
-    EXPECT_TRUE(window_item->Contains(WmWindowAura::Get(window)));
+        WmWindow::GetAuraWindow(window_item->root_window());
+    EXPECT_TRUE(window_item->Contains(WmWindow::Get(window)));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
         GetTransformedTargetBounds(window)));
     EXPECT_TRUE(
         root_window->GetBoundsInScreen().Contains(GetTransformedTargetBounds(
             GetCloseButton(window_item)->GetNativeView())));
   }
 
   void FilterItems(const base::StringPiece& pattern) {
     window_selector()->ContentsChanged(nullptr, base::UTF8ToUTF16(pattern));
   }
@@ skipping 240 matching lines @@
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED,
             wm::GetWindowState(docked2.get())->GetStateType());
 
   ToggleOverview();
 
   EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
 
   gfx::Rect container_bounds = docked1->parent()->bounds();
   ShelfWidget* shelf = GetPrimaryShelf()->shelf_widget();
   DockedWindowLayoutManager* manager =
-      DockedWindowLayoutManager::Get(WmWindowAura::Get(docked1.get()));
+      DockedWindowLayoutManager::Get(WmWindow::Get(docked1.get()));
 
   // Minimized docked windows stays invisible.
   EXPECT_FALSE(docked2->IsVisible());
   EXPECT_TRUE(GetOverviewWindowForMinimizedState(0, docked2.get()));
 
   // Docked area shrinks.
   EXPECT_EQ(0, manager->docked_bounds().width());
 
   // Work area takes the whole screen minus the shelf.
   gfx::Rect work_area = display::Screen::GetScreen()
@@ skipping 1013 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(),
-            WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_windows[0]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
-            WmWindowAura::GetAuraWindow(overview_windows[1]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_windows[1]->GetWindow()));
   SendKey(ui::VKEY_TAB);
   EXPECT_EQ(GetSelectedWindow(),
-            WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_windows[0]->GetWindow()));
 }
 
 // Tests that pressing Ctrl+W while a window is selected in overview closes it.
 TEST_F(WindowSelectorTest, CloseWindowWithKey) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
   aura::Window* window1 = widget->GetNativeWindow();
   ToggleOverview();
@@ skipping 54 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(),
-            WmWindowAura::GetAuraWindow(overview_root1[0]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_root1[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            WmWindowAura::GetAuraWindow(overview_root1[1]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_root1[1]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            WmWindowAura::GetAuraWindow(overview_root2[0]->GetWindow()));
+            WmWindow::GetAuraWindow(overview_root2[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
   EXPECT_EQ(GetSelectedWindow(),
-            WmWindowAura::GetAuraWindow(overview_root2[1]->GetWindow()));
+            WmWindow::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 88 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)));
-  WmWindow* wm_panel1 = WmWindowAura::Get(panel1.get());
+  WmWindow* wm_panel1 = WmWindow::Get(panel1.get());
   std::unique_ptr<aura::Window> panel2(
       CreatePanelWindow(gfx::Rect(0, 0, 100, 100)));
-  WmWindow* wm_panel2 = WmWindowAura::Get(panel2.get());
+  WmWindow* wm_panel2 = WmWindow::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 284 matching lines @@
       transformed_rect.y() + (int)(scale * inset) - header_height - bounds.y(),
       bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 // Start dragging a window and activate overview mode. This test should not
 // crash or DCHECK inside aura::Window::StackChildRelativeTo().
 TEST_F(WindowSelectorTest, OverviewWhileDragging) {
   const gfx::Rect bounds(10, 10, 100, 100);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
   std::unique_ptr<WindowResizer> resizer(
-      CreateWindowResizer(WmWindowAura::Get(window.get()), gfx::Point(),
-                          HTCAPTION, aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+      CreateWindowResizer(WmWindow::Get(window.get()), gfx::Point(), HTCAPTION,
+                          aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   gfx::Point location = resizer->GetInitialLocation();
   location.Offset(20, 20);
   resizer->Drag(location, 0);
   ToggleOverview();
   resizer->RevertDrag();
 }
 
 }  // namespace ash