Centralizes snap sizing and implements spec'd behavior. Three resize

ash/wm/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/shell.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/root_window_event_filter.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
+#include "ash/wm/workspace/snap_sizer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(int)
@@ skipping 36 matching lines @@
 int GetWidthBeforeObscured(aura::Window* window) {
   return window->GetProperty(kWidthBeforeObscuredKey);
 }
 
 void ClearWidthBeforeObscured(aura::Window* window) {
   window->SetProperty(kWidthBeforeObscuredKey, 0);
 }
 
 }  // namespace
 
-WorkspaceWindowResizer::PhantomPlacement::PhantomPlacement() : type(TYPE_NONE) {
-}
-
-WorkspaceWindowResizer::PhantomPlacement::~PhantomPlacement() {
-}
-
 // static
 const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   if (root_filter_)
     root_filter_->UnlockCursor();
 }
 
 // static
-gfx::Rect WorkspaceWindowResizer::GetBoundsForWindowAlongEdge(
-    aura::Window* window,
-    WorkspaceWindowResizer::EdgeType edge,
-    int grid_size) {
-  gfx::Rect work_area(gfx::Screen::GetMonitorWorkAreaNearestWindow(window));
-  int y = WindowResizer::AlignToGridRoundUp(work_area.y(), grid_size);
-  int max_y =
-      WindowResizer::AlignToGridRoundDown(work_area.bottom(), grid_size);
-  if (edge == LEFT_EDGE) {
-    int x = WindowResizer::AlignToGridRoundUp(work_area.x(), grid_size);
-    int mid_x = WindowResizer::AlignToGridRoundUp(
-        work_area.x() + work_area.width() / 2, grid_size);
-    return gfx::Rect(x, y, mid_x - x, max_y - y);
-  }
-  int x = WindowResizer::AlignToGridRoundUp(
-      work_area.x() + work_area.width() / 2, grid_size);
-  int max_x = WindowResizer::AlignToGridRoundDown(work_area.right(), grid_size);
-  return gfx::Rect(x , y, max_x - x, max_y - y);
-}
-
-// static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location,
     int window_component,
     int grid_size,
     const std::vector<aura::Window*>& attached_windows) {
   Details details(window, location, window_component, grid_size);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
@@ skipping 11 matching lines @@
     else
       LayoutAttachedWindowsVertically(bounds);
   }
   if (bounds != details_.window->bounds())
     details_.window->SetBounds(bounds);
   // WARNING: we may have been deleted.
 }
 
 void WorkspaceWindowResizer::CompleteDrag() {
   if (phantom_window_controller_.get()) {
-    if (phantom_placement_.type == TYPE_DESTINATION)
+    if (snap_type_ == SNAP_DESTINATION)
       phantom_window_controller_->DelayedClose(kSnapDurationMS);
     phantom_window_controller_.reset();
   }
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  if (phantom_placement_.type == TYPE_LEFT_EDGE ||
-      phantom_placement_.type == TYPE_RIGHT_EDGE) {
+  if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) {
     if (!GetRestoreBounds(details_.window))
       SetRestoreBounds(details_.window, details_.initial_bounds);
-    details_.window->SetBounds(phantom_placement_.bounds);
+    details_.window->SetBounds(snap_sizer_->target_bounds());
     return;
   }
 
   if (details_.grid_size <= 1)
     return;
 
   gfx::Rect bounds(GetFinalBounds());
   if (bounds == details_.window->bounds())
     return;
 
@@ skipping 42 matching lines @@
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     const Details& details,
     const std::vector<aura::Window*>& attached_windows)
     : details_(details),
       constrain_size_(wm::IsWindowNormal(details.window)),
       attached_windows_(attached_windows),
       did_move_or_resize_(false),
       root_filter_(NULL),
       total_min_(0),
       total_initial_size_(0),
+      snap_type_(SNAP_NONE),
       num_mouse_moves_since_bounds_change_(0) {
   DCHECK(details_.is_resizable);
   root_filter_ = Shell::GetInstance()->root_filter();
   if (root_filter_)
     root_filter_->LockCursor();
 
   // We should never be in a situation where we have an attached window and not
   // constrain the size. The only case we don't constrain size is for dragging
   // tabs, which should never have an attached window.
   DCHECK(attached_windows_.empty() || constrain_size_);
@@ skipping 237 matching lines @@
     default:
       NOTREACHED();
   }
   return 0;
 }
 
 void WorkspaceWindowResizer::UpdatePhantomWindow(const gfx::Point& location) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  PhantomPlacement last_placement = phantom_placement_;
