Don't use PostTask queueing between compositor and main thread.

content/common/input/web_input_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_COMMON_INPUT_WEB_INPUT_EVENT_QUEUE_H_
 #define CONTENT_COMMON_INPUT_WEB_INPUT_EVENT_QUEUE_H_
 
 #include <deque>
 #include <memory>
 
 namespace content {
 
-enum class WebInputEventQueueState { ITEM_PENDING, ITEM_NOT_PENDING };
-
-// WebInputEventQueue is a coalescing queue with the addition of a state
-// variable that represents whether an item is pending to be processed.
+// WebInputEventQueue is a coalescing queue.

[tdresser, 2016/07/20 20:52:27]

Could the changes in this file be made separately from the other changes?

[dtapuska, 2016/07/27 05:29:00]

Done.

 // The desired usage sending with this queue is:
-//   if (queue.state() == WebInputEventQueueState::ITEM_PENDING) {
-//     queue.Queue(T);
-//   } else {
-//     send T
-//     queue.set_state(WebInputEventQueueState::ITEM_PENDING);
-//   }
+//   bool send_notification = queue.empty();
+//   queue.Queue(T);
+//   send notification

[tdresser, 2016/07/20 20:52:27]

This is a somewhat odd pseudo-pseudo-code.

I'd prefer it be either more or less pseudo-code.

In particular, ending some lines with ; and others without is kinda weird.

Maybe the last line should be

if (send_notification) {
   send T;
}

[dtapuska, 2016/07/27 05:29:00]

Done.

 //
 // Processing the event response:
 //  if (!queue.empty()) {
 //    T = queue.Pop();
 //    send T now
 //  } else {
 //    queue.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);

[tdresser, 2016/07/20 20:52:27]

Update comment.

 //  }
 //
 template <typename T>
 class WebInputEventQueue {
  public:
-  WebInputEventQueue() : state_(WebInputEventQueueState::ITEM_NOT_PENDING) {}
+  WebInputEventQueue() {}
 
   // Adds an event to the queue. The event may be coalesced with previously
   // queued events.
-  void Queue(const T& event) {
-    if (!queue_.empty()) {
-      std::unique_ptr<T>& last_event = queue_.back();
-      if (last_event->CanCoalesceWith(event)) {
-        last_event->CoalesceWith(event);
+  void Queue(std::unique_ptr<T>&& event) {
+    for (auto last_event_iter = queue_.rbegin();
+         last_event_iter != queue_.rend(); ++last_event_iter) {

[tdresser, 2016/07/20 20:52:27]

Range based for?

[dtapuska, 2016/07/27 05:29:00]

It's a reverse iteration; so you can't do a reversed range based for in C++11

+      if (!(*last_event_iter)->event().isSameEventClass(event->event())) {
+        continue;
+      }
+
+      if ((*last_event_iter)->CanCoalesceWith(*event.get())) {

[tdresser, 2016/07/20 20:52:27]

Could we get weird out of order coalescing happening with this logic?

For example, if there were two separate scroll gestures in the queue, could we
coalesce into the wrong gesture?

[dtapuska, 2016/07/27 05:29:00]

No because it should stop at the most recent gesture sequence.

+        (*last_event_iter)->CoalesceWith(*event.get());
         return;
       }
+      break;
     }
-    queue_.emplace_back(std::unique_ptr<T>(new T(event)));
+    queue_.emplace_back(std::move(event));
   }
 
   std::unique_ptr<T> Pop() {
     std::unique_ptr<T> result;
     if (!queue_.empty()) {
       result.reset(queue_.front().release());
       queue_.pop_front();
     }
     return result;
   }
 
   bool empty() const { return queue_.empty(); }
 
   size_t size() const { return queue_.size(); }
 
-  void set_state(WebInputEventQueueState state) { state_ = state; }
-
-  WebInputEventQueueState state() const WARN_UNUSED_RESULT { return state_; }
-
  private:
   typedef std::deque<std::unique_ptr<T>> EventQueue;
   EventQueue queue_;
-  WebInputEventQueueState state_;
 
   DISALLOW_COPY_AND_ASSIGN(WebInputEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_INPUT_WEB_INPUT_EVENT_QUEUE_H_