Makes it easier to snap or dock windows near the edges when using touch

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 <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 91 matching lines @@
     window_resizer = internal::DockedWindowResizer::Create(window_resizer,
                                                            window_state);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
-// Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
-// when resizing a window using touchscreen.
-const int kScreenEdgeInsetForTouchResize = 32;
-
 // Returns true if the window should stick to the edge.
 bool ShouldStickToEdge(int distance_from_edge, int sticky_size) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableStickyEdges)) {
     // TODO(varkha): Consider keeping snapping behavior for touch drag.
     return distance_from_edge < 0 &&
            distance_from_edge > -sticky_size;
   }
   return distance_from_edge < sticky_size &&
          distance_from_edge > -sticky_size * 2;
@@ skipping 235 matching lines @@
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
   } else if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAshEnableStickyEdges)) {
     sticky_size = kStickyDistancePixels;
   } else if ((details().bounds_change & kBoundsChange_Resizes) &&
       details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
-    sticky_size = kScreenEdgeInsetForTouchResize;
+    sticky_size = SnapSizer::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()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details().restore_bounds.IsEmpty())
@@ skipping 530 matching lines @@
   if (!can_snap && !can_dock) {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     SetDraggedWindowDocked(false);
     return;
   }
   SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT) ?
       SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
   if (!snap_sizer_) {
-    snap_sizer_.reset(new SnapSizer(window_state(),
-                                    location,
-                                    edge,
-                                    internal::SnapSizer::OTHER_INPUT));
+    SnapSizer::InputType input =
+        details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH ?
+            SnapSizer::TOUCH_DRAG_INPUT : SnapSizer::OTHER_INPUT;
+    snap_sizer_.reset(new SnapSizer(window_state(), location, edge, input));
   } else {
     snap_sizer_->Update(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;
   if (can_snap && (!can_dock || GetTarget()->bounds().width() >
       DockedWindowLayoutManager::kMaxDockWidth)) {
@@ skipping 58 matching lines @@
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
   gfx::Rect area(ScreenUtil::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(ScreenUtil::GetDisplayBoundsInParent(GetTarget()));
     int inset_left = 0;
     if (area.x() == display_bounds.x())
-      inset_left = kScreenEdgeInsetForTouchResize;
+      inset_left = SnapSizer::kScreenEdgeInsetForTouchDrag;
     int inset_right = 0;
     if (area.right() == display_bounds.right())
-      inset_right = kScreenEdgeInsetForTouchResize;
+      inset_right = SnapSizer::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 &&
       dock_layout_->GetAlignmentOfWindow(GetTarget()) !=
           DOCKED_ALIGNMENT_NONE) {
     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);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash