Explicitly suppress scrolling for wheel events that will trigger zooming

content/browser/renderer_host/input/input_router_impl.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/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 118 matching lines @@
   SendWheelEvent(QueuedWheelEvent(wheel_event, false));
 }
 
 void InputRouterImpl::SendWheelEvent(const QueuedWheelEvent& wheel_event) {
   if (mouse_wheel_pending_) {
     // 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).
     // Note that we can't coalesce wheel events for pinches because the GEQ
-    // expects one ACK for each (but it's fine to coalesce non-pinch wheels
-    // into a pinch one).  Note that the GestureEventQueue ensures we only
-    // ever have a single pinch event queued here.
+    // expects one ACK for each.  But such events always have canScroll==false
+    // and hasPreciseDeltas=true, which should never happen for a real wheel
+    // event and so coalescing shouldn't occur.  Note that the
+    // GestureEventQueue ensures we only ever have a single pinch event queued
+    // here.
     if (coalesced_mouse_wheel_events_.empty() ||
-        wheel_event.synthesized_from_pinch ||
+        wheel_event.synthesized_from_pinch !=
+            coalesced_mouse_wheel_events_.back().synthesized_from_pinch ||
         !coalesced_mouse_wheel_events_.back().event.CanCoalesceWith(
             wheel_event.event)) {
       coalesced_mouse_wheel_events_.push_back(wheel_event);
     } else {
       coalesced_mouse_wheel_events_.back().event.CoalesceWith(
           wheel_event.event);
     }
     return;
   }
 
@@ skipping 297 matching lines @@
   //  - magnitude roughly matches wheels: f(2) > 25 && f(2) < 100
   //  - a formula that's relatively easy to use from JavaScript
   // Note that 'wheel' event deltaY values have their sign inverted.  So to
   // convert a wheel deltaY back to a scale use Math.exp(-deltaY/100).
   DCHECK_GT(pinch_event.event.data.pinchUpdate.scale, 0);
   wheelEvent.deltaY = 100.0f * log(pinch_event.event.data.pinchUpdate.scale);
   wheelEvent.hasPreciseScrollingDeltas = true;
   wheelEvent.wheelTicksX = 0;
   wheelEvent.wheelTicksY =
       pinch_event.event.data.pinchUpdate.scale > 1 ? 1 : -1;
-
+  // Prevent trackpad pinch from scrolling on Mac OS.

[Rick Byers, 2014/12/12 22:20:29]

nit: This comment seems redundant with the code (and the intention is to use
this code on ChromeOS someday too) - I'd just remove it.

[lanwei, 2014/12/17 23:16:40]

Done.

+  wheelEvent.canScroll = false;
   SendWheelEvent(QueuedWheelEvent(
       MouseWheelEventWithLatencyInfo(wheelEvent, pinch_event.latency), true));
 }
 
 void InputRouterImpl::OnInputEventAck(
     const InputHostMsg_HandleInputEvent_ACK_Params& ack) {
   client_->DecrementInFlightEventCount();
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
@@ skipping 240 matching lines @@
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
     const MouseWheelEventWithLatencyInfo& event,
     bool synthesized_from_pinch)
     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 }
 
 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 }
 
 }  // namespace content