Generalize the main thread event queue into a common event queue.

content/renderer/input/main_thread_event_queue.h

 // 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.
 
 #ifndef CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
 #define CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
 
 #include <deque>
+#include "base/memory/ref_counted.h"

[tdresser, 2016/07/22 19:13:41]

Not used (yet).

[dtapuska, 2016/07/22 20:14:08]

Done.

 #include "content/common/content_export.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/common/input/input_event_dispatch_type.h"
 #include "content/common/input/web_input_event_queue.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 
 namespace content {
 
-template <typename BaseClass, typename BaseType>
-class EventWithDispatchType : public BaseClass {
+class EventWithDispatchType : public ScopedWebInputEventWithLatencyInfo {
  public:
-  EventWithDispatchType(const BaseType& e,
-                        const ui::LatencyInfo& l,
-                        InputEventDispatchType t)
-      : BaseClass(e, l), type(t) {}
+  EventWithDispatchType(const blink::WebInputEvent& event,
+                        const ui::LatencyInfo& latency,
+                        InputEventDispatchType dispatch_type);
+  ~EventWithDispatchType();
+  bool CanCoalesceWith(const EventWithDispatchType& other) const
+      WARN_UNUSED_RESULT;
+  void CoalesceWith(const EventWithDispatchType& other);
 
-  InputEventDispatchType type;
-  std::deque<uint32_t> eventsToAck;
+  const std::deque<uint32_t>& eventsToAck() const { return eventsToAck_; }
+  InputEventDispatchType dispatchType() const { return dispatch_type_; }
 
-  bool CanCoalesceWith(const EventWithDispatchType& other) const
-      WARN_UNUSED_RESULT {
-    return other.type == type && BaseClass::CanCoalesceWith(other);
-  }
-
-  void CoalesceWith(const EventWithDispatchType& other) {
-    // If we are blocking and are coalescing touch, make sure to keep
-    // the touch ids that need to be acked.
-    if (type == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN) {
-      // We should only have blocking touch events that need coalescing.
-      DCHECK(blink::WebInputEvent::isTouchEventType(other.event.type));
-      eventsToAck.push_back(
-          WebInputEventTraits::GetUniqueTouchEventId(other.event));
-    }
-    BaseClass::CoalesceWith(other);
-  }
+ private:
+  InputEventDispatchType dispatch_type_;
+  std::deque<uint32_t> eventsToAck_;

[tdresser, 2016/07/22 19:13:41]

Indicate that this is touch specific.

[dtapuska, 2016/07/22 20:14:08]

I think that is a specialization just in the instance of this right now (and is
really hidden because it only works on touch and mouse wheel) and won't
necessarily be true for mouse moves that get coalesced.
I'd expect eventsToAck_ to have a list of a series of 0's for a bunch of mouse
moves. Ideally we could just adjust the IPC and really return a list here.

But I think we could change all of this around with historical points and pass
the list of coalesced events at the event time.

[tdresser, 2016/07/25 14:01:40]

I guess that's reasonable. Maybe add a comment indicating how this is populated
for different input modalities?

 };
 
-using PendingMouseWheelEvent =
-    EventWithDispatchType<MouseWheelEventWithLatencyInfo,
-                          blink::WebMouseWheelEvent>;
-
-using PendingTouchEvent =
-    EventWithDispatchType<TouchEventWithLatencyInfo, blink::WebTouchEvent>;
-
 class CONTENT_EXPORT MainThreadEventQueueClient {
  public:
   // Send an |event| that was previously queued (possibly
   // coalesced with another event) to the |routing_id|'s
   // channel. Implementors must implement this callback.
   virtual void SendEventToMainThread(int routing_id,
                                      const blink::WebInputEvent* event,
                                      const ui::LatencyInfo& latency,
                                      InputEventDispatchType dispatch_type) = 0;
 
@@ skipping 55 matching lines @@
   // in flight.
   void EventHandled(blink::WebInputEvent::Type type,
                     InputEventAckState ack_result);
 
   void set_is_flinging(bool is_flinging) { is_flinging_ = is_flinging; }
 
  private:
   friend class MainThreadEventQueueTest;
   int routing_id_;
   MainThreadEventQueueClient* client_;
-  WebInputEventQueue<PendingMouseWheelEvent> wheel_events_;
-  WebInputEventQueue<PendingTouchEvent> touch_events_;
+  WebInputEventQueue<EventWithDispatchType> events_;
+  std::unique_ptr<EventWithDispatchType> in_flight_event_;
   bool is_flinging_;
-
-  // TODO(dtapuska): These can be removed when the queues are dequeued
-  // on the main thread. See crbug.com/624021
-  std::unique_ptr<PendingMouseWheelEvent> in_flight_wheel_event_;
-  std::unique_ptr<PendingTouchEvent> in_flight_touch_event_;
+  bool sent_notification_to_main_;
 
   DISALLOW_COPY_AND_ASSIGN(MainThreadEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_