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

content/common/input/event_with_latency_info.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/common/input/event_with_latency_info.h"
 
 #include <bitset>
 #include <limits>
+#include "content/common/input/web_input_event_traits.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using std::numeric_limits;
 
 namespace content {
@@ skipping 168 matching lines @@
     event->data.pinchUpdate.scale *= event_to_coalesce.data.pinchUpdate.scale;
     // Ensure the scale remains bounded above 0 and below Infinity so that
     // we can reliably perform operations like log on the values.
     if (event->data.pinchUpdate.scale < numeric_limits<float>::min())
       event->data.pinchUpdate.scale = numeric_limits<float>::min();
     else if (event->data.pinchUpdate.scale > numeric_limits<float>::max())
       event->data.pinchUpdate.scale = numeric_limits<float>::max();
   }
 }
 
+bool CanCoalesce(const blink::WebInputEvent& event_to_coalesce,
+                 const blink::WebInputEvent& event) {
+  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isGestureEventType(event.type)) {
+    return CanCoalesce(
+        static_cast<const blink::WebGestureEvent&>(event_to_coalesce),
+        static_cast<const blink::WebGestureEvent&>(event));
+  }
+  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isMouseEventType(event.type)) {
+    return CanCoalesce(
+        static_cast<const blink::WebMouseEvent&>(event_to_coalesce),
+        static_cast<const blink::WebMouseEvent&>(event));
+  }
+  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isTouchEventType(event.type)) {
+    return CanCoalesce(
+        static_cast<const blink::WebTouchEvent&>(event_to_coalesce),
+        static_cast<const blink::WebTouchEvent&>(event));
+  }
+  if (event_to_coalesce.type == blink::WebInputEvent::MouseWheel &&
+      event.type == blink::WebInputEvent::MouseWheel) {
+    return CanCoalesce(
+        static_cast<const blink::WebMouseWheelEvent&>(event_to_coalesce),
+        static_cast<const blink::WebMouseWheelEvent&>(event));
+  }
+  return false;
+}
+
+void Coalesce(const blink::WebInputEvent& event_to_coalesce,
+              blink::WebInputEvent* event) {
+  if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isGestureEventType(event->type)) {
+    Coalesce(static_cast<const blink::WebGestureEvent&>(event_to_coalesce),
+             static_cast<blink::WebGestureEvent*>(event));
+    return;
+  }
+  if (blink::WebInputEvent::isMouseEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isMouseEventType(event->type)) {
+    Coalesce(static_cast<const blink::WebMouseEvent&>(event_to_coalesce),
+             static_cast<blink::WebMouseEvent*>(event));
+    return;
+  }
+  if (blink::WebInputEvent::isTouchEventType(event_to_coalesce.type) &&
+      blink::WebInputEvent::isTouchEventType(event->type)) {
+    Coalesce(static_cast<const blink::WebTouchEvent&>(event_to_coalesce),
+             static_cast<blink::WebTouchEvent*>(event));
+    return;
+  }
+  if (event_to_coalesce.type == blink::WebInputEvent::MouseWheel &&
+      event->type == blink::WebInputEvent::MouseWheel) {
+    Coalesce(static_cast<const blink::WebMouseWheelEvent&>(event_to_coalesce),
+             static_cast<blink::WebMouseWheelEvent*>(event));
+  }
+}
+
 }  // namespace internal
+
+ScopedWebInputEventWithLatencyInfo::ScopedWebInputEventWithLatencyInfo(
+    const WebInputEvent& e,
+    const ui::LatencyInfo& l)
+    : event_(WebInputEventTraits::Clone(e)), latency_(l) {}
+
+ScopedWebInputEventWithLatencyInfo::~ScopedWebInputEventWithLatencyInfo() {}
+
+bool ScopedWebInputEventWithLatencyInfo::CanCoalesceWith(
+    const ScopedWebInputEventWithLatencyInfo& other) const {
+  return internal::CanCoalesce(other.event(), event());
+}
+
+void ScopedWebInputEventWithLatencyInfo::CoalesceWith(
+    const ScopedWebInputEventWithLatencyInfo& other) {
+  // |other| should be a newer event than |this|.
+  if (other.latency_.trace_id() >= 0 && latency_.trace_id() >= 0)
+    DCHECK_GT(other.latency_.trace_id(), latency_.trace_id());
+
+  // New events get coalesced into older events, and the newer timestamp
+  // should always be preserved.
+  const double time_stamp_seconds = other.event().timeStampSeconds;
+  internal::Coalesce(other.event(), event_.get());
+  event_->timeStampSeconds = time_stamp_seconds;
+
+  // When coalescing two input events, we keep the oldest LatencyInfo
+  // for Telemetry latency tests, since it will represent the longest

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

While you're here, we shouldn't really say "for Telemetry latency tests", since
it's used for other things as well.

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

Done.

+  // latency.
+  other.latency_ = latency_;
+  other.latency_.set_coalesced();
+}
+
+const blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() const {
+  return *event_;
+}
+
+blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() {
+  return *event_;
+}
+
 }  // namespace content