chromeos: Renames WmWindowAura to WmWindow

ash/root_window_controller.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/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_touch_exploration_manager_chromeos.h"
 #include "ash/aura/aura_layout_manager_adapter.h"
-#include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
@@ skipping 228 matching lines @@
   window->SetShellWindowId(window_id);
   window->SetName(name);
   parent->AddChild(window);
   if (window_id != kShellWindowId_UnparentedControlContainer)
     window->Show();
   return window;
 }
 
 // TODO(sky): This should take an aura::Window. http://crbug.com/671246.
 bool ShouldDestroyWindowInCloseChildWindows(WmWindow* window) {
-  if (!WmWindowAura::GetAuraWindow(window)->owned_by_parent())
+  if (!WmWindow::GetAuraWindow(window)->owned_by_parent())
     return false;
 
   if (!WmShell::Get()->IsRunningInMash())
     return true;
 
   aura::WindowMus* window_mus =
-      aura::WindowMus::Get(WmWindowAura::GetAuraWindow(window));
+      aura::WindowMus::Get(WmWindow::GetAuraWindow(window));
   return Shell::window_tree_client()->WasCreatedByThisClient(window_mus) ||
          Shell::window_tree_client()->IsRoot(window_mus);
 }
 
 }  // namespace
 
 RootWindowController::~RootWindowController() {
   Shutdown();
   ash_host_.reset();
   mus_window_tree_host_.reset();
@@ skipping 46 matching lines @@
 
 aura::Window* RootWindowController::GetRootWindow() {
   return GetHost()->window();
 }
 
 const aura::Window* RootWindowController::GetRootWindow() const {
   return GetHost()->window();
 }
 
 const WmWindow* RootWindowController::GetWindow() const {
-  return WmWindowAura::Get(GetRootWindow());
+  return WmWindow::Get(GetRootWindow());
 }
 
 wm::WorkspaceWindowState RootWindowController::GetWorkspaceWindowState() {
   return workspace_controller_ ? workspace_controller()->GetWindowState()
                                : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
 }
 
 bool RootWindowController::HasShelf() {
   return wm_shelf_->shelf_widget() != nullptr;
 }
@@ skipping 13 matching lines @@
     docked_window_layout_manager_->SetShelf(wm_shelf_.get());
     if (wm_shelf_->shelf_layout_manager())
       docked_window_layout_manager_->AddObserver(
           wm_shelf_->shelf_layout_manager());
   }
 
   // Notify shell observers that the shelf has been created.
   // TODO(jamescook): Move this into WmShelf::InitializeShelf(). This will
   // require changing AttachedPanelWidgetTargeter's access to WmShelf.
   WmShell::Get()->NotifyShelfCreatedForRootWindow(
-      WmWindowAura::Get(GetRootWindow()));
+      WmWindow::Get(GetRootWindow()));
 
   wm_shelf_->shelf_widget()->PostCreateShelf();
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
   return wm_shelf_->shelf_layout_manager();
 }
 
 SystemModalContainerLayoutManager*
 RootWindowController::GetSystemModalLayoutManager(WmWindow* window) {
@@ skipping 46 matching lines @@
   if (WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked()) {
     blocking_container =
         GetContainer(kShellWindowId_LockScreenContainersContainer);
     modal_container_id = kShellWindowId_LockSystemModalContainer;
   } else {
     modal_container_id = kShellWindowId_SystemModalContainer;
   }
   aura::Window* modal_container = GetContainer(modal_container_id);
   SystemModalContainerLayoutManager* modal_layout_manager = nullptr;
   modal_layout_manager = static_cast<SystemModalContainerLayoutManager*>(
-      WmWindowAura::Get(modal_container)->GetLayoutManager());
+      WmWindow::Get(modal_container)->GetLayoutManager());
 
   if (modal_layout_manager->has_window_dimmer())
     blocking_container = modal_container;
   else
     modal_container = nullptr;  // Don't check modal dialogs.
 
   // In normal session.
   if (!blocking_container)
     return true;
 
   if (!IsWindowAboveContainer(window, blocking_container))
     return false;
 
   // If the window is in the target modal container, only allow the top most
   // one.
   if (modal_container && modal_container->Contains(window))
     return modal_layout_manager->IsPartOfActiveModalWindow(
-        WmWindowAura::Get(window));
+        WmWindow::Get(window));
 
   return true;
 }
 
 WmWindow* RootWindowController::FindEventTarget(
     const gfx::Point& location_in_screen) {
   gfx::Point location_in_root(location_in_screen);
   aura::Window* root_window = GetRootWindow();
   ::wm::ConvertPointFromScreen(root_window, &location_in_root);
   ui::MouseEvent test_event(ui::ET_MOUSE_MOVED, location_in_root,
                             location_in_root, ui::EventTimeForNow(),
                             ui::EF_NONE, ui::EF_NONE);
   ui::EventTarget* event_handler =
       static_cast<ui::EventTarget*>(root_window)
           ->GetEventTargeter()
           ->FindTargetForEvent(root_window, &test_event);
-  return WmWindowAura::Get(static_cast<aura::Window*>(event_handler));
+  return WmWindow::Get(static_cast<aura::Window*>(event_handler));
 }
 
 gfx::Point RootWindowController::GetLastMouseLocationInRoot() {
   return window_tree_host_->dispatcher()->GetLastMouseLocationInRoot();
 }
 
 aura::Window* RootWindowController::GetContainer(int container_id) {
   return GetRootWindow()->GetChildById(container_id);
 }
 
 const aura::Window* RootWindowController::GetContainer(int container_id) const {
   return window_tree_host_->window()->GetChildById(container_id);
 }
 
 const WmWindow* RootWindowController::GetWmContainer(int container_id) const {
   const aura::Window* window = GetContainer(container_id);
-  return WmWindowAura::Get(window);
+  return WmWindow::Get(window);
 }
 
 void RootWindowController::SetWallpaperWidgetController(
     WallpaperWidgetController* controller) {
   wallpaper_widget_controller_.reset(controller);
 }
 
 void RootWindowController::SetAnimatingWallpaperWidgetController(
     AnimatingWallpaperWidgetController* controller) {
   if (animating_wallpaper_widget_controller_.get())
@@ skipping 116 matching lines @@
   if (shelf->IsShelfInitialized())
     shelf->ShutdownShelf();
 
   aura::client::SetDragDropClient(GetRootWindow(), nullptr);
   aura::client::SetTooltipClient(GetRootWindow(), nullptr);
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   // Clear the workspace controller, so it doesn't incorrectly update the shelf.
   workspace_controller_.reset();
-  ReparentAllWindows(GetWindow(), WmWindowAura::Get(dst));
+  ReparentAllWindows(GetWindow(), WmWindow::Get(dst));
 }
 
 void RootWindowController::UpdateShelfVisibility() {
   wm_shelf_->UpdateVisibilityState();
 }
 
 void RootWindowController::InitTouchHuds() {
   if (WmShell::Get()->IsRunningInMash())
     return;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::GetInstance()->is_touch_hud_projection_enabled())
     EnableTouchHudProjection();
 }
 
 aura::Window* RootWindowController::GetWindowForFullscreenMode() {
-  return WmWindowAura::GetAuraWindow(
-      wm::GetWindowForFullscreenMode(WmWindowAura::Get(GetRootWindow())));
+  return WmWindow::GetAuraWindow(
+      wm::GetWindowForFullscreenMode(WmWindow::Get(GetRootWindow())));
 }
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
   keyboard_controller->AddObserver(wm_shelf_->shelf_layout_manager());
