Moves WindowSelectorController onto WmShell

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/material_design/material_design_controller.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/mru_window_tracker.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_shell.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/material_design_controller_test_api.h"
 #include "ash/test/shelf_test_api.h"
@@ skipping 134 matching lines @@
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     return window;
   }
 
   bool WindowsOverlapping(aura::Window* window1, aura::Window* window2) {
     gfx::RectF window1_bounds = GetTransformedTargetBounds(window1);
     gfx::RectF window2_bounds = GetTransformedTargetBounds(window2);
     return window1_bounds.Intersects(window2_bounds);
   }
 
-  void ToggleOverview() {
-    ash::Shell::GetInstance()->window_selector_controller()->ToggleOverview();
+  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(); }
+
   gfx::RectF 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 bounds;
   }
 
@@ skipping 25 matching lines @@
     ui::test::EventGenerator event_generator(window->GetRootWindow(), window);
     event_generator.ClickLeftButton();
   }
 
   void SendKey(ui::KeyboardCode key) {
     ui::test::EventGenerator event_generator(Shell::GetPrimaryRootWindow());
       event_generator.PressKey(key, 0);
       event_generator.ReleaseKey(key, 0);
   }
 
-  bool IsSelecting() {
-    return ash::Shell::GetInstance()->window_selector_controller()->
-        IsSelecting();
-  }
+  bool IsSelecting() { return window_selector_controller()->IsSelecting(); }
 
   aura::Window* GetFocusedWindow() {
     return aura::client::GetFocusClient(
         Shell::GetPrimaryRootWindow())->GetFocusedWindow();
     }
 
   const std::vector<WindowSelectorItem*>& GetWindowItemsForRoot(int index) {
-    return ash::Shell::GetInstance()->window_selector_controller()->
-        window_selector_->grid_list_[index]->window_list_.get();
+    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));
                              });
@@ skipping 12 matching lines @@
     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();
+    WindowSelector* ws = window_selector();
     WindowSelectorItem* item =
         ws->grid_list_[ws->selected_grid_index_]->SelectedWindow();
     if (!item)
       return nullptr;
     return WmWindowAura::GetAuraWindow(item->GetWindow());
   }
 
   bool selection_widget_active() {
-    WindowSelector* ws = ash::Shell::GetInstance()->
-        window_selector_controller()->window_selector_.get();
+    WindowSelector* ws = window_selector();
     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();
+    return window_selector()
+        ->text_filter_widget_->GetNativeWindow()
+        ->layer()
+        ->GetTargetTransform()
+        .IsIdentity();
   }
 
   views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
     return window->close_button_->GetWidget();
   }
 
   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 =
         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()->
-            ContentsChanged(nullptr, base::UTF8ToUTF16(pattern));
+    window_selector()->ContentsChanged(nullptr, base::UTF8ToUTF16(pattern));
   }
 
   test::ShelfViewTestAPI* shelf_view_test() {
     return shelf_view_test_.get();
   }
 
   views::Widget* text_filter_widget() {
-    return ash::Shell::GetInstance()->
-        window_selector_controller()->window_selector_.get()->
-            text_filter_widget_.get();
+    return window_selector()->text_filter_widget_.get();
   }
 
  private:
   aura::test::TestWindowDelegate delegate_;
   NonActivatableActivationDelegate non_activatable_activation_delegate_;
   std::unique_ptr<test::ShelfViewTestAPI> shelf_view_test_;
   std::unique_ptr<test::MaterialDesignControllerTestAPI> material_design_state_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorTest);
 };
@@ skipping 272 matching lines @@
   ToggleOverview();
 
   EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
   // Docked windows stays the same.
   EXPECT_EQ(docked_bounds.ToString(), docked1->GetBoundsInScreen().ToString());
   EXPECT_FALSE(docked2->IsVisible());
 
   // Docked window can still be activated, which will exit the overview mode.
   ClickWindow(docked1.get());
   EXPECT_TRUE(wm::IsActiveWindow(docked1.get()));
-  EXPECT_FALSE(
-      ash::Shell::GetInstance()->window_selector_controller()->IsSelecting());
+  EXPECT_FALSE(window_selector_controller()->IsSelecting());
 }
 
 // Tests selecting a window by tapping on it.
 TEST_P(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(), GetFocusedWindow());
   ToggleOverview();
@@ skipping 1197 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