[mus+ash] Removes WmWindow from ash/wm/mru_window_tracker and overview mode

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/accessibility_types.h"
 #include "ash/drag_drop/drag_drop_controller.h"
@@ skipping 155 matching lines @@
 
   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 WmWindow::GetAuraWindow(
-        selector->GetOverviewWindowForMinimizedStateForTest());
+    return selector->GetOverviewWindowForMinimizedStateForTest();
   }
 
   gfx::Rect GetTransformedBounds(aura::Window* window) {
     gfx::Rect bounds_in_screen = window->layer()->bounds();
     ::wm::ConvertRectToScreen(window->parent(), &bounds_in_screen);
     gfx::RectF bounds(bounds_in_screen);
     gfx::Transform transform(gfx::TransformAboutPivot(
         gfx::ToFlooredPoint(bounds.origin()), window->layer()->transform()));
     transform.TransformRect(&bounds);
     return gfx::ToEnclosingRect(bounds);
@@ skipping 50 matching lines @@
     return window_selector()->grid_list_[index]->window_list();
   }
 
   WindowSelectorItem* GetWindowItemForWindow(int grid_index,
                                              aura::Window* window) {
     const std::vector<std::unique_ptr<WindowSelectorItem>>& windows =
         GetWindowItemsForRoot(grid_index);
     auto iter =
         std::find_if(windows.cbegin(), windows.cend(),
                      [window](const std::unique_ptr<WindowSelectorItem>& item) {
-                       return item->Contains(WmWindow::Get(window));
+                       return item->Contains(window);
                      });
     if (iter == windows.end())
       return nullptr;
     return iter->get();
   }
 
   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 WmWindow::GetAuraWindow(item->GetWindow());
+    return 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::Label* GetLabelView(WindowSelectorItem* window) {
     return window->label_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 =
-        WmWindow::GetAuraWindow(window_item->root_window());
-    EXPECT_TRUE(window_item->Contains(WmWindow::Get(window)));
+    aura::Window* root_window = window_item->root_window();
+    EXPECT_TRUE(window_item->Contains(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 185 matching lines @@
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindowWithId(bounds, 1));
   std::unique_ptr<aura::Window> window2(CreateWindowWithId(bounds, 2));
   std::unique_ptr<aura::Window> window3(CreateWindowWithId(bounds, 3));
 
   // The order of windows in overview mode is MRU.
   wm::GetWindowState(window1.get())->Activate();
   ToggleOverview();
   const std::vector<std::unique_ptr<WindowSelectorItem>>& overview1 =
       GetWindowItemsForRoot(0);
-  EXPECT_EQ(1, overview1[0]->GetWindow()->aura_window()->id());
-  EXPECT_EQ(3, overview1[1]->GetWindow()->aura_window()->id());
-  EXPECT_EQ(2, overview1[2]->GetWindow()->aura_window()->id());
+  EXPECT_EQ(1, overview1[0]->GetWindow()->id());
+  EXPECT_EQ(3, overview1[1]->GetWindow()->id());
+  EXPECT_EQ(2, overview1[2]->GetWindow()->id());
   ToggleOverview();
 
   // Activate the second window.
   wm::GetWindowState(window2.get())->Activate();
   ToggleOverview();
   const std::vector<std::unique_ptr<WindowSelectorItem>>& overview2 =
       GetWindowItemsForRoot(0);
 
   // The order should be MRU.
-  EXPECT_EQ(2, overview2[0]->GetWindow()->aura_window()->id());
-  EXPECT_EQ(1, overview2[1]->GetWindow()->aura_window()->id());
-  EXPECT_EQ(3, overview2[2]->GetWindow()->aura_window()->id());
+  EXPECT_EQ(2, overview2[0]->GetWindow()->id());
+  EXPECT_EQ(1, overview2[1]->GetWindow()->id());
+  EXPECT_EQ(3, overview2[2]->GetWindow()->id());
   ToggleOverview();
 }
 
 // Tests selecting a window by tapping on it.
 TEST_F(WindowSelectorTest, BasicGesture) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
   EXPECT_EQ(window1.get(), wm::GetFocusedWindow());
@@ skipping 795 matching lines @@
 // Tests traversing some windows in overview mode with the tab key.
 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<std::unique_ptr<WindowSelectorItem>>& overview_windows =
       GetWindowItemsForRoot(0);
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_windows[0]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_windows[0]->GetWindow());
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_windows[1]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_windows[1]->GetWindow());
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_windows[0]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), 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 29 matching lines @@
   for (size_t key_index = 0; key_index < arraysize(arrow_keys); key_index++) {
     ToggleOverview();
     const std::vector<std::unique_ptr<WindowSelectorItem>>& overview_windows =
         GetWindowItemsForRoot(0);
     for (size_t i = 0; i < test_windows + 1; i++) {
       SendKey(arrow_keys[key_index]);
       // TODO(flackr): Add a more readable error message by constructing a
       // string from the window IDs.
       const int index = index_path_for_direction[key_index][i];
       EXPECT_EQ(GetSelectedWindow()->id(),
-                overview_windows[index - 1]->GetWindow()->aura_window()->id());
+                overview_windows[index - 1]->GetWindow()->id());
     }
     ToggleOverview();
   }
 }
 
 // Tests basic selection across multiple monitors.
 TEST_F(WindowSelectorTest, BasicMultiMonitorArrowKeyNavigation) {
   UpdateDisplay("400x400,400x400");
   gfx::Rect bounds1(0, 0, 100, 100);
   gfx::Rect bounds2(450, 0, 100, 100);
   std::unique_ptr<aura::Window> window4(CreateWindow(bounds2));
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds2));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds1));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds1));
 
   ToggleOverview();
 
   const std::vector<std::unique_ptr<WindowSelectorItem>>& overview_root1 =
       GetWindowItemsForRoot(0);
   const std::vector<std::unique_ptr<WindowSelectorItem>>& overview_root2 =
       GetWindowItemsForRoot(1);
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_root1[0]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_root1[0]->GetWindow());
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_root1[1]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_root1[1]->GetWindow());
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_root2[0]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_root2[0]->GetWindow());
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(),
-            WmWindow::GetAuraWindow(overview_root2[1]->GetWindow()));
+  EXPECT_EQ(GetSelectedWindow(), overview_root2[1]->GetWindow());
 }
 
 // Tests first monitor when display order doesn't match left to right screen
 // positions.
 TEST_F(WindowSelectorTest, MultiMonitorReversedOrder) {
   // TODO: SetLayoutForCurrentDisplays() needs to ported to mash.
   // http://crbug.com/698043.
   if (Shell::GetAshConfig() == Config::MASH)
     return;
 
@@ skipping 404 matching lines @@
                           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