Adjusts dragging logic to be less likely to trigger false positive switch from snapping to docking

ash/wm/workspace/two_step_edge_cycler.cc

 // Copyright 2014 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/two_step_edge_cycler.h"
 
 #include <cstdlib>
 
 namespace ash {
 namespace {
 
 // We cycle to the second mode if any of the following happens while the mouse
 // is on the edge of the workspace:
 // . The user stops moving the mouse for |kMaxDelay| and then moves the mouse
-//   again.
+//   again in the preferred direction from the last paused location for at least
+//   |kMaxPixelsAfterPause| (horizontal distance).

[pkotwicz, 2015/05/11 17:32:41]

Nit: "(horizontal distance)" -> "horizontal pixels"

[varkha, 2015/05/11 20:19:38]

Done.

 // . The mouse moves |kMaxPixels| horizontal pixels.
-// . The mouse is moved |kMaxMoves| times.
-const int kMaxDelay = 500;
+// . The mouse is moved |kMaxMoves| times since the last pause. If mouse was
+//   paused at least once then this movement needs to be in the preferred
+//   direction.
+const int kMaxDelay = 400;
 const int kMaxPixels = 100;
+const int kMaxPixelsAfterPause = 10;
 const int kMaxMoves = 25;
 
 }  // namespace
 
-TwoStepEdgeCycler::TwoStepEdgeCycler(const gfx::Point& start)
+TwoStepEdgeCycler::TwoStepEdgeCycler(const gfx::Point& start,
+                                     TwoStepEdgeCycler::Direction direction)
     : second_mode_(false),
       time_last_move_(base::TimeTicks::Now()),
       num_moves_(0),
-      start_x_(start.x()) {
+      start_x_(start.x()),
+      paused_x_(start.x()),
+      paused_(false),
+      direction_(direction) {
 }
 
 TwoStepEdgeCycler::~TwoStepEdgeCycler() {
 }
 
 void TwoStepEdgeCycler::OnMove(const gfx::Point& location) {
   if (second_mode_)
     return;
 

[pkotwicz, 2015/05/11 17:32:41]

I would be tempted to do something like this:

if ((base::TimeTicks::Now() - time_last_move_).InMilliseconds() > kMaxDelay) {
  ...
}

time_last_move_ = base::TimeTicks::Now();

int compare_x = paused_ ? paused_x_ : start_x_;
if (location.x() != compare_x &&
    (location.x() < compare_x) != (direction == DIRECTION_LEFT) {
  return;
}

if (location.x() != compare_x)
  ++num_moves_;

bool moved_in_the_same_direction_after_pause =...

[pkotwicz, 2015/05/11 17:35:06]

Correction:

I would be tempted to do something like this:

if ((base::TimeTicks::Now() - time_last_move_).InMilliseconds() > kMaxDelay) {
  ...
}

time_last_move_ = base::TimeTicks::Now();

int compare_x = paused_ ? paused_x_ : start_x_;
if (location.x() != compare_x &&
    (location.x() < compare_x) != (direction == DIRECTION_LEFT) {
  return;
}

++num_moves_;

bool moved_in_the_same_direction_after_pause =...

[varkha, 2015/05/11 20:19:38]

Done.

-  ++num_moves_;
-  second_mode_ =
-      (base::TimeTicks::Now() - time_last_move_).InMilliseconds() >
-          kMaxDelay ||
-      std::abs(location.x() - start_x_) >= kMaxPixels ||
-      num_moves_ >= kMaxMoves;
+  if (!paused_ ||
+      (direction_ == DIRECTION_RIGHT && location.x() >= paused_x_) ||
+      (direction_ == DIRECTION_LEFT && location.x() <= paused_x_)) {
+    ++num_moves_;
+  }
+  if ((base::TimeTicks::Now() - time_last_move_).InMilliseconds() > kMaxDelay) {
+    paused_ = true;
+    paused_x_ = location.x();
+    num_moves_ = 0;
+  }
+  bool moved_in_the_same_direction_after_pause =
+      paused_ && ((direction_ == DIRECTION_RIGHT &&
+                   (location.x() - paused_x_) >= kMaxPixelsAfterPause) ||
+                  (direction_ == DIRECTION_LEFT &&
+                   (paused_x_ - location.x()) >= kMaxPixelsAfterPause));
+  second_mode_ = moved_in_the_same_direction_after_pause ||
+                 std::abs(location.x() - start_x_) >= kMaxPixels ||
+                 num_moves_ >= kMaxMoves;
   time_last_move_ = base::TimeTicks::Now();
 }
 
 }  // namespace ash