WIP Add getCoalescedEvents API using vector of WebInputEvents

content/renderer/input/main_thread_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/renderer/input/main_thread_event_queue.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 bool IsContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
-  switch (event->event().type) {
+  switch (event->coalescedEvent().event().type) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return true;
     case blink::WebInputEvent::TouchMove:
       // TouchMoves that are blocking end up blocking scroll. Do not treat
       // them as continuous events otherwise we will end up waiting up to an
       // additional frame.
-      return static_cast<const blink::WebTouchEvent&>(event->event())
+      return static_cast<const blink::WebTouchEvent&>(
+                 event->coalescedEvent().event())
                  .dispatchType != blink::WebInputEvent::Blocking;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 EventWithDispatchType::EventWithDispatchType(
-    ui::ScopedWebInputEvent event,
+    blink::CoalescedWebInputEvent::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType dispatch_type)
     : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
       dispatch_type_(dispatch_type),
       creation_timestamp_(base::TimeTicks::Now()),
       last_coalesced_timestamp_(creation_timestamp_) {}
 
 EventWithDispatchType::~EventWithDispatchType() {}
 
 bool EventWithDispatchType::CanCoalesceWith(
     const EventWithDispatchType& other) const {
   return other.dispatch_type_ == dispatch_type_ &&
          ScopedWebInputEventWithLatencyInfo::CanCoalesceWith(other);
 }
 
 void EventWithDispatchType::CoalesceWith(const EventWithDispatchType& other) {
-  coalesced_event_ids_.push_back(
-      ui::WebInputEventTraits::GetUniqueTouchEventId(other.event()));
+  coalesced_event_ids_.push_back(ui::WebInputEventTraits::GetUniqueTouchEventId(
+      other.coalescedEvent().event()));
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
   last_coalesced_timestamp_ = base::TimeTicks::Now();
 }
 
 MainThreadEventQueue::SharedState::SharedState()
     : sent_main_frame_request_(false) {}
 
 MainThreadEventQueue::SharedState::~SharedState() {}
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     blink::scheduler::RendererScheduler* renderer_scheduler)
     : routing_id_(routing_id),
       client_(client),
       last_touch_start_forced_nonblocking_due_to_fling_(false),
       enable_fling_passive_listener_flag_(base::FeatureList::IsEnabled(
           features::kPassiveEventListenersDueToFling)),
       handle_raf_aligned_touch_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)),
       handle_raf_aligned_mouse_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedMouseInputEvents)),
       main_task_runner_(main_task_runner),
       renderer_scheduler_(renderer_scheduler) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
-    ui::ScopedWebInputEvent event,
+    blink::CoalescedWebInputEvent::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
   DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
          ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING ||
          ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
@@ skipping 70 matching lines @@
           (now - in_flight_event_->creationTimestamp()).InMicroseconds(), 1,
           kTenSeconds, 50);
     }
 
     InputEventDispatchType dispatch_type = in_flight_event_->dispatchType();
     if (!in_flight_event_->coalescedEventIds().empty() &&
         dispatch_type == DISPATCH_TYPE_BLOCKING) {
       dispatch_type = DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN;
     }
 
-    client_->HandleEventOnMainThread(routing_id_, &in_flight_event_->event(),
-                                     in_flight_event_->latencyInfo(),
-                                     dispatch_type);
+    client_->HandleEventOnMainThread(
+        routing_id_, &in_flight_event_->coalescedEvent(),
+        in_flight_event_->latencyInfo(), dispatch_type);
   }
 
   in_flight_event_.reset();
 }
 
 void MainThreadEventQueue::PossiblyScheduleMainFrame() {
   if (IsRafAlignedInputDisabled())
     return;
   bool needs_main_frame = false;
   {
@@ skipping 22 matching lines @@
 }
 
 void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
                                         InputEventAckState ack_result) {
   if (in_flight_event_ &&
       in_flight_event_->dispatchType() == DISPATCH_TYPE_BLOCKING) {
     for (const auto id : in_flight_event_->coalescedEventIds()) {
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
       if (renderer_scheduler_) {
         renderer_scheduler_->DidHandleInputEventOnMainThread(
-            in_flight_event_->event());
+            in_flight_event_->coalescedEvent().event());
       }
     }
   }
 }
 
 void MainThreadEventQueue::DispatchRafAlignedInput() {
   if (IsRafAlignedInputDisabled())
     return;
 
   std::deque<std::unique_ptr<EventWithDispatchType>> events_to_process;
@@ skipping 56 matching lines @@
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
 bool MainThreadEventQueue::IsRafAlignedInputDisabled() {
   return !handle_raf_aligned_mouse_input_ && !handle_raf_aligned_touch_input_;
 }
 
 bool MainThreadEventQueue::IsRafAlignedEvent(
     const std::unique_ptr<EventWithDispatchType>& event) {
-  switch (event->event().type) {
+  switch (event->coalescedEvent().event().type) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
       // TouchMoves that are blocking end up blocking scroll. Do not treat
       // them as continuous events otherwise we will end up waiting up to an
       // additional frame.
-      return static_cast<const blink::WebTouchEvent&>(event->event())
+      return static_cast<const blink::WebTouchEvent&>(
+                 event->coalescedEvent().event())
                      .dispatchType != blink::WebInputEvent::Blocking &&
              handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content