Converts remaining usage of WmLayoutManager to aura::LayoutManager

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 <algorithm>
 #include <queue>
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/ash_touch_exploration_manager_chromeos.h"
-#include "ash/aura/aura_layout_manager_adapter.h"
 #include "ash/focus_cycler.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/login_status.h"
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_settings.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_controller.h"
@@ skipping 202 matching lines @@
   for (int id : container_ids) {
     aura::Window* src_container = src->GetChildById(id);
     aura::Window* dst_container = dst->GetChildById(id);
     while (!src_container->children().empty()) {
       // Restart iteration from the source container windows each time as they
       // may change as a result of moving other windows.
       const aura::Window::Windows& src_container_children =
           src_container->children();
       auto iter = src_container_children.begin();
       while (iter != src_container_children.end() &&
-             SystemModalContainerLayoutManager::IsModalBackground(
-                 WmWindow::Get(*iter))) {
+             SystemModalContainerLayoutManager::IsModalBackground(*iter)) {
         ++iter;
       }
       // If the entire window list is modal background windows then stop.
       if (iter == src_container_children.end())
         break;
       ReparentWindow(*iter, dst_container);
     }
   }
 }
 
@@ skipping 128 matching lines @@
   Shell::Get()->NotifyShelfCreatedForRootWindow(WmWindow::Get(GetRootWindow()));
 
   wm_shelf_->shelf_widget()->PostCreateShelf();
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
   return wm_shelf_->shelf_layout_manager();
 }
 
 SystemModalContainerLayoutManager*
-RootWindowController::GetSystemModalLayoutManager(WmWindow* window) {
-  WmWindow* modal_container = nullptr;
+RootWindowController::GetSystemModalLayoutManager(aura::Window* window) {
+  aura::Window* modal_container = nullptr;
   if (window) {
-    aura::Window* window_container =
-        wm::GetContainerForWindow(window->aura_window());
+    aura::Window* window_container = wm::GetContainerForWindow(window);
     if (window_container &&
         window_container->id() >= kShellWindowId_LockScreenContainer) {
-      modal_container = GetWmContainer(kShellWindowId_LockSystemModalContainer);
+      modal_container = GetContainer(kShellWindowId_LockSystemModalContainer);
     } else {
-      modal_container = GetWmContainer(kShellWindowId_SystemModalContainer);
+      modal_container = GetContainer(kShellWindowId_SystemModalContainer);
     }
   } else {
     int modal_window_id =
         Shell::Get()->session_controller()->IsUserSessionBlocked()
             ? kShellWindowId_LockSystemModalContainer
             : kShellWindowId_SystemModalContainer;
-    modal_container = GetWmContainer(modal_window_id);
+    modal_container = GetContainer(modal_window_id);
   }
   return modal_container ? static_cast<SystemModalContainerLayoutManager*>(
-                               modal_container->GetLayoutManager())
+                               modal_container->layout_manager())
                          : nullptr;
 }
 
 StatusAreaWidget* RootWindowController::GetStatusAreaWidget() {
   ShelfWidget* shelf_widget = wm_shelf_->shelf_widget();
   return shelf_widget ? shelf_widget->status_area_widget() : nullptr;
 }
 
 SystemTray* RootWindowController::GetSystemTray() {
   // We assume in throughout the code that this will not return NULL. If code
@@ skipping 17 matching lines @@
   if (Shell::Get()->session_controller()->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*>(
-      WmWindow::Get(modal_container)->GetLayoutManager());
+      modal_container->layout_manager());
 
   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(
-        WmWindow::Get(window));
+    return modal_layout_manager->IsPartOfActiveModalWindow(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,
@@ skipping 166 matching lines @@
   return wm::GetWindowForFullscreenMode(GetRootWindow());
 }
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
-  Shell::Get()->NotifyVirtualKeyboardActivated(true,
-                                               WmWindow::Get(GetRootWindow()));
+  Shell::Get()->NotifyVirtualKeyboardActivated(true, GetRootWindow());
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   DCHECK(parent);
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   keyboard_container->set_id(kShellWindowId_VirtualKeyboardContainer);
   parent->AddChild(keyboard_container);
 }
 
 void RootWindowController::DeactivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard_controller ||
       !keyboard_controller->keyboard_container_initialized()) {
     return;
   }
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   if (keyboard_container->GetRootWindow() == GetRootWindow()) {
     aura::Window* parent =
         GetContainer(kShellWindowId_ImeWindowParentContainer);
     DCHECK(parent);
     // Virtual keyboard may be deactivated while still showing, hide the
     // keyboard before removing it from view hierarchy.
     keyboard_controller->HideKeyboard(
         keyboard::KeyboardController::HIDE_REASON_AUTOMATIC);
     parent->RemoveChild(keyboard_container);
-    Shell::Get()->NotifyVirtualKeyboardActivated(
-        false, WmWindow::Get(GetRootWindow()));
+    Shell::Get()->NotifyVirtualKeyboardActivated(false, GetRootWindow());
   }
 }
 
 bool RootWindowController::IsVirtualKeyboardWindow(aura::Window* window) {
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   return parent ? parent->Contains(window) : false;
 }
 
 void RootWindowController::SetTouchAccessibilityAnchorPoint(
     const gfx::Point& anchor_point) {
@@ skipping 102 matching lines @@
       Shell::GetAshConfig() != Config::MASH) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   // Create the shelf and status area widgets.
   DCHECK(!wm_shelf_->shelf_widget());
   GetShelf()->CreateShelfWidget(GetWindow());
 
