Tiimer based phase info generated for mouse wheel events.

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 "content/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 218 matching lines @@
                           float y,
                           float dX,
                           float dY,
                           int modifiers,
                           bool precise) {
     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(x, y, dX, dY, modifiers,
                                                   precise)));
   }
 
+  void SimulateWheelEventWithPhase(float x,
+                                   float y,
+                                   float dX,
+                                   float dY,
+                                   int modifiers,
+                                   bool precise,
+                                   WebMouseWheelEvent::Phase phase) {
+    WebMouseWheelEvent wheel_event = SyntheticWebMouseWheelEventBuilder::Build(
+        x, y, dX, dY, modifiers, precise);
+    wheel_event.phase = phase;
+    input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(wheel_event));
+  }
+
   void SimulateMouseEvent(WebInputEvent::Type type, int x, int y) {
     input_router_->SendMouseEvent(MouseEventWithLatencyInfo(
         SyntheticWebMouseEventBuilder::Build(type, x, y, 0)));
   }
 
   void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) {
     input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo(
         SyntheticWebMouseWheelEventBuilder::Build(phase)));
   }
 
@@ skipping 131 matching lines @@
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay);
     base::RunLoop().Run();
   }
 
   void UnhandledWheelEvent(bool wheel_scroll_latching_enabled) {
     // Simulate wheel events.
-    SimulateWheelEvent(0, 0, 0, -5, 0, false);   // sent directly
-    SimulateWheelEvent(0, 0, 0, -10, 0, false);  // enqueued
+    if (wheel_scroll_latching_enabled) {
+      SimulateWheelEventWithPhase(
+          0, 0, 0, -5, 0, false,
+          WebMouseWheelEvent::kPhaseBegan);  // sent directly
+      SimulateWheelEventWithPhase(
+          0, 0, 0, -10, 0, false,
+          WebMouseWheelEvent::kPhaseChanged);  // enqueued
+    } else {
+      SimulateWheelEvent(0, 0, 0, -5, 0, false);   // sent directly
+      SimulateWheelEvent(0, 0, 0, -10, 0, false);  // enqueued
+    }
 
     // Check that only the first event was sent.
     EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
         InputMsg_HandleInputEvent::ID));
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
     // Indicate that the wheel event was unhandled.
     SendInputEventACK(WebInputEvent::kMouseWheel,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
@@ skipping 688 matching lines @@
       break;
     expected_events.erase(expected_events.begin(),
                           expected_events.begin() + acked.size());
   }
 
   EXPECT_TRUE(TouchEventQueueEmpty());
   EXPECT_EQ(0U, expected_events.size());
 }
 #endif  // defined(USE_AURA)
 
-TEST_F(InputRouterImplTest, UnhandledWheelEventWithoutLatching) {
+TEST_F(InputRouterImplTest, UnhandledWheelEvent) {
   UnhandledWheelEvent(true);
 }
-TEST_F(InputRouterImplWheelScrollLatchingDisabledTest,
-       UnhandledWheelEventWithLatching) {
+TEST_F(InputRouterImplWheelScrollLatchingDisabledTest, UnhandledWheelEvent) {
   UnhandledWheelEvent(false);
 }
 
 TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) {
   OnHasTouchEventHandlers(true);
   // Only acks for TouchCancel should always be ignored.
   ASSERT_TRUE(
       ShouldBlockEventStream(GetEventWithType(WebInputEvent::kTouchStart)));
   ASSERT_TRUE(
       ShouldBlockEventStream(GetEventWithType(WebInputEvent::kTouchMove)));
@@ skipping 1385 matching lines @@
   EXPECT_EQ(80, sent_event->data.fling_start.velocity_y);
 
   const WebGestureEvent* filter_event =
       GetFilterWebInputEvent<WebGestureEvent>();
   TestLocationInFilterEvent(filter_event, orig);
   EXPECT_EQ(30, filter_event->data.fling_start.velocity_x);
   EXPECT_EQ(40, filter_event->data.fling_start.velocity_y);
 }
 
 }  // namespace content