chromeos: Renames WmWindowAura to WmWindow

ash/aura/wm_shell_aura.cc

 // Copyright 2016 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/aura/wm_shell_aura.h"
 
 #include <utility>
 
 #include "ash/aura/key_event_watcher_aura.h"
 #include "ash/aura/pointer_watcher_adapter.h"
-#include "ash/aura/wm_window_aura.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm_activation_observer.h"
 #include "ash/common/wm_display_observer.h"
+#include "ash/common/wm_window.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/laser/laser_pointer_controller.h"
 #include "ash/metrics/task_switch_metrics_recorder.h"
 #include "ash/shared/immersive_fullscreen_controller.h"
 #include "ash/shell.h"
 #include "ash/touch/touch_uma.h"
 #include "ash/virtual_keyboard_controller.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/maximize_mode/maximize_mode_event_handler_aura.h"
@@ skipping 47 matching lines @@
 
 bool WmShellAura::IsRunningInMash() const {
   return false;
 }
 
 WmWindow* WmShellAura::NewWindow(ui::wm::WindowType window_type,
                                  ui::LayerType layer_type) {
   aura::Window* aura_window = new aura::Window(nullptr);
   aura_window->SetType(window_type);
   aura_window->Init(layer_type);
-  return WmWindowAura::Get(aura_window);
+  return WmWindow::Get(aura_window);
 }
 
 WmWindow* WmShellAura::GetFocusedWindow() {
-  return WmWindowAura::Get(
+  return WmWindow::Get(
       aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())
           ->GetFocusedWindow());
 }
 
 WmWindow* WmShellAura::GetActiveWindow() {
-  return WmWindowAura::Get(wm::GetActiveWindow());
+  return WmWindow::Get(wm::GetActiveWindow());
 }
 
 WmWindow* WmShellAura::GetCaptureWindow() {
   // Ash shares capture client among all RootWindowControllers, so we need only
   // check the primary root.
-  return WmWindowAura::Get(
+  return WmWindow::Get(
       aura::client::GetCaptureWindow(Shell::GetPrimaryRootWindow()));
 }
 
 WmWindow* WmShellAura::GetPrimaryRootWindow() {
-  return WmWindowAura::Get(Shell::GetPrimaryRootWindow());
+  return WmWindow::Get(Shell::GetPrimaryRootWindow());
 }
 
 WmWindow* WmShellAura::GetRootWindowForDisplayId(int64_t display_id) {
-  return WmWindowAura::Get(Shell::GetInstance()
-                               ->window_tree_host_manager()
-                               ->GetRootWindowForDisplayId(display_id));
+  return WmWindow::Get(Shell::GetInstance()
+                           ->window_tree_host_manager()
+                           ->GetRootWindowForDisplayId(display_id));
 }
 
 const display::ManagedDisplayInfo& WmShellAura::GetDisplayInfo(
     int64_t display_id) const {
   return Shell::GetInstance()->display_manager()->GetDisplayInfo(display_id);
 }
 
 bool WmShellAura::IsActiveDisplayId(int64_t display_id) const {
   return Shell::GetInstance()->display_manager()->IsActiveDisplayId(display_id);
 }
@@ skipping 14 matching lines @@
              ->current_default_multi_display_mode() ==
          display::DisplayManager::UNIFIED;
 }
 
 bool WmShellAura::IsForceMaximizeOnFirstRun() {
   return delegate()->IsForceMaximizeOnFirstRun();
 }
 
 void WmShellAura::SetDisplayWorkAreaInsets(WmWindow* window,
                                            const gfx::Insets& insets) {
-  aura::Window* aura_window = WmWindowAura::GetAuraWindow(window);
+  aura::Window* aura_window = WmWindow::GetAuraWindow(window);
   Shell::GetInstance()->SetDisplayWorkAreaInsets(aura_window, insets);
 }
 
 bool WmShellAura::IsPinned() {
   return Shell::GetInstance()->screen_pinning_controller()->IsPinned();
 }
 
 void WmShellAura::SetPinnedWindow(WmWindow* window) {
   return Shell::GetInstance()->screen_pinning_controller()->SetPinnedWindow(
       window);
 }
 
 void WmShellAura::LockCursor() {
   Shell::GetInstance()->cursor_manager()->LockCursor();
 }
 
 void WmShellAura::UnlockCursor() {
   Shell::GetInstance()->cursor_manager()->UnlockCursor();
 }
 
 bool WmShellAura::IsMouseEventsEnabled() {
   return Shell::GetInstance()->cursor_manager()->IsMouseEventsEnabled();
 }
 
 std::vector<WmWindow*> WmShellAura::GetAllRootWindows() {
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   std::vector<WmWindow*> wm_windows(root_windows.size());
   for (size_t i = 0; i < root_windows.size(); ++i)
-    wm_windows[i] = WmWindowAura::Get(root_windows[i]);
+    wm_windows[i] = WmWindow::Get(root_windows[i]);
   return wm_windows;
 }
 
 void WmShellAura::RecordUserMetricsAction(UserMetricsAction action) {
   Shell::GetInstance()->metrics()->RecordUserMetricsAction(action);
 }
 
 void WmShellAura::RecordGestureAction(GestureActionType action) {
   TouchUMA::GetInstance()->RecordGestureAction(action);
 }
@@ skipping 106 matching lines @@
 }
 
 void WmShellAura::SetLaserPointerEnabled(bool enabled) {
   Shell::GetInstance()->laser_pointer_controller()->SetEnabled(enabled);
 }
 
 void WmShellAura::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
-  WmWindow* gained_active_wm = WmWindowAura::Get(gained_active);
-  WmWindow* lost_active_wm = WmWindowAura::Get(lost_active);
+  WmWindow* gained_active_wm = WmWindow::Get(gained_active);
+  WmWindow* lost_active_wm = WmWindow::Get(lost_active);
   if (gained_active_wm)
     set_root_window_for_new_windows(gained_active_wm->GetRootWindow());
   for (auto& observer : activation_observers_)
     observer.OnWindowActivated(gained_active_wm, lost_active_wm);
 }
 
 void WmShellAura::OnAttemptToReactivateWindow(aura::Window* request_active,
                                               aura::Window* actual_active) {
   for (auto& observer : activation_observers_) {
-    observer.OnAttemptToReactivateWindow(WmWindowAura::Get(request_active),
-                                         WmWindowAura::Get(actual_active));
+    observer.OnAttemptToReactivateWindow(WmWindow::Get(request_active),
+                                         WmWindow::Get(actual_active));
   }
 }
 
 void WmShellAura::SessionStateChanged(session_manager::SessionState state) {
   // Create the shelf if necessary.
   WmShell::SessionStateChanged(state);
 
   // Recreate the keyboard after initial login and after multiprofile login.
   if (state == session_manager::SessionState::ACTIVE)
     Shell::GetInstance()->CreateKeyboard();
 }
 
 void WmShellAura::OnDisplayConfigurationChanging() {
   for (auto& observer : display_observers_)
     observer.OnDisplayConfigurationChanging();
 }
 
 void WmShellAura::OnDisplayConfigurationChanged() {
   for (auto& observer : display_observers_)
     observer.OnDisplayConfigurationChanged();
 }
 
 }  // namespace ash