Removes aura dependencies from WindowPositioner

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/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
+#include "ash/wm/common/window_positioning_utils.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ash/wm/workspace_controller.h"
@@ skipping 411 matching lines @@
       // 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 because the workarea can
       // be further shrunk by the docked area. The logic ensures 30%
       // visibility which should be enough to see where the window gets
       // moved.
       gfx::Rect display_area = ScreenUtil::GetDisplayBoundsInParent(window);
-      int min_width = bounds.width() * kMinimumPercentOnScreenArea;
-      int min_height = bounds.height() * kMinimumPercentOnScreenArea;
-      AdjustBoundsToEnsureWindowVisibility(
-          display_area, min_width, min_height, &bounds);
+      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->bounds() != bounds)
         window_state->SetBoundsConstrained(bounds);
       return true;
     }
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED: {
       if (window_state->is_dragged() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
@@ skipping 20 matching lines @@
         return true;
 
       if (window_state->is_dragged() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(
               window_state->aura_window());
       gfx::Rect bounds = window_state->aura_window()->bounds();
-      AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent, &bounds);
+      wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
+                                                      &bounds);
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->aura_window()->bounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
@@ skipping 35 matching lines @@
                              const SetBoundsEvent* event) {
   if (window_state->is_dragged()) {
     // TODO(oshima|varkha): This may be no longer needed, as the dragging
     // happens in docked window container. crbug.com/485612.
     window_state->SetBoundsDirect(event->requested_bounds());
   } else if (window_state->IsSnapped()) {
     gfx::Rect work_area_in_parent =
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(
             window_state->aura_window());
     gfx::Rect child_bounds(event->requested_bounds());
-    AdjustBoundsSmallerThan(work_area_in_parent.size(), &child_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,
                                     WindowStateType next_state_type) {
   // Do nothing if  we're already in the same state.
@@ skipping 116 matching lines @@
             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->bounds();
       }
       // Make sure that part of the window is always visible.
-      AdjustBoundsToEnsureMinimumWindowVisibility(
-          work_area_in_parent, &bounds_in_parent);
+      wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
+                                                      &bounds_in_parent);
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
       bounds_in_parent = ScreenUtil::GetMaximizedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
       bounds_in_parent = ScreenUtil::GetDisplayBoundsInParent(window);
       break;
 
@@ skipping 67 matching lines @@
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().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