mash: Migrate AccessibilityDelegate access to 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"
@@ skipping 86 matching lines @@
   return ScopedTransformOverviewWindow::GetItemScale(
       source.size(), target.size(), top_view_inset, title_height);
 }
 
 }  // namespace
 
 // TODO(bruthig): Move all non-simple method definitions out of class
 // declaration.
 class WindowSelectorTest
     : public test::AshTestBase,
-      public testing::WithParamInterface<ash::MaterialDesignController::Mode> {
+      public testing::WithParamInterface<MaterialDesignController::Mode> {

[James Cook, 2016/06/28 22:34:25]

I would leave the MaterialDesignController ones. The MD guys have both a
ui::MaterialDesignController and an ash::MaterialDesignController (ugh) and have
been trying to explicitly include namespace specifiers to make it easier for
them to read the code. I don't feel strongly, so I've been letting them do it.

[msw, 2016/06/28 22:49:50]

Done.

  public:
   WindowSelectorTest() {}
   ~WindowSelectorTest() override {}
 
   void SetUp() override {
     test::AshTestBase::SetUp();
     material_design_state_.reset(
         new test::MaterialDesignControllerTestAPI(GetParam()));
-    if (!ash::MaterialDesignController::IsOverviewMaterial()) {
+    if (!MaterialDesignController::IsOverviewMaterial()) {
       base::CommandLine::ForCurrentProcess()->AppendSwitch(
           switches::kAshEnableStableOverviewOrder);
     }
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
         test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).shelf_view()));
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   void TearDown() override {
     material_design_state_.reset();
     test::AshTestBase::TearDown();
   }
 
   aura::Window* CreateWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds);
   }
 
   aura::Window* CreateWindowWithId(const gfx::Rect& bounds, int id) {
     return CreateTestWindowInShellWithDelegate(&delegate_, id, bounds);
   }
   aura::Window* CreateNonActivatableWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateWindow(bounds);
     aura::client::SetActivationDelegate(window,
                                         &non_activatable_activation_delegate_);
-    EXPECT_FALSE(ash::wm::CanActivateWindow(window));
+    EXPECT_FALSE(wm::CanActivateWindow(window));
     return window;
   }
 
   // Creates a Widget containing a Window with the given |bounds|. This should
   // be used when the test requires a Widget. For example any test that will
   // cause a window to be closed via
   // views::Widget::GetWidgetForNativeView(window)->Close().
   std::unique_ptr<views::Widget> CreateWindowWidget(const gfx::Rect& bounds) {
     std::unique_ptr<views::Widget> widget(new views::Widget);
     views::Widget::InitParams params;
@@ skipping 129 matching lines @@
   }
 
   bool showing_filter_widget() {
     return window_selector()
         ->text_filter_widget_->GetNativeWindow()
         ->layer()
         ->GetTargetTransform()
         .IsIdentity();
   }
 
-  views::Widget* GetCloseButton(ash::WindowSelectorItem* window) {
+  views::Widget* GetCloseButton(WindowSelectorItem* window) {
     return window->close_button_->GetWidget();
   }
 
-  views::LabelButton* GetLabelButtonView(ash::WindowSelectorItem* window) {
+  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());
@@ skipping 22 matching lines @@
   std::unique_ptr<test::MaterialDesignControllerTestAPI> material_design_state_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSelectorTest);
 };
 
 // Note: First argument is optional and intentionally left blank.
 // (it's a prefix for the generated test cases)
 INSTANTIATE_TEST_CASE_P(
     ,
     WindowSelectorTest,
-    testing::Values(ash::MaterialDesignController::NON_MATERIAL,
-                    ash::MaterialDesignController::MATERIAL_NORMAL,
-                    ash::MaterialDesignController::MATERIAL_EXPERIMENTAL));
+    testing::Values(MaterialDesignController::NON_MATERIAL,
+                    MaterialDesignController::MATERIAL_NORMAL,
+                    MaterialDesignController::MATERIAL_EXPERIMENTAL));
 
 #if !defined(OS_WIN) || defined(USE_ASH)
 // TODO(msw): Broken on Windows. http://crbug.com/584038
 // Tests that the text field in the overview menu is repositioned and resized
 // after a screen rotation.
 TEST_P(WindowSelectorTest, OverviewScreenRotation) {
   gfx::Rect bounds(0, 0, 400, 300);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> panel1(CreatePanelWindow(bounds));
 
@@ skipping 10 matching lines @@
   // y: -kTextFilterHeight (since there's no text in the filter).
   // w: root_window->bounds().width() * kTextFilterScreenProportion.
   // h: kTextFilterHeight.
   //
   // With Material Design the text filter position is calculated as:
   // x: 0.5 * (total_bounds.width() -
   //           std::min(kTextFilterWidthMD, total_bounds.width())).
   // y: -kTextFilterHeightMD (since there's no text in the filter).
   // w: std::min(kTextFilterWidthMD, total_bounds.width()).
   // h: kTextFilterHeightMD.
-  const bool material = ash::MaterialDesignController::IsOverviewMaterial();
+  const bool material = MaterialDesignController::IsOverviewMaterial();
   gfx::Rect expected_bounds(150, -32, 100, 32);
   gfx::Rect expected_bounds_MD(60, -40, 280, 40);
   EXPECT_EQ((material ? expected_bounds_MD : expected_bounds).ToString(),
             text_filter->GetClientAreaBoundsInScreen().ToString());
 
   // Rotates the display, which triggers the WindowSelector's
   // RepositionTextFilterOnDisplayMetricsChange method.
   UpdateDisplay("400x300/r");
 
   // Uses the same formulas as above using width = 300, height = 400.
   expected_bounds = gfx::Rect(112, -32, 75, 32);
   expected_bounds_MD = gfx::Rect(10, -40, 280, 40);
   EXPECT_EQ((material ? expected_bounds_MD : expected_bounds).ToString(),
             text_filter->GetClientAreaBoundsInScreen().ToString());
 }
 #endif
 
 // Tests that an a11y alert is sent on entering overview mode.
 TEST_P(WindowSelectorTest, A11yAlertOnOverviewMode) {
   gfx::Rect bounds(0, 0, 400, 400);
-  AccessibilityDelegate* delegate =
-      ash::Shell::GetInstance()->accessibility_delegate();
+  AccessibilityDelegate* delegate = WmShell::Get()->GetAccessibilityDelegate();
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   EXPECT_NE(delegate->GetLastAccessibilityAlert(),
             A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
   ToggleOverview();
   EXPECT_EQ(delegate->GetLastAccessibilityAlert(),
             A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 }
 
 // Tests that there are no crashes when there is not enough screen space
 // available to show all of the windows.
@@ skipping 39 matching lines @@
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
   // Cursor should have been unlocked.
   EXPECT_FALSE(aura::client::GetCursorClient(root_window)->IsCursorLocked());
 }
 
 // Tests that the ordering of windows is near the windows' original positions.
 TEST_P(WindowSelectorTest, MinimizeMovement) {
   // With Material Design the order of windows in overview mode is MRU.
-  if (ash::MaterialDesignController::IsOverviewMaterial())
+  if (MaterialDesignController::IsOverviewMaterial())
     return;
   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));
   WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
