Make touch-resizing windows to screen edge possible

ash/wm/window_resizer.cc

Index: ash/wm/window_resizer.cc
diff --git a/ash/wm/window_resizer.cc b/ash/wm/window_resizer.cc
index 3773d0735099072ee932d1ffc915df274181a16b..f7a3395fceda90f7c5233cc3af9b587b43bda6df 100644
--- a/ash/wm/window_resizer.cc
+++ b/ash/wm/window_resizer.cc
@@ -4,6 +4,8 @@
 
 #include "ash/wm/window_resizer.h"
 
+#include <cmath>
+
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
@@ -107,7 +109,8 @@ WindowResizer::Details::Details()
       bounds_change(0),
       position_change_direction(0),
       size_change_direction(0),
-      is_resizable(false) {
+      is_resizable(false),
+      is_touch(false) {
 }
 
 WindowResizer::Details::Details(aura::Window* window,
@@ -124,7 +127,13 @@ WindowResizer::Details::Details(aura::Window* window,
           GetPositionChangeDirectionForWindowComponent(window_component)),
       size_change_direction(
           GetSizeChangeDirectionForWindowComponent(window_component)),
-      is_resizable(bounds_change != kBoundsChangeDirection_None) {
+      is_resizable(bounds_change != kBoundsChangeDirection_None),
+      is_touch(false) {
+  // Set |is_touch| if |current_event| is not NULL. |current_event| may be NULL
+  // in unit tests that don't use synthetically generated events and test window
+  // resizers directly.
+  if (window->GetRootWindow()->current_event())

[sky, 2013/06/04 21:18:55]

I don't like grabbing the current event, it's too error prone. Please pass the
state in you need.

+    is_touch = window->GetRootWindow()->current_event()->IsGestureEvent();
   if (wm::IsWindowNormal(window) &&
       GetRestoreBoundsInScreen(window) &&
       window_component == HTCAPTION)
@@ -181,6 +190,9 @@ gfx::Rect WindowResizer::CalculateBoundsForDrag(
   int delta_x = location.x() - details.initial_location_in_parent.x();
   int delta_y = location.y() - details.initial_location_in_parent.y();
 
+  // Adjust values of |delta_x| and |delta_y| for touch resizes.
+  AdjustDeltaForTouch(details, &delta_x, &delta_y);
+
   // The minimize size constraint may limit how much we change the window
   // position.  For example, dragging the left edge to the right should stop
   // repositioning the window when the minimize size is reached.
@@ -265,6 +277,49 @@ gfx::Rect WindowResizer::CalculateBoundsForDrag(
 }
 
 // static
+void WindowResizer::AdjustDeltaForTouch(const Details& details,

[sky, 2013/06/04 21:18:55]

Is all of this to snap the edge to the edge of the screen? Do we only care about
workspace windows or all windows? It seems like we should be able to share some
of the code in WorkspaceWindowResizer that snaps resizes. Something like
MagneticallySnapResizeToOtherWindows but that snaps to the screen edges.

[mohsen, 2013/06/05 16:20:00]

This code is not for snapping. Its purpose is to move window border faster than
the finger (when necessary) so that the border catches up the finger at the edge
of the screen (see:
https://code.google.com/p/chromium/issues/detail?id=151168#c6). For the snapping
part, I have just increased the snapping distance (for touch-resizing) used by
existing snapping code.

[sky, 2013/06/07 19:26:30]

This seems disconcerting and while I get what Dana is suggesting I don't see the
point of it. Aren't the changes in worskpacewindowresize all that is necessary
to fix the bug? If you prefer, I can bring this discussion back to the bug, or
email Alex.

[sky, 2013/06/07 19:26:30]

Aren't the changes in WorkspaceWindowResize enough to fix this bug? I'm a bit
skeptical of slowly shifting the position as you drag, that seems a bit odd. In
particular I'm worried the slight shift as dragging is going to make it so it
feels as though the border is shifting under the finger. I'm happy to continue
this discussion in the bug or email Alex if you prefer.

[mohsen, 2013/06/07 20:06:57]

The change in WorkspaceWindowResizer increases snapping distance from 8 to 16
for touch. Even with this increase we should try hard to drag as close to the
window border as possible to move the border close enough to the edge to trigger
the snapping. That's where the slight shift helps a lot. Anyway, I'm fine with
either discussing under the bug or emailing Alex, whichever you think is more
appropriate.

+                                        int* delta_x,
+                                        int* delta_y) {
+  if (!details.is_touch || !(details.bounds_change & kBoundsChange_Resizes))
+    return;
+
+  if (details.size_change_direction & kBoundsChangeDirection_Horizontal) {
+    if (IsRightEdge(details.window_component) && *delta_x > 0) {
+      int display_width = Shell::GetScreen()->GetDisplayNearestWindow(
+          details.window).bounds().width();
+      int right = details.initial_bounds_in_parent.right();
+      float window_distance = display_width - right;
+      float touch_distance = display_width -
+          details.initial_location_in_parent.x();
+      *delta_x = static_cast<int>(
+          ceil(*delta_x * window_distance / touch_distance));
+    } else if (!IsRightEdge(details.window_component) && *delta_x < 0) {
+      float window_distance = details.initial_bounds_in_parent.x();
+      float touch_distance = details.initial_location_in_parent.x();
+      *delta_x = static_cast<int>(
+          floor(*delta_x * window_distance / touch_distance));
+    }
+  }
+  if (details.size_change_direction & kBoundsChangeDirection_Vertical) {
+    if (IsBottomEdge(details.window_component) && *delta_y > 0) {
+      int display_height = Shell::GetScreen()->GetDisplayNearestWindow(
+          details.window).bounds().height();
+      int bottom = details.initial_bounds_in_parent.bottom();
+      float window_distance = display_height - bottom;
+      float touch_distance = display_height -
+          details.initial_location_in_parent.y();
+      *delta_y = static_cast<int>(
+          ceil(*delta_y * window_distance / touch_distance));
+    } else if (!IsBottomEdge(details.window_component) && *delta_y < 0) {
+      float window_distance = details.initial_bounds_in_parent.y();
+      float touch_distance = details.initial_location_in_parent.y();
+      *delta_y = static_cast<int>(
+          floor(*delta_y * window_distance / touch_distance));
+    }
+  }
+}
+
+// static
 bool WindowResizer::IsBottomEdge(int window_component) {
   return window_component == HTBOTTOMLEFT ||
       window_component == HTBOTTOM ||