chromeos: converts WindowResizer to aura::Window

ash/wm/window_positioning_utils.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/window_positioning_utils.h"
 
 #include <algorithm>
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm_window.h"
 #include "ui/aura/client/focus_client.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/display/display.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace ash {
 namespace wm {
 
 namespace {
 
 // Returns the default width of a snapped window.
-int GetDefaultSnappedWindowWidth(WmWindow* window) {
+int GetDefaultSnappedWindowWidth(aura::Window* window) {
   const float kSnappedWidthWorkspaceRatio = 0.5f;
 
   int work_area_width =
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window())
-          .width();
-  int min_width = window->GetMinimumSize().width();
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window).width();
+  int min_width =
+      window->delegate() ? window->delegate()->GetMinimumSize().width() : 0;
   int ideal_width =
       static_cast<int>(work_area_width * kSnappedWidthWorkspaceRatio);
   return std::min(work_area_width, std::max(ideal_width, min_width));
 }
 
 // Return true if the window or one of its ancestor returns true from
 // IsLockedToRoot().
 bool IsWindowOrAncestorLockedToRoot(const WmWindow* window) {
   return window && (window->IsLockedToRoot() ||
                     IsWindowOrAncestorLockedToRoot(window->GetParent()));
@@ skipping 55 matching lines @@
   if (bounds->y() < visible_area.y())
     bounds->set_y(visible_area.y());
 }
 
 void AdjustBoundsToEnsureMinimumWindowVisibility(const gfx::Rect& visible_area,
                                                  gfx::Rect* bounds) {
   AdjustBoundsToEnsureWindowVisibility(visible_area, kMinimumOnScreenArea,
                                        kMinimumOnScreenArea, bounds);
 }
 
-gfx::Rect GetDefaultLeftSnappedWindowBoundsInParent(WmWindow* window) {
+gfx::Rect GetDefaultLeftSnappedWindowBoundsInParent(aura::Window* window) {
   gfx::Rect work_area_in_parent(
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window()));
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window));
   return gfx::Rect(work_area_in_parent.x(), work_area_in_parent.y(),
                    GetDefaultSnappedWindowWidth(window),
                    work_area_in_parent.height());
 }
 
-gfx::Rect GetDefaultRightSnappedWindowBoundsInParent(WmWindow* window) {
+gfx::Rect GetDefaultRightSnappedWindowBoundsInParent(aura::Window* window) {
   gfx::Rect work_area_in_parent(
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window()));
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window));
   int width = GetDefaultSnappedWindowWidth(window);
   return gfx::Rect(work_area_in_parent.right() - width, work_area_in_parent.y(),
                    width, work_area_in_parent.height());
 }
 
 void CenterWindow(WmWindow* window) {
   WMEvent event(WM_EVENT_CENTER);
   window->GetWindowState()->OnWMEvent(&event);
 }
 
@@ skipping 64 matching lines @@
   }
   gfx::Point origin(bounds_in_screen.origin());
   const gfx::Point display_origin =
       window->GetDisplayNearestWindow().bounds().origin();
   origin.Offset(-display_origin.x(), -display_origin.y());
   window->SetBounds(gfx::Rect(origin, bounds_in_screen.size()));
 }
 
 }  // namespace wm
 }  // namespace ash