@@ skipping 23 matching lines @@
   const std::vector<WindowSelectorItem*>& overview3(GetWindowItemsForRoot(0));
   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_P(WindowSelectorTest, MinimizeMovementSecondDisplay) {
   // With Material Design the order of windows in overview mode is MRU.
-  if (ash::MaterialDesignController::IsOverviewMaterial() ||
+  if (MaterialDesignController::IsOverviewMaterial() ||
       !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));
   WmWindow* left_window_wm = WmWindowAura::Get(left_window.get());
   std::unique_ptr<aura::Window> right_window(CreateWindow(right_bounds));
@@ skipping 29 matching lines @@
 
   // Before Material Design the initial ordering is not defined, but should
   // remain consistent the next time overview is started.
   // With Material Design the order of windows in overview mode is MRU.
   wm::GetWindowState(window1.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview1(GetWindowItemsForRoot(0));
   int initial_order[3] = {overview1[0]->GetWindow()->GetShellWindowId(),
                           overview1[1]->GetWindow()->GetShellWindowId(),
                           overview1[2]->GetWindow()->GetShellWindowId()};
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
+  if (MaterialDesignController::IsOverviewMaterial()) {
     // With Material Design the order should be MRU.
     EXPECT_EQ(1, overview1[0]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(3, overview1[1]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(2, overview1[2]->GetWindow()->GetShellWindowId());
   }
   ToggleOverview();
 
   // Activate the second window.
   wm::GetWindowState(window2.get())->Activate();
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
 
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
+  if (MaterialDesignController::IsOverviewMaterial()) {
     // With Material Design the order should be MRU.
     EXPECT_EQ(2, overview2[0]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(1, overview2[1]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(3, overview2[2]->GetWindow()->GetShellWindowId());
   } else {
     // Before Material Design the order should be the same as the first time.
     EXPECT_EQ(initial_order[0], overview2[0]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(initial_order[1], overview2[1]->GetWindow()->GetShellWindowId());
     EXPECT_EQ(initial_order[2], overview2[2]->GetWindow()->GetShellWindowId());
   }
@@ skipping 350 matching lines @@
   EXPECT_TRUE(wm::GetWindowState(window1.get())->IsFullscreen());
 }
 
 // Tests that the shelf dimming state is removed while in overview and restored
 // on exiting overview.
 TEST_P(WindowSelectorTest, OverviewUndimsShelf) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   wm::WindowState* window_state = wm::GetWindowState(window1.get());
   window_state->Maximize();
-  ash::ShelfWidget* shelf =
-      Shell::GetPrimaryRootWindowController()->shelf_widget();
+  ShelfWidget* shelf = Shell::GetPrimaryRootWindowController()->shelf_widget();
   EXPECT_TRUE(shelf->GetDimsShelf());
   ToggleOverview();
   EXPECT_FALSE(shelf->GetDimsShelf());
   ToggleOverview();
   EXPECT_TRUE(shelf->GetDimsShelf());
 }
 
 // Tests that entering overview when a fullscreen window is active in maximized
 // mode correctly applies the transformations to the window and correctly
 // updates the window bounds on exiting overview mode: http://crbug.com/401664.
@@ skipping 323 matching lines @@
 }
 
 // Tests starting overview during a drag and drop tracking operation.
 // TODO(flackr): Fix memory corruption crash when running locally (not failing
 // on bots). See http://crbug.com/342528.
 TEST_P(WindowSelectorTest, DISABLED_DragDropInProgress) {
   bool drag_canceled_by_test = false;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
   test::ShellTestApi shell_test_api(Shell::GetInstance());
-  ash::DragDropController* drag_drop_controller =
+  DragDropController* drag_drop_controller =
       shell_test_api.drag_drop_controller();
   ui::OSExchangeData data;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WindowSelectorTest::ToggleOverview, base::Unretained(this)));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CancelDrag, drag_drop_controller, &drag_canceled_by_test));
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
   drag_drop_controller->StartDragAndDrop(
@@ skipping 20 matching lines @@
   EXPECT_EQ(label->GetText(), window_title);
 
   // Update the window title and check that the label is updated, too.
   base::string16 updated_title = base::UTF8ToUTF16("Updated title");
   window->SetTitle(updated_title);
   EXPECT_EQ(label->GetText(), updated_title);
 
   // Labels are located based on target_bounds, not the actual window item
   // bounds.
   gfx::Rect label_bounds = label->GetWidget()->GetWindowBoundsInScreen();
-  if (ash::MaterialDesignController::IsOverviewMaterial())
+  if (MaterialDesignController::IsOverviewMaterial())
     label_bounds.Inset(kWindowMarginMD, kWindowMarginMD);
   EXPECT_EQ(window_item->target_bounds(), label_bounds);
 }
 
 // Tests that overview updates the window positions if the display orientation
 // changes.
 TEST_P(WindowSelectorTest, DisplayOrientationChanged) {
   if (!SupportsHostWindowResize())
     return;
 
@@ skipping 87 matching lines @@
   };
 
   for (size_t key_index = 0; key_index < arraysize(arrow_keys); key_index++) {
     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.
-      const int index = ash::MaterialDesignController::IsOverviewMaterial()
+      const int index = MaterialDesignController::IsOverviewMaterial()
                             ? index_path_for_direction_MD[key_index][i]
                             : index_path_for_direction[key_index][i];
       EXPECT_EQ(GetSelectedWindow()->id(),
                 overview_windows[index - 1]->GetWindow()->GetShellWindowId());
     }
     ToggleOverview();
   }
 }
 
 // Tests basic selection across multiple monitors.
@@ skipping 362 matching lines @@
 // when inset and header height are specified.
 TEST_P(WindowSelectorTest, TransformedRectIsCenteredWithInset) {
   gfx::Rect rect(50, 50, 400, 200);
   gfx::Rect bounds(100, 100, 50, 50);
   const int inset = 20;
   const int header_height = 10;
   const float scale = GetItemScale(rect, bounds, inset, header_height);
   gfx::Rect transformed_rect =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           rect, bounds, inset, header_height);
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
+  if (MaterialDesignController::IsOverviewMaterial()) {
     // With Material Design the |rect| width does not fit and therefore it gets
     // centered outside |bounds| starting before |bounds.x()| and ending after
     // |bounds.right()|.
     EXPECT_LE(transformed_rect.x(), bounds.x());
     EXPECT_GE(transformed_rect.right(), bounds.right());
   } else {
     EXPECT_GE(transformed_rect.x(), bounds.x());
     EXPECT_LE(transformed_rect.right(), bounds.right());
   }
   EXPECT_GE(
       transformed_rect.y() + gfx::ToCeiledInt(scale * inset) - header_height,
       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