Converts overview to use common ash types

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/drag_drop/drag_drop_controller.h"
@@ skipping 196 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(window);
-                             });
+    auto iter =
+        std::find_if(windows.cbegin(), windows.cend(),
+                     [window](const WindowSelectorItem* item) {
+                       return item->Contains(wm::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 item->GetWindow();
+    return wm::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 = window_item->root_window();
-    EXPECT_TRUE(window_item->Contains(window));
+    aura::Window* root_window =
+        wm::WmWindowAura::GetAuraWindow(window_item->root_window());
+    EXPECT_TRUE(window_item->Contains(wm::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());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
+  wm::WmWindow* right_window_wm = 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.get());
-  EXPECT_EQ(overview1[1]->GetWindow(), right_window.get());
+  EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
+  EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
   ToggleOverview();
 
   // Active the right window, the order should be the same.
   wm::GetWindowState(right_window.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview2[0]->GetWindow(), left_window.get());
-  EXPECT_EQ(overview2[1]->GetWindow(), right_window.get());
+  EXPECT_EQ(overview2[0]->GetWindow(), left_window_wm);
+  EXPECT_EQ(overview2[1]->GetWindow(), right_window_wm);
   ToggleOverview();
 
   // Switch the window positions, and the order should be switched.
   left_window->SetBounds(right_bounds);
   right_window->SetBounds(left_bounds);
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview3(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview3[0]->GetWindow(), right_window.get());
-  EXPECT_EQ(overview3[1]->GetWindow(), left_window.get());
+  EXPECT_EQ(overview3[0]->GetWindow(), right_window_wm);
+  EXPECT_EQ(overview3[1]->GetWindow(), left_window_wm);
   ToggleOverview();
 }
 
 // Tests that the ordering of windows is near the windows' original positions
 // 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());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
+  wm::WmWindow* right_window_wm = 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.get());
-  EXPECT_EQ(overview1[1]->GetWindow(), right_window.get());
+  EXPECT_EQ(overview1[0]->GetWindow(), left_window_wm);
+  EXPECT_EQ(overview1[1]->GetWindow(), right_window_wm);
   ToggleOverview();
 
   // Active the right window, the order should be the same.
   wm::GetWindowState(right_window.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
-  EXPECT_EQ(overview2[0]->GetWindow(), left_window.get());
-  EXPECT_EQ(overview2[1]->GetWindow(), right_window.get());
+  EXPECT_EQ(overview2[0]->GetWindow(), left_window_wm);
+  EXPECT_EQ(overview2[1]->GetWindow(), right_window_wm);
   ToggleOverview();
 }
 
 // Tests that the ordering of windows is stable across different overview
 // sessions even when the windows have the same bounds.
 TEST_F(WindowSelectorTest, StableOrder) {
   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));
 
   // The initial ordering is not defined, but should remain consistent the next
   // time overview is started.
   wm::GetWindowState(window1.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
-  int initial_order[2] = {overview1[0]->GetWindow()->id(),
-                          overview1[1]->GetWindow()->id()};
+  int initial_order[2] = {overview1[0]->GetWindow()->GetShellWindowId(),
+                          overview1[1]->GetWindow()->GetShellWindowId()};
   ToggleOverview();
 
   // Activate the other window, the order should be the same.
   wm::GetWindowState(window2.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
-  EXPECT_EQ(initial_order[0], overview2[0]->GetWindow()->id());
-  EXPECT_EQ(initial_order[1], overview2[1]->GetWindow()->id());
+  EXPECT_EQ(initial_order[0], overview2[0]->GetWindow()->GetShellWindowId());
+  EXPECT_EQ(initial_order[1], overview2[1]->GetWindow()->GetShellWindowId());
   ToggleOverview();
 }
 
 // Tests entering overview mode with docked windows
 TEST_F(WindowSelectorTest, BasicWithDocked) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> docked1(CreateWindow(bounds));
@@ skipping 771 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<WindowSelectorItem*>& overview_windows =
       GetWindowItemsForRoot(0);
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(), overview_windows[0]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::WmWindowAura::GetAuraWindow(overview_windows[0]->GetWindow()));
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(), overview_windows[1]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::WmWindowAura::GetAuraWindow(overview_windows[1]->GetWindow()));
   SendKey(ui::VKEY_TAB);
-  EXPECT_EQ(GetSelectedWindow(), overview_windows[0]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::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 30 matching lines @@
     ToggleOverview();
     const std::vector<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.
       EXPECT_EQ(GetSelectedWindow()->id(),
                 overview_windows[index_path_for_direction[key_index][i] - 1]
                     ->GetWindow()
-                    ->id());
+                    ->GetShellWindowId());
     }
     ToggleOverview();
   }
 }
 
 // Tests basic selection across multiple monitors.
 TEST_F(WindowSelectorTest, BasicMultiMonitorArrowKeyNavigation) {
   if (!SupportsMultipleDisplays())
     return;
 
   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<WindowSelectorItem*>& overview_root1 =
       GetWindowItemsForRoot(0);
   const std::vector<WindowSelectorItem*>& overview_root2 =
       GetWindowItemsForRoot(1);
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(), overview_root1[0]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::WmWindowAura::GetAuraWindow(overview_root1[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(), overview_root1[1]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::WmWindowAura::GetAuraWindow(overview_root1[1]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(), overview_root2[0]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::WmWindowAura::GetAuraWindow(overview_root2[0]->GetWindow()));
   SendKey(ui::VKEY_RIGHT);
-  EXPECT_EQ(GetSelectedWindow(), overview_root2[1]->GetWindow());
+  EXPECT_EQ(GetSelectedWindow(),
+            wm::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 325 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