Removes a couple more functions from 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 <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"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/shelf_window_targeter.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_port.h"
 #include "ash/system/status_area_layout_manager.h"
@@ skipping 124 matching lines @@
 void MoveOriginRelativeToSize(const gfx::Size& src_size,
                               const gfx::Size& dst_size,
                               gfx::Rect* bounds_in_out) {
   gfx::Point origin = bounds_in_out->origin();
   bounds_in_out->set_origin(gfx::Point(
       ToRelativeValue(origin.x(), src_size.width(), dst_size.width()),
       ToRelativeValue(origin.y(), src_size.height(), dst_size.height())));
 }
 
 // Reparents |window| to |new_parent|.
-// TODO(sky): This should take an aura::Window. http://crbug.com/671246.
-void ReparentWindow(WmWindow* window, WmWindow* new_parent) {
-  const gfx::Size src_size = window->GetParent()->GetBounds().size();
-  const gfx::Size dst_size = new_parent->GetBounds().size();
+void ReparentWindow(aura::Window* window, aura::Window* new_parent) {
+  const gfx::Size src_size = window->parent()->bounds().size();
+  const gfx::Size dst_size = new_parent->bounds().size();
   // Update the restore bounds to make it relative to the display.
-  wm::WindowState* state = window->GetWindowState();
+  wm::WindowState* state = wm::GetWindowState(window);
   gfx::Rect restore_bounds;
   const bool has_restore_bounds = state->HasRestoreBounds();
 
   const bool update_bounds = state->IsNormalOrSnapped() || state->IsMinimized();
   gfx::Rect work_area_in_new_parent =
-      wm::GetDisplayWorkAreaBoundsInParent(new_parent);
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(new_parent);
 
   gfx::Rect local_bounds;
   if (update_bounds) {
     local_bounds = state->window()->GetBounds();
     MoveOriginRelativeToSize(src_size, dst_size, &local_bounds);
     local_bounds.AdjustToFit(work_area_in_new_parent);
   }
 
   if (has_restore_bounds) {
     restore_bounds = state->GetRestoreBoundsInParent();
     MoveOriginRelativeToSize(src_size, dst_size, &restore_bounds);
     restore_bounds.AdjustToFit(work_area_in_new_parent);
   }
 
   new_parent->AddChild(window);
 
   // Docked windows have bounds handled by the layout manager in AddChild().
   if (update_bounds)
     window->SetBounds(local_bounds);
 
   if (has_restore_bounds)
     state->SetRestoreBoundsInParent(restore_bounds);
 }
 
 // Reparents the appropriate set of windows from |src| to |dst|.
 // TODO(sky): This should take an aura::Window. http://crbug.com/671246.

[msw, 2017/04/12 22:12:50]

nit: remove todo

[sky, 2017/04/12 22:35:04]

Done.

-void ReparentAllWindows(WmWindow* src, WmWindow* dst) {
+void ReparentAllWindows(aura::Window* src, aura::Window* dst) {
   // Set of windows to move.
   const int kContainerIdsToMove[] = {
       kShellWindowId_DefaultContainer,
       kShellWindowId_PanelContainer,
       kShellWindowId_AlwaysOnTopContainer,
       kShellWindowId_SystemModalContainer,
       kShellWindowId_LockSystemModalContainer,
       kShellWindowId_UnparentedControlContainer,
       kShellWindowId_OverlayContainer,
   };
   const int kExtraContainerIdsToMoveInUnifiedMode[] = {
       kShellWindowId_LockScreenContainer,
       kShellWindowId_LockScreenWallpaperContainer,
   };
   std::vector<int> container_ids(
       kContainerIdsToMove,
       kContainerIdsToMove + arraysize(kContainerIdsToMove));
   // Check the display mode as this is also necessary when trasitioning between
   // mirror and unified mode.
   if (ShellPort::Get()->IsInUnifiedModeIgnoreMirroring()) {
     for (int id : kExtraContainerIdsToMoveInUnifiedMode)
       container_ids.push_back(id);
   }
 
   for (int id : container_ids) {
-    WmWindow* src_container = src->GetChildByShellWindowId(id);
-    WmWindow* dst_container = dst->GetChildByShellWindowId(id);
-    while (!src_container->GetChildren().empty()) {
+    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.
-      WmWindow::Windows src_container_children = src_container->GetChildren();
-      WmWindow::Windows::const_iterator iter = src_container_children.begin();
+      const aura::Window::Windows& src_container_children =
+          src_container->children();
+      auto iter = src_container_children.begin();
       while (iter != src_container_children.end() &&
-             SystemModalContainerLayoutManager::IsModalBackground(*iter)) {
+             SystemModalContainerLayoutManager::IsModalBackground(
+                 WmWindow::Get(*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 132 matching lines @@
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
   return wm_shelf_->shelf_layout_manager();
 }
 
 SystemModalContainerLayoutManager*
 RootWindowController::GetSystemModalLayoutManager(WmWindow* window) {
   WmWindow* modal_container = nullptr;
   if (window) {
     WmWindow* window_container = wm::GetContainerForWindow(window);
-    if (window_container &&
-        window_container->GetShellWindowId() >=
-            kShellWindowId_LockScreenContainer) {
+    if (window_container && window_container->aura_window()->id() >=
+                                kShellWindowId_LockScreenContainer) {
       modal_container = GetWmContainer(kShellWindowId_LockSystemModalContainer);
     } else {
       modal_container = GetWmContainer(kShellWindowId_SystemModalContainer);
     }
   } else {
     int modal_window_id =
         Shell::Get()->session_controller()->IsUserSessionBlocked()
             ? kShellWindowId_LockSystemModalContainer
             : kShellWindowId_SystemModalContainer;
     modal_container = GetWmContainer(modal_window_id);
@@ skipping 206 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(), WmWindow::Get(dst));
+  ReparentAllWindows(GetRootWindow(), dst);
 }
 
 void RootWindowController::UpdateShelfVisibility() {
   wm_shelf_->UpdateVisibilityState();
 }
 
 void RootWindowController::InitTouchHuds() {
   if (Shell::GetAshConfig() == Config::MASH)
     return;
 
@@ skipping 469 matching lines @@
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash