Consolidate WebInputEvent coalescing logic

content/browser/renderer_host/input/immediate_input_router.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/immediate_input_router.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
@@ skipping 18 matching lines @@
 using base::TimeTicks;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
-// Returns |true| if the two wheel events should be coalesced.
-bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
-                                    const WebMouseWheelEvent& new_event) {
-  return last_event.modifiers == new_event.modifiers &&
-         last_event.scrollByPage == new_event.scrollByPage &&
-         last_event.hasPreciseScrollingDeltas
-             == new_event.hasPreciseScrollingDeltas &&
-         last_event.phase == new_event.phase &&
-         last_event.momentumPhase == new_event.momentumPhase;
-}
-
-float GetUnacceleratedDelta(float accelerated_delta, float acceleration_ratio) {
-  return accelerated_delta * acceleration_ratio;
-}
-
-float GetAccelerationRatio(float accelerated_delta, float unaccelerated_delta) {
-  if (unaccelerated_delta == 0.f || accelerated_delta == 0.f)
-    return 1.f;
-  return unaccelerated_delta / accelerated_delta;
-}
-
 const char* GetEventAckName(InputEventAckState ack_result) {
   switch(ack_result) {
     case INPUT_EVENT_ACK_STATE_UNKNOWN: return "UNKNOWN";
     case INPUT_EVENT_ACK_STATE_CONSUMED: return "CONSUMED";
     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED: return "NOT_CONSUMED";
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
   default:
     DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.\n";
     break;
   }
@@ skipping 65 matching lines @@
     const MouseWheelEventWithLatencyInfo& wheel_event) {
   if (!client_->OnSendWheelEvent(wheel_event))
     return;
 
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
-        !ShouldCoalesceMouseWheelEvents(
-            coalesced_mouse_wheel_events_.back().event, wheel_event.event)) {
+        !coalesced_mouse_wheel_events_.back().TryCoalesceWith(wheel_event)) {
       coalesced_mouse_wheel_events_.push_back(wheel_event);
-    } else {
-      MouseWheelEventWithLatencyInfo* last_wheel_event =
-          &coalesced_mouse_wheel_events_.back();
-      float unaccelerated_x =
-          GetUnacceleratedDelta(last_wheel_event->event.deltaX,
-                                last_wheel_event->event.accelerationRatioX) +
-          GetUnacceleratedDelta(wheel_event.event.deltaX,
-                                wheel_event.event.accelerationRatioX);
-      float unaccelerated_y =
-          GetUnacceleratedDelta(last_wheel_event->event.deltaY,
-                                last_wheel_event->event.accelerationRatioY) +
-          GetUnacceleratedDelta(wheel_event.event.deltaY,
-                                wheel_event.event.accelerationRatioY);
-      last_wheel_event->event.deltaX += wheel_event.event.deltaX;
-      last_wheel_event->event.deltaY += wheel_event.event.deltaY;
-      last_wheel_event->event.wheelTicksX += wheel_event.event.wheelTicksX;
-      last_wheel_event->event.wheelTicksY += wheel_event.event.wheelTicksY;
-      last_wheel_event->event.accelerationRatioX =
-          GetAccelerationRatio(last_wheel_event->event.deltaX, unaccelerated_x);
-      last_wheel_event->event.accelerationRatioY =
-          GetAccelerationRatio(last_wheel_event->event.deltaY, unaccelerated_y);
-      DCHECK_GE(wheel_event.event.timeStampSeconds,
-                last_wheel_event->event.timeStampSeconds);
-      last_wheel_event->event.timeStampSeconds =
-          wheel_event.event.timeStampSeconds;
-      last_wheel_event->latency.MergeWith(wheel_event.latency);
     }
     return;
   }
   mouse_wheel_pending_ = true;
   current_wheel_event_ = wheel_event;
 
   HISTOGRAM_COUNTS_100("Renderer.WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
   FilterAndSendWebInputEvent(wheel_event.event, wheel_event.latency, false);
@@ skipping 39 matching lines @@
     const MouseEventWithLatencyInfo& mouse_event) {
   if (!client_->OnSendMouseEventImmediately(mouse_event))
     return;
 
   // Avoid spamming the renderer with mouse move events.  It is important
   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
   // more WM_MOUSEMOVE events than we wish to send to the renderer.
   if (mouse_event.event.type == WebInputEvent::MouseMove) {
     if (mouse_move_pending_) {
-      if (!next_mouse_move_) {
+      if (!next_mouse_move_ ||
+          !next_mouse_move_->TryCoalesceWith(mouse_event)) {
         next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
-      } else {
-        // Accumulate movement deltas.
-        int x = next_mouse_move_->event.movementX;
-        int y = next_mouse_move_->event.movementY;
-        next_mouse_move_->event = mouse_event.event;
-        next_mouse_move_->event.movementX += x;
-        next_mouse_move_->event.movementY += y;
-        next_mouse_move_->latency.MergeWith(mouse_event.latency);
       }
       return;
     }
     mouse_move_pending_ = true;
   }
 
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 }
 
 void ImmediateInputRouter::SendTouchEventImmediately(
@@ skipping 302 matching lines @@
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
 }
 
 void ImmediateInputRouter::HandleGestureScroll(
     const GestureEventWithLatencyInfo& gesture_event) {
   touch_event_queue_->OnGestureScrollEvent(gesture_event);
 }
 
 }  // namespace content