Promotes WmWindowMus functions to WmWindowAura and nukes WmWindowMus

ash/mus/accelerators/accelerator_controller_unittest.cc

 // Copyright (c) 2012 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 "ash/common/accelerators/accelerator_controller.h"
 
+#include "ash/aura/wm_window_aura.h"
 #include "ash/common/accelerators/accelerator_table.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/ime_control_delegate.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/system/brightness_control_delegate.h"
 #include "ash/common/system/keyboard_brightness_control_delegate.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/test/ash_test.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/mus/accelerators/accelerator_controller_registrar_test_api.h"
 #include "ash/mus/bridge/wm_shell_mus_test_api.h"
-#include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/test/wm_test_base.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "base/command_line.h"
 #include "base/test/user_action_tester.cc"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
@@ skipping 392 matching lines @@
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
   EXPECT_TRUE(GetController()->IsRegistered(accelerator_a));
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_shift_a));
   GetController()->UnregisterAll(&target);
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_a));
 }
 
 TEST_F(AcceleratorControllerTest, WindowSnap) {
   aura::Window* aura_window = CreateTestWindow(gfx::Rect(5, 5, 20, 20));
-  WmWindow* window = mus::WmWindowMus::Get(aura_window);
+  WmWindow* window = WmWindowAura::Get(aura_window);
   wm::WindowState* window_state = window->GetWindowState();
 
   window_state->Activate();
 
   {
     GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
     gfx::Rect expected_bounds =
         wm::GetDefaultLeftSnappedWindowBoundsInParent(window);
     EXPECT_EQ(expected_bounds.ToString(), window->GetBounds().ToString());
   }
@@ skipping 35 matching lines @@
   {
     GetController()->PerformActionIfEnabled(WINDOW_MINIMIZE);
     EXPECT_TRUE(window_state->IsMinimized());
   }
 }
 
 // Tests that when window docking is disabled, only snapping windows works.
 TEST_F(AcceleratorControllerTest, WindowSnapWithoutDocking) {
   ASSERT_FALSE(ash::switches::DockedWindowsEnabled());
   WmWindow* window =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
 
   // Snap right.
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   gfx::Rect normal_bounds = window_state->GetRestoreBoundsInParent();
   gfx::Rect expected_bounds =
       wm::GetDefaultRightSnappedWindowBoundsInParent(window);
   EXPECT_EQ(expected_bounds.ToString(), window->GetBounds().ToString());
   EXPECT_TRUE(window_state->IsSnapped());
@@ skipping 33 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EnabledDockedWindowsAcceleratorControllerTest);
 };
 
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest,
        WindowSnapLeftDockLeftRestore) {
   CreateTestWindow(gfx::Rect(5, 5, 20, 20));
   WmWindow* window1 =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
   wm::WindowState* window1_state = window1->GetWindowState();
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect normal_bounds = window1_state->GetRestoreBoundsInParent();
   gfx::Rect expected_bounds =
       wm::GetDefaultLeftSnappedWindowBoundsInParent(window1);
   EXPECT_EQ(expected_bounds.ToString(), window1->GetBounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_EQ(normal_bounds.ToString(), window1->GetBounds().ToString());
 }
 
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest,
        WindowSnapRightDockRightRestore) {
   CreateTestWindow(gfx::Rect(5, 5, 20, 20));
   WmWindow* window1 =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window1_state = window1->GetWindowState();
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   gfx::Rect normal_bounds = window1_state->GetRestoreBoundsInParent();
   gfx::Rect expected_bounds =
       wm::GetDefaultRightSnappedWindowBoundsInParent(window1);
   EXPECT_EQ(expected_bounds.ToString(), window1->GetBounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_EQ(normal_bounds.ToString(), window1->GetBounds().ToString());
 }
 
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest,
        WindowSnapLeftDockLeftSnapRight) {
-  mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+  WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
   WmWindow* window1 =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
 
   wm::WindowState* window1_state = window1->GetWindowState();
   window1_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect expected_bounds =
       wm::GetDefaultLeftSnappedWindowBoundsInParent(window1);
   gfx::Rect expected_bounds2 =
       wm::GetDefaultRightSnappedWindowBoundsInParent(window1);
   EXPECT_EQ(expected_bounds.ToString(), window1->GetBounds().ToString());
   EXPECT_TRUE(window1_state->IsSnapped());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   EXPECT_FALSE(window1_state->IsNormalOrSnapped());
   EXPECT_TRUE(window1_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window1_state->IsDocked());
   EXPECT_TRUE(window1_state->IsSnapped());
   EXPECT_EQ(expected_bounds2.ToString(), window1->GetBounds().ToString());
 }
 
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest,
        WindowDockLeftMinimizeWindowWithRestore) {
   WindowOwner window_owner(
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
   WindowOwner window1_owner(
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
   WmWindow* window1 = window1_owner.window();
 
   wm::WindowState* window1_state = window1->GetWindowState();
   window1_state->Activate();
 
   WindowOwner window2_owner(
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
   WmWindow* window2 = window2_owner.window();
 
   wm::WindowState* window2_state = window2->GetWindowState();
 
   WindowOwner window3_owner(
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
   WmWindow* window3 = window3_owner.window();
 
   wm::WindowState* window3_state = window3->GetWindowState();
   window3_state->Activate();
 
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect window3_docked_bounds = window3->GetBounds();
 
   window2_state->Activate();
@@ skipping 17 matching lines @@
   EXPECT_FALSE(window2_state->IsDocked());
   EXPECT_TRUE(window3_state->IsDocked());
   EXPECT_EQ(window3_docked_bounds.ToString(), window3->GetBounds().ToString());
 }
 
 // TODO: Needs CreatePanel(): http://crbug.com/632209.
 /*
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest,
        WindowPanelDockLeftDockRightRestore) {
   WmWndow* window0 =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
 
   std::unique_ptr<aura::Window> window(CreatePanel());
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   gfx::Rect window_restore_bounds2 = window->bounds();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_LEFT);
   gfx::Rect expected_bounds = wm::GetDefaultLeftSnappedWindowBoundsInParent(
       WmWindowAura::Get(window.get()));
   gfx::Rect window_restore_bounds = window_state->GetRestoreBoundsInScreen();
   EXPECT_NE(expected_bounds.ToString(), window->bounds().ToString());
   EXPECT_FALSE(window_state->IsSnapped());
   EXPECT_FALSE(window_state->IsNormalOrSnapped());
   EXPECT_TRUE(window_state->IsDocked());
   window_state->Restore();
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_TRUE(window_state->IsDocked());
   GetController()->PerformActionIfEnabled(WINDOW_CYCLE_SNAP_DOCK_RIGHT);
   EXPECT_FALSE(window_state->IsDocked());
   EXPECT_EQ(window_restore_bounds.ToString(),
             window_restore_bounds2.ToString());
   EXPECT_EQ(window_restore_bounds.ToString(), window->bounds().ToString());
 }
 */
 
 TEST_F(EnabledDockedWindowsAcceleratorControllerTest, CenterWindowAccelerator) {
   WindowOwner window_owner(
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20))));
   WmWindow* window = window_owner.window();
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
 
   // Center the window using accelerator.
   GetController()->PerformActionIfEnabled(WINDOW_POSITION_CENTER);
   gfx::Rect work_area = window->GetDisplayNearestWindow().work_area();
   gfx::Rect bounds = window->GetBoundsInScreen();
   EXPECT_NEAR(bounds.x() - work_area.x(), work_area.right() - bounds.right(),
               1);
@@ skipping 86 matching lines @@
 TEST_F(AcceleratorControllerTest, DontRepeatToggleFullscreen) {
   const AcceleratorData accelerators[] = {
       {true, ui::VKEY_J, ui::EF_ALT_DOWN, TOGGLE_FULLSCREEN},
       {true, ui::VKEY_K, ui::EF_ALT_DOWN, TOGGLE_FULLSCREEN},
   };
   GetController()->RegisterAccelerators(accelerators, arraysize(accelerators));
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.bounds = gfx::Rect(5, 5, 20, 20);
   views::Widget* widget = new views::Widget;
-  mus::WmWindowMus::Get(GetPrimaryRootWindow())
+  WmWindowAura::Get(GetPrimaryRootWindow())
       ->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           widget, kShellWindowId_DefaultContainer, &params);
   widget->Init(params);
   widget->GetNativeView()->SetProperty(aura::client::kResizeBehaviorKey,
                                        ui::mojom::kResizeBehaviorCanMaximize);
   widget->Show();
   widget->Activate();
 
   wm::WindowState* window_state =
@@ skipping 321 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PreferredReservedAcceleratorsTest);
 };
 
 }  // namespace
 
 // TODO: needs LockStateController ported: http://crbug.com/632189.
 TEST_F(PreferredReservedAcceleratorsTest, AcceleratorsWithFullscreen) {
-  WmWindow* w1 = mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect()));
-  WmWindow* w2 = mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect()));
+  WmWindow* w1 = WmWindowAura::Get(CreateTestWindow(gfx::Rect()));
+  WmWindow* w2 = WmWindowAura::Get(CreateTestWindow(gfx::Rect()));
   wm::ActivateWindow(w1);
 
   wm::WMEvent fullscreen(wm::WM_EVENT_FULLSCREEN);
   wm::WindowState* w1_state = w1->GetWindowState();
   w1_state->OnWMEvent(&fullscreen);
   ASSERT_TRUE(w1_state->IsFullscreen());
 
   ui::test::EventGenerator& generator = GetEventGenerator();
 #if defined(OS_CHROMEOS)
   // Power key (reserved) should always be handled.
@@ skipping 75 matching lines @@
     actionsAllowedAtModalWindow.insert(kActionsAllowedAtModalWindow[k]);
   for (const auto& action : actionsAllowedAtModalWindow) {
     EXPECT_TRUE(all_actions.find(action) != all_actions.end() ||
                 all_debug_actions.find(action) != all_debug_actions.end() ||
                 all_dev_actions.find(action) != all_dev_actions.end())
         << " action from kActionsAllowedAtModalWindow"
         << " not found in kAcceleratorData, kDebugAcceleratorData or"
         << " kDeveloperAcceleratorData action: " << action;
   }
   WmWindow* window =
-      mus::WmWindowMus::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
+      WmWindowAura::Get(CreateTestWindow(gfx::Rect(5, 5, 20, 20)));
   window->Activate();
   WmShell::Get()->SimulateModalWindowOpenForTesting(true);
   for (const auto& action : all_actions) {
     if (actionsAllowedAtModalWindow.find(action) ==
         actionsAllowedAtModalWindow.end()) {
       EXPECT_TRUE(GetController()->PerformActionIfEnabled(action))
           << " for action (disallowed at modal window): " << action;
     }
   }
   //  Testing of top row (F5-F10) accelerators that should still work
@@ skipping 77 matching lines @@
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i) {
     delegate->TriggerAccessibilityAlert(A11Y_ALERT_NONE);
     EXPECT_TRUE(
         GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]));
     EXPECT_EQ(delegate->GetLastAccessibilityAlert(), A11Y_ALERT_WINDOW_NEEDED);
   }
 
   // Make sure we don't alert if we do have a window.
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i) {
     aura::Window* aura_window = CreateTestWindow(gfx::Rect(5, 5, 20, 20));
-    mus::WmWindowMus::Get(aura_window)->Activate();
+    WmWindowAura::Get(aura_window)->Activate();
     delegate->TriggerAccessibilityAlert(A11Y_ALERT_NONE);
     GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]);
     EXPECT_NE(delegate->GetLastAccessibilityAlert(), A11Y_ALERT_WINDOW_NEEDED);
     delete aura_window;
   }
 
   // Don't alert if we have a minimized window either.
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i) {
     aura::Window* aura_window = CreateTestWindow(gfx::Rect(5, 5, 20, 20));
-    mus::WmWindowMus::Get(aura_window)->Activate();
+    WmWindowAura::Get(aura_window)->Activate();
     GetController()->PerformActionIfEnabled(WINDOW_MINIMIZE);
     delegate->TriggerAccessibilityAlert(A11Y_ALERT_NONE);
     GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]);
     EXPECT_NE(delegate->GetLastAccessibilityAlert(), A11Y_ALERT_WINDOW_NEEDED);
     delete aura_window;
   }
 }
 
 #if defined(OS_CHROMEOS)
 namespace {
@@ skipping 102 matching lines @@
     EXPECT_TRUE(IsMessageCenterEmpty());
 
     // If the action is LOCK_SCREEN, we must reset the state by unlocking the
     // screen before we proceed testing the rest of accelerators.
     ResetStateIfNeeded();
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace ash