@@ skipping 131 matching lines @@
       shell->InitKeyboard();
   } else {
     window_tree_host_->Show();
 
     // Create a shelf if a user is already logged in.
     if (wm_shell->GetSessionStateDelegate()->NumberOfLoggedInUsers())
       CreateShelf();
 
     // Notify shell observers about new root window.
     if (!wm_shell->IsRunningInMash())
-      shell->OnRootWindowAdded(WmWindowAura::Get(root_window));
+      shell->OnRootWindowAdded(WmWindow::Get(root_window));
   }
 
   // TODO: AshTouchExplorationManager doesn't work with mus.
   // http://crbug.com/679782
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableTouchExplorationMode) &&
       !wm_shell->IsRunningInMash()) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
@@ skipping 45 matching lines @@
   // Create Panel layout manager
   WmWindow* wm_panel_container = GetWmContainer(kShellWindowId_PanelContainer);
   panel_layout_manager_ = new PanelLayoutManager(wm_panel_container);
   wm_panel_container->SetLayoutManager(base::WrapUnique(panel_layout_manager_));
 
   wm::WmSnapToPixelLayoutManager::InstallOnContainers(root);
 
   // Make it easier to resize windows that partially overlap the shelf. Must
   // occur after the ShelfLayoutManager is constructed by ShelfWidget.
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
-  WmWindow* wm_shelf_container = WmWindowAura::Get(shelf_container);
+  WmWindow* wm_shelf_container = WmWindow::Get(shelf_container);
   shelf_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_shelf_container, wm_shelf_.get()));
   aura::Window* status_container = GetContainer(kShellWindowId_StatusContainer);
-  WmWindow* wm_status_container = WmWindowAura::Get(status_container);
+  WmWindow* wm_status_container = WmWindow::Get(status_container);
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_status_container, wm_shelf_.get()));
 
   panel_container_handler_ = base::MakeUnique<PanelWindowEventHandler>();
   GetContainer(kShellWindowId_PanelContainer)
       ->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
@@ skipping 253 matching lines @@
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash