chromeos: Move files in //ash/common to //ash

ash/common/wm/workspace/workspace_window_resizer.cc

Index: ash/common/wm/workspace/workspace_window_resizer.cc
diff --git a/ash/common/wm/workspace/workspace_window_resizer.cc b/ash/common/wm/workspace/workspace_window_resizer.cc
deleted file mode 100644
index 5f66ec57fd572e0d84222001b04f1f4081818698..0000000000000000000000000000000000000000
--- a/ash/common/wm/workspace/workspace_window_resizer.cc
+++ /dev/null
@@ -1,1021 +0,0 @@
-// 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/common/wm/workspace/workspace_window_resizer.h"
-
-#include <algorithm>
-#include <cmath>
-#include <utility>
-#include <vector>
-
-#include "ash/common/ash_switches.h"
-#include "ash/common/metrics/user_metrics_action.h"
-#include "ash/common/wm/default_window_resizer.h"
-#include "ash/common/wm/dock/docked_window_layout_manager.h"
-#include "ash/common/wm/dock/docked_window_resizer.h"
-#include "ash/common/wm/panels/panel_window_resizer.h"
-#include "ash/common/wm/window_positioning_utils.h"
-#include "ash/common/wm/window_state.h"
-#include "ash/common/wm/wm_event.h"
-#include "ash/common/wm/wm_screen_util.h"
-#include "ash/common/wm/workspace/phantom_window_controller.h"
-#include "ash/common/wm/workspace/two_step_edge_cycler.h"
-#include "ash/common/wm_shell.h"
-#include "ash/common/wm_window.h"
-#include "ash/public/cpp/shell_window_ids.h"
-#include "ash/root_window_controller.h"
-#include "ash/shell.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/display.h"
-#include "ui/display/screen.h"
-#include "ui/gfx/transform.h"
-#include "ui/wm/public/window_types.h"
-
-namespace ash {
-
-std::unique_ptr<WindowResizer> CreateWindowResizer(
-    WmWindow* window,
-    const gfx::Point& point_in_parent,
-    int window_component,
-    aura::client::WindowMoveSource source) {
-  DCHECK(window);
-  wm::WindowState* window_state = window->GetWindowState();
-  // No need to return a resizer when the window cannot get resized or when a
-  // resizer already exists for this window.
-  if ((!window_state->CanResize() && window_component != HTCAPTION) ||
-      window_state->drag_details()) {
-    return nullptr;
-  }
-
-  if (window_component == HTCAPTION && !window_state->can_be_dragged())
-    return nullptr;
-
-  // TODO(varkha): The chaining of window resizers causes some of the logic
-  // to be repeated and the logic flow difficult to control. With some windows
-  // classes using reparenting during drag operations it becomes challenging to
-  // implement proper transition from one resizer to another during or at the
-  // end of the drag. This also causes http://crbug.com/247085.
-  // It seems the only thing the panel or dock resizer needs to do is notify the
-  // 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);
-  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)) {
-    window_resizer.reset(
-        WorkspaceWindowResizer::Create(window_state, std::vector<WmWindow*>()));
-  } else {
-    window_resizer.reset(DefaultWindowResizer::Create(window_state));
-  }
-  window_resizer = window->GetShell()->CreateDragWindowResizer(
-      std::move(window_resizer), window_state);
-  if (window->GetType() == ui::wm::WINDOW_TYPE_PANEL)
-    window_resizer.reset(
-        PanelWindowResizer::Create(window_resizer.release(), window_state));
-  if (window_resizer && window->GetParent() && !window->GetTransientParent() &&
-      (parent_shell_window_id == kShellWindowId_DefaultContainer ||
-       parent_shell_window_id == kShellWindowId_DockedContainer ||
-       parent_shell_window_id == kShellWindowId_PanelContainer)) {
-    window_resizer.reset(
-        DockedWindowResizer::Create(window_resizer.release(), window_state));
-  }
-  return window_resizer;
-}
-
-namespace {
-
-// Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
-// when resizing a window using touchscreen.
-const int kScreenEdgeInsetForTouchDrag = 32;
-
-// Current instance for use by the WorkspaceWindowResizerTest.
-WorkspaceWindowResizer* instance = NULL;
-
-// Returns true if the window should stick to the edge.
-bool ShouldStickToEdge(int distance_from_edge, int sticky_size) {
-  return distance_from_edge < sticky_size &&
-         distance_from_edge > -sticky_size * 2;
-}
-
-// Returns the coordinate along the secondary axis to snap to.
-int CoordinateAlongSecondaryAxis(SecondaryMagnetismEdge edge,
-                                 int leading,
-                                 int trailing,
-                                 int none) {
-  switch (edge) {
-    case SECONDARY_MAGNETISM_EDGE_LEADING:
-      return leading;
-    case SECONDARY_MAGNETISM_EDGE_TRAILING:
-      return trailing;
-    case SECONDARY_MAGNETISM_EDGE_NONE:
-      return none;
-  }
-  NOTREACHED();
-  return none;
-}
-
-// Returns the origin for |src| when magnetically attaching to |attach_to| along
-// the edges |edges|. |edges| is a bitmask of the MagnetismEdges.
-gfx::Point OriginForMagneticAttach(const gfx::Rect& src,
-                                   const gfx::Rect& attach_to,
-                                   const MatchedEdge& edge) {
-  int x = 0, y = 0;
-  switch (edge.primary_edge) {
-    case MAGNETISM_EDGE_TOP:
-      y = attach_to.bottom();
-      break;
-    case MAGNETISM_EDGE_LEFT:
-      x = attach_to.right();
-      break;
-    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());
-      break;
-    case MAGNETISM_EDGE_LEFT:
-    case MAGNETISM_EDGE_RIGHT:
-      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,
-                                        const MatchedEdge& edge) {
-  int x = src.x();
-  int y = src.y();
-  int w = src.width();
-  int h = src.height();
-  gfx::Point attach_origin(OriginForMagneticAttach(src, attach_to, edge));
-  switch (edge.primary_edge) {
-    case MAGNETISM_EDGE_LEFT:
-      x = attach_origin.x();
-      w = src.right() - x;
-      break;
-    case MAGNETISM_EDGE_RIGHT:
-      w += attach_origin.x() - src.x();
-      break;
-    case MAGNETISM_EDGE_TOP:
-      y = attach_origin.y();
-      h = src.bottom() - y;
-      break;
-    case MAGNETISM_EDGE_BOTTOM:
-      h += attach_origin.y() - src.y();
-      break;
-  }
-  switch (edge.primary_edge) {
-    case MAGNETISM_EDGE_LEFT:
-    case MAGNETISM_EDGE_RIGHT:
-      if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_LEADING) {
-        y = attach_origin.y();
-        h = src.bottom() - y;
-      } else if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_TRAILING) {
-        h += attach_origin.y() - src.y();
-      }
-      break;
-    case MAGNETISM_EDGE_TOP:
-    case MAGNETISM_EDGE_BOTTOM:
-      if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_LEADING) {
-        x = attach_origin.x();
-        w = src.right() - x;
-      } else if (edge.secondary_edge == SECONDARY_MAGNETISM_EDGE_TRAILING) {
-        w += attach_origin.x() - src.x();
-      }
-      break;
-  }
-  return gfx::Rect(x, y, w, h);
-}
-
-// Converts a window component edge to the magnetic edge to snap to.
-uint32_t WindowComponentToMagneticEdge(int window_component) {
-  switch (window_component) {
-    case HTTOPLEFT:
-      return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_TOP;
-    case HTTOPRIGHT:
-      return MAGNETISM_EDGE_TOP | MAGNETISM_EDGE_RIGHT;
-    case HTBOTTOMLEFT:
-      return MAGNETISM_EDGE_LEFT | MAGNETISM_EDGE_BOTTOM;
-    case HTBOTTOMRIGHT:
-      return MAGNETISM_EDGE_RIGHT | MAGNETISM_EDGE_BOTTOM;
-    case HTTOP:
-      return MAGNETISM_EDGE_TOP;
-    case HTBOTTOM:
-      return MAGNETISM_EDGE_BOTTOM;
-    case HTRIGHT:
-      return MAGNETISM_EDGE_RIGHT;
-    case HTLEFT:
-      return MAGNETISM_EDGE_LEFT;
-    default:
-      break;
-  }
-  return 0;
-}
-
-}  // namespace
-
-// static
-const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
-
-// static
-const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
-
-// static
-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) {
-    // 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_; }
-
-  bool has_min() const { return min_ != 0; }
-
-  bool has_max() const { return max_ != 0; }
-
-  bool is_valid() const { return !is_overflowing() && !is_underflowing(); }
-
-  bool is_overflowing() const { return has_max() && size_ > max_; }
-
-  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_;
-    }
-
-    if (has_max() && new_value > max_) {
-      size_ = max_;
-      return new_value - max_;
-    }
-
-    size_ = new_value;
-    return 0;
-  }
-
- private:
-  int size_;
-  int min_;
-  int max_;
-};
-
-WorkspaceWindowResizer::~WorkspaceWindowResizer() {
-  if (did_lock_cursor_)
-    shell_->UnlockCursor();
-
-  if (instance == this)
-    instance = NULL;
-}
-
-// static
-WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
-    wm::WindowState* window_state,
-    const std::vector<WmWindow*>& attached_windows) {
-  return new WorkspaceWindowResizer(window_state, attached_windows);
-}
-
-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) {
-    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_) {
-      if (!details().restore_bounds.IsEmpty())
-        window_state()->ClearRestoreBounds();
-      RestackWindows();
-    }
-    did_move_or_resize_ = true;
-  }
-
-  gfx::Point location_in_screen =
-      GetTarget()->GetParent()->ConvertPointToScreen(location_in_parent);
-
-  WmWindow* root = nullptr;
-  display::Display display =
-      display::Screen::GetScreen()->GetDisplayNearestPoint(location_in_screen);
-  // Track the last screen that the pointer was on to keep the snap phantom
-  // window there.
-  if (display.bounds().Contains(location_in_screen)) {
-    root =
-        Shell::GetRootWindowControllerWithDisplayId(display.id())->GetWindow();
-  }
-  if (!attached_windows_.empty())
-    LayoutAttachedWindows(&bounds);
-  if (bounds != GetTarget()->GetBounds()) {
-    // SetBounds needs to be called to update the layout which affects where the
-    // phantom window is drawn. Keep track if the window was destroyed during
-    // the drag and quit early if so.
-    base::WeakPtr<WorkspaceWindowResizer> resizer(
-        weak_ptr_factory_.GetWeakPtr());
-    GetTarget()->SetBounds(bounds);
-    if (!resizer)
-      return;
-  }
-  const bool in_original_root = !root || root == GetTarget()->GetRootWindow();
-  // Hide a phantom window for snapping if the cursor is in another root window.
-  if (in_original_root) {
-    UpdateSnapPhantomWindow(location_in_parent, bounds);
-  } else {
-    snap_type_ = SNAP_NONE;
-    snap_phantom_window_controller_.reset();
-    edge_cycler_.reset();
-    SetDraggedWindowDocked(false);
-  }
-}
-
-void WorkspaceWindowResizer::CompleteDrag() {
-  if (!did_move_or_resize_)
-    return;
-
-  window_state()->set_bounds_changed_by_user(true);
-  snap_phantom_window_controller_.reset();
-
-  // If the window's state type changed over the course of the drag do not snap
-  // the window. This happens when the user minimizes or maximizes the window
-  // 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);
-    }
-    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);
-      window_state()->OnWMEvent(&event);
-      shell_->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
-                                          ? UMA_DRAG_MAXIMIZE_LEFT
-                                          : UMA_DRAG_MAXIMIZE_RIGHT);
-      snapped = true;
-    }
-  }
-
-  if (!snapped) {
-    if (window_state()->IsSnapped()) {
-      // Keep the window snapped if the user resizes the window such that the
-      // window has valid bounds for a snapped window. Always unsnap the window
-      // if the user dragged the window via the caption area because doing this
-      // is slightly less confusing.
-      if (details().window_component == HTCAPTION ||
-          !AreBoundsValidSnappedBounds(window_state()->GetStateType(),
-                                       GetTarget()->GetBounds())) {
-        // Set the window to WINDOW_STATE_TYPE_NORMAL but keep the
-        // window at the bounds that the user has moved/resized the
-        // window to.
-        window_state()->SaveCurrentBoundsForRestore();
-        window_state()->Restore();
-      }
-    } else if (!dock_layout_->is_dragged_window_docked()) {
-      // The window was not snapped and is not snapped. This is a user
-      // resize/drag and so the current bounds should be maintained, clearing
-      // any prior restore bounds. When the window is docked the restore bound
-      // must be kept so the docked state can be reverted properly.
-      window_state()->ClearRestoreBounds();
-    }
-  }
-}
-
-void WorkspaceWindowResizer::RevertDrag() {
-  window_state()->set_bounds_changed_by_user(initial_bounds_changed_by_user_);
-  snap_phantom_window_controller_.reset();
-
-  if (!did_move_or_resize_)
-    return;
-
-  GetTarget()->SetBounds(details().initial_bounds_in_parent);
-  if (!details().restore_bounds.IsEmpty())
-    window_state()->SetRestoreBoundsInScreen(details().restore_bounds);
-
-  if (details().window_component == HTRIGHT) {
-    int last_x = details().initial_bounds_in_parent.right();
-    for (size_t i = 0; i < attached_windows_.size(); ++i) {
-      gfx::Rect bounds(attached_windows_[i]->GetBounds());
-      bounds.set_x(last_x);
-      bounds.set_width(initial_size_[i]);
-      attached_windows_[i]->SetBounds(bounds);
-      last_x = attached_windows_[i]->GetBounds().right();
-    }
-  } else {
-    int last_y = details().initial_bounds_in_parent.bottom();
-    for (size_t i = 0; i < attached_windows_.size(); ++i) {
-      gfx::Rect bounds(attached_windows_[i]->GetBounds());
-      bounds.set_y(last_y);
-      bounds.set_height(initial_size_[i]);
-      attached_windows_[i]->SetBounds(bounds);
-      last_y = attached_windows_[i]->GetBounds().bottom();
-    }
-  }
-}
-
-WorkspaceWindowResizer::WorkspaceWindowResizer(
-    wm::WindowState* window_state,
-    const std::vector<WmWindow*>& attached_windows)
-    : WindowResizer(window_state),
-      attached_windows_(attached_windows),
-      shell_(window_state->window()->GetShell()),
-      did_lock_cursor_(false),
-      did_move_or_resize_(false),
-      initial_bounds_changed_by_user_(window_state_->bounds_changed_by_user()),
-      total_min_(0),
-      total_initial_size_(0),
-      snap_type_(SNAP_NONE),
-      num_mouse_moves_since_bounds_change_(0),
-      magnetism_window_(NULL),
-      weak_ptr_factory_(this) {
-  DCHECK(details().is_resizable);
-
-  // 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) {
-    shell_->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));
-
-  // 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) {
-  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);
-
-  // leftovers > 0 means that the attached windows can't grow to compensate for
-  // the shrinkage of the main window. This line causes the attached windows to
-  // be moved so they are still flush against the main window, rather than the
-  // main window being prevented from shrinking.
-  leftovers = std::min(0, leftovers);
-  // Reallocate any leftover pixels back into the main window. This is
-  // necessary when, for example, the main window shrinks, but none of the
-  // attached windows can grow without exceeding their max size constraints.
-  // Adding the pixels back to the main window effectively prevents the main
-  // window from resizing too far.
-  if (details().window_component == HTRIGHT)
-    bounds->set_width(bounds->width() + leftovers);
-  else
-    bounds->set_height(bounds->height() + leftovers);
-
-  DCHECK_EQ(attached_windows_.size(), sizes.size());
-  int last = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
-  for (size_t i = 0; i < attached_windows_.size(); ++i) {
-    gfx::Rect attached_bounds(attached_windows_[i]->GetBounds());
-    if (details().window_component == HTRIGHT) {
-      attached_bounds.set_x(last);
-      attached_bounds.set_width(sizes[i]);
-    } else {
-      attached_bounds.set_y(last);
-      attached_bounds.set_height(sizes[i]);
-    }
-    attached_windows_[i]->SetBounds(attached_bounds);
-    last += sizes[i];
-  }
-}
-
-int WorkspaceWindowResizer::CalculateAttachedSizes(
-    int delta,
-    int available_size,
-    std::vector<int>* sizes) const {
-  std::vector<WindowSize> window_sizes;
-  CreateBucketsForAttached(&window_sizes);
-
-  // How much we need to grow the attached by (collectively).
-  int grow_attached_by = 0;
-  if (delta > 0) {
-    // If the attached windows don't fit when at their initial size, we will
-    // have to shrink them by how much they overflow.
-    if (total_initial_size_ >= available_size)
-      grow_attached_by = available_size - total_initial_size_;
-  } else {
-    // If we're shrinking, we grow the attached so the total size remains
-    // constant.
-    grow_attached_by = -delta;
-  }
-
-  int leftover_pixels = 0;
-  while (grow_attached_by != 0) {
-    int leftovers = GrowFairly(grow_attached_by, &window_sizes);
-    if (leftovers == grow_attached_by) {
-      leftover_pixels = leftovers;
-      break;
-    }
-    grow_attached_by = leftovers;
-  }
-
-  for (size_t i = 0; i < window_sizes.size(); ++i)
-    sizes->push_back(window_sizes[i].size());
-
-  return leftover_pixels;
-}
-
-int WorkspaceWindowResizer::GrowFairly(int pixels,
-                                       std::vector<WindowSize>* sizes) const {
-  bool shrinking = pixels < 0;
-  std::vector<WindowSize*> nonfull_windows;
-  for (size_t i = 0; i < sizes->size(); ++i) {
-    WindowSize& current_window_size = (*sizes)[i];
-    if (!current_window_size.is_at_capacity(shrinking))
-      nonfull_windows.push_back(&current_window_size);
-  }
-  std::vector<float> ratios;
-  CalculateGrowthRatios(nonfull_windows, &ratios);
-
-  int remaining_pixels = pixels;
-  bool add_leftover_pixels_to_last = true;
-  for (size_t i = 0; i < nonfull_windows.size(); ++i) {
-    int grow_by = pixels * ratios[i];
-    // Put any leftover pixels into the last window.
-    if (i == nonfull_windows.size() - 1 && add_leftover_pixels_to_last)
-      grow_by = remaining_pixels;
-    int remainder = nonfull_windows[i]->Add(grow_by);
-    int consumed = grow_by - remainder;
-    remaining_pixels -= consumed;
-    if (nonfull_windows[i]->is_at_capacity(shrinking) && remainder > 0) {
-      // Because this window overflowed, some of the pixels in
-      // |remaining_pixels| aren't there due to rounding errors. Rather than
-      // unfairly giving all those pixels to the last window, we refrain from
-      // allocating them so that this function can be called again to distribute
-      // the pixels fairly.
-      add_leftover_pixels_to_last = false;
-    }
-  }
-  return remaining_pixels;
-}
-
-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);
-}
-
-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));
-  }
-}
-
-void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
-  if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
-    gfx::Point point = OriginForMagneticAttach(
-        GetTarget()->GetParent()->ConvertRectToScreen(*bounds),
-        magnetism_window_->GetBoundsInScreen(), magnetism_edge_);
-    point = GetTarget()->GetParent()->ConvertPointFromScreen(point);
-    bounds->set_origin(point);
-  }
-}
-
-void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
-    gfx::Rect* bounds) {
-  const uint32_t edges =
-      WindowComponentToMagneticEdge(details().window_component);
-  if (UpdateMagnetismWindow(*bounds, edges)) {
-    *bounds = GetTarget()->GetParent()->ConvertRectFromScreen(
-        BoundsForMagneticResizeAttach(
-            GetTarget()->GetParent()->ConvertRectToScreen(*bounds),
-            magnetism_window_->GetBoundsInScreen(), magnetism_edge_));
-  }
-}
-
-bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
-                                                   uint32_t edges) {
-  // |bounds| are in coordinates of original window's parent.
-  gfx::Rect bounds_in_screen =
-      GetTarget()->GetParent()->ConvertRectToScreen(bounds);
-  MagnetismMatcher matcher(bounds_in_screen, edges);
-
-  // If we snapped to a window then check it first. That way we don't bounce
-  // around when close to multiple edges.
-  if (magnetism_window_) {
-    if (window_tracker_.Contains(magnetism_window_->aura_window()) &&
-        matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
-                             &magnetism_edge_)) {
-      return true;
-    }
-    window_tracker_.Remove(magnetism_window_->aura_window());
-    magnetism_window_ = NULL;
-  }
-
-  // Avoid magnetically snapping windows that are not resizable.
-  // TODO(oshima): change this to window.type() == TYPE_NORMAL.
-  if (!window_state()->CanResize())
-    return false;
-
-  for (WmWindow* root_window : shell_->GetAllRootWindows()) {
-    // Test all children from the desktop in each root window.
-    const std::vector<WmWindow*> children =
-        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_)) {
-        magnetism_window_ = other_state->window();
-        window_tracker_.Add(magnetism_window_->aura_window());
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-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());
-    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
-      // work area.
-      if (display.work_area().Contains(last_mouse_location_in_screen))
-        StickToWorkAreaOnMove(work_area, sticky_size, bounds);
-      MagneticallySnapToOtherWindows(bounds);
-    }
-  } else if (sticky_size > 0) {
-    MagneticallySnapResizeToOtherWindows(bounds);
-    if (!magnetism_window_ && sticky_size > 0)
-      StickToWorkAreaOnResize(work_area, sticky_size, bounds);
-  }
-
-  if (attached_windows_.empty())
-    return;
-
-  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 {
-  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 {
-  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);
-  }
-  if (edges & MAGNETISM_EDGE_LEFT &&
-      ShouldStickToEdge(bounds->x() - left_edge, sticky_size)) {
-    bounds->set_width(bounds->right() - left_edge);
-    bounds->set_x(left_edge);
-  }
-  if (edges & MAGNETISM_EDGE_BOTTOM &&
-      ShouldStickToEdge(bottom_edge - bounds->bottom(), sticky_size)) {
-    bounds->set_height(bottom_edge - bounds->y());
-  }
-  if (edges & MAGNETISM_EDGE_RIGHT &&
-      ShouldStickToEdge(right_edge - bounds->right(), sticky_size)) {
-    bounds->set_width(right_edge - bounds->x());
-  }
-}
-
-int WorkspaceWindowResizer::PrimaryAxisSize(const gfx::Size& size) const {
-  return PrimaryAxisCoordinate(size.width(), size.height());
-}
-
-int WorkspaceWindowResizer::PrimaryAxisCoordinate(int x, int y) const {
-  switch (details().window_component) {
-    case HTRIGHT:
-      return x;
-    case HTBOTTOM:
-      return y;
-    default:
-      NOTREACHED();
-  }
-  return 0;
-}
-
-void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
-                                                     const gfx::Rect& bounds) {
-  if (!did_move_or_resize_ || details().window_component != HTCAPTION)
-    return;
-
-  SnapType last_type = snap_type_;
-  snap_type_ = GetSnapType(location);
-  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;
-  const bool can_dock =
-      ash::switches::DockedWindowsEnabled() &&
-      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();
-  if (!can_snap && !can_dock) {
-    snap_type_ = SNAP_NONE;
-    snap_phantom_window_controller_.reset();
-    edge_cycler_.reset();
-    return;
-  }
-  if (!edge_cycler_) {
-    edge_cycler_.reset(new TwoStepEdgeCycler(
-        location, snap_type_ == SNAP_LEFT
-                      ? TwoStepEdgeCycler::DIRECTION_LEFT
-                      : TwoStepEdgeCycler::DIRECTION_RIGHT));
-  } else {
-    edge_cycler_->OnMove(location);
-  }
-
-  // Update phantom window with snapped or docked guide bounds.
-  // Windows that cannot be snapped or are less wide than kMaxDockWidth can get
-  // docked without going through a snapping sequence.
-  gfx::Rect phantom_bounds;
-  const bool should_dock =
-      can_dock && (!can_snap ||
-                   GetTarget()->GetBounds().width() <=
-                       DockedWindowLayoutManager::kMaxDockWidth ||
-                   edge_cycler_->use_second_mode() ||
-                   dock_layout_->is_dragged_window_docked());
-  if (should_dock) {
-    SetDraggedWindowDocked(true);
-    phantom_bounds = GetTarget()->GetParent()->ConvertRectFromScreen(
-        dock_layout_->dragged_bounds());
-  } else {
-    phantom_bounds =
-        (snap_type_ == SNAP_LEFT)
-            ? wm::GetDefaultLeftSnappedWindowBoundsInParent(GetTarget())
-            : wm::GetDefaultRightSnappedWindowBoundsInParent(GetTarget());
-  }
-
-  if (!snap_phantom_window_controller_) {
-    snap_phantom_window_controller_.reset(
-        new PhantomWindowController(GetTarget()));
-  }
-  snap_phantom_window_controller_->Show(
-      GetTarget()->GetParent()->ConvertRectToScreen(phantom_bounds));
-}
-
-void WorkspaceWindowResizer::RestackWindows() {
-  if (attached_windows_.empty())
-    return;
-  // Build a map from index in children to window, returning if there is a
-  // window with a different parent.
-  using IndexToWindowMap = std::map<size_t, WmWindow*>;
-  IndexToWindowMap map;
-  WmWindow* parent = GetTarget()->GetParent();
-  const std::vector<WmWindow*> windows(parent->GetChildren());
-  map[std::find(windows.begin(), windows.end(), GetTarget()) -
-      windows.begin()] = GetTarget();
-  for (auto i = attached_windows_.begin(); i != attached_windows_.end(); ++i) {
-    if ((*i)->GetParent() != parent)
-      return;
-    size_t index =
-        std::find(windows.begin(), windows.end(), *i) - windows.begin();
-    map[index] = *i;
-  }
-
-  // Reorder the windows starting at the topmost.
-  parent->StackChildAtTop(map.rbegin()->second);
-  for (auto i = map.rbegin(); i != map.rend();) {
-    WmWindow* window = i->second;
-    ++i;
-    if (i != map.rend())
-      parent->StackChildBelow(i->second, window);
-  }
-}
-
-WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType(
-    const gfx::Point& location) const {
-  // TODO: this likely only wants total display area, not the area of a single
-  // display.
-  gfx::Rect area(wm::GetDisplayWorkAreaBoundsInParent(GetTarget()));
-  if (details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
-    // Increase tolerance for touch-snapping near the screen edges. This is only
-    // necessary when the work area left or right edge is same as screen edge.
-    gfx::Rect display_bounds(wm::GetDisplayBoundsInParent(GetTarget()));
-    int inset_left = 0;
-    if (area.x() == display_bounds.x())
-      inset_left = kScreenEdgeInsetForTouchDrag;
-    int inset_right = 0;
-    if (area.right() == display_bounds.right())
-      inset_right = kScreenEdgeInsetForTouchDrag;
-    area.Inset(inset_left, 0, inset_right, 0);
-  }
-  if (location.x() <= area.x())
-    return SNAP_LEFT;
-  if (location.x() >= area.right() - 1)
-    return SNAP_RIGHT;
-  return SNAP_NONE;
-}
-
-void WorkspaceWindowResizer::SetDraggedWindowDocked(bool should_dock) {
-  if (should_dock) {
-    if (!dock_layout_->is_dragged_window_docked()) {
-      window_state()->set_bounds_changed_by_user(false);
-      dock_layout_->DockDraggedWindow(GetTarget());
-    }
-  } else {
-    if (dock_layout_->is_dragged_window_docked()) {
-      dock_layout_->UndockDraggedWindow();
-      window_state()->set_bounds_changed_by_user(true);
-    }
-  }
-}
-
-bool WorkspaceWindowResizer::AreBoundsValidSnappedBounds(
-    wm::WindowStateType snapped_type,
-    const gfx::Rect& bounds_in_parent) const {
-  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