-  WmWindow* root = GetWindow();
+  aura::Window* root = GetRootWindow();
   root_window_layout_manager_ = new wm::RootWindowLayoutManager(root);
-  root->SetLayoutManager(base::WrapUnique(root_window_layout_manager_));
+  root->SetLayoutManager(root_window_layout_manager_);
 
   aura::Window* default_container =
       GetContainer(kShellWindowId_DefaultContainer);
   // Installs WorkspaceLayoutManager on |default_container|.
   workspace_controller_.reset(new WorkspaceController(default_container));
 
-  WmWindow* modal_container =
-      GetWmContainer(kShellWindowId_SystemModalContainer);
-  DCHECK(modal_container);
+  aura::Window* modal_container =
+      GetContainer(kShellWindowId_SystemModalContainer);
   modal_container->SetLayoutManager(
-      base::MakeUnique<SystemModalContainerLayoutManager>(modal_container));
+      new SystemModalContainerLayoutManager(modal_container));
 
-  WmWindow* lock_modal_container =
-      GetWmContainer(kShellWindowId_LockSystemModalContainer);
+  aura::Window* lock_modal_container =
+      GetContainer(kShellWindowId_LockSystemModalContainer);
   DCHECK(lock_modal_container);
   lock_modal_container->SetLayoutManager(
-      base::MakeUnique<SystemModalContainerLayoutManager>(
-          lock_modal_container));
+      new SystemModalContainerLayoutManager(lock_modal_container));
 
-  WmWindow* lock_container = GetWmContainer(kShellWindowId_LockScreenContainer);
+  aura::Window* lock_container =
+      GetContainer(kShellWindowId_LockScreenContainer);
   DCHECK(lock_container);
-  lock_container->SetLayoutManager(
-      base::MakeUnique<LockLayoutManager>(lock_container));
+  lock_container->SetLayoutManager(new LockLayoutManager(lock_container));
 
   WmWindow* always_on_top_container =
       GetWmContainer(kShellWindowId_AlwaysOnTopContainer);
   DCHECK(always_on_top_container);
   always_on_top_controller_ =
       base::MakeUnique<AlwaysOnTopController>(always_on_top_container);
 
   // Create Panel layout manager
   WmWindow* wm_panel_container = GetWmContainer(kShellWindowId_PanelContainer);
   panel_layout_manager_ = new PanelLayoutManager(wm_panel_container);
@@ skipping 271 matching lines @@
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash