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/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
@@ skipping 20 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;
-}
-
 GestureEventWithLatencyInfo MakeGestureEvent(WebInputEvent::Type type,
                                              double timestamp_seconds,
                                              int x,
                                              int y,
                                              int modifiers,
                                              const ui::LatencyInfo latency) {
   WebGestureEvent result;
 
   result.type = type;
   result.x = x;
@@ skipping 87 matching lines @@
 }
 
 void ImmediateInputRouter::SendWheelEvent(
     const MouseWheelEventWithLatencyInfo& wheel_event) {
   // 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().CanCoalesceWith(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);
+      coalesced_mouse_wheel_events_.back().CoalesceWith(wheel_event);
     }
     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 38 matching lines @@
 // Forwards MouseEvent without passing it through
 // TouchpadTapSuppressionController.
 void ImmediateInputRouter::SendMouseEventImmediately(
     const MouseEventWithLatencyInfo& mouse_event) {
   // 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_.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);
-      }
+      else
+        next_mouse_move_->CoalesceWith(mouse_event);
       return;
     }
     mouse_move_pending_ = true;
   }
 
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 }
 
 void ImmediateInputRouter::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
@@ skipping 407 matching lines @@
       break;
   }
 }
 
 bool ImmediateInputRouter::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content