MouseWheelEventQueue should respect ScrollBegin/End state from RenderWidgetHost.

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/base_event_utils.h"
@@ skipping 19 matching lines @@
     TRACE_EVENT_ASYNC_END0("input", "MouseWheelEventQueue::QueueEvent", this);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QueuedWebMouseWheelEvent);
 };
 
 MouseWheelEventQueue::MouseWheelEventQueue(MouseWheelEventQueueClient* client,
                                            bool enable_scroll_latching)
     : client_(client),
-      needs_scroll_begin_(true),
-      needs_scroll_end_(false),
       enable_scroll_latching_(enable_scroll_latching),
       scrolling_device_(blink::kWebGestureDeviceUninitialized) {
   DCHECK(client);
   scroll_transaction_ms_ =
       enable_scroll_latching_ ? kDefaultWheelScrollLatchingTransactionMs : 0;
 }
 
 MouseWheelEventQueue::~MouseWheelEventQueue() {
 }
 
@@ skipping 121 matching lines @@
     }
 
     bool needs_update = scroll_update.data.scroll_update.delta_x != 0 ||
                         scroll_update.data.scroll_update.delta_y != 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;
+    bool empty_sequence = !needs_update && !client_->is_in_gesture_scroll() &&
+                          current_phase_ended;
 
     if (enable_scroll_latching_) {
       if (event_sent_for_gesture_ack_->event.momentum_phase ==
           blink::WebMouseWheelEvent::kPhaseBegan) {
         // Don't send the pending scrollEnd if a fling starts.
         if (scroll_end_timer_.IsRunning())
           scroll_end_timer_.Stop();
       }
 
       if (needs_update || !empty_sequence) {
-        if (needs_scroll_begin_) {
+        if (!client_->is_in_gesture_scroll()) {
           SendScrollBegin(scroll_update, false);
         }
 
         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 (momentum_phase_ended) {
           // Send GSE with if scroll latching is enabled and no fling is going
           // to happen next.
           SendScrollEnd(scroll_update, false);
         } else if (scroll_phase_ended || !has_phase_info) {
           // If scroll latching is enabled and a fling might happen next, or
           // no phase info exists, start the scroll_end_timer_.
           scroll_end_timer_.Start(
               FROM_HERE,
               base::TimeDelta::FromMilliseconds(scroll_transaction_ms_),
               base::Bind(&MouseWheelEventQueue::SendScrollEnd,
                          base::Unretained(this), scroll_update, false));
         }
       }
 
     } else {  // !enable_scroll_latching_
       if (needs_update || !empty_sequence) {
-        if (needs_scroll_begin_) {
+        if (!client_->is_in_gesture_scroll()) {
           // If no GSB has been sent, it will be a non-synthetic GSB.
           SendScrollBegin(scroll_update, false);

[dtapuska, 2017/04/12 19:24:46]

It there any potential dangerous scenarios here? We generally assume that the
gesture scroll begin has the delta hints and such from the first gesture scroll
update. (and phase information). If it doesn't then could it be subtly broken
somewhere?

[wjmaclean, 2017/04/12 19:47:35]

I suppose, but (1) it passes the tests, and (2) appears to work fine in manual
testing. If something else does break, then we can fix it when we discover it.

[wjmaclean, 2017/04/12 19:48:42]

Also, it does fix something we know is already broken.

         } else if (has_phase_info) {
           // 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(
@@ skipping 40 matching lines @@
              (gesture_event.event.GetType() ==
                   blink::WebInputEvent::kGestureScrollEnd ||
               gesture_event.event.GetType() ==
                   blink::WebInputEvent::kGestureFlingStart)) {
     scrolling_device_ = blink::kWebGestureDeviceUninitialized;
     if (scroll_end_timer_.IsRunning()) {
       if (enable_scroll_latching_) {
         // Don't send the pending ScrollEnd if a fling is happening.
         // The next wheel event will still need a ScrollBegin.
         scroll_end_timer_.Stop();
-        needs_scroll_begin_ = true;
-        needs_scroll_end_ = false;
       } else {
         scroll_end_timer_.Reset();
       }
     }
   }
 }
 
 void MouseWheelEventQueue::TryForwardNextEventToRenderer() {
   TRACE_EVENT0("input", "MouseWheelEventQueue::TryForwardNextEventToRenderer");
 
   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) {
-  DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_);
+  DCHECK((synthetic && !client_->is_in_gesture_scroll()) ||
+         client_->is_in_gesture_scroll());
 
   WebGestureEvent scroll_end(update_event);
   scroll_end.SetTimeStampSeconds(
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_end.SetType(WebInputEvent::kGestureScrollEnd);
   scroll_end.resending_plugin_id = -1;
   scroll_end.data.scroll_end.synthetic = synthetic;
   scroll_end.data.scroll_end.inertial_phase =
       update_event.data.scroll_update.inertial_phase;
   scroll_end.data.scroll_end.delta_units =
       update_event.data.scroll_update.delta_units;
 
-  if (!synthetic) {
-    needs_scroll_begin_ = true;
-    needs_scroll_end_ = false;
+  if (!synthetic && scroll_end_timer_.IsRunning())
+    scroll_end_timer_.Reset();
 
-    if (scroll_end_timer_.IsRunning())
-      scroll_end_timer_.Reset();
-  }
   client_->ForwardGestureEventWithLatencyInfo(
       scroll_end, ui::LatencyInfo(ui::SourceEventType::WHEEL));
 }
 
 void MouseWheelEventQueue::SendScrollBegin(
     const WebGestureEvent& gesture_update,
     bool synthetic) {
-  DCHECK((synthetic && !needs_scroll_begin_) || needs_scroll_begin_);
+  DCHECK((synthetic && client_->is_in_gesture_scroll()) ||
+         !client_->is_in_gesture_scroll());
 
   WebGestureEvent scroll_begin(gesture_update);
   scroll_begin.SetType(WebInputEvent::kGestureScrollBegin);
   scroll_begin.data.scroll_begin.synthetic = synthetic;
   scroll_begin.data.scroll_begin.inertial_phase =
       gesture_update.data.scroll_update.inertial_phase;
   scroll_begin.data.scroll_begin.delta_x_hint =
       gesture_update.data.scroll_update.delta_x;
   scroll_begin.data.scroll_begin.delta_y_hint =
       gesture_update.data.scroll_update.delta_y;
   scroll_begin.data.scroll_begin.target_viewport = false;
   scroll_begin.data.scroll_begin.delta_hint_units =
       gesture_update.data.scroll_update.delta_units;
 
-  needs_scroll_begin_ = false;
-  needs_scroll_end_ = true;
   client_->ForwardGestureEventWithLatencyInfo(
       scroll_begin, ui::LatencyInfo(ui::SourceEventType::WHEEL));
 }
 
 }  // namespace content