Consolidate WebInputEvent coalescing logic

content/browser/renderer_host/input/touch_event_queue.cc

 // Copyright 2013 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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 
 namespace content {
 
 typedef std::vector<TouchEventWithLatencyInfo> WebTouchEventWithLatencyList;
 
 // This class represents a single coalesced touch event. However, it also keeps
 // track of all the original touch-events that were coalesced into a single
 // event. The coalesced event is forwarded to the renderer, while the original
 // touch-events are sent to the Client (on ACK for the coalesced event) so that
 // the Client receives the event with their original timestamp.
 class CoalescedWebTouchEvent {
  public:
   explicit CoalescedWebTouchEvent(const TouchEventWithLatencyInfo& event)
-      : coalesced_event_(event),
-        ignore_ack_(false) {
+      : coalesced_event_(event) {
     events_.push_back(event);
     TRACE_EVENT_ASYNC_BEGIN0(
         "input", "TouchEventQueue::QueueEvent", this);
   }
 
   ~CoalescedWebTouchEvent() {
     TRACE_EVENT_ASYNC_END0(
         "input", "TouchEventQueue::QueueEvent", this);
   }
 
   // Coalesces the event with the existing event if possible. Returns whether
   // the event was coalesced.
   bool CoalesceEventIfPossible(
       const TouchEventWithLatencyInfo& event_with_latency) {
-    if (coalesced_event_.event.type == WebKit::WebInputEvent::TouchMove &&
-        event_with_latency.event.type == WebKit::WebInputEvent::TouchMove &&
-        coalesced_event_.event.modifiers ==
-        event_with_latency.event.modifiers &&
-        coalesced_event_.event.touchesLength ==
-        event_with_latency.event.touchesLength &&
-        !ignore_ack_) {
+    if (!ignore_ack_ &&
+        coalesced_event_.CanCoalesceWith(event_with_latency)) {
       TRACE_EVENT_INSTANT0(
           "input", "TouchEventQueue::MoveCoalesced", TRACE_EVENT_SCOPE_THREAD);
+      coalesced_event_.CoalesceWith(event_with_latency);
       events_.push_back(event_with_latency);
-      // The WebTouchPoints include absolute position information. So it is
-      // sufficient to simply replace the previous event with the new event.
-      // However, it is necessary to make sure that all the points have the
-      // correct state, i.e. the touch-points that moved in the last event, but
-      // didn't change in the current event, will have Stationary state. It is
-      // necessary to change them back to Moved state.
-      const WebKit::WebTouchEvent last_event = coalesced_event_.event;
-      const ui::LatencyInfo last_latency = coalesced_event_.latency;
-      coalesced_event_ = event_with_latency;
-      coalesced_event_.latency.MergeWith(last_latency);
-      for (unsigned i = 0; i < last_event.touchesLength; ++i) {
-        if (last_event.touches[i].state == WebKit::WebTouchPoint::StateMoved)
-          coalesced_event_.event.touches[i].state =
-              WebKit::WebTouchPoint::StateMoved;
-      }
       return true;
     }
 
     return false;
   }
 
   const TouchEventWithLatencyInfo& coalesced_event() const {
     return coalesced_event_;
   }
 
@@ skipping 201 matching lines @@
       // If the ACK status of a point is unknown, then the event should be
       // forwarded to the renderer.
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace content