diff options
Diffstat (limited to 'content/browser')
7 files changed, 348 insertions, 101 deletions
diff --git a/content/browser/renderer_host/input/composited_scrolling_browsertest.cc b/content/browser/renderer_host/input/composited_scrolling_browsertest.cc index cbf48e8..fdca6bc 100644 --- a/content/browser/renderer_host/input/composited_scrolling_browsertest.cc +++ b/content/browser/renderer_host/input/composited_scrolling_browsertest.cc @@ -84,7 +84,7 @@ class CompositedScrollingBrowserTest : public ContentBrowserTest { RenderWidgetHostImpl* host = GetWidgetHost(); scoped_refptr<FrameWatcher> frame_watcher(new FrameWatcher()); - host->GetProcess()->AddFilter(frame_watcher.get()); + frame_watcher->AttachTo(shell()->web_contents()); host->GetView()->SetSize(gfx::Size(400, 400)); base::string16 ready_title(base::ASCIIToUTF16("ready")); diff --git a/content/browser/renderer_host/input/mouse_wheel_event_queue.cc b/content/browser/renderer_host/input/mouse_wheel_event_queue.cc index 48dbad2..5e56e9b 100644 --- a/content/browser/renderer_host/input/mouse_wheel_event_queue.cc +++ b/content/browser/renderer_host/input/mouse_wheel_event_queue.cc @@ -37,6 +37,7 @@ MouseWheelEventQueue::MouseWheelEventQueue(MouseWheelEventQueueClient* client, int64_t scroll_transaction_ms) : client_(client), needs_scroll_begin_(true), + needs_scroll_end_(false), send_gestures_(send_gestures), scroll_transaction_ms_(scroll_transaction_ms), scrolling_device_(blink::WebGestureDeviceUninitialized) { @@ -85,6 +86,9 @@ void MouseWheelEventQueue::ProcessMouseWheelAck( (scrolling_device_ == blink::WebGestureDeviceUninitialized || scrolling_device_ == blink::WebGestureDeviceTouchpad)) { GestureEventWithLatencyInfo scroll_update; + scroll_update.event.timeStampSeconds = + event_sent_for_gesture_ack_->event.timeStampSeconds; + scroll_update.event.x = event_sent_for_gesture_ack_->event.x; scroll_update.event.y = event_sent_for_gesture_ack_->event.y; scroll_update.event.globalX = event_sent_for_gesture_ack_->event.globalX; @@ -96,6 +100,11 @@ void MouseWheelEventQueue::ProcessMouseWheelAck( event_sent_for_gesture_ack_->event.deltaX; scroll_update.event.data.scrollUpdate.deltaY = event_sent_for_gesture_ack_->event.deltaY; + // Only OSX populates the momentumPhase; so expect this to + // always be PhaseNone on all other platforms. + scroll_update.event.data.scrollUpdate.inertial = + event_sent_for_gesture_ack_->event.momentumPhase != + blink::WebMouseWheelEvent::PhaseNone; if (event_sent_for_gesture_ack_->event.scrollByPage) { scroll_update.event.data.scrollUpdate.deltaUnits = blink::WebGestureEvent::Page; @@ -114,7 +123,67 @@ void MouseWheelEventQueue::ProcessMouseWheelAck( ? blink::WebGestureEvent::PrecisePixels : blink::WebGestureEvent::Pixels; } - SendGesture(scroll_update); + + bool current_phase_ended = false; + bool has_phase_info = false; + + if (event_sent_for_gesture_ack_->event.phase != + blink::WebMouseWheelEvent::PhaseNone || + event_sent_for_gesture_ack_->event.momentumPhase != + blink::WebMouseWheelEvent::PhaseNone) { + has_phase_info = true; + current_phase_ended = event_sent_for_gesture_ack_->event.phase == + blink::WebMouseWheelEvent::PhaseEnded || + event_sent_for_gesture_ack_->event.phase == + blink::WebMouseWheelEvent::PhaseCancelled || + event_sent_for_gesture_ack_->event.momentumPhase == + blink::WebMouseWheelEvent::PhaseEnded || + event_sent_for_gesture_ack_->event.momentumPhase == + blink::WebMouseWheelEvent::PhaseCancelled; + } + + bool needs_update = scroll_update.event.data.scrollUpdate.deltaX != 0 || + scroll_update.event.data.scrollUpdate.deltaY != 0; + + // If there is no update to send and the current phase is ended yet a GSB + // needs to be sent, this event sequence doesn't need to be generated + // because the events generated will be a GSB (non-synthetic) and GSE + // (non-synthetic). This situation arises when OSX generates double + // phase end information. + bool empty_sequence = + !needs_update && needs_scroll_begin_ && current_phase_ended; + + if (needs_update || !empty_sequence) { + if (needs_scroll_begin_) { + // If no GSB has been sent, it will be a non-synthetic GSB. + SendScrollBegin(scroll_update, false); + } else if (has_phase_info) { + // If a GSB has been sent, generate a synthetic GSB if we have phase + // information. This should be removed once crbug.com/526463 is fully + // implemented. + SendScrollBegin(scroll_update, true); + } + + if (needs_update) + client_->SendGestureEvent(scroll_update); + + if (current_phase_ended) { + // Non-synthetic GSEs are sent when the current phase is canceled or + // ended. + SendScrollEnd(scroll_update.event, false); + } else if (has_phase_info) { + // Generate a synthetic GSE for every update to force hit testing so + // that the non-latching behavior is preserved. Remove once + // crbug.com/526463 is fully implemented. + SendScrollEnd(scroll_update.event, true); + } else { + scroll_end_timer_.Start( + FROM_HERE, + base::TimeDelta::FromMilliseconds(scroll_transaction_ms_), + base::Bind(&MouseWheelEventQueue::SendScrollEnd, + base::Unretained(this), scroll_update.event, false)); + } + } } event_sent_for_gesture_ack_.reset(); @@ -158,62 +227,52 @@ void MouseWheelEventQueue::TryForwardNextEventToRenderer() { client_->SendMouseWheelEventImmediately(send_event); } -void MouseWheelEventQueue::SendScrollEnd(blink::WebGestureEvent update_event) { - GestureEventWithLatencyInfo scroll_end; +void MouseWheelEventQueue::SendScrollEnd(blink::WebGestureEvent update_event, + bool synthetic) { + DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_); + + GestureEventWithLatencyInfo scroll_end(update_event); + scroll_end.event.timeStampSeconds = + (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF(); scroll_end.event.type = WebInputEvent::GestureScrollEnd; - scroll_end.event.sourceDevice = blink::WebGestureDeviceTouchpad; scroll_end.event.resendingPluginId = -1; + scroll_end.event.data.scrollEnd.synthetic = synthetic; + scroll_end.event.data.scrollEnd.inertial = + update_event.data.scrollUpdate.inertial; scroll_end.event.data.scrollEnd.deltaUnits = update_event.data.scrollUpdate.deltaUnits; - scroll_end.event.x = update_event.x; - scroll_end.event.y = update_event.y; - scroll_end.event.globalX = update_event.globalX; - scroll_end.event.globalY = update_event.globalY; - SendGesture(scroll_end); -} + if (!synthetic) { + needs_scroll_begin_ = true; + needs_scroll_end_ = false; -void MouseWheelEventQueue::SendGesture( - const GestureEventWithLatencyInfo& gesture) { - switch (gesture.event.type) { - case WebInputEvent::GestureScrollUpdate: - if (needs_scroll_begin_) { - GestureEventWithLatencyInfo scroll_begin(gesture); - scroll_begin.event.x = gesture.event.x; - scroll_begin.event.y = gesture.event.y; - scroll_begin.event.globalX = gesture.event.globalX; - scroll_begin.event.globalY = gesture.event.globalY; - scroll_begin.event.type = WebInputEvent::GestureScrollBegin; - scroll_begin.event.data.scrollBegin.deltaXHint = - gesture.event.data.scrollUpdate.deltaX; - scroll_begin.event.data.scrollBegin.deltaYHint = - gesture.event.data.scrollUpdate.deltaY; - scroll_begin.event.data.scrollBegin.targetViewport = false; - scroll_begin.event.data.scrollBegin.deltaHintUnits = - gesture.event.data.scrollUpdate.deltaUnits; - - SendGesture(scroll_begin); - } - if (scroll_end_timer_.IsRunning()) { - scroll_end_timer_.Reset(); - } else { - scroll_end_timer_.Start( - FROM_HERE, - base::TimeDelta::FromMilliseconds(scroll_transaction_ms_), - base::Bind(&MouseWheelEventQueue::SendScrollEnd, - base::Unretained(this), gesture.event)); - } - break; - case WebInputEvent::GestureScrollEnd: - needs_scroll_begin_ = true; - break; - case WebInputEvent::GestureScrollBegin: - needs_scroll_begin_ = false; - break; - default: - return; + if (scroll_end_timer_.IsRunning()) + scroll_end_timer_.Reset(); } - client_->SendGestureEvent(gesture); + client_->SendGestureEvent(scroll_end); +} + +void MouseWheelEventQueue::SendScrollBegin( + const GestureEventWithLatencyInfo& gesture_update, + bool synthetic) { + DCHECK((synthetic && !needs_scroll_begin_) || needs_scroll_begin_); + + GestureEventWithLatencyInfo scroll_begin(gesture_update); + scroll_begin.event.type = WebInputEvent::GestureScrollBegin; + scroll_begin.event.data.scrollBegin.synthetic = synthetic; + scroll_begin.event.data.scrollBegin.inertial = + gesture_update.event.data.scrollUpdate.inertial; + scroll_begin.event.data.scrollBegin.deltaXHint = + gesture_update.event.data.scrollUpdate.deltaX; + scroll_begin.event.data.scrollBegin.deltaYHint = + gesture_update.event.data.scrollUpdate.deltaY; + scroll_begin.event.data.scrollBegin.targetViewport = false; + scroll_begin.event.data.scrollBegin.deltaHintUnits = + gesture_update.event.data.scrollUpdate.deltaUnits; + + needs_scroll_begin_ = false; + needs_scroll_end_ = true; + client_->SendGestureEvent(scroll_begin); } } // namespace content diff --git a/content/browser/renderer_host/input/mouse_wheel_event_queue.h b/content/browser/renderer_host/input/mouse_wheel_event_queue.h index b5ad7f2..a224b9e 100644 --- a/content/browser/renderer_host/input/mouse_wheel_event_queue.h +++ b/content/browser/renderer_host/input/mouse_wheel_event_queue.h @@ -17,7 +17,9 @@ namespace content { // The duration in which a ScrollEnd will be sent after the last // ScrollUpdate was sent for wheel based gesture scrolls. -const int64_t kDefaultWheelScrollTransactionMs = 100; +// Set the default wheel transaction to 0ms until +// crbug.com/526463 is fully implemented. +const int64_t kDefaultWheelScrollTransactionMs = 0; // 100; class QueuedWebMouseWheelEvent; @@ -76,16 +78,24 @@ class CONTENT_EXPORT MouseWheelEventQueue { private: void TryForwardNextEventToRenderer(); - void SendScrollEnd(blink::WebGestureEvent update_event); - void SendGesture(const GestureEventWithLatencyInfo& gesture); + void SendScrollEnd(blink::WebGestureEvent update_event, bool synthetic); + void SendScrollBegin(const GestureEventWithLatencyInfo& gesture_update, + bool synthetic); MouseWheelEventQueueClient* client_; - bool needs_scroll_begin_; base::OneShotTimer scroll_end_timer_; typedef std::deque<QueuedWebMouseWheelEvent*> WheelEventQueue; WheelEventQueue wheel_queue_; scoped_ptr<QueuedWebMouseWheelEvent> event_sent_for_gesture_ack_; + + // True if a non-synthetic GSB needs to be sent before a GSU is sent. + bool needs_scroll_begin_; + + // True if a non-synthetic GSE needs to be sent because a non-synthetic + // GSB has been sent in the past. + bool needs_scroll_end_; + bool send_gestures_; int64_t scroll_transaction_ms_; blink::WebGestureDevice scrolling_device_; 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 f9e10a9..f14b6e6 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 @@ -34,6 +34,81 @@ base::TimeDelta DefaultScrollEndTimeoutDelay() { return base::TimeDelta::FromMilliseconds(kScrollEndTimeoutMs); } +#define EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event) \ + EXPECT_EQ(WebInputEvent::GestureScrollBegin, event->type); \ + EXPECT_EQ(kWheelScrollX, event->x); \ + EXPECT_EQ(kWheelScrollY, event->y); \ + EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ + EXPECT_EQ(kWheelScrollGlobalY, event->globalY); \ + EXPECT_EQ(scroll_units, event->data.scrollBegin.deltaHintUnits); + +#define EXPECT_GESTURE_SCROLL_BEGIN(event) \ + EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ + EXPECT_FALSE(event->data.scrollBegin.synthetic); \ + EXPECT_FALSE(event->data.scrollBegin.inertial); + +#define EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(event) \ + EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ + EXPECT_TRUE(event->data.scrollBegin.synthetic); \ + EXPECT_FALSE(event->data.scrollBegin.inertial); + +#define EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(event) \ + EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ + EXPECT_FALSE(event->data.scrollBegin.synthetic); \ + EXPECT_TRUE(event->data.scrollBegin.inertial); + +#define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(event) \ + EXPECT_GESTURE_SCROLL_BEGIN_IMPL(event); \ + EXPECT_TRUE(event->data.scrollBegin.synthetic); \ + EXPECT_TRUE(event->data.scrollBegin.inertial); + +#define EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event) \ + EXPECT_EQ(WebInputEvent::GestureScrollUpdate, event->type); \ + EXPECT_EQ(scroll_units, event->data.scrollUpdate.deltaUnits); \ + EXPECT_EQ(kWheelScrollX, event->x); \ + EXPECT_EQ(kWheelScrollY, event->y); \ + EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ + EXPECT_EQ(kWheelScrollGlobalY, event->globalY); + +#define EXPECT_GESTURE_SCROLL_UPDATE(event) \ + EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event); \ + EXPECT_FALSE(event->data.scrollUpdate.inertial); + +#define EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(event) \ + EXPECT_GESTURE_SCROLL_UPDATE_IMPL(event); \ + EXPECT_TRUE(event->data.scrollUpdate.inertial); + +#define EXPECT_GESTURE_SCROLL_END_IMPL(event) \ + EXPECT_EQ(WebInputEvent::GestureScrollEnd, event->type); \ + EXPECT_EQ(scroll_units, event->data.scrollEnd.deltaUnits); \ + EXPECT_EQ(kWheelScrollX, event->x); \ + EXPECT_EQ(kWheelScrollY, event->y); \ + EXPECT_EQ(kWheelScrollGlobalX, event->globalX); \ + EXPECT_EQ(kWheelScrollGlobalY, event->globalY); + +#define EXPECT_GESTURE_SCROLL_END(event) \ + EXPECT_GESTURE_SCROLL_END_IMPL(event); \ + EXPECT_FALSE(event->data.scrollEnd.synthetic); \ + EXPECT_FALSE(event->data.scrollEnd.inertial); + +#define EXPECT_SYNTHETIC_GESTURE_SCROLL_END(event) \ + EXPECT_GESTURE_SCROLL_END_IMPL(event); \ + EXPECT_TRUE(event->data.scrollEnd.synthetic); \ + EXPECT_FALSE(event->data.scrollEnd.inertial); + +#define EXPECT_INERTIAL_GESTURE_SCROLL_END(event) \ + EXPECT_GESTURE_SCROLL_END_IMPL(event); \ + EXPECT_FALSE(event->data.scrollEnd.synthetic); \ + EXPECT_TRUE(event->data.scrollEnd.inertial); + +#define EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(event) \ + EXPECT_GESTURE_SCROLL_END_IMPL(event); \ + EXPECT_TRUE(event->data.scrollEnd.synthetic); \ + EXPECT_TRUE(event->data.scrollEnd.inertial); + +#define EXPECT_MOUSE_WHEEL(event) \ + EXPECT_EQ(WebInputEvent::MouseWheel, event->type); + } // namespace class MouseWheelEventQueueTest : public testing::Test, @@ -50,12 +125,17 @@ class MouseWheelEventQueueTest : public testing::Test, // MouseWheelEventQueueClient void SendMouseWheelEventImmediately( const MouseWheelEventWithLatencyInfo& event) override { - sent_events_.push_back(event.event); + WebMouseWheelEvent* cloned_event = new WebMouseWheelEvent(); + scoped_ptr<WebInputEvent> cloned_event_holder(cloned_event); + *cloned_event = event.event; + sent_events_.push_back(std::move(cloned_event_holder)); } void SendGestureEvent(const GestureEventWithLatencyInfo& event) override { - sent_events_.push_back(event.event); - sent_gesture_events_.push_back(event.event); + WebGestureEvent* cloned_event = new WebGestureEvent(); + scoped_ptr<WebInputEvent> cloned_event_holder(cloned_event); + *cloned_event = event.event; + sent_events_.push_back(std::move(cloned_event_holder)); } void OnMouseWheelEventAck(const MouseWheelEventWithLatencyInfo& event, @@ -75,10 +155,15 @@ class MouseWheelEventQueueTest : public testing::Test, bool event_in_flight() const { return queue_->event_in_flight(); } - std::vector<WebInputEvent>& all_sent_events() { return sent_events_; } + std::vector<scoped_ptr<WebInputEvent>>& all_sent_events() { + return sent_events_; + } - std::vector<WebGestureEvent>& sent_gesture_events() { - return sent_gesture_events_; + const scoped_ptr<WebInputEvent>& sent_input_event(size_t index) { + return sent_events_[index]; + } + const WebGestureEvent* sent_gesture_event(size_t index) { + return static_cast<WebGestureEvent*>(sent_events_[index].get()); } const WebMouseWheelEvent& acked_event() const { return last_acked_event_; } @@ -86,7 +171,6 @@ class MouseWheelEventQueueTest : public testing::Test, size_t GetAndResetSentEventCount() { size_t count = sent_events_.size(); sent_events_.clear(); - sent_gesture_events_.clear(); return count; } @@ -113,6 +197,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; @@ -137,7 +239,8 @@ class MouseWheelEventQueueTest : public testing::Test, EXPECT_TRUE(event_in_flight()); EXPECT_EQ(1U, GetAndResetSentEventCount()); - // The second mouse wheel should not be sent since one is already in queue. + // The second mouse wheel should not be sent since one is already in + // queue. SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 5, 5, 0, high_precision); EXPECT_EQ(1U, queued_event_count()); @@ -152,36 +255,104 @@ class MouseWheelEventQueueTest : public testing::Test, EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); EXPECT_EQ(1U, GetAndResetAckedEventCount()); EXPECT_EQ(3U, 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(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); - EXPECT_EQ(scroll_units, - sent_gesture_events()[1].data.scrollUpdate.deltaUnits); - 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); - EXPECT_EQ(WebInputEvent::MouseWheel, all_sent_events()[2].type); + EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); + EXPECT_MOUSE_WHEEL(sent_input_event(2)); EXPECT_EQ(3U, GetAndResetSentEventCount()); RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2); EXPECT_EQ(1U, all_sent_events().size()); - EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type); - EXPECT_EQ(scroll_units, sent_gesture_events()[0].data.scrollEnd.deltaUnits); - 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_GESTURE_SCROLL_END(sent_gesture_event(0)); + } + + void PhaseGestureSendingTest(bool high_precision) { + const WebGestureEvent::ScrollUnits scroll_units = + high_precision ? WebGestureEvent::PrecisePixels + : WebGestureEvent::Pixels; + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 1, 1, 0, high_precision, + WebMouseWheelEvent::PhaseBegan, + WebMouseWheelEvent::PhaseNone); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(3U, all_sent_events().size()); + EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); + EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); + EXPECT_EQ(3U, GetAndResetSentEventCount()); + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 5, 5, 0, high_precision, + WebMouseWheelEvent::PhaseChanged, + WebMouseWheelEvent::PhaseNone); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(3U, all_sent_events().size()); + EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); + EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); + EXPECT_EQ(3U, GetAndResetSentEventCount()); + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 0, 0, 0, high_precision, + WebMouseWheelEvent::PhaseEnded, + WebMouseWheelEvent::PhaseNone); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(2U, all_sent_events().size()); + EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_END(sent_gesture_event(1)); + EXPECT_EQ(2U, GetAndResetSentEventCount()); + + // Send a double phase end; OSX does it consistently. + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 0, 0, 0, high_precision, + WebMouseWheelEvent::PhaseEnded, + WebMouseWheelEvent::PhaseNone); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(0U, all_sent_events().size()); + EXPECT_EQ(0U, GetAndResetSentEventCount()); + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 5, 5, 0, high_precision, + WebMouseWheelEvent::PhaseNone, + WebMouseWheelEvent::PhaseBegan); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(3U, all_sent_events().size()); + EXPECT_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); + EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(2)); + EXPECT_EQ(3U, GetAndResetSentEventCount()); + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 5, 5, 0, high_precision, + WebMouseWheelEvent::PhaseNone, + WebMouseWheelEvent::PhaseChanged); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(3U, all_sent_events().size()); + EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); + EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(2)); + EXPECT_EQ(3U, GetAndResetSentEventCount()); + + SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, + kWheelScrollGlobalY, 0, 0, 0, high_precision, + WebMouseWheelEvent::PhaseNone, + WebMouseWheelEvent::PhaseEnded); + EXPECT_EQ(1U, GetAndResetSentEventCount()); + SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + EXPECT_EQ(2U, all_sent_events().size()); + EXPECT_SYNTHETIC_INERTIAL_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_INERTIAL_GESTURE_SCROLL_END(sent_gesture_event(1)); + EXPECT_EQ(2U, GetAndResetSentEventCount()); } scoped_ptr<MouseWheelEventQueue> queue_; - std::vector<WebInputEvent> sent_events_; - std::vector<WebGestureEvent> sent_gesture_events_; + std::vector<scoped_ptr<WebInputEvent>> sent_events_; size_t acked_event_count_; InputEventAckState last_acked_event_state_; base::MessageLoopForUI message_loop_; @@ -230,8 +401,21 @@ TEST_F(MouseWheelEventQueueTest, GestureSendingPrecisePixels) { GestureSendingTest(false); } +TEST_F(MouseWheelEventQueueTest, GestureSendingWithPhaseInformation) { + SetUpForGestureTesting(true); + PhaseGestureSendingTest(false); +} + +TEST_F(MouseWheelEventQueueTest, + GestureSendingWithPhaseInformationPrecisePixels) { + SetUpForGestureTesting(true); + PhaseGestureSendingTest(true); +} + TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) { SetUpForGestureTesting(true); + const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::Pixels; + SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 1, 1, 0, false); EXPECT_EQ(0U, queued_event_count()); @@ -245,14 +429,14 @@ TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) { EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); EXPECT_EQ(1U, GetAndResetAckedEventCount()); EXPECT_EQ(2U, all_sent_events().size()); - EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type); - EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); + EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); EXPECT_EQ(2U, GetAndResetSentEventCount()); // Ensure that a gesture scroll begin terminates the current scroll event. SendGestureEvent(WebInputEvent::GestureScrollBegin); EXPECT_EQ(1U, all_sent_events().size()); - EXPECT_EQ(WebInputEvent::GestureScrollEnd, all_sent_events()[0].type); + EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); EXPECT_EQ(1U, GetAndResetSentEventCount()); SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, @@ -286,8 +470,8 @@ TEST_F(MouseWheelEventQueueTest, GestureSendingInterrupted) { EXPECT_EQ(WebInputEvent::MouseWheel, acked_event().type); EXPECT_EQ(1U, GetAndResetAckedEventCount()); EXPECT_EQ(2U, all_sent_events().size()); - EXPECT_EQ(WebInputEvent::GestureScrollBegin, all_sent_events()[0].type); - EXPECT_EQ(WebInputEvent::GestureScrollUpdate, all_sent_events()[1].type); + EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); + EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); EXPECT_EQ(2U, GetAndResetSentEventCount()); } diff --git a/content/browser/renderer_host/input/non_blocking_event_browsertest.cc b/content/browser/renderer_host/input/non_blocking_event_browsertest.cc index c681914..abed148 100644 --- a/content/browser/renderer_host/input/non_blocking_event_browsertest.cc +++ b/content/browser/renderer_host/input/non_blocking_event_browsertest.cc @@ -113,7 +113,7 @@ class NonBlockingEventBrowserTest : public ContentBrowserTest { EXPECT_EQ(1000, scrollHeight); scoped_refptr<FrameWatcher> frame_watcher(new FrameWatcher()); - GetWidgetHost()->GetProcess()->AddFilter(frame_watcher.get()); + frame_watcher->AttachTo(shell()->web_contents()); scoped_refptr<InputMsgWatcher> input_msg_watcher( new InputMsgWatcher(GetWidgetHost(), blink::WebInputEvent::MouseWheel)); @@ -138,7 +138,7 @@ class NonBlockingEventBrowserTest : public ContentBrowserTest { EXPECT_EQ(1000, scrollHeight); scoped_refptr<FrameWatcher> frame_watcher(new FrameWatcher()); - GetWidgetHost()->GetProcess()->AddFilter(frame_watcher.get()); + frame_watcher->AttachTo(shell()->web_contents()); SyntheticSmoothScrollGestureParams params; params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT; @@ -162,18 +162,12 @@ class NonBlockingEventBrowserTest : public ContentBrowserTest { DISALLOW_COPY_AND_ASSIGN(NonBlockingEventBrowserTest); }; -// Disabled on MacOS because it doesn't support wheel gestures -// just yet. -#if defined(OS_MACOSX) -#define MAYBE_MouseWheel DISABLED_MouseWheel -#else // Also appears to be flaky under TSan. crbug.com/588199 #if defined(THREAD_SANITIZER) #define MAYBE_MouseWheel DISABLED_MouseWheel #else #define MAYBE_MouseWheel MouseWheel #endif -#endif IN_PROC_BROWSER_TEST_F(NonBlockingEventBrowserTest, MAYBE_MouseWheel) { LoadURL(); DoWheelScroll(); diff --git a/content/browser/renderer_host/input/touch_action_browsertest.cc b/content/browser/renderer_host/input/touch_action_browsertest.cc index 72c8bc9..a1a9e83 100644 --- a/content/browser/renderer_host/input/touch_action_browsertest.cc +++ b/content/browser/renderer_host/input/touch_action_browsertest.cc @@ -94,7 +94,7 @@ class TouchActionBrowserTest : public ContentBrowserTest { RenderWidgetHostImpl* host = GetWidgetHost(); scoped_refptr<FrameWatcher> frame_watcher(new FrameWatcher()); - host->GetProcess()->AddFilter(frame_watcher.get()); + frame_watcher->AttachTo(shell()->web_contents()); host->GetView()->SetSize(gfx::Size(400, 400)); base::string16 ready_title(base::ASCIIToUTF16("ready")); diff --git a/content/browser/web_contents/web_contents_view_aura_browsertest.cc b/content/browser/web_contents/web_contents_view_aura_browsertest.cc index 8d08134..b896035 100644 --- a/content/browser/web_contents/web_contents_view_aura_browsertest.cc +++ b/content/browser/web_contents/web_contents_view_aura_browsertest.cc @@ -272,7 +272,7 @@ class WebContentsViewAuraTest : public ContentBrowserTest { controller->SetScreenshotManager(make_scoped_ptr(screenshot_manager_)); frame_watcher_ = new FrameWatcher(); - GetRenderWidgetHost()->GetProcess()->AddFilter(frame_watcher_.get()); + frame_watcher_->AttachTo(shell()->web_contents()); } void SetUpCommandLine(base::CommandLine* cmd) override { |