chromeos: Renames WmWindowAura to WmWindow

ash/wm/screen_pinning_controller.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/wm/screen_pinning_controller.h"
 
 #include <algorithm>
 #include <vector>
 
-#include "ash/aura/wm_window_aura.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/window_dimmer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_observer.h"
 #include "ash/common/wm_window_user_data.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "base/auto_reset.h"
@@ skipping 16 matching lines @@
     if (system_modal->GetRootWindow() == pinned_root)
       continue;
     result.push_back(system_modal);
   }
   return result;
 }
 
 void AddObserverToChildren(WmWindow* container,
                            aura::WindowObserver* observer) {
   for (WmWindow* child : container->GetChildren()) {
-    WmWindowAura::GetAuraWindow(child)->AddObserver(observer);
+    WmWindow::GetAuraWindow(child)->AddObserver(observer);
   }
 }
 
 void RemoveObserverFromChildren(WmWindow* container,
                                 aura::WindowObserver* observer) {
   for (WmWindow* child : container->GetChildren()) {
-    WmWindowAura::GetAuraWindow(child)->RemoveObserver(observer);
+    WmWindow::GetAuraWindow(child)->RemoveObserver(observer);
   }
 }
 
 }  // namespace
 
 // Adapter to fire OnPinnedContainerWindowStackingChanged().
 class ScreenPinningController::PinnedContainerChildWindowObserver
     : public aura::WindowObserver {
  public:
   explicit PinnedContainerChildWindowObserver(
       ScreenPinningController* controller)
       : controller_(controller) {}
 
   void OnWindowStackingChanged(aura::Window* window) override {
-    controller_->OnPinnedContainerWindowStackingChanged(
-        WmWindowAura::Get(window));
+    controller_->OnPinnedContainerWindowStackingChanged(WmWindow::Get(window));
   }
 
  private:
   ScreenPinningController* controller_;
   DISALLOW_COPY_AND_ASSIGN(PinnedContainerChildWindowObserver);
 };
 
 // Adapter to translate OnWindowAdded/OnWillRemoveWindow for the container
 // containing the pinned window, to the corresponding controller's methods.
 class ScreenPinningController::PinnedContainerWindowObserver
     : public aura::WindowObserver {
  public:
   explicit PinnedContainerWindowObserver(ScreenPinningController* controller)
       : controller_(controller) {}
 
   void OnWindowAdded(aura::Window* new_window) override {
-    controller_->OnWindowAddedToPinnedContainer(WmWindowAura::Get(new_window));
+    controller_->OnWindowAddedToPinnedContainer(WmWindow::Get(new_window));
   }
   void OnWillRemoveWindow(aura::Window* window) override {
-    controller_->OnWillRemoveWindowFromPinnedContainer(
-        WmWindowAura::Get(window));
+    controller_->OnWillRemoveWindowFromPinnedContainer(WmWindow::Get(window));
   }
   void OnWindowDestroying(aura::Window* window) override {
     // Just in case. There is nothing we can do here.
     window->RemoveObserver(this);
   }
 
  private:
   ScreenPinningController* controller_;
   DISALLOW_COPY_AND_ASSIGN(PinnedContainerWindowObserver);
 };
 
 // Adapter to fire OnSystemModalContainerWindowStackingChanged().
 class ScreenPinningController::SystemModalContainerChildWindowObserver
     : public aura::WindowObserver {
  public:
   explicit SystemModalContainerChildWindowObserver(
       ScreenPinningController* controller)
       : controller_(controller) {}
 
   void OnWindowStackingChanged(aura::Window* window) override {
     controller_->OnSystemModalContainerWindowStackingChanged(
-        WmWindowAura::Get(window));
+        WmWindow::Get(window));
   }
 
  private:
   ScreenPinningController* controller_;
   DISALLOW_COPY_AND_ASSIGN(SystemModalContainerChildWindowObserver);
 };
 
 // Adapter to translate OnWindowAdded/OnWillRemoveWindow for the
 // SystemModalContainer to the corresponding controller's methods.
 class ScreenPinningController::SystemModalContainerWindowObserver
     : public aura::WindowObserver {
  public:
   explicit SystemModalContainerWindowObserver(
       ScreenPinningController* controller)
       : controller_(controller) {}
 
   void OnWindowAdded(aura::Window* new_window) override {
-    controller_->OnWindowAddedToSystemModalContainer(
-        WmWindowAura::Get(new_window));
+    controller_->OnWindowAddedToSystemModalContainer(WmWindow::Get(new_window));
   }
   void OnWillRemoveWindow(aura::Window* window) override {
     controller_->OnWillRemoveWindowFromSystemModalContainer(
-        WmWindowAura::Get(window));
+        WmWindow::Get(window));
   }
   void OnWindowDestroying(aura::Window* window) override {
     // Just in case. There is nothing we can do here.
     window->RemoveObserver(this);
   }
 
  private:
   ScreenPinningController* controller_;
   DISALLOW_COPY_AND_ASSIGN(SystemModalContainerWindowObserver);
 };
@@ skipping 39 matching lines @@
     pinned_window_ = pinned_window;
     container->StackChildAtTop(pinned_window);
     container->StackChildBelow(CreateWindowDimmer(container), pinned_window);
 
     // Set the dim windows to the system containers, other than the one which
     // the root window of the pinned window holds.
     for (WmWindow* system_modal : system_modal_containers)
       system_modal->StackChildAtBottom(CreateWindowDimmer(system_modal));
 
     // Set observers.
-    WmWindowAura::GetAuraWindow(container)->AddObserver(
+    WmWindow::GetAuraWindow(container)->AddObserver(
         pinned_container_window_observer_.get());
     AddObserverToChildren(container,
                           pinned_container_child_window_observer_.get());
     for (WmWindow* system_modal : system_modal_containers) {
-      WmWindowAura::GetAuraWindow(system_modal)
+      WmWindow::GetAuraWindow(system_modal)
           ->AddObserver(system_modal_container_window_observer_.get());
       AddObserverToChildren(
           system_modal, system_modal_container_child_window_observer_.get());
     }
   } else {
     if (pinned_window != pinned_window_) {
       LOG(DFATAL) << "Pinned mode is being disabled, but for the different "
                   << "target window.";
       return;
     }
 
     WmWindow* container = pinned_window->GetParent();
     std::vector<WmWindow*> system_modal_containers =
         GetSystemModalWindowsExceptPinned(pinned_window_);
 
     // Unset observers.
     for (WmWindow* system_modal :
          GetSystemModalWindowsExceptPinned(pinned_window_)) {
       RemoveObserverFromChildren(
           system_modal, system_modal_container_child_window_observer_.get());
-      WmWindowAura::GetAuraWindow(system_modal)
+      WmWindow::GetAuraWindow(system_modal)
           ->RemoveObserver(system_modal_container_window_observer_.get());
     }
     RemoveObserverFromChildren(container,
                                pinned_container_child_window_observer_.get());
-    WmWindowAura::GetAuraWindow(container)->RemoveObserver(
+    WmWindow::GetAuraWindow(container)->RemoveObserver(
         pinned_container_window_observer_.get());
 
     pinned_window_ = nullptr;
   }
 
   WmShell::Get()->NotifyPinnedStateChanged(pinned_window);
 }
 
 void ScreenPinningController::OnWindowAddedToPinnedContainer(
     WmWindow* new_window) {
   KeepPinnedWindowOnTop();
-  WmWindowAura::GetAuraWindow(new_window)
+  WmWindow::GetAuraWindow(new_window)
       ->AddObserver(pinned_container_child_window_observer_.get());
 }
 
 void ScreenPinningController::OnWillRemoveWindowFromPinnedContainer(
     WmWindow* window) {
-  WmWindowAura::GetAuraWindow(window)->RemoveObserver(
+  WmWindow::GetAuraWindow(window)->RemoveObserver(
       pinned_container_child_window_observer_.get());
   if (window == pinned_window_) {
     pinned_window_->GetWindowState()->Restore();
     return;
   }
 }
 
 void ScreenPinningController::OnPinnedContainerWindowStackingChanged(
     WmWindow* window) {
   KeepPinnedWindowOnTop();
 }
 
 void ScreenPinningController::OnWindowAddedToSystemModalContainer(
     WmWindow* new_window) {
   KeepDimWindowAtBottom(new_window->GetParent());
-  WmWindowAura::GetAuraWindow(new_window)
+  WmWindow::GetAuraWindow(new_window)
       ->AddObserver(system_modal_container_child_window_observer_.get());
 }
 
 void ScreenPinningController::OnWillRemoveWindowFromSystemModalContainer(
     WmWindow* window) {
-  WmWindowAura::GetAuraWindow(window)->RemoveObserver(
+  WmWindow::GetAuraWindow(window)->RemoveObserver(
       system_modal_container_child_window_observer_.get());
 }
 
 void ScreenPinningController::OnSystemModalContainerWindowStackingChanged(
     WmWindow* window) {
   KeepDimWindowAtBottom(window->GetParent());
 }
 
 WmWindow* ScreenPinningController::CreateWindowDimmer(WmWindow* container) {
   std::unique_ptr<WindowDimmer> window_dimmer =
@@ skipping 32 matching lines @@
   for (WmWindow* system_modal : system_modal_containers) {
     if (window_dimmers_->Get(system_modal)) {
       // |system_modal| already has a WindowDimmer.
       continue;
     }
 
     // This is the new system modal dialog.
     system_modal->StackChildAtBottom(CreateWindowDimmer(system_modal));
 
     // Set observers to the tree.
-    WmWindowAura::GetAuraWindow(system_modal)
+    WmWindow::GetAuraWindow(system_modal)
         ->AddObserver(system_modal_container_window_observer_.get());
     AddObserverToChildren(system_modal,
                           system_modal_container_child_window_observer_.get());
   }
 }
 
 void ScreenPinningController::KeepPinnedWindowOnTop() {
   if (in_restacking_)
     return;
 
@@ skipping 10 matching lines @@
     return;
 
   WindowDimmer* window_dimmer = window_dimmers_->Get(container);
   if (window_dimmer) {
     base::AutoReset<bool> auto_reset(&in_restacking_, true);
     container->StackChildAtBottom(window_dimmer->window());
   }
 }
 
 }  // namespace ash