Moves windowsresizers to ash/wm/common

ash/wm/common/workspace/workspace_window_resizer.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/wm/workspace/workspace_window_resizer.h"
+#include "ash/wm/common/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/wm/common/default_window_resizer.h"
 #include "ash/wm/common/dock/docked_window_layout_manager.h"
+#include "ash/wm/common/dock/docked_window_resizer.h"
+#include "ash/wm/common/panels/panel_window_resizer.h"
 #include "ash/wm/common/window_positioning_utils.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_event.h"
 #include "ash/wm/common/wm_globals.h"
 #include "ash/wm/common/wm_root_window_controller.h"
 #include "ash/wm/common/wm_screen_util.h"
 #include "ash/wm/common/wm_shell_window_ids.h"
 #include "ash/wm/common/wm_user_metrics_action.h"
 #include "ash/wm/common/wm_window.h"
-#include "ash/wm/dock/docked_window_resizer.h"
-#include "ash/wm/panels/panel_window_resizer.h"
-#include "ash/wm/workspace/phantom_window_controller.h"
-#include "ash/wm/workspace/two_step_edge_cycler.h"
+#include "ash/wm/common/workspace/phantom_window_controller.h"
+#include "ash/wm/common/workspace/two_step_edge_cycler.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/public/window_types.h"
 
 namespace ash {
 
@@ skipping 23 matching lines @@
   // layout manager when a docked window is being dragged. We should have a
   // better way of doing this, perhaps by having a way of observing drags or
   // having a generic drag window wrapper which informs a layout manager that a
   // drag has started or stopped.
   // It may be possible to refactor and eliminate chaining.
   std::unique_ptr<WindowResizer> window_resizer;
 
   if (!window_state->IsNormalOrSnapped() && !window_state->IsDocked())
     return std::unique_ptr<WindowResizer>();
 
-  int bounds_change = WindowResizer::GetBoundsChangeForWindowComponent(
-      window_component);
+  int bounds_change =
+      WindowResizer::GetBoundsChangeForWindowComponent(window_component);
   if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
     return std::unique_ptr<WindowResizer>();
 
   window_state->CreateDragDetails(point_in_parent, window_component, source);
   const int parent_shell_window_id =
       window->GetParent() ? window->GetParent()->GetShellWindowId() : -1;
   if (window->GetParent() &&
       (parent_shell_window_id == kShellWindowId_DefaultContainer ||
        parent_shell_window_id == kShellWindowId_DockedContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
@@ skipping 65 matching lines @@
     case MAGNETISM_EDGE_BOTTOM:
       y = attach_to.y() - src.height();
       break;
     case MAGNETISM_EDGE_RIGHT:
       x = attach_to.x() - src.width();
       break;
   }
   switch (edge.primary_edge) {
     case MAGNETISM_EDGE_TOP:
     case MAGNETISM_EDGE_BOTTOM:
-      x = CoordinateAlongSecondaryAxis(
-          edge.secondary_edge, attach_to.x(), attach_to.right() - src.width(),
-          src.x());
+      x = CoordinateAlongSecondaryAxis(edge.secondary_edge, attach_to.x(),
+                                       attach_to.right() - src.width(),
+                                       src.x());
       break;
     case MAGNETISM_EDGE_LEFT:
     case MAGNETISM_EDGE_RIGHT:
-      y = CoordinateAlongSecondaryAxis(
-          edge.secondary_edge, attach_to.y(), attach_to.bottom() - src.height(),
-          src.y());
+      y = CoordinateAlongSecondaryAxis(edge.secondary_edge, attach_to.y(),
+                                       attach_to.bottom() - src.height(),
+                                       src.y());
       break;
   }
   return gfx::Point(x, y);
 }
 
 // Returns the bounds for a magnetic attach when resizing. |src| is the bounds
 // of window being resized, |attach_to| the bounds of the window to attach to
 // and |edge| identifies the edge to attach to.
 gfx::Rect BoundsForMagneticResizeAttach(const gfx::Rect& src,
                                         const gfx::Rect& attach_to,
@@ skipping 79 matching lines @@
 const int WorkspaceWindowResizer::kScreenEdgeInset = 8;
 
 WorkspaceWindowResizer* WorkspaceWindowResizer::GetInstanceForTest() {
   return instance;
 }
 
 // Represents the width or height of a window with constraints on its minimum
 // and maximum size. 0 represents a lack of a constraint.
 class WindowSize {
  public:
-  WindowSize(int size, int min, int max)
-      : size_(size),
-        min_(min),
-        max_(max) {
+  WindowSize(int size, int min, int max) : size_(size), min_(min), max_(max) {
     // Grow the min/max bounds to include the starting size.
     if (is_underflowing())
       min_ = size_;
     if (is_overflowing())
       max_ = size_;
   }
 
   bool is_at_capacity(bool shrinking) const {
     return size_ == (shrinking ? min_ : max_);
   }
 
-  int size() const {
-    return size_;
-  }
+  int size() const { return size_; }
 
-  bool has_min() const {
-    return min_ != 0;
-  }
+  bool has_min() const { return min_ != 0; }
 
-  bool has_max() const {
-    return max_ != 0;
-  }
+  bool has_max() const { return max_ != 0; }
 
-  bool is_valid() const {
-    return !is_overflowing() && !is_underflowing();
-  }
+  bool is_valid() const { return !is_overflowing() && !is_underflowing(); }
 
-  bool is_overflowing() const {
-    return has_max() && size_ > max_;
-  }
+  bool is_overflowing() const { return has_max() && size_ > max_; }
 
-  bool is_underflowing() const {
-    return has_min() && size_ < min_;
-  }
+  bool is_underflowing() const { return has_min() && size_ < min_; }
 
   // Add |amount| to this WindowSize not exceeding min or max size constraints.
   // Returns by how much |size_| + |amount| exceeds the min/max constraints.
   int Add(int amount) {
     DCHECK(is_valid());
     int new_value = size_ + amount;
 
     if (has_min() && new_value < min_) {
       size_ = min_;
       return new_value - min_;
@@ skipping 30 matching lines @@
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
                                   int event_flags) {
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
   } else if ((details().bounds_change & kBoundsChange_Resizes) &&
-      details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
+             details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchDrag;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |GetTarget()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(location_in_parent);
   AdjustBoundsForMainWindow(sticky_size, &bounds);
 
   if (bounds != GetTarget()->GetBounds()) {
     if (!did_move_or_resize_) {
@@ skipping 52 matching lines @@
   // using a keyboard shortcut while dragging it.
   if (window_state()->GetStateType() != details().initial_state_type)
     return;
 
   bool snapped = false;
   if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
     if (!window_state()->HasRestoreBounds()) {
       gfx::Rect initial_bounds = GetTarget()->GetParent()->ConvertRectToScreen(
           details().initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
-          details().restore_bounds.IsEmpty() ?
-          initial_bounds :
-          details().restore_bounds);
+          details().restore_bounds.IsEmpty() ? initial_bounds
+                                             : details().restore_bounds);
     }
     if (!dock_layout_->is_dragged_window_docked()) {
       // TODO(oshima): Add event source type to WMEvent and move
       // metrics recording inside WindowState::OnWMEvent.
-      const wm::WMEvent event(snap_type_ == SNAP_LEFT ?
-                              wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
+      const wm::WMEvent event(snap_type_ == SNAP_LEFT
+                                  ? wm::WM_EVENT_SNAP_LEFT
+                                  : wm::WM_EVENT_SNAP_RIGHT);
       window_state()->OnWMEvent(&event);
       globals_->RecordUserMetricsAction(
           snap_type_ == SNAP_LEFT
               ? wm::WmUserMetricsAction::DRAG_MAXIMIZE_LEFT
               : wm::WmUserMetricsAction::DRAG_MAXIMIZE_RIGHT);
       snapped = true;
     }
   }
 
   if (!snapped) {
@@ skipping 77 matching lines @@
   // A mousemove should still show the cursor even if the window is
   // being moved or resized with touch, so do not lock the cursor.
   if (details().source != aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     globals_->LockCursor();
     did_lock_cursor_ = true;
   }
 
   dock_layout_ = DockedWindowLayoutManager::Get(GetTarget());
 
   // Only support attaching to the right/bottom.
-  DCHECK(attached_windows_.empty() ||
-         (details().window_component == HTRIGHT ||
-          details().window_component == HTBOTTOM));
+  DCHECK(attached_windows_.empty() || (details().window_component == HTRIGHT ||
+                                       details().window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
   int total_available = 0;
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Size min(attached_windows_[i]->GetMinimumSize());
     int initial_size =
         PrimaryAxisSize(attached_windows_[i]->GetBounds().size());
     initial_size_.push_back(initial_size);
     // If current size is smaller than the min, use the current size as the min.
     // This way we don't snap on resize.
     int min_size = std::min(initial_size,
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
   instance = this;
 }
 
-void WorkspaceWindowResizer::LayoutAttachedWindows(
-    gfx::Rect* bounds) {
+void WorkspaceWindowResizer::LayoutAttachedWindows(gfx::Rect* bounds) {
   gfx::Rect work_area(wm::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   int initial_size = PrimaryAxisSize(details().initial_bounds_in_parent.size());
   int current_size = PrimaryAxisSize(bounds->size());
   int start = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   int end = PrimaryAxisCoordinate(work_area.right(), work_area.bottom());
 
   int delta = current_size - initial_size;
   int available_size = end - start;
   std::vector<int> sizes;
   int leftovers = CalculateAttachedSizes(delta, available_size, &sizes);
@@ skipping 101 matching lines @@
 
 void WorkspaceWindowResizer::CalculateGrowthRatios(
     const std::vector<WindowSize*>& sizes,
     std::vector<float>* out_ratios) const {
   DCHECK(out_ratios->empty());
   int total_value = 0;
   for (size_t i = 0; i < sizes.size(); ++i)
     total_value += sizes[i]->size();
 
   for (size_t i = 0; i < sizes.size(); ++i)
-    out_ratios->push_back(
-        (static_cast<float>(sizes[i]->size())) / total_value);
+    out_ratios->push_back((static_cast<float>(sizes[i]->size())) / total_value);
 }
 
 void WorkspaceWindowResizer::CreateBucketsForAttached(
     std::vector<WindowSize>* sizes) const {
   for (size_t i = 0; i < attached_windows_.size(); i++) {
     int initial_size = initial_size_[i];
     int min = PrimaryAxisSize(attached_windows_[i]->GetMinimumSize());
     int max = PrimaryAxisSize(attached_windows_[i]->GetMaximumSize());
 
     sizes->push_back(WindowSize(initial_size, min, max));
@@ skipping 52 matching lines @@
         root_window->GetChildByShellWindowId(kShellWindowId_DefaultContainer)
             ->GetChildren();
     for (auto i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
       wm::WindowState* other_state = (*i)->GetWindowState();
       if (other_state->window() == GetTarget() ||
           !other_state->window()->IsVisible() ||
           !other_state->IsNormalOrSnapped() || !other_state->CanResize()) {
         continue;
       }
-      if (matcher.ShouldAttach(
-              other_state->window()->GetBoundsInScreen(), &magnetism_edge_)) {
+      if (matcher.ShouldAttach(other_state->window()->GetBoundsInScreen(),
+                               &magnetism_edge_)) {
         magnetism_window_ = other_state->window();
         window_tracker_.Add(magnetism_window_);
         return true;
       }
     }
   }
   return false;
 }
 
-void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
-    int sticky_size,
-    gfx::Rect* bounds) {
+void WorkspaceWindowResizer::AdjustBoundsForMainWindow(int sticky_size,
+                                                       gfx::Rect* bounds) {
   gfx::Point last_mouse_location_in_screen =
       GetTarget()->GetParent()->ConvertPointToScreen(last_mouse_location_);
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestPoint(
           last_mouse_location_in_screen);
   gfx::Rect work_area =
       GetTarget()->GetParent()->ConvertRectFromScreen(display.work_area());
   if (details().window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight or the window height (whichever is less)
     // on the bottom.
-    int max_y = work_area.bottom() - std::min(kMinOnscreenHeight,
-                                              bounds->height());
+    int max_y =
+        work_area.bottom() - std::min(kMinOnscreenHeight, bounds->height());
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
       // cursor reaches the work area above if any.
       bounds->set_y(work_area.y());
     }
 
     if (sticky_size > 0) {
       // Possibly stick to edge except when a mouse pointer is outside the
@@ skipping 14 matching lines @@
   if (details().window_component == HTRIGHT) {
     bounds->set_width(std::min(bounds->width(),
                                work_area.right() - total_min_ - bounds->x()));
   } else {
     DCHECK_EQ(HTBOTTOM, details().window_component);
     bounds->set_height(std::min(bounds->height(),
                                 work_area.bottom() - total_min_ - bounds->y()));
   }
 }
 
-bool WorkspaceWindowResizer::StickToWorkAreaOnMove(
-    const gfx::Rect& work_area,
-    int sticky_size,
-    gfx::Rect* bounds) const {
+bool WorkspaceWindowResizer::StickToWorkAreaOnMove(const gfx::Rect& work_area,
+                                                   int sticky_size,
+                                                   gfx::Rect* bounds) const {
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
   bool updated = false;
   if (ShouldStickToEdge(bounds->x() - left_edge, sticky_size)) {
     bounds->set_x(left_edge);
     updated = true;
   } else if (ShouldStickToEdge(right_edge - bounds->right(), sticky_size)) {
     bounds->set_x(right_edge - bounds->width());
     updated = true;
   }
   if (ShouldStickToEdge(bounds->y() - top_edge, sticky_size)) {
     bounds->set_y(top_edge);
     updated = true;
   } else if (ShouldStickToEdge(bottom_edge - bounds->bottom(), sticky_size) &&
              bounds->height() < (bottom_edge - top_edge)) {
     // Only snap to the bottom if the window is smaller than the work area.
     // Doing otherwise can lead to window snapping in weird ways as it bounces
     // between snapping to top then bottom.
     bounds->set_y(bottom_edge - bounds->height());
     updated = true;
   }
   return updated;
 }
 
-void WorkspaceWindowResizer::StickToWorkAreaOnResize(
-    const gfx::Rect& work_area,
-    int sticky_size,
-    gfx::Rect* bounds) const {
+void WorkspaceWindowResizer::StickToWorkAreaOnResize(const gfx::Rect& work_area,
+                                                     int sticky_size,
+                                                     gfx::Rect* bounds) const {
   const uint32_t edges =
       WindowComponentToMagneticEdge(details().window_component);
   const int left_edge = work_area.x();
   const int right_edge = work_area.right();
   const int top_edge = work_area.y();
   const int bottom_edge = work_area.bottom();
   if (edges & MAGNETISM_EDGE_TOP &&
       ShouldStickToEdge(bounds->y() - top_edge, sticky_size)) {
     bounds->set_height(bounds->bottom() - top_edge);
     bounds->set_y(top_edge);
@@ skipping 39 matching lines @@
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
     if (snap_type_ == SNAP_NONE) {
       SetDraggedWindowDocked(false);
       return;
     }
   }
 
   DCHECK(snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT);
-  DockedAlignment desired_alignment = (snap_type_ == SNAP_LEFT) ?
-      DOCKED_ALIGNMENT_LEFT : DOCKED_ALIGNMENT_RIGHT;
+  DockedAlignment desired_alignment = (snap_type_ == SNAP_LEFT)
+                                          ? DOCKED_ALIGNMENT_LEFT
+                                          : DOCKED_ALIGNMENT_RIGHT;
   const bool can_dock =
       dock_layout_->CanDockWindow(GetTarget(), desired_alignment) &&
       dock_layout_->GetAlignmentOfWindow(GetTarget()) != DOCKED_ALIGNMENT_NONE;
   if (!can_dock) {
     // If the window cannot be docked, undock the window. This may change the
     // workspace bounds and hence |snap_type_|.
     SetDraggedWindowDocked(false);
     snap_type_ = GetSnapType(location);
   }
   const bool can_snap = snap_type_ != SNAP_NONE && window_state()->CanSnap();
@@ skipping 114 matching lines @@
   DCHECK(snapped_type == wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ||
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds = wm::GetDisplayWorkAreaBoundsInParent(GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash