GSB uses delta_hints to calculate scrolling chain.

content/browser/renderer_host/input/synthetic_smooth_move_gesture.cc

 // Copyright 2013 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 "content/browser/renderer_host/input/synthetic_smooth_move_gesture.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/point_f.h"
@@ skipping 131 matching lines @@
           << "State SETUP invalid for synthetic scroll using touch input.";
     case DONE:
       NOTREACHED()
           << "State DONE invalid for synthetic scroll using touch input.";
   }
 }
 
 void SyntheticSmoothMoveGesture::ForwardMouseWheelInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
+  blink::WebMouseWheelEvent::Phase phase =
+      blink::WebMouseWheelEvent::kPhaseChanged;
   switch (state_) {
     case STARTED:
       if (MoveIsNoOp()) {
         state_ = DONE;
         break;
       }
       ComputeNextMoveSegment();
       state_ = MOVING;
+      phase = blink::WebMouseWheelEvent::kPhaseBegan;
       // Fall through to forward the first event.
     case MOVING: {
       // Even though WebMouseWheelEvents take floating point deltas,
       // internally the scroll position is stored as an integer. We therefore
       // keep track of the discrete delta which is consistent with the
       // internal scrolling state. This ensures that when the gesture has
       // finished we've scrolled exactly the specified distance.
       base::TimeTicks event_timestamp = ClampTimestamp(timestamp);
       gfx::Vector2dF current_move_segment_total_delta =
           GetPositionDeltaAtTime(event_timestamp);
       gfx::Vector2d delta_discrete =
           FloorTowardZero(current_move_segment_total_delta -
                           current_move_segment_total_delta_discrete_);
-      ForwardMouseWheelEvent(target, delta_discrete, event_timestamp);
+      ForwardMouseWheelEvent(target, delta_discrete, phase, event_timestamp);
       current_move_segment_total_delta_discrete_ += delta_discrete;
 
       if (FinishedCurrentMoveSegment(event_timestamp)) {
         if (!IsLastMoveSegment()) {
           current_move_segment_total_delta_discrete_ = gfx::Vector2d();
           ComputeNextMoveSegment();
           ForwardMouseWheelInputEvents(timestamp, target);
         } else {
           state_ = DONE;
+          ForwardMouseWheelEvent(target, gfx::Vector2d(),
+                                 blink::WebMouseWheelEvent::kPhaseEnded,
+                                 event_timestamp);
         }
       }
     } break;
     case SETUP:
       NOTREACHED() << "State SETUP invalid for synthetic scroll using mouse "
                       "wheel input.";
     case STOPPING:
       NOTREACHED() << "State STOPPING invalid for synthetic scroll using mouse "
                       "wheel input.";
     case DONE:
@@ skipping 40 matching lines @@
           << "State SETUP invalid for synthetic drag using mouse input.";
     case DONE:
       NOTREACHED()
           << "State DONE invalid for synthetic drag using mouse input.";
   }
 }
 
 void SyntheticSmoothMoveGesture::ForwardMouseWheelEvent(
     SyntheticGestureTarget* target,
     const gfx::Vector2dF& delta,
+    const blink::WebMouseWheelEvent::Phase phase,
     const base::TimeTicks& timestamp) const {
   blink::WebMouseWheelEvent mouse_wheel_event =
       SyntheticWebMouseWheelEventBuilder::Build(0, 0, delta.x(), delta.y(), 0,
                                                 false);
 
   mouse_wheel_event.SetPositionInWidget(
       current_move_segment_start_position_.x(),
       current_move_segment_start_position_.y());
+  mouse_wheel_event.phase = phase;
 
   mouse_wheel_event.SetTimeStampSeconds(ConvertTimestampToSeconds(timestamp));
 
   target->DispatchInputEventToPlatform(mouse_wheel_event);
 }
 
 void SyntheticSmoothMoveGesture::PressPoint(SyntheticGestureTarget* target,
                                             const base::TimeTicks& timestamp) {
   DCHECK_EQ(current_move_segment_, 0);
   synthetic_pointer_driver_->Press(current_move_segment_start_position_.x(),
@@ skipping 76 matching lines @@
   DCHECK_LT(current_move_segment_, static_cast<int>(params_.distances.size()));
   return current_move_segment_ ==
          static_cast<int>(params_.distances.size()) - 1;
 }
 
 bool SyntheticSmoothMoveGesture::MoveIsNoOp() const {
   return params_.distances.size() == 0 || params_.distances[0].IsZero();
 }
 
 }  // namespace content