Explicitly suppress scrolling for wheel events that will trigger zooming

content/browser/renderer_host/input/input_router_impl_unittest.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 <math.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 1613 matching lines @@
   EXPECT_EQ(25, wheel_event->y);
   EXPECT_EQ(20, wheel_event->globalX);
   EXPECT_EQ(25, wheel_event->globalY);
   EXPECT_EQ(20, wheel_event->windowX);
   EXPECT_EQ(25, wheel_event->windowY);
   EXPECT_EQ(PinchScaleToWheelDelta(1.5), wheel_event->deltaY);
   EXPECT_EQ(0, wheel_event->deltaX);
   EXPECT_TRUE(wheel_event->hasPreciseScrollingDeltas);
   EXPECT_EQ(1, wheel_event->wheelTicksY);
   EXPECT_EQ(0, wheel_event->wheelTicksX);
+  EXPECT_FALSE(wheel_event->canScroll);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Indicate that the wheel event was unhandled.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // Check that the correct unhandled pinch event was received.
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   ASSERT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state());
   EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
   EXPECT_EQ(0, client_->in_flight_event_count());
 
   // Second a second pinch event.
   SimulateGesturePinchUpdateEvent(
       0.3f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(0.3f), wheel_event->deltaY);
   EXPECT_TRUE(wheel_event->hasPreciseScrollingDeltas);
   EXPECT_EQ(-1, wheel_event->wheelTicksY);
+  EXPECT_FALSE(wheel_event->canScroll);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Indicate that the wheel event was handled this time.
   SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Check that the correct HANDLED pinch event was received.
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state());
   EXPECT_FLOAT_EQ(0.3f,
@@ skipping 59 matching lines @@
   EXPECT_FLOAT_EQ(1.6f * 1.7f,
                   ack_handler_->acked_gesture_event().data.pinchUpdate.scale);
 }
 
 // Test interleaving pinch and wheel events.
 TEST_F(InputRouterImplTest, TouchpadPinchAndWheel) {
   // Simulate queued wheel and pinch events events.
   // Note that in practice interleaving pinch and wheel events should be rare
   // (eg. requires the use of a mouse and trackpad at the same time).
 
-  // Use the control modifier to match the synthetic wheel events so that
-  // they're elligble for coalescing.
+  // Synthetic wheel and real wheel events can never be coalesced together.
   int mod = WebInputEvent::ControlKey;
 
   // Event 1: sent directly.
   SimulateWheelEvent(0, -5, mod, true);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Event 2: enqueued in InputRouter.
   SimulateWheelEvent(0, -10, mod, true);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
-  // Event 3: enqueued in InputRouter, not coalesced into #2.
+  // Event 3: enqueued in InputRouter, not coalesced into #2 because of
+  // synthesized_from_pinch.
   SimulateGesturePinchUpdateEvent(
       1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   // Event 4: enqueued in GestureEventQueue.
   SimulateGesturePinchUpdateEvent(
       1.2f, 20, 25, 0, blink::WebGestureDeviceTouchpad);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
-  // Event 5: coalesced into wheel event for #3.
+  // Event 5: enqueued in InputRouter, not coalesced into #3 because of
+  // synthesized_from_pinch.
   SimulateWheelEvent(2, 0, mod, true);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
+  // Event 6: coalesced into #5.
+  SimulateWheelEvent(0, 3, mod, true);
+  EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
+
   // Send ack for #1.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
 
   // Verify we sent #2.
   ASSERT_EQ(1U, process_->sink().message_count());
   const WebInputEvent* input_event =
       GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
   const WebMouseWheelEvent* wheel_event =
       static_cast<const WebMouseWheelEvent*>(input_event);
   EXPECT_EQ(0, wheel_event->deltaX);
   EXPECT_EQ(-10, wheel_event->deltaY);
   EXPECT_EQ(mod, wheel_event->modifiers);
+  EXPECT_TRUE(wheel_event->canScroll);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Send ack for #2.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
 
-  // Verify we sent #3 (with #5 coalesced in).
+  // Verify we sent #3.
   ASSERT_EQ(1U, process_->sink().message_count());
   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
-  EXPECT_EQ(2, wheel_event->deltaX);
+  EXPECT_EQ(0, wheel_event->deltaX);
   EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY);
   EXPECT_EQ(mod, wheel_event->modifiers);
+  EXPECT_FALSE(wheel_event->canScroll);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
+
   // Send ack for #3.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
 
+  // Verify we sent #5 with #6 coalesced into it.
+  ASSERT_EQ(1U, process_->sink().message_count());
+  input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
+  ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
+  wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
+  EXPECT_EQ(2, wheel_event->deltaX);
+  EXPECT_EQ(3, wheel_event->deltaY);
+  EXPECT_EQ(mod, wheel_event->modifiers);
+  EXPECT_TRUE(wheel_event->canScroll);
+  EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
+
+  // Send ack for #5.
+  SendInputEventACK(WebInputEvent::MouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
+  EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type());
+
   // Verify we sent #4.
   ASSERT_EQ(1U, process_->sink().message_count());
   input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
   ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type);
   wheel_event = static_cast<const WebMouseWheelEvent*>(input_event);
   EXPECT_EQ(0, wheel_event->deltaX);
   EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.2f), wheel_event->deltaY);
   EXPECT_EQ(mod, wheel_event->modifiers);
+  EXPECT_FALSE(wheel_event->canScroll);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Send ack for #4.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type());
 }
 
 // Test proper handling of touchpad Gesture{Pinch,Scroll}Update sequences.
@@ skipping 80 matching lines @@
   client_overscroll = client_->GetAndResetOverscroll();
   EXPECT_EQ(wheel_overscroll.accumulated_overscroll,
             client_overscroll.accumulated_overscroll);
   EXPECT_EQ(wheel_overscroll.latest_overscroll_delta,
             client_overscroll.latest_overscroll_delta);
   EXPECT_EQ(wheel_overscroll.current_fling_velocity,
             client_overscroll.current_fling_velocity);
 }
 
 }  // namespace content