Animated scroll shouldn't consume unhandled scrolls for OOPIFs.

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);
         } 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) {
@@ skipping 42 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