Fix drift while scrolling.

ui/base/gestures/gesture_sequence.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 "ui/base/gestures/gesture_sequence.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 20 matching lines @@
 };
 
 // ui::TouchStatus is mapped to TouchStatusInternal to simply indicate whether a
 // processed touch-event should affect gesture-recognition or not.
 enum TouchStatusInternal {
   TSI_NOT_PROCESSED,  // The touch-event should take-part into
                       // gesture-recognition only if the touch-event has not
                       // been processed.
 
   TSI_PROCESSED,      // The touch-event should affect gesture-recognition only
-                      // if the touch-event has been processed.
+                      // if the touch-event has been processed. In particular,
+                      // this means that a JavaScript touch handler called
+                      // |preventDefault| on the associated touch event.

[sadrul, 2012/09/21 23:09:40]

This is also for touch-events that were processed by an aura-window or
views-view. So mentioning the preventDefault() case as an example would be
better (we have some similar comment in
GestureRecognizerImpl::AdvanceTouchQueueByOne)

[rjkroege, 2012/09/24 13:53:16]

Done.

 
   TSI_ALWAYS          // The touch-event should always affect gesture
                       // recognition.
 };
 
 // Get equivalent TouchState from EventType |type|.
 TouchState TouchEventTypeToTouchState(ui::EventType type) {
   switch (type) {
     case ui::ET_TOUCH_RELEASED:
       return TS_RELEASED;
@@ skipping 30 matching lines @@
   GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_NOT_PROCESSED),
 
   GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_PROCESSED),
 
   // Ignore processed touch-move events until gesture-scroll starts.
   GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_MOVED, TSI_NOT_PROCESSED),
 
+  GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED =
+      G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_MOVED, TSI_PROCESSED),
+
   GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_STATIONARY, TSI_NOT_PROCESSED),
 
   GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED =
       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_CANCELLED, TSI_ALWAYS),
 
   GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED =
       G(GS_PENDING_SYNTHETIC_CLICK, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 
   GST_SCROLL_FIRST_RELEASED =
@@ skipping 105 matching lines @@
   CHECK((touch_id & 0xfff) == touch_id);
   TouchState touch_state = TouchEventTypeToTouchState(type);
   EdgeStateSignatureType signature = static_cast<EdgeStateSignatureType>
       (G(gesture_state, touch_id, touch_state, touch_status));
 
   switch (signature) {
     case GST_NO_GESTURE_FIRST_PRESSED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
+    case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
     case GST_SCROLL_FIRST_RELEASED:
     case GST_SCROLL_FIRST_MOVED:
     case GST_SCROLL_FIRST_CANCELLED:
     case GST_SCROLL_SECOND_PRESSED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
@@ skipping 40 matching lines @@
 unsigned int ComputeTouchBitmask(const GesturePoint* points) {
   unsigned int touch_bitmask = 0;
   for (int i = 0; i < GestureSequence::kMaxGesturePoints; ++i) {
     if (points[i].in_use())
       touch_bitmask |= 1 << points[i].touch_id();
   }
   return touch_bitmask;
 }
 
 float CalibrateFlingVelocity(float velocity) {
-  // TODO(sad|rjkroege): fling-curve is currently configured to work well with
-  // touchpad scroll-events. This curve needs to be adjusted to work correctly
-  // with both touchpad and touchscreen. Until then, scale quadratically.
-  // http://crbug.com/120154
   const float velocity_scaling  =
       GestureConfiguration::touchscreen_fling_acceleration_adjustment();
   return velocity_scaling * velocity;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // GestureSequence Public:
 
@@ skipping 83 matching lines @@
       break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_STATIONARY:
       if (ScrollStart(event, point, gestures.get())) {
         PrependTapCancelGestureEvent(point, gestures.get());
         set_state(GS_SCROLL);
         if (ScrollUpdate(event, point, gestures.get()))
           point.UpdateForScroll();
       }
       break;
+    case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
+      point.UpdateForScroll();
+      break;
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
       PrependTapCancelGestureEvent(point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
     case GST_SCROLL_FIRST_MOVED:
       if (scroll_type_ == ST_VERTICAL ||
           scroll_type_ == ST_HORIZONTAL)
         BreakRailScroll(event, point, gestures.get());
-      if (ScrollUpdate(event, point, gestures.get()))
-        point.UpdateForScroll();
+        if (ScrollUpdate(event, point, gestures.get()))

[rjkroege, 2012/09/21 22:50:38]

oops.

[rjkroege, 2012/09/24 13:53:16]

Done.

+          point.UpdateForScroll();
       break;
     case GST_SCROLL_FIRST_RELEASED:
     case GST_SCROLL_FIRST_CANCELLED:
       ScrollEnd(event, point, gestures.get());
       set_state(GS_NO_GESTURE);
       break;
     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
       PrependTapCancelGestureEvent(point, gestures.get());
       // fall through
     case GST_SCROLL_SECOND_PRESSED:
@@ skipping 291 matching lines @@
         location,
         flags_,
         base::Time::FromDoubleT(point.last_touch_time()),
         1 << point.touch_id()));
   }
 }
 
 void GestureSequence::AppendScrollGestureUpdate(GesturePoint& point,
                                                 const gfx::Point& location,
                                                 Gestures* gestures) {
-  gfx::Point current_center = bounding_box_.CenterPoint();
-  int dx = current_center.x() - bounding_box_last_center_.x();
-  int dy = current_center.y() - bounding_box_last_center_.y();
+  int dx, dy;
+  if (point_count_ == 1) {
+    dx = round(point.x_delta());
+    dy = round(point.y_delta());
+  } else {
+    gfx::Point current_center = bounding_box_.CenterPoint();
+    dx = current_center.x() - bounding_box_last_center_.x();
+    dy = current_center.y() - bounding_box_last_center_.y();
+  }
   if (scroll_type_ == ST_HORIZONTAL)
     dy = 0;
   else if (scroll_type_ == ST_VERTICAL)
     dx = 0;
   if (dx == 0 && dy == 0)
     return;
 
   GestureEventDetails details(ui::ET_GESTURE_SCROLL_UPDATE, dx, dy);
   details.SetScrollVelocity(
       scroll_type_ == ST_VERTICAL ? 0 : point.XVelocity(),
@@ skipping 350 matching lines @@
     return;
 
   // Since long press timer has been started, there should be a non-NULL point.
   const GesturePoint* point = GetPointByPointId(0);
   if (!ui::gestures::IsInsideManhattanSquare(point->first_touch_position(),
       event.location()))
     long_press_timer_->Stop();
 }
 
 }  // namespace ui