Moves more code to ash/wm/common

ash/wm/common/window_positioner.cc

 // Copyright 2013 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_positioner.h"
+#include "ash/wm/common/window_positioner.h"
 
 #include "ash/wm/common/window_positioning_utils.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_screen_util.h"
 #include "ash/wm/common/wm_window.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 
@@ skipping 85 matching lines @@
     if ((child_bounds.x() <= work_area.x() &&
          new_child_bounds.x() <= work_area.x()) ||
         (child_bounds.right() >= work_area.right() &&
          new_child_bounds.right() >= work_area.right())) {
       continue;
     }
     if (new_child_bounds.right() > work_area.right())
       new_child_bounds.set_x(work_area.right() - bounds.width());
     else if (new_child_bounds.x() < work_area.x())
       new_child_bounds.set_x(work_area.x());
-    SetBoundsAndOffsetTransientChildren(transient_child,
-                                        new_child_bounds, work_area, offset);
+    SetBoundsAndOffsetTransientChildren(transient_child, new_child_bounds,
+                                        work_area, offset);
   }
 
   window->SetBoundsWithTransitionDelay(
       bounds, base::TimeDelta::FromMilliseconds(kWindowAutoMoveDurationMS));
 }
 
 // Move a |window| to new |bounds|. Animate if desired by user.
 // Note: The function will do nothing if the bounds did not change.
 void SetBoundsAnimated(wm::WmWindow* window,
                        const gfx::Rect& bounds,
@@ skipping 124 matching lines @@
         *show_state_out = ui::SHOW_STATE_MAXIMIZED;
     }
     return;
   }
 
   wm::WindowState* top_window_state = top_window->GetWindowState();
   bool maximized = top_window_state->IsMaximized();
   // We ignore the saved show state, but look instead for the top level
   // window's show state.
   if (show_state_in == ui::SHOW_STATE_DEFAULT) {
-    *show_state_out = maximized ? ui::SHOW_STATE_MAXIMIZED :
-        ui::SHOW_STATE_DEFAULT;
+    *show_state_out =
+        maximized ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_DEFAULT;
   }
 
   if (maximized || top_window_state->IsFullscreen()) {
     bool has_restore_bounds = top_window_state->HasRestoreBounds();
     if (has_restore_bounds) {
       // For a maximized/fullscreen window ignore the real bounds of
       // the top level window and use its restore bounds
       // instead. Offset the bounds to prevent the windows from
       // overlapping exactly when restored.
-      *bounds_in_out = top_window_state->GetRestoreBoundsInScreen() +
+      *bounds_in_out =
+          top_window_state->GetRestoreBoundsInScreen() +
           gfx::Vector2d(kMinimumWindowOffset, kMinimumWindowOffset);
     }
     if (is_saved_bounds || has_restore_bounds) {
       gfx::Rect work_area = target->GetDisplayNearestWindow().work_area();
       bounds_in_out->AdjustToFit(work_area);
       // Use adjusted saved bounds or restore bounds, if there is one.
       return;
     }
   }
 
@@ skipping 96 matching lines @@
 
 WindowPositioner::WindowPositioner(wm::WmGlobals* globals)
     : globals_(globals),
       pop_position_offset_increment_x(0),
       pop_position_offset_increment_y(0),
       popup_position_offset_from_screen_corner_x(0),
       popup_position_offset_from_screen_corner_y(0),
       last_popup_position_x_(0),
       last_popup_position_y_(0) {}
 
-WindowPositioner::~WindowPositioner() {
-}
+WindowPositioner::~WindowPositioner() {}
 
 gfx::Rect WindowPositioner::GetDefaultWindowBounds(
     const display::Display& display) {
   const gfx::Rect work_area = display.work_area();
   // There should be a 'desktop' border around the window at the left and right
   // side.
   int default_width = work_area.width() - 2 * kDesktopBorderSize;
   // There should also be a 'desktop' border around the window at the top.
   // Since the workspace excludes the tray area we only need one border size.
   int default_height = work_area.height() - kDesktopBorderSize;
   int offset_x = kDesktopBorderSize;
   if (default_width > kMaximumWindowWidth) {
     // The window should get centered on the screen and not follow the grid.
     offset_x = (work_area.width() - kMaximumWindowWidth) / 2;
     default_width = kMaximumWindowWidth;
   }
-  return gfx::Rect(work_area.x() + offset_x,
-                   work_area.y() + kDesktopBorderSize,
-                   default_width,
-                   default_height);
+  return gfx::Rect(work_area.x() + offset_x, work_area.y() + kDesktopBorderSize,
+                   default_width, default_height);
 }
 
 gfx::Rect WindowPositioner::GetPopupPosition(const gfx::Rect& old_pos) {
   int grid = kMinimumWindowOffset;
   popup_position_offset_from_screen_corner_x = grid;
   popup_position_offset_from_screen_corner_y = grid;
   if (!pop_position_offset_increment_x) {
     // When the popup position increment is 0, the last popup position
     // was not yet initialized.
     last_popup_position_x_ = popup_position_offset_from_screen_corner_x;
     last_popup_position_y_ = popup_position_offset_from_screen_corner_y;
   }
   pop_position_offset_increment_x = grid;
   pop_position_offset_increment_y = grid;
   // We handle the Multi monitor support by retrieving the active window's
   // work area.
   wm::WmWindow* window = globals_->GetActiveWindow();
   const gfx::Rect work_area =
       window && window->IsVisible()
           ? window->GetDisplayNearestWindow().work_area()
           : display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
   // Only try to reposition the popup when it is not spanning the entire
   // screen.
   if ((old_pos.width() + popup_position_offset_from_screen_corner_x >=
-      work_area.width()) ||
+       work_area.width()) ||
       (old_pos.height() + popup_position_offset_from_screen_corner_y >=
        work_area.height()))
     return AlignPopupPosition(old_pos, work_area, grid);
   const gfx::Rect result = SmartPopupPosition(old_pos, work_area, grid);
   if (!result.IsEmpty())
     return AlignPopupPosition(result, work_area, grid);
   return NormalPopupPosition(old_pos, work_area);
 }
 
 // static
 void WindowPositioner::SetMaximizeFirstWindow(bool maximize) {
   maximize_first_window = maximize;
 }
 
-gfx::Rect WindowPositioner::NormalPopupPosition(
-    const gfx::Rect& old_pos,
-    const gfx::Rect& work_area) {
+gfx::Rect WindowPositioner::NormalPopupPosition(const gfx::Rect& old_pos,
+                                                const gfx::Rect& work_area) {
   int w = old_pos.width();
   int h = old_pos.height();
   // Note: The 'last_popup_position' is checked and kept relative to the
   // screen size. The offsetting will be done in the last step when the
   // target rectangle gets returned.
   bool reset = false;
   if (last_popup_position_y_ + h > work_area.height() ||
       last_popup_position_x_ + w > work_area.width()) {
     // Popup does not fit on screen. Reset to next diagonal row.
     last_popup_position_x_ -= last_popup_position_y_ -
@@ skipping 10 matching lines @@
   }
   int x = last_popup_position_x_;
   int y = last_popup_position_y_;
   if (!reset) {
     last_popup_position_x_ += pop_position_offset_increment_x;
     last_popup_position_y_ += pop_position_offset_increment_y;
   }
   return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h);
 }
 
-gfx::Rect WindowPositioner::SmartPopupPosition(
-    const gfx::Rect& old_pos,
-    const gfx::Rect& work_area,
-    int grid) {
+gfx::Rect WindowPositioner::SmartPopupPosition(const gfx::Rect& old_pos,
+                                               const gfx::Rect& work_area,
+                                               int grid) {
   const std::vector<wm::WmWindow*> windows =
       globals_->GetMruWindowListIgnoreModals();
 
   std::vector<const gfx::Rect*> regions;
   // Process the window list and check if we can bail immediately.
   for (size_t i = 0; i < windows.size(); i++) {
     // We only include opaque and visible windows.
     if (windows[i] && windows[i]->IsVisible() && windows[i]->GetLayer() &&
         (windows[i]->GetLayer()->fills_bounds_opaquely() ||
          windows[i]->GetLayer()->GetTargetOpacity() == 1.0)) {
@@ skipping 16 matching lines @@
   // We parse for a proper location on the screen. We do this in two runs:
   // The first run will start from the left, parsing down, skipping any
   // overlapping windows it will encounter until the popup's height can not
   // be served anymore. Then the next grid position to the right will be
   // taken, and the same cycle starts again. This will be repeated until we
   // hit the middle of the screen (or we find a suitable location).
   // In the second run we parse beginning from the right corner downwards and
   // then to the left.
   // When no location was found, an empty rectangle will be returned.
   for (int run = 0; run < 2; run++) {
-    if (run == 0) { // First run: Start left, parse right till mid screen.
+    if (run == 0) {  // First run: Start left, parse right till mid screen.
       x = 0;
       x_increment = pop_position_offset_increment_x;
-    } else { // Second run: Start right, parse left till mid screen.
+    } else {  // Second run: Start right, parse left till mid screen.
       x = work_area.width() - w;
       x_increment = -pop_position_offset_increment_x;
     }
     // Note: The passing (x,y,w,h) window is always relative to the work area's
     // origin.
     for (; x_increment > 0 ? (x < x_end) : (x > x_end); x += x_increment) {
       int y = 0;
       while (y + h <= work_area.height()) {
         size_t i;
         for (i = 0; i < regions.size(); i++) {
-          if (regions[i]->Intersects(gfx::Rect(x + work_area.x(),
-                                               y + work_area.y(), w, h))) {
+          if (regions[i]->Intersects(
+                  gfx::Rect(x + work_area.x(), y + work_area.y(), w, h))) {
             y = regions[i]->bottom() - work_area.y();
             break;
           }
         }
         if (i >= regions.size())
           return gfx::Rect(x + work_area.x(), y + work_area.y(), w, h);
       }
     }
   }
   return gfx::Rect(0, 0, 0, 0);
 }
 
-gfx::Rect WindowPositioner::AlignPopupPosition(
-    const gfx::Rect& pos,
-    const gfx::Rect& work_area,
-    int grid) {
+gfx::Rect WindowPositioner::AlignPopupPosition(const gfx::Rect& pos,
+                                               const gfx::Rect& work_area,
+                                               int grid) {
   if (grid <= 1)
     return pos;
 
   int x = pos.x() - (pos.x() - work_area.x()) % grid;
   int y = pos.y() - (pos.y() - work_area.y()) % grid;
   int w = pos.width();
   int h = pos.height();
 
   // If the alignment was pushing the window out of the screen, we ignore the
   // alignment for that call.
   if (abs(pos.right() - work_area.right()) < grid)
     x = work_area.right() - w;
   if (abs(pos.bottom() - work_area.bottom()) < grid)
     y = work_area.bottom() - h;
   return gfx::Rect(x, y, w, h);
 }
 
 }  // namespace ash