-  phantom_placement_ = GetPhantomPlacement(location);
-  if (phantom_placement_.type == TYPE_NONE) {
+  snap_type_ = GetSnapType(location);
+  if (snap_type_ == SNAP_NONE) {
     phantom_window_controller_.reset();
+    snap_sizer_.reset();
     return;
   }
   PhantomWindowController::Type phantom_type;
-  if (phantom_placement_.type == TYPE_LEFT_EDGE ||
-      phantom_placement_.type == TYPE_RIGHT_EDGE) {
+  if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)
     phantom_type = PhantomWindowController::TYPE_EDGE;
-    UpdatePhantomWindowBoundsAlongEdge(last_placement);
-  } else {
+  else
     phantom_type = PhantomWindowController::TYPE_DESTINATION;
-  }
   if (phantom_window_controller_.get() &&
       phantom_window_controller_->type() != phantom_type) {
     phantom_window_controller_.reset();
+    snap_sizer_.reset();
+  }
+  if (phantom_type == PhantomWindowController::TYPE_EDGE) {
+    if (!snap_sizer_.get()) {
+      SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
+          SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
+      snap_sizer_.reset(
+          new SnapSizer(details_.window, location, edge, details_.grid_size));
+    } else {
+      snap_sizer_->Update(location);
+    }
   }
   if (!phantom_window_controller_.get()) {
     phantom_window_controller_.reset(
         new PhantomWindowController(details_.window, phantom_type,
                                     kPhantomDelayMS));
   }
-  phantom_window_controller_->Show(phantom_placement_.bounds);
+  gfx::Rect bounds;
+  if (snap_sizer_.get())
+    bounds = snap_sizer_->target_bounds();
+  else
+    bounds = GetFinalBounds();
+  phantom_window_controller_->Show(bounds);
 }
 
-void WorkspaceWindowResizer::UpdatePhantomWindowBoundsAlongEdge(
-    const PhantomPlacement& last_placement) {
-  if (last_placement.type == phantom_placement_.type) {
-    int grid_size = std::max(1, details_.grid_size);
-    if (++num_mouse_moves_since_bounds_change_ >= grid_size / 2) {
-      gfx::Rect area(gfx::Screen::GetMonitorAreaNearestWindow(details_.window));
-      gfx::Rect bounds(last_placement.bounds);
-      if (last_placement.type == TYPE_LEFT_EDGE) {
-        bounds.set_width(std::min(WindowResizer::AlignToGridRoundDown(
-                                      area.width() - bounds.x(), grid_size),
-                                  bounds.width() + grid_size));
-      } else {
-        int x = std::max(
-            WindowResizer::AlignToGridRoundUp(area.x(), grid_size),
-            bounds.x() - grid_size);
-        bounds.set_width(phantom_placement_.bounds.width() - x);
-        bounds.set_x(x);
-      }
-      phantom_placement_.bounds = bounds;
-      num_mouse_moves_since_bounds_change_ = 0;
-    } else {
-      phantom_placement_.bounds = last_placement.bounds;
-    }
-  } else {
-    num_mouse_moves_since_bounds_change_ = 0;
-  }
-}
-
-WorkspaceWindowResizer::PhantomPlacement
-WorkspaceWindowResizer::GetPhantomPlacement(const gfx::Point& location) {
+WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType(
+    const gfx::Point& location) const {
   // TODO: this likely only wants total monitor area, not the area of a single
   // monitor.
-  PhantomPlacement placement;
   gfx::Rect area(gfx::Screen::GetMonitorAreaNearestWindow(details_.window));
-  if (location.x() <= area.x()) {
-    placement.type = TYPE_LEFT_EDGE;
-    placement.bounds = GetBoundsForWindowAlongEdge(
-        details_.window, LEFT_EDGE, details_.grid_size);
-  } else if (location.x() >= area.right() - 1) {
-    placement.type = TYPE_RIGHT_EDGE;
-    placement.bounds = GetBoundsForWindowAlongEdge(
-        details_.window, RIGHT_EDGE, details_.grid_size);
-  } else if (details_.grid_size > 1 && wm::IsWindowNormal(details_.window)) {
-    placement.bounds = GetFinalBounds();
-    placement.type = TYPE_DESTINATION;
-  }
-  return placement;
+  if (location.x() <= area.x())
+    return SNAP_LEFT_EDGE;
+  if (location.x() >= area.right() - 1)
+    return SNAP_RIGHT_EDGE;
+  if (details_.grid_size > 1 && wm::IsWindowNormal(details_.window))
+    return SNAP_DESTINATION;
+  return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash