Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(319)

Unified Diff: content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc

Issue 1749343004: Implement Wheel Gesture Scrolling on OSX. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc
diff --git a/content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc b/content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc
index f9e10a901301818fb9270dc1fc3056c222353374..5c494320da04e1a4454df7b0033af239bf751b4b 100644
--- a/content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc
+++ b/content/browser/renderer_host/input/mouse_wheel_event_queue_unittest.cc
@@ -113,6 +113,24 @@ class MouseWheelEventQueueTest : public testing::Test,
x, y, global_x, global_y, dX, dY, modifiers, high_precision)));
}
+ void SendMouseWheelWithPhase(
+ float x,
+ float y,
+ float global_x,
+ float global_y,
+ float dX,
+ float dY,
+ int modifiers,
+ bool high_precision,
+ blink::WebMouseWheelEvent::Phase phase,
+ blink::WebMouseWheelEvent::Phase momentum_phase) {
+ WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build(
+ x, y, global_x, global_y, dX, dY, modifiers, high_precision);
+ event.phase = phase;
+ event.momentumPhase = momentum_phase;
+ queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event));
+ }
+
void SendGestureEvent(WebInputEvent::Type type) {
WebGestureEvent event;
event.type = type;
@@ -179,6 +197,124 @@ class MouseWheelEventQueueTest : public testing::Test,
EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY);
}
+ const uint32_t HAS_SCROLL_UPDATE = 1;
+ const uint32_t HAS_MOUSEWHEEL = 1 << 1;
+ const uint32_t HAS_SYNTHETIC_BEGIN = 1 << 2;
+ const uint32_t HAS_SYNTHETIC_END = 1 << 3;
+ const uint32_t HAS_INERTIAL = 1 << 4;
+
+ void ValidatePhaseSequence(bool high_precision,
+ size_t expect_queue_count,
+ uint32_t flags) {
+ const WebGestureEvent::ScrollUnits scroll_units =
+ high_precision ? WebGestureEvent::PrecisePixels
+ : WebGestureEvent::Pixels;
+ SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+ EXPECT_EQ(expect_queue_count, queued_event_count());
+ EXPECT_EQ((flags & HAS_MOUSEWHEEL) != 0, event_in_flight());
+ EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type);
+
+ size_t expect_event_count = 2;
+ if (flags & HAS_SCROLL_UPDATE)
+ ++expect_event_count;
+ if (flags & HAS_MOUSEWHEEL)
+ ++expect_event_count;
+
+ EXPECT_EQ(1U, GetAndResetAckedEventCount());
+ EXPECT_EQ(expect_event_count, all_sent_events().size());
+ EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type);
+ EXPECT_EQ(scroll_units,
+ sent_gesture_events()[0].data.scrollBegin.deltaHintUnits);
+ EXPECT_EQ(kWheelScrollX, sent_gesture_events()[0].x);
+ EXPECT_EQ(kWheelScrollY, sent_gesture_events()[0].y);
+ EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[0].globalX);
+ EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[0].globalY);
+ EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+ sent_gesture_events()[0].data.scrollBegin.inertial);
+ EXPECT_EQ((flags & HAS_SYNTHETIC_BEGIN) != 0,
+ sent_gesture_events()[0].data.scrollBegin.synthetic);
+ size_t index = 1;
+ if (flags & HAS_SCROLL_UPDATE) {
+ EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type);
+ EXPECT_EQ(scroll_units,
+ sent_gesture_events()[1].data.scrollUpdate.deltaUnits);
+ EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+ sent_gesture_events()[1].data.scrollUpdate.inertial);
+ EXPECT_EQ(kWheelScrollX, sent_gesture_events()[1].x);
+ EXPECT_EQ(kWheelScrollY, sent_gesture_events()[1].y);
+ EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[1].globalX);
+ EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[1].globalY);
+ ++index;
+ }
+
+ EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[index].type);
+ EXPECT_EQ(scroll_units,
+ sent_gesture_events()[index].data.scrollEnd.deltaUnits);
+ EXPECT_EQ(kWheelScrollX, sent_gesture_events()[index].x);
+ EXPECT_EQ(kWheelScrollY, sent_gesture_events()[index].y);
+ EXPECT_EQ(kWheelScrollGlobalX, sent_gesture_events()[index].globalX);
+ EXPECT_EQ(kWheelScrollGlobalY, sent_gesture_events()[index].globalY);
+ EXPECT_EQ((flags & HAS_INERTIAL) != 0,
+ sent_gesture_events()[index].data.scrollEnd.inertial);
+ EXPECT_EQ((flags & HAS_SYNTHETIC_END) != 0,
+ sent_gesture_events()[index].data.scrollEnd.synthetic);
+ ++index;
+ if (flags & HAS_MOUSEWHEEL)
+ EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[index].type);
+ EXPECT_EQ(expect_event_count, GetAndResetSentEventCount());
+ }
+
+ void PhaseGestureSendingTest(bool high_precision) {
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 1, 1, 0, high_precision,
+ WebMouseWheelEvent::PhaseBegan,
+ WebMouseWheelEvent::PhaseNone);
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 5, 5, 0, high_precision,
+ WebMouseWheelEvent::PhaseChanged,
+ WebMouseWheelEvent::PhaseNone);
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 0, 0, 0, high_precision,
+ WebMouseWheelEvent::PhaseEnded,
+ WebMouseWheelEvent::PhaseNone);
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 5, 5, 0, high_precision,
+ WebMouseWheelEvent::PhaseNone,
+ WebMouseWheelEvent::PhaseBegan);
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 5, 5, 0, high_precision,
+ WebMouseWheelEvent::PhaseNone,
+ WebMouseWheelEvent::PhaseChanged);
+ SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,
+ kWheelScrollGlobalY, 0, 0, 0, high_precision,
+ WebMouseWheelEvent::PhaseNone,
+ WebMouseWheelEvent::PhaseEnded);
+
+ EXPECT_EQ(5U, queued_event_count());
+ EXPECT_TRUE(event_in_flight());
+ EXPECT_EQ(1U, GetAndResetSentEventCount());
+
+ // Receive an ACK for the mouse wheel event and release the next
+ // mouse wheel event.
+ ValidatePhaseSequence(high_precision, 4U, HAS_SCROLL_UPDATE |
+ HAS_MOUSEWHEEL |
+ HAS_SYNTHETIC_END);
tdresser 2016/03/08 14:28:53 The distance between sending the mousewheel and de
dtapuska 2016/03/08 20:31:49 I've replaced it with macros that I find much easi
+ ValidatePhaseSequence(high_precision, 3U,
+ HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL |
+ HAS_SYNTHETIC_BEGIN | HAS_SYNTHETIC_END);
+ ValidatePhaseSequence(high_precision, 2U,
+ HAS_SYNTHETIC_BEGIN | HAS_MOUSEWHEEL);
+ ValidatePhaseSequence(
+ high_precision, 1U,
+ HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL | HAS_SYNTHETIC_END | HAS_INERTIAL);
+ ValidatePhaseSequence(high_precision, 0U,
+ HAS_SCROLL_UPDATE | HAS_MOUSEWHEEL |
+ HAS_SYNTHETIC_BEGIN | HAS_SYNTHETIC_END |
+ HAS_INERTIAL);
+ ValidatePhaseSequence(high_precision, 0U,
+ HAS_SYNTHETIC_BEGIN | HAS_INERTIAL);
+ }
+
scoped_ptr<MouseWheelEventQueue> queue_;
std::vector<WebInputEvent> sent_events_;
std::vector<WebGestureEvent> sent_gesture_events_;
@@ -230,6 +366,17 @@ TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) {
GestureSendingTest(false);
}
+TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) {
tdresser 2016/03/08 14:28:53 You could use TEST_P here, but I don't think it ha
dtapuska 2016/03/08 20:31:49 For two parameters; true vs false it is much more
+ SetUpForGestureTesting(true);
+ PhaseGestureSendingTest(false);
+}
+
+TEST_F(MouseWheelEventQueueTest,
+ GestureSendingWithPhaseInformationPrecisePixels) {
+ SetUpForGestureTesting(true);
+ PhaseGestureSendingTest(true);
+}
+
TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) {
SetUpForGestureTesting(true);
SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX,

Powered by Google App Engine
This is Rietveld 408576698