Make touch-resizing windows to screen edge possible

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 18 matching lines @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace ash {
 
-scoped_ptr<WindowResizer> CreateWindowResizer(aura::Window* window,
-                                              const gfx::Point& point_in_parent,
-                                              int window_component) {
+scoped_ptr<WindowResizer> CreateWindowResizer(
+    aura::Window* window,
+    const gfx::Point& point_in_parent,
+    int window_component,
+    aura::client::WindowMoveSource source) {
   DCHECK(window);
   // No need to return a resizer when the window cannot get resized.
   if (!wm::CanResizeWindow(window) && window_component != HTCAPTION)
     return scoped_ptr<WindowResizer>();
 
   WindowResizer* window_resizer = NULL;
   if (window->parent() &&
       window->parent()->id() == internal::kShellWindowId_WorkspaceContainer) {
     // Allow dragging maximized windows if it's not tracked by workspace. This
     // is set by tab dragging code.
     if (!wm::IsWindowNormal(window) &&
         (window_component != HTCAPTION || GetTrackedByWorkspace(window)))
       return scoped_ptr<WindowResizer>();
     window_resizer = internal::WorkspaceWindowResizer::Create(
         window,
         point_in_parent,
         window_component,
+        source,
         std::vector<aura::Window*>());
   } else if (wm::IsWindowNormal(window)) {
     window_resizer = DefaultWindowResizer::Create(
-        window, point_in_parent, window_component);
+        window, point_in_parent, window_component, source);
   }
   if (window_resizer) {
     window_resizer = internal::DragWindowResizer::Create(
-        window_resizer, window, point_in_parent, window_component);
+        window_resizer, window, point_in_parent, window_component, source);
   }
   if (window_resizer && window->type() == aura::client::WINDOW_TYPE_PANEL) {
     window_resizer = PanelWindowResizer::Create(
-        window_resizer, window, point_in_parent, window_component);
+        window_resizer, window, point_in_parent, window_component, source);
   }
   return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
 // Distance in pixels that the cursor must move past an edge for a window
 // to move or resize beyond that edge.
 const int kStickyDistancePixels = 64;
 
+// 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)) {
     return distance_from_edge < 0 &&
            distance_from_edge > -sticky_size;
   }
   return distance_from_edge < sticky_size &&
                               distance_from_edge > -sticky_size * 2;
 }
@@ skipping 210 matching lines @@
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->UnlockCursor();
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location_in_parent,
     int window_component,
+    aura::client::WindowMoveSource source,
     const std::vector<aura::Window*>& attached_windows) {
-  Details details(window, location_in_parent, window_component);
+  Details details(window, location_in_parent, window_component, source);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
 
 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 (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;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
 
   if (wm::IsWindowNormal(window()))
     AdjustBoundsForMainWindow(sticky_size, &bounds);
 
   if (bounds != window()->bounds()) {
@@ skipping 505 matching lines @@
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window()));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash