Touchpad scroll latching enabled for Mac behind flag.

content/browser/renderer_host/input/mouse_wheel_event_queue.cc

 // Copyright 2016 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/mouse_wheel_event_queue.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/blink/web_input_event_traits.h"
@@ skipping 131 matching lines @@
 
       if (event_sent_for_gesture_ack_->event.railsMode ==
           WebInputEvent::RailsModeVertical)
         scroll_update.data.scrollUpdate.deltaX = 0;
       if (event_sent_for_gesture_ack_->event.railsMode ==
           WebInputEvent::RailsModeHorizontal)
         scroll_update.data.scrollUpdate.deltaY = 0;
     }
 
     bool current_phase_ended = false;
+    bool scroll_phase_ended = false;
+    bool momentum_phase_ended = false;
     bool has_phase_info = false;
 
     if (event_sent_for_gesture_ack_->event.phase !=
             blink::WebMouseWheelEvent::PhaseNone ||
         event_sent_for_gesture_ack_->event.momentumPhase !=
             blink::WebMouseWheelEvent::PhaseNone) {
       has_phase_info = true;
-      current_phase_ended = event_sent_for_gesture_ack_->event.phase ==
-                                blink::WebMouseWheelEvent::PhaseEnded ||
-                            event_sent_for_gesture_ack_->event.phase ==
-                                blink::WebMouseWheelEvent::PhaseCancelled ||
-                            event_sent_for_gesture_ack_->event.momentumPhase ==
-                                blink::WebMouseWheelEvent::PhaseEnded ||
-                            event_sent_for_gesture_ack_->event.momentumPhase ==
-                                blink::WebMouseWheelEvent::PhaseCancelled;
+      scroll_phase_ended = event_sent_for_gesture_ack_->event.phase ==
+                               blink::WebMouseWheelEvent::PhaseEnded ||
+                           event_sent_for_gesture_ack_->event.phase ==
+                               blink::WebMouseWheelEvent::PhaseCancelled;
+      momentum_phase_ended = event_sent_for_gesture_ack_->event.momentumPhase ==
+                                 blink::WebMouseWheelEvent::PhaseEnded ||
+                             event_sent_for_gesture_ack_->event.momentumPhase ==
+                                 blink::WebMouseWheelEvent::PhaseCancelled;
+      current_phase_ended = scroll_phase_ended || momentum_phase_ended;
     }
 
     bool needs_update = scroll_update.data.scrollUpdate.deltaX != 0 ||
                         scroll_update.data.scrollUpdate.deltaY != 0;
 
     // If there is no update to send and the current phase is ended yet a GSB
     // needs to be sent, this event sequence doesn't need to be generated
     // because the events generated will be a GSB (non-synthetic) and GSE
     // (non-synthetic). This situation arises when OSX generates double
     // phase end information.
     bool empty_sequence =
         !needs_update && needs_scroll_begin_ && current_phase_ended;
 
+    if (has_phase_info && enable_scroll_latching_) {
+      if (event_sent_for_gesture_ack_->event.momentumPhase ==
+          blink::WebMouseWheelEvent::PhaseBegan) {

[tdresser, 2016/11/22 21:44:40]

Should we combine the two nested if's into a single if?

[sahel, 2016/11/24 15:28:55]

Done.

+        // Send the pending GSE with |mayPrecedeFling = true|.
+        if (scroll_end_timer_.IsRunning()) {
+          scroll_end_timer_.Stop();
+          SendScrollEnd(last_scroll_update_, false, true);
+        } else {
+          // GSE is already sent.
+          DCHECK(needs_scroll_begin_ && current_phase_ended);
+        }
+      }
+    }
+
     if (needs_update || !empty_sequence) {
       if (needs_scroll_begin_) {
         // If no GSB has been sent, it will be a non-synthetic GSB.
         SendScrollBegin(scroll_update, false);
-      } else if (has_phase_info) {
+      } else if (has_phase_info && !enable_scroll_latching_) {
         // If a GSB has been sent, generate a synthetic GSB if we have phase
         // information. This should be removed once crbug.com/526463 is fully
         // implemented.
         SendScrollBegin(scroll_update, true);
       }
 
       if (needs_update) {
         ui::LatencyInfo latency = ui::LatencyInfo(ui::SourceEventType::WHEEL);
         latency.AddLatencyNumber(
             ui::INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL, 0,
             0);
         client_->ForwardGestureEventWithLatencyInfo(scroll_update, latency);
       }
 
       if (current_phase_ended) {

[dtapuska, 2016/11/22 22:10:34]

Can these blocks of code be reduced a bit to be:

if ((enable_scroll_latching && momentum_phase_ended) ||
(!enabled_scroll_latching && current_phase_ended)) {
  SendScrollEnd(...);
} else if (has_phase_info && !enable_scroll_latching!) {
  SendScrolLEnd(...);
} else {
  Schedule...
}

[sahel, 2016/11/24 15:28:55]

Done.

         // Non-synthetic GSEs are sent when the current phase is canceled or
         // ended.
-        SendScrollEnd(scroll_update, false);
+        if (enable_scroll_latching_) {
+          if (momentum_phase_ended) {
+            SendScrollEnd(scroll_update, false, false);
+          } else {
+            // Don't send the ScrollEnd right away, instead set a timer
+            // and wait to see if a MouseWheelEvent with momentum phase (fling)
+            // arrives or not.
+            DCHECK(scroll_phase_ended);
+            scroll_end_timer_.Start(
+                FROM_HERE,
+                base::TimeDelta::FromMilliseconds(scroll_transaction_ms_),
+                base::Bind(&MouseWheelEventQueue::SendScrollEnd,
+                           base::Unretained(this), scroll_update, false,
+                           false));
+          }
+
+        } else {
+          SendScrollEnd(scroll_update, false, false);
+        }
       } else if (has_phase_info) {
         // Generate a synthetic GSE for every update to force hit testing so
         // that the non-latching behavior is preserved. Remove once
         // crbug.com/526463 is fully implemented.
-        SendScrollEnd(scroll_update, true);
+        if (!enable_scroll_latching_)
+          SendScrollEnd(scroll_update, true, false);
       } else {
         scroll_end_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(scroll_transaction_ms_),
             base::Bind(&MouseWheelEventQueue::SendScrollEnd,
-                       base::Unretained(this), scroll_update, false));
+                       base::Unretained(this), scroll_update, false, false));
       }
     }
+    last_scroll_update_ = scroll_update;
   }
 
   event_sent_for_gesture_ack_.reset();
   TryForwardNextEventToRenderer();
 }
 
 void MouseWheelEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
     // If there is a current scroll going on and a new scroll that isn't
@@ skipping 22 matching lines @@
   if (wheel_queue_.empty() || event_sent_for_gesture_ack_)
     return;
 
   event_sent_for_gesture_ack_ = std::move(wheel_queue_.front());
   wheel_queue_.pop_front();
 
   client_->SendMouseWheelEventImmediately(*event_sent_for_gesture_ack_);
 }
 
 void MouseWheelEventQueue::SendScrollEnd(WebGestureEvent update_event,
-                                         bool synthetic) {
+                                         bool synthetic,
+                                         bool may_precede_fling) {
   DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_);
 
   WebGestureEvent scroll_end(update_event);
   scroll_end.timeStampSeconds =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   scroll_end.type = WebInputEvent::GestureScrollEnd;
   scroll_end.resendingPluginId = -1;
   scroll_end.data.scrollEnd.synthetic = synthetic;
+  scroll_end.data.scrollEnd.mayPrecedeFling = may_precede_fling;
   scroll_end.data.scrollEnd.inertialPhase =
       update_event.data.scrollUpdate.inertialPhase;
   scroll_end.data.scrollEnd.deltaUnits =
       update_event.data.scrollUpdate.deltaUnits;
 
   if (!synthetic) {
     needs_scroll_begin_ = true;
     needs_scroll_end_ = false;
 
     if (scroll_end_timer_.IsRunning())
@@ skipping 21 matching lines @@
   scroll_begin.data.scrollBegin.deltaHintUnits =
       gesture_update.data.scrollUpdate.deltaUnits;
 
   needs_scroll_begin_ = false;
   needs_scroll_end_ = true;
   client_->ForwardGestureEventWithLatencyInfo(
       scroll_begin, ui::LatencyInfo(ui::SourceEventType::WHEEL));
 }
 
 }  // namespace content