chromeos: gets rid of wm_screen_util

ash/wm/default_state.cc

 // Copyright 2014 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/default_state.h"
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
+#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wm/screen_pinning_controller.h"
 #include "ash/wm/window_animation_types.h"
 #include "ash/wm/window_parenting_utils.h"
 #include "ash/wm/window_positioning_utils.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_util.h"
 #include "ash/wm/wm_event.h"
-#include "ash/wm/wm_screen_util.h"
 #include "ash/wm_window.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // This specifies how much percent (30%) of a window rect
@@ skipping 213 matching lines @@
       if (window_state->IsFullscreen()) {
         const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
         window_state->OnWMEvent(&event);
       } else if (window_state->IsMaximized()) {
         window_state->Restore();
       } else if (window_state->CanMaximize()) {
         window_state->Maximize();
       }
       return true;
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE: {
-      gfx::Rect work_area = GetDisplayWorkAreaBoundsInParent(window);
+      gfx::Rect work_area =
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
 
       // Maximize vertically if:
       // - The window does not have a max height defined.
       // - The window has the normal state type. Snapped windows are excluded
       //   because they are already maximized vertically and reverting to the
       //   restored bounds looks weird.
       if (window->GetMaximumSize().height() != 0 ||
           !window_state->IsNormalStateType()) {
         return true;
       }
@@ skipping 10 matching lines @@
       return true;
     }
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE: {
       // Maximize horizontally if:
       // - The window does not have a max width defined.
       // - The window is snapped or has the normal state type.
       if (window->GetMaximumSize().width() != 0)
         return true;
       if (!window_state->IsNormalOrSnapped())
         return true;
-      gfx::Rect work_area = GetDisplayWorkAreaBoundsInParent(window);
+      gfx::Rect work_area =
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
       if (window_state->IsNormalStateType() &&
           window_state->HasRestoreBounds() &&
           (window->GetBounds().width() == work_area.width() &&
            window->GetBounds().x() == work_area.x())) {
         window_state->SetAndClearRestoreBounds();
       } else {
         gfx::Rect new_bounds(work_area.x(), window->GetBounds().y(),
                              work_area.width(), window->GetBounds().height());
 
         gfx::Rect restore_bounds = window->GetBounds();
@@ skipping 67 matching lines @@
       // Only windows of type WINDOW_TYPE_NORMAL or WINDOW_TYPE_PANEL need to be
       // adjusted to have minimum visibility, because they are positioned by the
       // user and user should always be able to interact with them. Other
       // windows are positioned programmatically.
       if (!window_state->IsUserPositionable())
         return true;
 
       // Use entire display instead of workarea. The logic ensures 30%
       // visibility which should be enough to see where the window gets
       // moved.
-      gfx::Rect display_area = GetDisplayBoundsInParent(window);
+      gfx::Rect display_area =
+          ScreenUtil::GetDisplayBoundsInParent(window->aura_window());
       int min_width = bounds.width() * wm::kMinimumPercentOnScreenArea;
       int min_height = bounds.height() * wm::kMinimumPercentOnScreenArea;
       wm::AdjustBoundsToEnsureWindowVisibility(display_area, min_width,
                                                min_height, &bounds);
       window_state->AdjustSnappedBounds(&bounds);
       if (window->GetBounds() != bounds)
         window_state->SetBoundsConstrained(bounds);
       return true;
     }
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED: {
       if (window_state->is_dragged() ||
           window_state->allow_set_bounds_direct() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
-          GetDisplayWorkAreaBoundsInParent(window_state->window());
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+              window_state->window()->aura_window());
       gfx::Rect bounds = window_state->window()->GetTargetBounds();
       // When display bounds has changed, make sure the entire window is fully
       // visible.
       bounds.AdjustToFit(work_area_in_parent);
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->window()->GetTargetBounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED: {
       // Don't resize the maximized window when the desktop is covered
       // by fullscreen window. crbug.com/504299.
       bool in_fullscreen =
           window_state->window()
               ->GetRootWindowController()
               ->GetWorkspaceWindowState() == WORKSPACE_WINDOW_STATE_FULL_SCREEN;
       if (in_fullscreen && window_state->IsMaximized())
         return true;
 
       if (window_state->is_dragged() ||
           window_state->allow_set_bounds_direct() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
-          GetDisplayWorkAreaBoundsInParent(window_state->window());
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+              window_state->window()->aura_window());
       gfx::Rect bounds = window_state->window()->GetTargetBounds();
       if (!window_state->window()->GetTransientParent()) {
         wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
                                                         &bounds);
       }
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->window()->GetTargetBounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
@@ skipping 18 matching lines @@
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   DCHECK(!window_state->allow_set_bounds_direct());
   if (window_state->IsMaximized()) {
-    window_state->SetBoundsDirect(
-        GetMaximizedWindowBoundsInParent(window_state->window()));
+    window_state->SetBoundsDirect(ScreenUtil::GetMaximizedWindowBoundsInParent(
+        window_state->window()->aura_window()));
     return true;
   }
   if (window_state->IsFullscreen()) {
-    window_state->SetBoundsDirect(
-        GetDisplayBoundsInParent(window_state->window()));
+    window_state->SetBoundsDirect(ScreenUtil::GetDisplayBoundsInParent(
+        window_state->window()->aura_window()));
     return true;
   }
   return false;
 }
 
 // static
 void DefaultState::SetBounds(WindowState* window_state,
                              const SetBoundsEvent* event) {
   if (window_state->is_dragged() || window_state->allow_set_bounds_direct()) {
     // TODO(oshima|varkha): Is this still needed? crbug.com/485612.
     window_state->SetBoundsDirect(event->requested_bounds());
   } else if (window_state->IsSnapped()) {
     gfx::Rect work_area_in_parent =
-        GetDisplayWorkAreaBoundsInParent(window_state->window());
+        ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+            window_state->window()->aura_window());
     gfx::Rect child_bounds(event->requested_bounds());
     wm::AdjustBoundsSmallerThan(work_area_in_parent.size(), &child_bounds);
     window_state->AdjustSnappedBounds(&child_bounds);
     window_state->SetBoundsDirect(child_bounds);
   } else if (!SetMaximizedOrFullscreenBounds(window_state)) {
     window_state->SetBoundsConstrained(event->requested_bounds());
   }
 }
 
 void DefaultState::EnterToNextState(WindowState* window_state,
@@ skipping 99 matching lines @@
     case WINDOW_STATE_TYPE_LEFT_SNAPPED:
     case WINDOW_STATE_TYPE_RIGHT_SNAPPED:
       bounds_in_parent =
           state_type_ == WINDOW_STATE_TYPE_LEFT_SNAPPED
               ? GetDefaultLeftSnappedWindowBoundsInParent(window)
               : GetDefaultRightSnappedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
-      gfx::Rect work_area_in_parent = GetDisplayWorkAreaBoundsInParent(window);
+      gfx::Rect work_area_in_parent =
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
             bounds_in_parent.width() >= work_area_in_parent.width() &&
             bounds_in_parent.height() >= work_area_in_parent.height()) {
           bounds_in_parent = work_area_in_parent;
           bounds_in_parent.Inset(kMaximizedWindowInset, kMaximizedWindowInset,
                                  kMaximizedWindowInset, kMaximizedWindowInset);
         }
       } else {
         bounds_in_parent = window->GetBounds();
       }
       // Make sure that part of the window is always visible.
       if (!window_state->is_dragged()) {
         // Avoid doing this while the window is being dragged as its root
         // window hasn't been updated yet in the case of dragging to another
         // display. crbug.com/666836.
         wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
                                                         &bounds_in_parent);
       }
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
-      bounds_in_parent = GetMaximizedWindowBoundsInParent(window);
+      bounds_in_parent =
+          ScreenUtil::GetMaximizedWindowBoundsInParent(window->aura_window());
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
     case WINDOW_STATE_TYPE_PINNED:
     case WINDOW_STATE_TYPE_TRUSTED_PINNED:
-      bounds_in_parent = GetDisplayBoundsInParent(window);
+      bounds_in_parent =
+          ScreenUtil::GetDisplayBoundsInParent(window->aura_window());
       break;
 
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
   }
 
@@ skipping 46 matching lines @@
   WmWindow* window = window_state->window();
   if (window_state->IsSnapped()) {
     gfx::Rect center_in_screen = window->GetDisplayNearestWindow().work_area();
     gfx::Size size = window_state->HasRestoreBounds()
                          ? window_state->GetRestoreBoundsInScreen().size()
                          : window->GetBounds().size();
     center_in_screen.ClampToCenteredSize(size);
     window_state->SetRestoreBoundsInScreen(center_in_screen);
     window_state->Restore();
   } else {
-    gfx::Rect center_in_parent = GetDisplayWorkAreaBoundsInParent(window);
+    gfx::Rect center_in_parent =
+        ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
     center_in_parent.ClampToCenteredSize(window->GetBounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash