Explicitly suppress scrolling for wheel events that will trigger zooming

content/common/input/web_input_event_traits_unittest.cc

 // Copyright 2014 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/web_input_event_traits.h"
 
 #include <limits>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 33 matching lines @@
 
   static WebGestureEvent CreateGesture(WebInputEvent::Type type,
                                        float x,
                                        float y) {
     WebGestureEvent event;
     event.type = type;
     event.x = x;
     event.y = y;
     return event;
   }
+
+  static WebMouseWheelEvent CreateMouseWheel(float deltaX,
+                                             float deltaY,
+                                             bool canScroll) {
+    WebMouseWheelEvent event;
+    event.type = WebInputEvent::MouseWheel;
+    event.deltaX = deltaX;
+    event.deltaY = deltaY;
+    event.canScroll = canScroll;
+    return event;
+  }
 };
 
 TEST_F(WebInputEventTraitsTest, TouchEventCoalescing) {
   WebTouchEvent touch0 = CreateTouch(WebInputEvent::TouchStart);
   WebTouchEvent touch1 = CreateTouch(WebInputEvent::TouchMove);
 
   // Non touch-moves won't coalesce.
   EXPECT_FALSE(WebInputEventTraits::CanCoalesce(touch0, touch0));
 
   // Touches of different types won't coalesce.
@@ skipping 91 matching lines @@
   // Scales have a maximum value and can never reach Infinity.
   pinch0 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
   pinch0.data.pinchUpdate.scale = numeric_limits<float>::max() / 2.0f;
   pinch1 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
   pinch1.data.pinchUpdate.scale = 10.0f;
   EXPECT_TRUE(WebInputEventTraits::CanCoalesce(pinch0, pinch1));
   WebInputEventTraits::Coalesce(pinch0, &pinch1);
   EXPECT_EQ(numeric_limits<float>::max(), pinch1.data.pinchUpdate.scale);
 }
 
+TEST_F(WebInputEventTraitsTest, WebMouseWheelEventCoalescing) {
+  WebMouseWheelEvent mouseWheel0 =
+      CreateMouseWheel(1, 1, true);
+  WebMouseWheelEvent mouseWheel1 =
+      CreateMouseWheel(2, 2, true);
+
+  // WebMouseWheelEvent objects with same values except different deltaX and
+  // deltaY should coalesce.
+  EXPECT_TRUE(WebInputEventTraits::CanCoalesce(mouseWheel0, mouseWheel1));
+
+  mouseWheel0 = CreateMouseWheel(1, 1, true);
+  mouseWheel1 = CreateMouseWheel(1, 1, false);
+
+  // WebMouseWheelEvent objects with different canScroll values should not
+  // coalesce.
+  EXPECT_FALSE(WebInputEventTraits::CanCoalesce(mouseWheel0, mouseWheel1));
+
+  // WebMouseWheelEvent objects with different modifiers should not coalesce.
+  mouseWheel0 = CreateMouseWheel(1, 1, true);
+  mouseWheel1 = CreateMouseWheel(1, 1, true);
+  mouseWheel0.modifiers = blink::WebInputEvent::ControlKey;
+  mouseWheel1.modifiers = blink::WebInputEvent::ShiftKey;
+  EXPECT_FALSE(WebInputEventTraits::CanCoalesce(mouseWheel0, mouseWheel1));
+}
+
 // Very basic smoke test to ensure stringification doesn't explode.
 TEST_F(WebInputEventTraitsTest, ToString) {
   WebKeyboardEvent key;
   key.type = WebInputEvent::RawKeyDown;
   EXPECT_FALSE(WebInputEventTraits::ToString(key).empty());
 
   WebMouseEvent mouse;
   mouse.type = WebInputEvent::MouseMove;
   EXPECT_FALSE(WebInputEventTraits::ToString(mouse).empty());
 
   WebMouseWheelEvent mouse_wheel;
   mouse_wheel.type = WebInputEvent::MouseWheel;
   EXPECT_FALSE(WebInputEventTraits::ToString(mouse_wheel).empty());
 
   WebGestureEvent gesture =
       CreateGesture(WebInputEvent::GesturePinchBegin, 1, 1);
   EXPECT_FALSE(WebInputEventTraits::ToString(gesture).empty());
 
   WebTouchEvent touch = CreateTouch(WebInputEvent::TouchStart);
   EXPECT_FALSE(WebInputEventTraits::ToString(touch).empty());
 }
 
 }  // namespace
 }  // namespace content