Async Wheel Event with only the first one cancellable behind a 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 "content/common/input/input_event_dispatch_type.h"
+#include "content/public/common/content_features.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/blink/web_input_event_traits.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseWheelEvent;
 using ui::LatencyInfo;
 
 namespace content {
 
@@ skipping 13 matching lines @@
  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),
+      enable_async_wheel_events_(
+          base::FeatureList::IsEnabled(features::kAsyncWheelEvents)),
+      send_wheel_events_async_(false),
       scrolling_device_(blink::kWebGestureDeviceUninitialized) {
   DCHECK(client);
 }
 
 MouseWheelEventQueue::~MouseWheelEventQueue() {
 }
 
 void MouseWheelEventQueue::QueueEvent(
     const MouseWheelEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "MouseWheelEventQueue::QueueEvent");
@@ skipping 116 matching lines @@
               blink::WebMouseWheelEvent::kPhaseCancelled;
       current_phase_ended = scroll_phase_ended || momentum_phase_ended;
     }
 
     bool needs_update = scroll_update.data.scroll_update.delta_x != 0 ||
                         scroll_update.data.scroll_update.delta_y != 0;
 
     if (enable_scroll_latching_) {
       if (event_sent_for_gesture_ack_->event.phase ==
           blink::WebMouseWheelEvent::kPhaseBegan) {
+        send_wheel_events_async_ = true;
         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);
       }
@@ skipping 71 matching lines @@
 
 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();
 
+  if (enable_async_wheel_events_) {
+    DCHECK(event_sent_for_gesture_ack_->event.phase !=
+               blink::WebMouseWheelEvent::kPhaseNone ||
+           event_sent_for_gesture_ack_->event.momentum_phase !=
+               blink::WebMouseWheelEvent::kPhaseNone);
+    if (event_sent_for_gesture_ack_->event.phase ==
+        blink::WebMouseWheelEvent::kPhaseBegan) {
+      send_wheel_events_async_ = false;
+    } else if (send_wheel_events_async_) {
+      event_sent_for_gesture_ack_->event.dispatch_type =
+          WebInputEvent::kEventNonBlocking;
+    }
+  }
+
   client_->SendMouseWheelEventImmediately(*event_sent_for_gesture_ack_);
 }
 
 void MouseWheelEventQueue::SendScrollEnd(WebGestureEvent update_event,
                                          bool synthetic) {
   DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_);
 
   WebGestureEvent scroll_end(update_event);
   scroll_end.SetTimeStampSeconds(
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
@@ skipping 31 matching lines @@
   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