Coalesced mouse wheel event has the position of the most recent event.

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>
 
 using blink::WebGestureEvent;
@@ skipping 78 matching lines @@
 void Coalesce(const WebMouseWheelEvent& event_to_coalesce,
               WebMouseWheelEvent* event) {
   DCHECK(CanCoalesce(event_to_coalesce, *event));
   float unaccelerated_x =
       GetUnacceleratedDelta(event->deltaX, event->accelerationRatioX) +
       GetUnacceleratedDelta(event_to_coalesce.deltaX,
                             event_to_coalesce.accelerationRatioX);
   float unaccelerated_y =
       GetUnacceleratedDelta(event->deltaY, event->accelerationRatioY) +
       GetUnacceleratedDelta(event_to_coalesce.deltaY,
                             event_to_coalesce.accelerationRatioY);

[tdresser, 2016/08/19 12:43:30]

WebMouseWheelEvent is a WebMouseEvent.
Could we call WebMouseEvent::Coalesce in here, and then only deal explicitly
with the deltas and wheelTicks?

That way if someone adds a new field to WebMouseEvent, we don't need to remember
to write the coalescing logic in both places.

[sahel, 2016/08/19 15:17:56]

I see your point here, but this way we guarantee that the coalesced event is the
new one with merged delta. It will be true if some logic is added to either of
the classes.

-  event->deltaX += event_to_coalesce.deltaX;
-  event->deltaY += event_to_coalesce.deltaY;
-  event->wheelTicksX += event_to_coalesce.wheelTicksX;
-  event->wheelTicksY += event_to_coalesce.wheelTicksY;
+  float old_deltaX = event->deltaX;
+  float old_deltaY = event->deltaY;
+  float old_wheelTicksX = event->wheelTicksX;
+  float old_wheelTicksY = event->wheelTicksY;
+  float old_movementX = event->movementX;
+  float old_movementY = event->movementY;
+  *event = event_to_coalesce;
+  event->deltaX += old_deltaX;
+  event->deltaY += old_deltaY;
+  event->wheelTicksX += old_wheelTicksX;
+  event->wheelTicksY += old_wheelTicksY;
+  event->movementX += old_movementX;
+  event->movementY += old_movementY;
   event->accelerationRatioX =
       GetAccelerationRatio(event->deltaX, unaccelerated_x);
   event->accelerationRatioY =
       GetAccelerationRatio(event->deltaY, unaccelerated_y);
 }
 
 bool CanCoalesce(const WebTouchEvent& event_to_coalesce,
                  const WebTouchEvent& event) {
   if (event.type != event_to_coalesce.type ||
       event.type != WebInputEvent::TouchMove ||
@@ skipping 171 matching lines @@
 
 const blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() const {
   return *event_;
 }
 
 blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() {
   return *event_;
 }
 
 }  // namespace content