From 5d8596504544ee64049242d88b15fc3a79295519 Mon Sep 17 00:00:00 2001 From: nzolghadr Date: Mon, 23 Jan 2017 14:59:35 -0800 Subject: [PATCH] Keep track of coalesced events in main thread event queue This CL keeps track of the coaleced events in the main thread event queue and passes them to Blink. So that Blink later exposes them to the js through PointerEvent.getCoalescedEvents API. BUG=680678 Review-Url: https://codereview.chromium.org/2621303004 Cr-Commit-Position: refs/heads/master@{#445528} --- components/plugins/renderer/webview_plugin.cc | 5 +- components/test_runner/event_sender.cc | 7 +- .../test_runner/text_input_controller.cc | 4 +- .../renderer_host/input/input_router_impl.cc | 5 +- .../render_widget_host_unittest.cc | 2 +- .../render_widget_host_view_aura_unittest.cc | 2 +- .../render_widget_host_view_mac_unittest.mm | 3 +- .../common/input/event_with_latency_info.cc | 15 +- .../common/input/event_with_latency_info.h | 3 +- content/common/input_messages.h | 14 +- content/public/test/render_view_test.cc | 14 +- .../gpu/gpu_benchmarking_extension.cc | 3 +- content/renderer/idle_user_detector.cc | 1 + content/renderer/idle_user_detector.h | 10 +- content/renderer/input/input_event_filter.cc | 11 +- content/renderer/input/input_event_filter.h | 2 +- .../input/input_event_filter_unittest.cc | 23 ++- .../renderer/input/main_thread_event_queue.cc | 6 +- .../renderer/input/main_thread_event_queue.h | 2 +- .../input/main_thread_event_queue_unittest.cc | 177 +++++++++++++----- .../input/render_widget_input_handler.cc | 5 +- .../input/render_widget_input_handler.h | 9 +- .../pepper/pepper_plugin_instance_impl.cc | 2 +- content/renderer/render_frame_impl.cc | 3 +- content/renderer/render_view_impl.cc | 1 + content/renderer/render_view_impl.h | 8 +- content/renderer/render_widget.cc | 13 +- content/renderer/render_widget.h | 8 +- .../render_widget_fullscreen_pepper.cc | 6 +- content/renderer/render_widget_unittest.cc | 9 +- .../exported/WebCoalescedInputEvent.cpp | 13 +- .../WebKit/Source/web/ExternalPopupMenu.cpp | 2 +- .../WebKit/Source/web/WebFrameWidgetImpl.cpp | 7 +- .../WebKit/Source/web/WebFrameWidgetImpl.h | 4 +- .../WebKit/Source/web/WebPagePopupImpl.cpp | 4 +- .../WebKit/Source/web/WebPagePopupImpl.h | 2 +- .../WebKit/Source/web/WebViewFrameWidget.cpp | 2 +- .../WebKit/Source/web/WebViewFrameWidget.h | 2 +- third_party/WebKit/Source/web/WebViewImpl.cpp | 7 +- third_party/WebKit/Source/web/WebViewImpl.h | 2 +- .../Source/web/tests/BrowserControlsTest.cpp | 8 +- .../Source/web/tests/ImeOnFocusTest.cpp | 2 +- .../Source/web/tests/LinkSelectionTest.cpp | 12 +- .../Source/web/tests/RootScrollerTest.cpp | 22 +-- .../Source/web/tests/TouchActionTest.cpp | 2 +- .../Source/web/tests/VisualViewportTest.cpp | 12 +- .../WebKit/Source/web/tests/WebFrameTest.cpp | 24 +-- .../web/tests/WebPluginContainerTest.cpp | 10 +- .../WebKit/Source/web/tests/WebViewTest.cpp | 90 ++++----- .../public/platform/WebCoalescedInputEvent.h | 6 +- third_party/WebKit/public/web/WebWidget.h | 4 +- 51 files changed, 371 insertions(+), 239 deletions(-) diff --git a/components/plugins/renderer/webview_plugin.cc b/components/plugins/renderer/webview_plugin.cc index 0141ce4f6a560b..0e57baa5d2b71f 100644 --- a/components/plugins/renderer/webview_plugin.cc +++ b/components/plugins/renderer/webview_plugin.cc @@ -17,7 +17,7 @@ #include "content/public/renderer/render_view.h" #include "gin/converter.h" #include "skia/ext/platform_canvas.h" -#include "third_party/WebKit/public/platform/WebInputEvent.h" +#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" #include "third_party/WebKit/public/platform/WebURL.h" #include "third_party/WebKit/public/platform/WebURLResponse.h" #include "third_party/WebKit/public/web/WebDocument.h" @@ -219,7 +219,8 @@ blink::WebInputEventResult WebViewPlugin::handleInputEvent( return blink::WebInputEventResult::HandledSuppressed; } current_cursor_ = cursor; - blink::WebInputEventResult handled = web_view()->handleInputEvent(event); + blink::WebInputEventResult handled = + web_view()->handleInputEvent(blink::WebCoalescedInputEvent(event)); cursor = current_cursor_; return handled; diff --git a/components/test_runner/event_sender.cc b/components/test_runner/event_sender.cc index 366f20aa2a3a26..7f38826f9b52e9 100644 --- a/components/test_runner/event_sender.cc +++ b/components/test_runner/event_sender.cc @@ -26,8 +26,8 @@ #include "gin/handle.h" #include "gin/object_template_builder.h" #include "gin/wrappable.h" +#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" #include "third_party/WebKit/public/platform/WebGestureEvent.h" -#include "third_party/WebKit/public/platform/WebInputEvent.h" #include "third_party/WebKit/public/platform/WebKeyboardEvent.h" #include "third_party/WebKit/public/platform/WebPointerProperties.h" #include "third_party/WebKit/public/platform/WebString.h" @@ -2808,7 +2808,8 @@ WebInputEventResult EventSender::HandleInputEventOnViewOrPopup( raw_event, delegate()->GetWindowToViewportScale()); const WebInputEvent* popup_friendly_event = scaled_event.get() ? scaled_event.get() : &raw_event; - return popup->handleInputEvent(*popup_friendly_event); + return popup->handleInputEvent( + blink::WebCoalescedInputEvent(*popup_friendly_event)); } std::unique_ptr widget_event = @@ -2816,7 +2817,7 @@ WebInputEventResult EventSender::HandleInputEventOnViewOrPopup( const WebInputEvent* event = widget_event.get() ? static_cast(widget_event.get()) : &raw_event; - return widget()->handleInputEvent(*event); + return widget()->handleInputEvent(blink::WebCoalescedInputEvent(*event)); } void EventSender::SendGesturesForMouseWheelEvent( diff --git a/components/test_runner/text_input_controller.cc b/components/test_runner/text_input_controller.cc index 3232d73813265a..9b5c9828cebc4e 100644 --- a/components/test_runner/text_input_controller.cc +++ b/components/test_runner/text_input_controller.cc @@ -11,7 +11,7 @@ #include "gin/handle.h" #include "gin/object_template_builder.h" #include "gin/wrappable.h" -#include "third_party/WebKit/public/platform/WebInputEvent.h" +#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" #include "third_party/WebKit/public/platform/WebInputEventResult.h" #include "third_party/WebKit/public/platform/WebKeyboardEvent.h" #include "third_party/WebKit/public/web/WebCompositionUnderline.h" @@ -301,7 +301,7 @@ void TextInputController::SetComposition(const std::string& text) { ui::EventTimeStampToSeconds(ui::EventTimeForNow())); key_down.windowsKeyCode = 0xE5; // VKEY_PROCESSKEY - view()->handleInputEvent(key_down); + view()->handleInputEvent(blink::WebCoalescedInputEvent(key_down)); // The value returned by std::string::length() may not correspond to the // actual number of encoded characters in sequences of multi-byte or diff --git a/content/browser/renderer_host/input/input_router_impl.cc b/content/browser/renderer_host/input/input_router_impl.cc index d442aee99494f3..a823b63903e3cf 100644 --- a/content/browser/renderer_host/input/input_router_impl.cc +++ b/content/browser/renderer_host/input/input_router_impl.cc @@ -428,8 +428,9 @@ bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event, const WebInputEvent* event_to_send = event_in_viewport ? event_in_viewport.get() : &input_event; - if (Send(new InputMsg_HandleInputEvent(routing_id(), event_to_send, - latency_info, dispatch_type))) { + if (Send(new InputMsg_HandleInputEvent( + routing_id(), event_to_send, std::vector(), + latency_info, dispatch_type))) { // Ack messages for ignored ack event types should never be sent by the // renderer. Consequently, such event types should not affect event time // or in-flight event count metrics. diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc index e0de9d3e66d505..bfe79f742fb26b 100644 --- a/content/browser/renderer_host/render_widget_host_unittest.cc +++ b/content/browser/renderer_host/render_widget_host_unittest.cc @@ -1574,7 +1574,7 @@ void CheckLatencyInfoComponentInMessage(RenderWidgetHostProcess* process, EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - ui::LatencyInfo latency_info = std::get<1>(params); + ui::LatencyInfo latency_info = std::get<2>(params); EXPECT_TRUE(event->type() == expected_type); EXPECT_TRUE(latency_info.FindLatency( diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc index 7652b2e168ea8c..29a8e8cb9b8230 100644 --- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc +++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc @@ -674,7 +674,7 @@ class RenderWidgetHostViewAuraTest : public testing::Test { return; } - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING) return; diff --git a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm index 1bb60b7c53be4b..8761ed4da7d444 100644 --- a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm +++ b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm @@ -1174,7 +1174,8 @@ bool ZoomDisabledForPinchUpdateMessage() { break; } DCHECK(message); - std::tuple, ui::LatencyInfo, InputEventDispatchType> data; InputMsg_HandleInputEvent::Read(message, &data); diff --git a/content/common/input/event_with_latency_info.cc b/content/common/input/event_with_latency_info.cc index 79084e5aa128bc..d4ea6731bc9e04 100644 --- a/content/common/input/event_with_latency_info.cc +++ b/content/common/input/event_with_latency_info.cc @@ -11,7 +11,8 @@ namespace content { ScopedWebInputEventWithLatencyInfo::ScopedWebInputEventWithLatencyInfo( blink::WebScopedInputEvent event, const ui::LatencyInfo& latency_info) - : event_(std::move(event)), latency_(latency_info) {} + : event_(new blink::WebCoalescedInputEvent(std::move(event))), + latency_(latency_info) {} ScopedWebInputEventWithLatencyInfo::~ScopedWebInputEventWithLatencyInfo() {} @@ -29,8 +30,9 @@ void ScopedWebInputEventWithLatencyInfo::CoalesceWith( // New events get coalesced into older events, and the newer timestamp // should always be preserved. const double time_stamp_seconds = other.event().timeStampSeconds(); - ui::Coalesce(other.event(), event_.get()); - event_->setTimeStampSeconds(time_stamp_seconds); + ui::Coalesce(other.event(), event_->eventPointer()); + event_->eventPointer()->setTimeStampSeconds(time_stamp_seconds); + event_->addCoalescedEvent(other.event()); // When coalescing two input events, we keep the oldest LatencyInfo // since it will represent the longest latency. @@ -39,10 +41,15 @@ void ScopedWebInputEventWithLatencyInfo::CoalesceWith( } const blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() const { - return *event_; + return event_->event(); } blink::WebInputEvent& ScopedWebInputEventWithLatencyInfo::event() { + return *event_->eventPointer(); +} + +const blink::WebCoalescedInputEvent& +ScopedWebInputEventWithLatencyInfo::coalesced_event() const { return *event_; } diff --git a/content/common/input/event_with_latency_info.h b/content/common/input/event_with_latency_info.h index 4af4aec5334554..c8814063829b9a 100644 --- a/content/common/input/event_with_latency_info.h +++ b/content/common/input/event_with_latency_info.h @@ -28,13 +28,14 @@ class ScopedWebInputEventWithLatencyInfo { WARN_UNUSED_RESULT; const blink::WebInputEvent& event() const; + const blink::WebCoalescedInputEvent& coalesced_event() const; blink::WebInputEvent& event(); const ui::LatencyInfo latencyInfo() const { return latency_; } void CoalesceWith(const ScopedWebInputEventWithLatencyInfo& other); private: - blink::WebScopedInputEvent event_; + blink::WebScopedCoalescedInputEvent event_; mutable ui::LatencyInfo latency_; }; diff --git a/content/common/input_messages.h b/content/common/input_messages.h index 5a003383667dcc..7221f95d3d31c1 100644 --- a/content/common/input_messages.h +++ b/content/common/input_messages.h @@ -135,11 +135,15 @@ IPC_STRUCT_TRAITS_BEGIN(content::InputEventAck) IPC_STRUCT_TRAITS_MEMBER(unique_touch_event_id) IPC_STRUCT_TRAITS_END() -// Sends an input event to the render widget. -IPC_MESSAGE_ROUTED3(InputMsg_HandleInputEvent, - IPC::WebInputEventPointer /* event */, - ui::LatencyInfo /* latency_info */, - content::InputEventDispatchType) +// Sends an input event to the render widget. The input event in general +// contains a list of coalesced events and one event that is representative of +// all those events (https://w3c.github.io/pointerevents/extension.html). +IPC_MESSAGE_ROUTED4( + InputMsg_HandleInputEvent, + IPC::WebInputEventPointer /* event */, + std::vector /* coalesced events */, + ui::LatencyInfo /* latency_info */, + content::InputEventDispatchType) // Sends the cursor visibility state to the render widget. IPC_MESSAGE_ROUTED1(InputMsg_CursorVisibilityChange, diff --git a/content/public/test/render_view_test.cc b/content/public/test/render_view_test.cc index 0eefe39f067a25..d36497a87af56f 100644 --- a/content/public/test/render_view_test.cc +++ b/content/public/test/render_view_test.cc @@ -385,7 +385,7 @@ void RenderViewTest::SendWebKeyboardEvent( const blink::WebKeyboardEvent& key_event) { RenderViewImpl* impl = static_cast(view_); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &key_event, ui::LatencyInfo(), + 0, &key_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); } @@ -393,7 +393,7 @@ void RenderViewTest::SendWebMouseEvent( const blink::WebMouseEvent& mouse_event) { RenderViewImpl* impl = static_cast(view_); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &mouse_event, ui::LatencyInfo(), + 0, &mouse_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); } @@ -462,11 +462,11 @@ void RenderViewTest::SimulatePointClick(const gfx::Point& point) { mouse_event.clickCount = 1; RenderViewImpl* impl = static_cast(view_); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &mouse_event, ui::LatencyInfo(), + 0, &mouse_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); mouse_event.setType(WebInputEvent::MouseUp); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &mouse_event, ui::LatencyInfo(), + 0, &mouse_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); } @@ -489,11 +489,11 @@ void RenderViewTest::SimulatePointRightClick(const gfx::Point& point) { mouse_event.clickCount = 1; RenderViewImpl* impl = static_cast(view_); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &mouse_event, ui::LatencyInfo(), + 0, &mouse_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); mouse_event.setType(WebInputEvent::MouseUp); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &mouse_event, ui::LatencyInfo(), + 0, &mouse_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); } @@ -509,7 +509,7 @@ void RenderViewTest::SimulateRectTap(const gfx::Rect& rect) { gesture_event.sourceDevice = blink::WebGestureDeviceTouchpad; RenderViewImpl* impl = static_cast(view_); impl->OnMessageReceived(InputMsg_HandleInputEvent( - 0, &gesture_event, ui::LatencyInfo(), + 0, &gesture_event, std::vector(), ui::LatencyInfo(), InputEventDispatchType::DISPATCH_TYPE_BLOCKING)); impl->FocusChangeComplete(); } diff --git a/content/renderer/gpu/gpu_benchmarking_extension.cc b/content/renderer/gpu/gpu_benchmarking_extension.cc index 196746a154b6a7..e9034af09313ea 100644 --- a/content/renderer/gpu/gpu_benchmarking_extension.cc +++ b/content/renderer/gpu/gpu_benchmarking_extension.cc @@ -354,7 +354,8 @@ bool BeginSmoothScroll(v8::Isolate* isolate, ui::EventTimeStampToSeconds(ui::EventTimeForNow())); mouseMove.x = (contentRect.x + contentRect.width / 2) * page_scale_factor; mouseMove.y = (contentRect.y + contentRect.height / 2) * page_scale_factor; - context.web_view()->handleInputEvent(mouseMove); + context.web_view()->handleInputEvent( + blink::WebCoalescedInputEvent(mouseMove)); context.web_view()->setCursorVisibilityState(true); } diff --git a/content/renderer/idle_user_detector.cc b/content/renderer/idle_user_detector.cc index a2f2fd0d2b86b6..43979cfb722ebb 100644 --- a/content/renderer/idle_user_detector.cc +++ b/content/renderer/idle_user_detector.cc @@ -27,6 +27,7 @@ bool IdleUserDetector::OnMessageReceived(const IPC::Message& message) { void IdleUserDetector::OnHandleInputEvent( const blink::WebInputEvent* event, + const std::vector& coalesced_events, const ui::LatencyInfo& latency_info, InputEventDispatchType dispatch_type) { if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) { diff --git a/content/renderer/idle_user_detector.h b/content/renderer/idle_user_detector.h index 8d55af7ddc661a..0fd24ede6f37d0 100644 --- a/content/renderer/idle_user_detector.h +++ b/content/renderer/idle_user_detector.h @@ -9,6 +9,8 @@ #include "content/common/input/input_event_dispatch_type.h" #include "content/public/renderer/render_view_observer.h" +#include + namespace blink { class WebInputEvent; } @@ -31,9 +33,11 @@ class IdleUserDetector : public RenderViewObserver { bool OnMessageReceived(const IPC::Message& message) override; void OnDestruct() override; - void OnHandleInputEvent(const blink::WebInputEvent* event, - const ui::LatencyInfo& latency_info, - InputEventDispatchType dispatch_type); + void OnHandleInputEvent( + const blink::WebInputEvent* event, + const std::vector& coalesced_events, + const ui::LatencyInfo& latency_info, + InputEventDispatchType dispatch_type); DISALLOW_COPY_AND_ASSIGN(IdleUserDetector); }; diff --git a/content/renderer/input/input_event_filter.cc b/content/renderer/input/input_event_filter.cc index 160e083394edd8..af4cb4b5de8775 100644 --- a/content/renderer/input/input_event_filter.cc +++ b/content/renderer/input/input_event_filter.cc @@ -212,8 +212,8 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message, return; blink::WebScopedInputEvent event = ui::WebInputEventTraits::Clone(*std::get<0>(params)); - ui::LatencyInfo latency_info = std::get<1>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + ui::LatencyInfo latency_info = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); DCHECK(event); DCHECK(dispatch_type == DISPATCH_TYPE_BLOCKING || @@ -287,13 +287,14 @@ void InputEventFilter::SendMessageOnIOThread( void InputEventFilter::HandleEventOnMainThread( int routing_id, - const blink::WebInputEvent* event, + const blink::WebCoalescedInputEvent* event, const ui::LatencyInfo& latency_info, InputEventDispatchType dispatch_type) { TRACE_EVENT_INSTANT0("input", "InputEventFilter::HandlEventOnMainThread", TRACE_EVENT_SCOPE_THREAD); - IPC::Message new_msg = - InputMsg_HandleInputEvent(routing_id, event, latency_info, dispatch_type); + IPC::Message new_msg = InputMsg_HandleInputEvent( + routing_id, &event->event(), event->getCoalescedEventsPointers(), + latency_info, dispatch_type); main_listener_.Run(new_msg); } diff --git a/content/renderer/input/input_event_filter.h b/content/renderer/input/input_event_filter.h index 82532fbed69d1c..3fd3442e939e6d 100644 --- a/content/renderer/input/input_event_filter.h +++ b/content/renderer/input/input_event_filter.h @@ -84,7 +84,7 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient, // MainThreadEventQueueClient methods: void HandleEventOnMainThread(int routing_id, - const blink::WebInputEvent* event, + const blink::WebCoalescedInputEvent* event, const ui::LatencyInfo& latency, InputEventDispatchType dispatch_type) override; // Send an InputEventAck IPC message. |touch_event_id| represents diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc index 286e6bb5892e2c..3a8b8ce8826553 100644 --- a/content/renderer/input/input_event_filter_unittest.cc +++ b/content/renderer/input/input_event_filter_unittest.cc @@ -135,7 +135,8 @@ void AddEventsToFilter(IPC::MessageFilter* message_filter, std::vector messages; for (size_t i = 0; i < count; ++i) { messages.push_back(InputMsg_HandleInputEvent( - kTestRoutingID, &events[i], ui::LatencyInfo(), + kTestRoutingID, &events[i], std::vector(), + ui::LatencyInfo(), ui::WebInputEventTraits::ShouldBlockEventStream(events[i]) ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); @@ -271,7 +272,8 @@ TEST_F(InputEventFilterTest, PreserveRelativeOrder) { std::vector messages; messages.push_back(InputMsg_HandleInputEvent( - kTestRoutingID, &mouse_down, ui::LatencyInfo(), + kTestRoutingID, &mouse_down, std::vector(), + ui::LatencyInfo(), ui::WebInputEventTraits::ShouldBlockEventStream(mouse_down) ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); @@ -301,7 +303,8 @@ TEST_F(InputEventFilterTest, PreserveRelativeOrder) { messages.push_back(InputMsg_MoveCaret(kTestRoutingID, gfx::Point())); messages.push_back(InputMsg_HandleInputEvent( - kTestRoutingID, &mouse_up, ui::LatencyInfo(), + kTestRoutingID, &mouse_up, std::vector(), + ui::LatencyInfo(), ui::WebInputEventTraits::ShouldBlockEventStream(mouse_up) ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); @@ -342,7 +345,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kEvents[i].size(), event->size()); kEvents[i].dispatchType = @@ -361,7 +364,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) { EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebMouseWheelEvent* event = static_cast(std::get<0>(params)); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); kEvents[2].dispatchType = WebInputEvent::DispatchType::ListenersNonBlockingPassive; @@ -403,7 +406,7 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kEvents[i].size(), event->size()); kEvents[i].dispatchType = @@ -422,7 +425,7 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) { EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebTouchEvent* event = static_cast(std::get<0>(params)); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kEvents[3].size(), event->size()); EXPECT_EQ(1u, kEvents[3].touchesLength); @@ -460,7 +463,7 @@ TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kEvents[0].size(), event->size()); kEvents[0].dispatchType = @@ -476,7 +479,7 @@ TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kEvents[1].size(), event->size()); kEvents[1].dispatchType = @@ -492,7 +495,7 @@ TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); const WebInputEvent* event = std::get<0>(params); - InputEventDispatchType dispatch_type = std::get<2>(params); + InputEventDispatchType dispatch_type = std::get<3>(params); EXPECT_EQ(kBlockingEvents[0].size(), event->size()); EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size()) == 0); diff --git a/content/renderer/input/main_thread_event_queue.cc b/content/renderer/input/main_thread_event_queue.cc index 120206aaa8e492..aad6fb544a3713 100644 --- a/content/renderer/input/main_thread_event_queue.cc +++ b/content/renderer/input/main_thread_event_queue.cc @@ -193,9 +193,9 @@ void MainThreadEventQueue::DispatchInFlightEvent() { NOTREACHED(); } } - client_->HandleEventOnMainThread(routing_id_, &in_flight_event_->event(), - in_flight_event_->latencyInfo(), - dispatch_type); + client_->HandleEventOnMainThread( + routing_id_, &in_flight_event_->coalesced_event(), + in_flight_event_->latencyInfo(), dispatch_type); } in_flight_event_.reset(); diff --git a/content/renderer/input/main_thread_event_queue.h b/content/renderer/input/main_thread_event_queue.h index 8762fa5c2cb0fa..96d07600b86e91 100644 --- a/content/renderer/input/main_thread_event_queue.h +++ b/content/renderer/input/main_thread_event_queue.h @@ -62,7 +62,7 @@ class CONTENT_EXPORT MainThreadEventQueueClient { // channel. Implementors must implement this callback. virtual void HandleEventOnMainThread( int routing_id, - const blink::WebInputEvent* event, + const blink::WebCoalescedInputEvent* event, const ui::LatencyInfo& latency, InputEventDispatchType dispatch_type) = 0; diff --git a/content/renderer/input/main_thread_event_queue_unittest.cc b/content/renderer/input/main_thread_event_queue_unittest.cc index 3eec236e186e59..dda0969c4a3683 100644 --- a/content/renderer/input/main_thread_event_queue_unittest.cc +++ b/content/renderer/input/main_thread_event_queue_unittest.cc @@ -70,12 +70,15 @@ class MainThreadEventQueueTest : public testing::TestWithParam, } void HandleEventOnMainThread(int routing_id, - const blink::WebInputEvent* event, + const blink::WebCoalescedInputEvent* event, const ui::LatencyInfo& latency, InputEventDispatchType type) override { EXPECT_EQ(kTestRoutingID, routing_id); - handled_events_.push_back(ui::WebInputEventTraits::Clone(*event)); - queue_->EventHandled(event->type(), INPUT_EVENT_ACK_STATE_NOT_CONSUMED); + handled_events_.push_back(blink::WebCoalescedInputEvent( + event->event(), event->getCoalescedEventsPointers())); + + queue_->EventHandled(event->event().type(), + INPUT_EVENT_ACK_STATE_NOT_CONSUMED); } void SendInputEventAck(int routing_id, @@ -125,7 +128,8 @@ class MainThreadEventQueueTest : public testing::TestWithParam, scoped_refptr main_task_runner_; blink::scheduler::MockRendererScheduler renderer_scheduler_; scoped_refptr queue_; - std::vector handled_events_; + std::vector handled_events_; + std::vector additional_acked_events_; int raf_aligned_input_setting_; bool needs_main_frame_; @@ -154,12 +158,16 @@ TEST_P(MainThreadEventQueueTest, NonBlockingWheel) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(2u, handled_events_.size()); + for (const auto& coalesced_event : handled_events_) { + EXPECT_EQ(2u, coalesced_event.coalescedEventSize()); + } { - EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size()); - EXPECT_EQ(kEvents[0].type(), handled_events_.at(0)->type()); + EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size()); + EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type()); const WebMouseWheelEvent* last_wheel_event = - static_cast(handled_events_.at(0).get()); + static_cast( + handled_events_.at(0).eventPointer()); EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, last_wheel_event->dispatchType); WebMouseWheelEvent coalesced_event = kEvents[0]; @@ -169,15 +177,53 @@ TEST_P(MainThreadEventQueueTest, NonBlockingWheel) { EXPECT_EQ(coalesced_event, *last_wheel_event); } + { + WebMouseWheelEvent coalesced_event = kEvents[0]; + std::vector coalesced_events = + handled_events_[0].getCoalescedEventsPointers(); + const WebMouseWheelEvent* coalesced_wheel_event0 = + static_cast(coalesced_events[0]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); + + coalesced_event = kEvents[1]; + const WebMouseWheelEvent* coalesced_wheel_event1 = + static_cast(coalesced_events[1]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_wheel_event1); + } + { const WebMouseWheelEvent* last_wheel_event = - static_cast(handled_events_.at(1).get()); + static_cast( + handled_events_.at(1).eventPointer()); WebMouseWheelEvent coalesced_event = kEvents[2]; ui::Coalesce(kEvents[3], &coalesced_event); coalesced_event.dispatchType = WebInputEvent::DispatchType::ListenersNonBlockingPassive; EXPECT_EQ(coalesced_event, *last_wheel_event); } + + { + WebMouseWheelEvent coalesced_event = kEvents[2]; + std::vector coalesced_events = + handled_events_[1].getCoalescedEventsPointers(); + const WebMouseWheelEvent* coalesced_wheel_event0 = + static_cast(coalesced_events[0]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); + + coalesced_event = kEvents[3]; + const WebMouseWheelEvent* coalesced_wheel_event1 = + static_cast(coalesced_events[1]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_wheel_event1); + } + histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 1, 2); } @@ -204,31 +250,67 @@ TEST_P(MainThreadEventQueueTest, NonBlockingTouch) { EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(3u, handled_events_.size()); - EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size()); - EXPECT_EQ(kEvents[0].type(), handled_events_.at(0)->type()); + EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size()); + EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type()); const WebTouchEvent* last_touch_event = - static_cast(handled_events_.at(0).get()); + static_cast(handled_events_.at(0).eventPointer()); kEvents[0].dispatchType = WebInputEvent::DispatchType::ListenersNonBlockingPassive; EXPECT_EQ(kEvents[0], *last_touch_event); - EXPECT_EQ(kEvents[1].size(), handled_events_.at(1)->size()); - EXPECT_EQ(kEvents[1].type(), handled_events_.at(1)->type()); + { + EXPECT_EQ(1u, handled_events_[0].coalescedEventSize()); + const WebTouchEvent* coalesced_touch_event = + static_cast( + handled_events_[0].getCoalescedEventsPointers()[0]); + EXPECT_EQ(kEvents[0], *coalesced_touch_event); + } + + EXPECT_EQ(kEvents[1].size(), handled_events_.at(1).event().size()); + EXPECT_EQ(kEvents[1].type(), handled_events_.at(1).event().type()); last_touch_event = - static_cast(handled_events_.at(1).get()); + static_cast(handled_events_.at(1).eventPointer()); kEvents[1].dispatchType = WebInputEvent::DispatchType::ListenersNonBlockingPassive; EXPECT_EQ(kEvents[1], *last_touch_event); - EXPECT_EQ(kEvents[2].size(), handled_events_.at(1)->size()); - EXPECT_EQ(kEvents[2].type(), handled_events_.at(2)->type()); + { + EXPECT_EQ(1u, handled_events_[1].coalescedEventSize()); + const WebTouchEvent* coalesced_touch_event = + static_cast( + handled_events_[1].getCoalescedEventsPointers()[0]); + EXPECT_EQ(kEvents[1], *coalesced_touch_event); + } + + EXPECT_EQ(kEvents[2].size(), handled_events_.at(1).event().size()); + EXPECT_EQ(kEvents[2].type(), handled_events_.at(2).event().type()); last_touch_event = - static_cast(handled_events_.at(2).get()); + static_cast(handled_events_.at(2).eventPointer()); WebTouchEvent coalesced_event = kEvents[2]; ui::Coalesce(kEvents[3], &coalesced_event); coalesced_event.dispatchType = WebInputEvent::DispatchType::ListenersNonBlockingPassive; EXPECT_EQ(coalesced_event, *last_touch_event); + + { + EXPECT_EQ(2u, handled_events_[2].coalescedEventSize()); + WebTouchEvent coalesced_event = kEvents[2]; + std::vector coalesced_events = + handled_events_[2].getCoalescedEventsPointers(); + const WebTouchEvent* coalesced_touch_event0 = + static_cast(coalesced_events[0]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_touch_event0); + + coalesced_event = kEvents[3]; + const WebTouchEvent* coalesced_touch_event1 = + static_cast(coalesced_events[1]); + coalesced_event.dispatchType = + WebInputEvent::DispatchType::ListenersNonBlockingPassive; + EXPECT_EQ(coalesced_event, *coalesced_touch_event1); + } + histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 0, 1); histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 1); } @@ -297,10 +379,11 @@ TEST_P(MainThreadEventQueueTest, InterleavedEvents) { EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(2u, handled_events_.size()); { - EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0)->size()); - EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0)->type()); + EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0).event().size()); + EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0).event().type()); const WebMouseWheelEvent* last_wheel_event = - static_cast(handled_events_.at(0).get()); + static_cast( + handled_events_.at(0).eventPointer()); EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, last_wheel_event->dispatchType); WebMouseWheelEvent coalesced_event = kWheelEvents[0]; @@ -310,10 +393,10 @@ TEST_P(MainThreadEventQueueTest, InterleavedEvents) { EXPECT_EQ(coalesced_event, *last_wheel_event); } { - EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1)->size()); - EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1)->type()); + EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1).event().size()); + EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1).event().type()); const WebTouchEvent* last_touch_event = - static_cast(handled_events_.at(1).get()); + static_cast(handled_events_.at(1).eventPointer()); WebTouchEvent coalesced_event = kTouchEvents[0]; ui::Coalesce(kTouchEvents[1], &coalesced_event); coalesced_event.dispatchType = @@ -503,11 +586,11 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesDuringFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(1u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(0)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(0)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type()); EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); const WebTouchEvent* last_touch_event = - static_cast(handled_events_.at(0).get()); + static_cast(handled_events_.at(0).eventPointer()); kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; EXPECT_EQ(kEvents, *last_touch_event); @@ -520,11 +603,11 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesDuringFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(2u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(1)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(1)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type()); EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); last_touch_event = - static_cast(handled_events_.at(1).get()); + static_cast(handled_events_.at(1).eventPointer()); kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; EXPECT_EQ(kEvents, *last_touch_event); @@ -535,11 +618,11 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesDuringFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(3u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(2)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(2)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); last_touch_event = - static_cast(handled_events_.at(2).get()); + static_cast(handled_events_.at(2).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); kEvents.ReleasePoint(0); @@ -548,11 +631,11 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesDuringFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(4u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(3)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(3)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); last_touch_event = - static_cast(handled_events_.at(3).get()); + static_cast(handled_events_.at(3).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); } @@ -567,12 +650,12 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(1u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(0)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(0)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); const WebTouchEvent* last_touch_event = - static_cast(handled_events_.at(0).get()); + static_cast(handled_events_.at(0).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); set_enable_fling_passive_listener_flag(false); @@ -581,12 +664,12 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(2u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(1)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(1)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); last_touch_event = - static_cast(handled_events_.at(1).get()); + static_cast(handled_events_.at(1).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); set_enable_fling_passive_listener_flag(true); @@ -595,12 +678,12 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(3u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(2)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(2)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); last_touch_event = - static_cast(handled_events_.at(2).get()); + static_cast(handled_events_.at(2).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); kEvents.MovePoint(0, 30, 30); @@ -609,12 +692,12 @@ TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { EXPECT_FALSE(main_task_runner_->HasPendingTask()); EXPECT_EQ(0u, event_queue().size()); EXPECT_EQ(4u, handled_events_.size()); - EXPECT_EQ(kEvents.size(), handled_events_.at(3)->size()); - EXPECT_EQ(kEvents.type(), handled_events_.at(3)->type()); + EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size()); + EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type()); EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); last_touch_event = - static_cast(handled_events_.at(3).get()); + static_cast(handled_events_.at(3).eventPointer()); EXPECT_EQ(kEvents, *last_touch_event); } diff --git a/content/renderer/input/render_widget_input_handler.cc b/content/renderer/input/render_widget_input_handler.cc index a373d07351df05..f6f161d0cfb6b3 100644 --- a/content/renderer/input/render_widget_input_handler.cc +++ b/content/renderer/input/render_widget_input_handler.cc @@ -207,9 +207,10 @@ RenderWidgetInputHandler::RenderWidgetInputHandler( RenderWidgetInputHandler::~RenderWidgetInputHandler() {} void RenderWidgetInputHandler::HandleInputEvent( - const WebInputEvent& input_event, + const blink::WebCoalescedInputEvent& coalesced_event, const ui::LatencyInfo& latency_info, InputEventDispatchType dispatch_type) { + const WebInputEvent& input_event = coalesced_event.event(); base::AutoReset handling_input_event_resetter(&handling_input_event_, true); base::AutoReset handling_event_type_resetter( @@ -308,7 +309,7 @@ void RenderWidgetInputHandler::HandleInputEvent( !suppress_next_char_events_) { suppress_next_char_events_ = false; if (processed == WebInputEventResult::NotHandled && widget_->GetWebWidget()) - processed = widget_->GetWebWidget()->handleInputEvent(input_event); + processed = widget_->GetWebWidget()->handleInputEvent(coalesced_event); } // TODO(dtapuska): Use the input_event.timeStampSeconds as the start diff --git a/content/renderer/input/render_widget_input_handler.h b/content/renderer/input/render_widget_input_handler.h index 43b494fd794ba7..04256edec6d313 100644 --- a/content/renderer/input/render_widget_input_handler.h +++ b/content/renderer/input/render_widget_input_handler.h @@ -11,7 +11,7 @@ #include "base/time/time.h" #include "content/common/input/input_event_ack.h" #include "content/common/input/input_event_dispatch_type.h" -#include "third_party/WebKit/public/platform/WebInputEvent.h" +#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" #include "ui/base/ui_base_types.h" #include "ui/events/blink/did_overscroll_params.h" @@ -38,9 +38,10 @@ class CONTENT_EXPORT RenderWidgetInputHandler { virtual ~RenderWidgetInputHandler(); // Handle input events from the input event provider. - virtual void HandleInputEvent(const blink::WebInputEvent& input_event, - const ui::LatencyInfo& latency_info, - InputEventDispatchType dispatch_type); + virtual void HandleInputEvent( + const blink::WebCoalescedInputEvent& coalesced_event, + const ui::LatencyInfo& latency_info, + InputEventDispatchType dispatch_type); // Handle overscroll from Blink. void DidOverscrollFromBlink( diff --git a/content/renderer/pepper/pepper_plugin_instance_impl.cc b/content/renderer/pepper/pepper_plugin_instance_impl.cc index 2e19b69a9fc893..520892b27fc2ee 100644 --- a/content/renderer/pepper/pepper_plugin_instance_impl.cc +++ b/content/renderer/pepper/pepper_plugin_instance_impl.cc @@ -2242,7 +2242,7 @@ void PepperPluginInstanceImpl::SimulateInputEvent( for (std::vector>::iterator it = events.begin(); it != events.end(); ++it) { - widget->handleInputEvent(*it->get()); + widget->handleInputEvent(blink::WebCoalescedInputEvent(*it->get())); } } diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc index 4f317a3a8133fd..f1458b0d654360 100644 --- a/content/renderer/render_frame_impl.cc +++ b/content/renderer/render_frame_impl.cc @@ -6644,7 +6644,8 @@ void RenderFrameImpl::HandlePepperImeCommit(const base::string16& text) { } if (GetRenderWidget()->GetWebWidget()) - GetRenderWidget()->GetWebWidget()->handleInputEvent(char_event); + GetRenderWidget()->GetWebWidget()->handleInputEvent( + blink::WebCoalescedInputEvent(char_event)); } } else { // Mimics the order of events sent by WebKit. diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc index cc597bd1005feb..1dd307da1b3254 100644 --- a/content/renderer/render_view_impl.cc +++ b/content/renderer/render_view_impl.cc @@ -2715,6 +2715,7 @@ void RenderViewImpl::UpdateWebViewWithDeviceScaleFactor() { void RenderViewImpl::OnDiscardInputEvent( const blink::WebInputEvent* input_event, + const std::vector& coalesced_events, const ui::LatencyInfo& latency_info, InputEventDispatchType dispatch_type) { if (!input_event || (dispatch_type != DISPATCH_TYPE_BLOCKING && diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h index e379b7e4ff1c05..aac43770f7cc3d 100644 --- a/content/renderer/render_view_impl.h +++ b/content/renderer/render_view_impl.h @@ -642,9 +642,11 @@ class CONTENT_EXPORT RenderViewImpl void UpdateWebViewWithDeviceScaleFactor(); // Send the appropriate ack to be able discard this input event message. - void OnDiscardInputEvent(const blink::WebInputEvent* input_event, - const ui::LatencyInfo& latency_info, - InputEventDispatchType dispatch_type); + void OnDiscardInputEvent( + const blink::WebInputEvent* input_event, + const std::vector& coalesced_events, + const ui::LatencyInfo& latency_info, + InputEventDispatchType dispatch_type); // --------------------------------------------------------------------------- // ADDING NEW FUNCTIONS? Please keep private functions alphabetized and put diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc index 2e60181441cc17..9ceb7970c31e94 100644 --- a/content/renderer/render_widget.cc +++ b/content/renderer/render_widget.cc @@ -782,12 +782,17 @@ GURL RenderWidget::GetURLForGraphicsContext3D() { return GURL(); } -void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event, - const ui::LatencyInfo& latency_info, - InputEventDispatchType dispatch_type) { +void RenderWidget::OnHandleInputEvent( + const blink::WebInputEvent* input_event, + const std::vector& coalesced_events, + const ui::LatencyInfo& latency_info, + InputEventDispatchType dispatch_type) { if (!input_event) return; - input_handler_->HandleInputEvent(*input_event, latency_info, dispatch_type); + + input_handler_->HandleInputEvent( + blink::WebCoalescedInputEvent(*input_event, coalesced_events), + latency_info, dispatch_type); } void RenderWidget::OnCursorVisibilityChange(bool is_visible) { diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h index cac9876645ddff..f85af22c6efbe3 100644 --- a/content/renderer/render_widget.h +++ b/content/renderer/render_widget.h @@ -474,9 +474,11 @@ class CONTENT_EXPORT RenderWidget #endif // RenderWidget IPC message handlers - void OnHandleInputEvent(const blink::WebInputEvent* event, - const ui::LatencyInfo& latency_info, - InputEventDispatchType dispatch_type); + void OnHandleInputEvent( + const blink::WebInputEvent* event, + const std::vector& coalesced_events, + const ui::LatencyInfo& latency_info, + InputEventDispatchType dispatch_type); void OnCursorVisibilityChange(bool is_visible); void OnMouseCaptureLost(); void OnSetEditCommandsForNextKeyEvent(const EditCommands& edit_commands); diff --git a/content/renderer/render_widget_fullscreen_pepper.cc b/content/renderer/render_widget_fullscreen_pepper.cc index 56b92532db700a..64bbe72499fb29 100644 --- a/content/renderer/render_widget_fullscreen_pepper.cc +++ b/content/renderer/render_widget_fullscreen_pepper.cc @@ -29,6 +29,7 @@ #include "ui/gl/gpu_preference.h" using blink::WebCanvas; +using blink::WebCoalescedInputEvent; using blink::WebCompositionUnderline; using blink::WebCursorInfo; using blink::WebGestureEvent; @@ -154,10 +155,13 @@ class PepperWidget : public WebWidget { void themeChanged() override { NOTIMPLEMENTED(); } - WebInputEventResult handleInputEvent(const WebInputEvent& event) override { + WebInputEventResult handleInputEvent( + const WebCoalescedInputEvent& coalesced_event) override { if (!widget_->plugin()) return WebInputEventResult::NotHandled; + const WebInputEvent& event = coalesced_event.event(); + // This cursor info is ignored, we always set the cursor directly from // RenderWidgetFullscreenPepper::DidChangeCursor. WebCursorInfo cursor; diff --git a/content/renderer/render_widget_unittest.cc b/content/renderer/render_widget_unittest.cc index d06bc55c520564..6d227f8bd7768a 100644 --- a/content/renderer/render_widget_unittest.cc +++ b/content/renderer/render_widget_unittest.cc @@ -19,7 +19,7 @@ #include "ipc/ipc_test_sink.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebInputEvent.h" +#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h" #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h" #include "ui/events/base_event_utils.h" #include "ui/events/blink/web_input_event_traits.h" @@ -48,8 +48,9 @@ enum { class MockWebWidget : public blink::WebWidget { public: - MOCK_METHOD1(handleInputEvent, - blink::WebInputEventResult(const blink::WebInputEvent&)); + MOCK_METHOD1( + handleInputEvent, + blink::WebInputEventResult(const blink::WebCoalescedInputEvent&)); }; } // namespace @@ -74,7 +75,7 @@ class InteractiveRenderWidget : public RenderWidget { void SendInputEvent(const blink::WebInputEvent& event) { OnHandleInputEvent( - &event, ui::LatencyInfo(), + &event, std::vector(), ui::LatencyInfo(), ui::WebInputEventTraits::ShouldBlockEventStream(event) ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING); diff --git a/third_party/WebKit/Source/platform/exported/WebCoalescedInputEvent.cpp b/third_party/WebKit/Source/platform/exported/WebCoalescedInputEvent.cpp index 6b2484d970cf90..3fc631c87821ac 100644 --- a/third_party/WebKit/Source/platform/exported/WebCoalescedInputEvent.cpp +++ b/third_party/WebKit/Source/platform/exported/WebCoalescedInputEvent.cpp @@ -90,8 +90,9 @@ size_t WebCoalescedInputEvent::coalescedEventSize() const { return m_coalescedEvents.size(); } -const WebInputEvent* WebCoalescedInputEvent::coalescedEvent(int index) const { - return m_coalescedEvents[index].get(); +const WebInputEvent& WebCoalescedInputEvent::coalescedEvent( + size_t index) const { + return *m_coalescedEvents[index].get(); } std::vector @@ -103,20 +104,18 @@ WebCoalescedInputEvent::getCoalescedEventsPointers() const { } WebCoalescedInputEvent::WebCoalescedInputEvent(WebScopedInputEvent event) - : m_event(std::move(event)), m_coalescedEvents() { + : m_event(std::move(event)) { m_coalescedEvents.push_back(makeWebScopedInputEvent(*(m_event.get()))); } -WebCoalescedInputEvent::WebCoalescedInputEvent(const WebInputEvent& event) - : m_event(), m_coalescedEvents() { +WebCoalescedInputEvent::WebCoalescedInputEvent(const WebInputEvent& event) { m_event = makeWebScopedInputEvent(event); m_coalescedEvents.push_back(makeWebScopedInputEvent(event)); } WebCoalescedInputEvent::WebCoalescedInputEvent( const WebInputEvent& event, - const std::vector& coalescedEvents) - : m_event(), m_coalescedEvents(coalescedEvents.size()) { + const std::vector& coalescedEvents) { m_event = makeWebScopedInputEvent(event); for (const auto& coalescedEvent : coalescedEvents) m_coalescedEvents.push_back(makeWebScopedInputEvent(*coalescedEvent)); diff --git a/third_party/WebKit/Source/web/ExternalPopupMenu.cpp b/third_party/WebKit/Source/web/ExternalPopupMenu.cpp index 8a7af6f859a959..3b1a991e00b949 100644 --- a/third_party/WebKit/Source/web/ExternalPopupMenu.cpp +++ b/third_party/WebKit/Source/web/ExternalPopupMenu.cpp @@ -127,7 +127,7 @@ void ExternalPopupMenu::show() { } void ExternalPopupMenu::dispatchEvent(TimerBase*) { - m_webView.handleInputEvent(*m_syntheticEvent); + m_webView.handleInputEvent(blink::WebCoalescedInputEvent(*m_syntheticEvent)); m_syntheticEvent.reset(); } diff --git a/third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp b/third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp index c0e69a2d0a7169..563b887b646c93 100644 --- a/third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp +++ b/third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp @@ -308,7 +308,8 @@ void WebFrameWidgetImpl::themeChanged() { const WebInputEvent* WebFrameWidgetImpl::m_currentInputEvent = nullptr; WebInputEventResult WebFrameWidgetImpl::handleInputEvent( - const WebInputEvent& inputEvent) { + const WebCoalescedInputEvent& coalescedEvent) { + const WebInputEvent& inputEvent = coalescedEvent.event(); TRACE_EVENT1("input", "WebFrameWidgetImpl::handleInputEvent", "type", WebInputEvent::GetName(inputEvent.type())); @@ -379,8 +380,8 @@ WebInputEventResult WebFrameWidgetImpl::handleInputEvent( return WebInputEventResult::HandledSystem; } - return PageWidgetDelegate::handleInputEvent( - *this, WebCoalescedInputEvent(inputEvent), m_localRoot->frame()); + return PageWidgetDelegate::handleInputEvent(*this, coalescedEvent, + m_localRoot->frame()); } void WebFrameWidgetImpl::setCursorVisibilityState(bool isVisible) { diff --git a/third_party/WebKit/Source/web/WebFrameWidgetImpl.h b/third_party/WebKit/Source/web/WebFrameWidgetImpl.h index 6376a9869091bb..3168dcaeca10c0 100644 --- a/third_party/WebKit/Source/web/WebFrameWidgetImpl.h +++ b/third_party/WebKit/Source/web/WebFrameWidgetImpl.h @@ -34,7 +34,7 @@ #include "platform/graphics/GraphicsLayer.h" #include "platform/heap/SelfKeepAlive.h" #include "platform/scroll/ScrollTypes.h" -#include "public/platform/WebInputEvent.h" +#include "public/platform/WebCoalescedInputEvent.h" #include "public/platform/WebPoint.h" #include "public/platform/WebSize.h" #include "public/web/WebInputMethodController.h" @@ -87,7 +87,7 @@ class WebFrameWidgetImpl final void compositeAndReadbackAsync( WebCompositeAndReadbackAsyncCallback*) override; void themeChanged() override; - WebInputEventResult handleInputEvent(const WebInputEvent&) override; + WebInputEventResult handleInputEvent(const WebCoalescedInputEvent&) override; void setCursorVisibilityState(bool isVisible) override; bool hasTouchEventHandlersAt(const WebPoint&) override; diff --git a/third_party/WebKit/Source/web/WebPagePopupImpl.cpp b/third_party/WebKit/Source/web/WebPagePopupImpl.cpp index 8360378cf042cd..19243199a405c9 100644 --- a/third_party/WebKit/Source/web/WebPagePopupImpl.cpp +++ b/third_party/WebKit/Source/web/WebPagePopupImpl.cpp @@ -511,11 +511,11 @@ bool WebPagePopupImpl::isViewportPointInWindow(int x, int y) { } WebInputEventResult WebPagePopupImpl::handleInputEvent( - const WebInputEvent& event) { + const WebCoalescedInputEvent& event) { if (m_closing) return WebInputEventResult::NotHandled; return PageWidgetDelegate::handleInputEvent( - *this, WebCoalescedInputEvent(event), m_page->deprecatedLocalMainFrame()); + *this, event, m_page->deprecatedLocalMainFrame()); } void WebPagePopupImpl::setFocus(bool enable) { diff --git a/third_party/WebKit/Source/web/WebPagePopupImpl.h b/third_party/WebKit/Source/web/WebPagePopupImpl.h index c168f67bde2c33..1d89868f0dcaf6 100644 --- a/third_party/WebKit/Source/web/WebPagePopupImpl.h +++ b/third_party/WebKit/Source/web/WebPagePopupImpl.h @@ -82,7 +82,7 @@ class WebPagePopupImpl final : public WebPagePopup, void paint(WebCanvas*, const WebRect&) override; void resize(const WebSize&) override; void close() override; - WebInputEventResult handleInputEvent(const WebInputEvent&) override; + WebInputEventResult handleInputEvent(const WebCoalescedInputEvent&) override; void setFocus(bool) override; bool isPagePopup() const override { return true; } bool isAcceleratedCompositingActive() const override { diff --git a/third_party/WebKit/Source/web/WebViewFrameWidget.cpp b/third_party/WebKit/Source/web/WebViewFrameWidget.cpp index ed47459983404c..2e935aa649a062 100644 --- a/third_party/WebKit/Source/web/WebViewFrameWidget.cpp +++ b/third_party/WebKit/Source/web/WebViewFrameWidget.cpp @@ -84,7 +84,7 @@ void WebViewFrameWidget::themeChanged() { } WebInputEventResult WebViewFrameWidget::handleInputEvent( - const WebInputEvent& event) { + const WebCoalescedInputEvent& event) { return m_webView->handleInputEvent(event); } diff --git a/third_party/WebKit/Source/web/WebViewFrameWidget.h b/third_party/WebKit/Source/web/WebViewFrameWidget.h index ab4001581172e1..2d89f2e338271e 100644 --- a/third_party/WebKit/Source/web/WebViewFrameWidget.h +++ b/third_party/WebKit/Source/web/WebViewFrameWidget.h @@ -55,7 +55,7 @@ class WebViewFrameWidget : public WebFrameWidgetBase { void compositeAndReadbackAsync( WebCompositeAndReadbackAsyncCallback*) override; void themeChanged() override; - WebInputEventResult handleInputEvent(const WebInputEvent&) override; + WebInputEventResult handleInputEvent(const WebCoalescedInputEvent&) override; void setCursorVisibilityState(bool isVisible) override; bool hasTouchEventHandlersAt(const WebPoint&) override; void applyViewportDeltas(const WebFloatSize& visualViewportDelta, diff --git a/third_party/WebKit/Source/web/WebViewImpl.cpp b/third_party/WebKit/Source/web/WebViewImpl.cpp index ab8025e66cc581..5aefab4a47c232 100644 --- a/third_party/WebKit/Source/web/WebViewImpl.cpp +++ b/third_party/WebKit/Source/web/WebViewImpl.cpp @@ -961,7 +961,7 @@ WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent( wheelEvent.wheelTicksX = 0; wheelEvent.wheelTicksY = pinchEvent.data.pinchUpdate.scale > 1 ? 1 : -1; - return handleInputEvent(wheelEvent); + return handleInputEvent(blink::WebCoalescedInputEvent(wheelEvent)); } void WebViewImpl::transferActiveWheelFlingAnimation( @@ -2104,7 +2104,8 @@ bool WebViewImpl::hasVerticalScrollbar() { const WebInputEvent* WebViewImpl::m_currentInputEvent = nullptr; WebInputEventResult WebViewImpl::handleInputEvent( - const WebInputEvent& inputEvent) { + const WebCoalescedInputEvent& coalescedEvent) { + const WebInputEvent& inputEvent = coalescedEvent.event(); // TODO(dcheng): The fact that this is getting called when there is no local // main frame is problematic and probably indicates a bug in the input event // routing code. @@ -2208,7 +2209,7 @@ WebInputEventResult WebViewImpl::handleInputEvent( // FIXME: This should take in the intended frame, not the local frame root. WebInputEventResult result = PageWidgetDelegate::handleInputEvent( - *this, WebCoalescedInputEvent(inputEvent), mainFrameImpl()->frame()); + *this, coalescedEvent, mainFrameImpl()->frame()); if (result != WebInputEventResult::NotHandled) return result; diff --git a/third_party/WebKit/Source/web/WebViewImpl.h b/third_party/WebKit/Source/web/WebViewImpl.h index 8e0205585a74f3..e88da4c0266c6c 100644 --- a/third_party/WebKit/Source/web/WebViewImpl.h +++ b/third_party/WebKit/Source/web/WebViewImpl.h @@ -140,7 +140,7 @@ class WEB_EXPORT WebViewImpl final void compositeAndReadbackAsync( WebCompositeAndReadbackAsyncCallback*) override; void themeChanged() override; - WebInputEventResult handleInputEvent(const WebInputEvent&) override; + WebInputEventResult handleInputEvent(const WebCoalescedInputEvent&) override; void setCursorVisibilityState(bool isVisible) override; bool hasTouchEventHandlersAt(const WebPoint&) override; diff --git a/third_party/WebKit/Source/web/tests/BrowserControlsTest.cpp b/third_party/WebKit/Source/web/tests/BrowserControlsTest.cpp index 1e81b49e7ade90..e0e5ba0376c079 100644 --- a/third_party/WebKit/Source/web/tests/BrowserControlsTest.cpp +++ b/third_party/WebKit/Source/web/tests/BrowserControlsTest.cpp @@ -98,9 +98,9 @@ class BrowserControlsTest : public testing::Test { WebString::fromUTF8(fileName.c_str())); } - WebGestureEvent generateEvent(WebInputEvent::Type type, - int deltaX = 0, - int deltaY = 0) { + WebCoalescedInputEvent generateEvent(WebInputEvent::Type type, + int deltaX = 0, + int deltaY = 0) { WebGestureEvent event(type, WebInputEvent::NoModifiers, WebInputEvent::TimeStampForTesting); event.sourceDevice = WebGestureDeviceTouchscreen; @@ -110,7 +110,7 @@ class BrowserControlsTest : public testing::Test { event.data.scrollUpdate.deltaX = deltaX; event.data.scrollUpdate.deltaY = deltaY; } - return event; + return WebCoalescedInputEvent(event); } void verticalScroll(float deltaY) { diff --git a/third_party/WebKit/Source/web/tests/ImeOnFocusTest.cpp b/third_party/WebKit/Source/web/tests/ImeOnFocusTest.cpp index 50f42c511dc9ee..29d336767d957e 100644 --- a/third_party/WebKit/Source/web/tests/ImeOnFocusTest.cpp +++ b/third_party/WebKit/Source/web/tests/ImeOnFocusTest.cpp @@ -76,7 +76,7 @@ void ImeOnFocusTest::sendGestureTap(WebView* webView, IntPoint clientPoint) { webGestureEvent.data.tap.width = 10; webGestureEvent.data.tap.height = 10; - webView->handleInputEvent(webGestureEvent); + webView->handleInputEvent(WebCoalescedInputEvent(webGestureEvent)); runPendingTasks(); } diff --git a/third_party/WebKit/Source/web/tests/LinkSelectionTest.cpp b/third_party/WebKit/Source/web/tests/LinkSelectionTest.cpp index e327df9a8d2a8b..d9b10dbc0e442d 100644 --- a/third_party/WebKit/Source/web/tests/LinkSelectionTest.cpp +++ b/third_party/WebKit/Source/web/tests/LinkSelectionTest.cpp @@ -61,7 +61,7 @@ void LinkSelectionTestBase::emulateMouseDrag(const IntPoint& downPoint, const auto& downEvent = FrameTestHelpers::createMouseEvent( WebMouseEvent::MouseDown, WebMouseEvent::Button::Left, downPoint, modifiers); - m_webView->handleInputEvent(downEvent); + m_webView->handleInputEvent(WebCoalescedInputEvent(downEvent)); } const int kMoveEventsNumber = 10; @@ -73,14 +73,14 @@ void LinkSelectionTestBase::emulateMouseDrag(const IntPoint& downPoint, const auto& moveEvent = FrameTestHelpers::createMouseEvent( WebMouseEvent::MouseMove, WebMouseEvent::Button::Left, movePoint, modifiers); - m_webView->handleInputEvent(moveEvent); + m_webView->handleInputEvent(WebCoalescedInputEvent(moveEvent)); } if (dragFlags & SendUpEvent) { const auto& upEvent = FrameTestHelpers::createMouseEvent( WebMouseEvent::MouseUp, WebMouseEvent::Button::Left, upPoint, modifiers); - m_webView->handleInputEvent(upEvent); + m_webView->handleInputEvent(WebCoalescedInputEvent(upEvent)); } } @@ -91,9 +91,9 @@ void LinkSelectionTestBase::emulateMouseClick(const IntPoint& clickPoint, auto event = FrameTestHelpers::createMouseEvent( WebMouseEvent::MouseDown, button, clickPoint, modifiers); event.clickCount = count; - m_webView->handleInputEvent(event); + m_webView->handleInputEvent(WebCoalescedInputEvent(event)); event.setType(WebMouseEvent::MouseUp); - m_webView->handleInputEvent(event); + m_webView->handleInputEvent(WebCoalescedInputEvent(event)); } void LinkSelectionTestBase::emulateMouseDown(const IntPoint& clickPoint, @@ -103,7 +103,7 @@ void LinkSelectionTestBase::emulateMouseDown(const IntPoint& clickPoint, auto event = FrameTestHelpers::createMouseEvent( WebMouseEvent::MouseDown, button, clickPoint, modifiers); event.clickCount = count; - m_webView->handleInputEvent(event); + m_webView->handleInputEvent(WebCoalescedInputEvent(event)); } String LinkSelectionTestBase::getSelectionText() { diff --git a/third_party/WebKit/Source/web/tests/RootScrollerTest.cpp b/third_party/WebKit/Source/web/tests/RootScrollerTest.cpp index 230727d51733a7..a90a6531502c5d 100644 --- a/third_party/WebKit/Source/web/tests/RootScrollerTest.cpp +++ b/third_party/WebKit/Source/web/tests/RootScrollerTest.cpp @@ -124,24 +124,24 @@ class RootScrollerTest : public ::testing::Test { return &doc->rootScrollerController().effectiveRootScroller(); } - WebGestureEvent generateTouchGestureEvent(WebInputEvent::Type type, - int deltaX = 0, - int deltaY = 0) { + WebCoalescedInputEvent generateTouchGestureEvent(WebInputEvent::Type type, + int deltaX = 0, + int deltaY = 0) { return generateGestureEvent(type, WebGestureDeviceTouchscreen, deltaX, deltaY); } - WebGestureEvent generateWheelGestureEvent(WebInputEvent::Type type, - int deltaX = 0, - int deltaY = 0) { + WebCoalescedInputEvent generateWheelGestureEvent(WebInputEvent::Type type, + int deltaX = 0, + int deltaY = 0) { return generateGestureEvent(type, WebGestureDeviceTouchpad, deltaX, deltaY); } protected: - WebGestureEvent generateGestureEvent(WebInputEvent::Type type, - WebGestureDevice device, - int deltaX, - int deltaY) { + WebCoalescedInputEvent generateGestureEvent(WebInputEvent::Type type, + WebGestureDevice device, + int deltaX, + int deltaY) { WebGestureEvent event(type, WebInputEvent::NoModifiers, WebInputEvent::TimeStampForTesting); event.sourceDevice = device; @@ -151,7 +151,7 @@ class RootScrollerTest : public ::testing::Test { event.data.scrollUpdate.deltaX = deltaX; event.data.scrollUpdate.deltaY = deltaY; } - return event; + return WebCoalescedInputEvent(event); } WebViewImpl* initializeInternal(const std::string& url, diff --git a/third_party/WebKit/Source/web/tests/TouchActionTest.cpp b/third_party/WebKit/Source/web/tests/TouchActionTest.cpp index dfef3aaeb301e0..e34e6813e0ac72 100644 --- a/third_party/WebKit/Source/web/tests/TouchActionTest.cpp +++ b/third_party/WebKit/Source/web/tests/TouchActionTest.cpp @@ -389,7 +389,7 @@ void TouchActionTest::sendTouchEvent(WebView* webView, webTouchEvent.touches[0].radiusY = 10; webTouchEvent.touches[0].force = 1.0; - webView->handleInputEvent(webTouchEvent); + webView->handleInputEvent(WebCoalescedInputEvent(webTouchEvent)); runPendingTasks(); } diff --git a/third_party/WebKit/Source/web/tests/VisualViewportTest.cpp b/third_party/WebKit/Source/web/tests/VisualViewportTest.cpp index 15ec9d455aa7f6..74884f37fc6a0d 100644 --- a/third_party/WebKit/Source/web/tests/VisualViewportTest.cpp +++ b/third_party/WebKit/Source/web/tests/VisualViewportTest.cpp @@ -1167,12 +1167,12 @@ TEST_P(VisualViewportTest, TestContextMenuShownInCorrectLocation) { // Do a sanity check with no scale applied. webViewImpl()->mainFrameImpl()->setClient(&mockWebFrameClient); - webViewImpl()->handleInputEvent(mouseDownEvent); - webViewImpl()->handleInputEvent(mouseUpEvent); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(mouseDownEvent)); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(mouseUpEvent)); Mock::VerifyAndClearExpectations(&mockWebFrameClient); mouseDownEvent.button = WebMouseEvent::Button::Left; - webViewImpl()->handleInputEvent(mouseDownEvent); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(mouseDownEvent)); // Now pinch zoom into the page and move the visual viewport. The context menu // should still appear at the location of the event, relative to the WebView. @@ -1185,8 +1185,8 @@ TEST_P(VisualViewportTest, TestContextMenuShownInCorrectLocation) { mouseDownEvent.x, mouseDownEvent.y))); mouseDownEvent.button = WebMouseEvent::Button::Right; - webViewImpl()->handleInputEvent(mouseDownEvent); - webViewImpl()->handleInputEvent(mouseUpEvent); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(mouseDownEvent)); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(mouseUpEvent)); // Reset the old client so destruction can occur naturally. webViewImpl()->mainFrameImpl()->setClient(oldClient); @@ -2015,7 +2015,7 @@ TEST_P(VisualViewportTest, PinchZoomGestureScrollsVisualViewportOnly) { pinchUpdate.data.pinchUpdate.scale = 2; pinchUpdate.data.pinchUpdate.zoomDisabled = false; - webViewImpl()->handleInputEvent(pinchUpdate); + webViewImpl()->handleInputEvent(WebCoalescedInputEvent(pinchUpdate)); VisualViewport& visualViewport = webViewImpl()->page()->frameHost().visualViewport(); diff --git a/third_party/WebKit/Source/web/tests/WebFrameTest.cpp b/third_party/WebKit/Source/web/tests/WebFrameTest.cpp index ae18e971058648..921bd1f8e3ca0b 100644 --- a/third_party/WebKit/Source/web/tests/WebFrameTest.cpp +++ b/third_party/WebKit/Source/web/tests/WebFrameTest.cpp @@ -5846,7 +5846,7 @@ class DisambiguationPopupTestWebViewClient bool m_triggered; }; -static WebGestureEvent fatTap(int x, int y) { +static WebCoalescedInputEvent fatTap(int x, int y) { WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers, WebInputEvent::TimeStampForTesting); event.sourceDevice = WebGestureDeviceTouchscreen; @@ -5854,7 +5854,7 @@ static WebGestureEvent fatTap(int x, int y) { event.y = y; event.data.tap.width = 50; event.data.tap.height = 50; - return event; + return WebCoalescedInputEvent(event); } TEST_P(ParameterizedWebFrameTest, DisambiguationPopup) { @@ -9726,9 +9726,9 @@ class WebFrameOverscrollTest : public WebFrameTest, public ::testing::WithParamInterface { protected: - WebGestureEvent generateEvent(WebInputEvent::Type type, - float deltaX = 0.0, - float deltaY = 0.0) { + WebCoalescedInputEvent generateEvent(WebInputEvent::Type type, + float deltaX = 0.0, + float deltaY = 0.0) { WebGestureEvent event(type, WebInputEvent::NoModifiers, WebInputEvent::TimeStampForTesting); // TODO(wjmaclean): Make sure that touchpad device is only ever used for @@ -9740,7 +9740,7 @@ class WebFrameOverscrollTest event.data.scrollUpdate.deltaX = deltaX; event.data.scrollUpdate.deltaY = deltaY; } - return event; + return WebCoalescedInputEvent(event); } void ScrollBegin(FrameTestHelpers::WebViewHelper* webViewHelper) { @@ -10684,13 +10684,15 @@ TEST_F(WebFrameTest, ScrollBeforeLayoutDoesntCrash) { // Try GestureScrollEnd and GestureScrollUpdate first to make sure that not // seeing a Begin first doesn't break anything. (This currently happens). - webViewHelper.webView()->handleInputEvent(endEvent); - webViewHelper.webView()->handleInputEvent(updateEvent); + webViewHelper.webView()->handleInputEvent(WebCoalescedInputEvent(endEvent)); + webViewHelper.webView()->handleInputEvent( + WebCoalescedInputEvent(updateEvent)); // Try a full Begin/Update/End cycle. - webViewHelper.webView()->handleInputEvent(beginEvent); - webViewHelper.webView()->handleInputEvent(updateEvent); - webViewHelper.webView()->handleInputEvent(endEvent); + webViewHelper.webView()->handleInputEvent(WebCoalescedInputEvent(beginEvent)); + webViewHelper.webView()->handleInputEvent( + WebCoalescedInputEvent(updateEvent)); + webViewHelper.webView()->handleInputEvent(WebCoalescedInputEvent(endEvent)); } TEST_F(WebFrameTest, HidingScrollbarsOnScrollableAreaDisablesScrollbars) { diff --git a/third_party/WebKit/Source/web/tests/WebPluginContainerTest.cpp b/third_party/WebKit/Source/web/tests/WebPluginContainerTest.cpp index 8b428a7b955ef6..54b44ad9895716 100644 --- a/third_party/WebKit/Source/web/tests/WebPluginContainerTest.cpp +++ b/third_party/WebKit/Source/web/tests/WebPluginContainerTest.cpp @@ -372,7 +372,7 @@ TEST_F(WebPluginContainerTest, CopyFromContextMenu) { event.clickCount = 1; // Make sure the right-click + Copy works in common scenario. - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); EXPECT_TRUE(webView->mainFrame()->toWebLocalFrame()->executeCommand("Copy")); EXPECT_EQ(WebString("x"), Platform::current()->clipboard()->readPlainText( WebClipboard::Buffer())); @@ -384,7 +384,7 @@ TEST_F(WebPluginContainerTest, CopyFromContextMenu) { // Now, let's try a more complex scenario: // 1) open the context menu. This will focus the plugin. - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); // 2) document blurs the plugin, because it can. webView->clearFocusedElement(); // 3) Copy should still operate on the context node, even though the focus had @@ -508,7 +508,7 @@ TEST_F(WebPluginContainerTest, GestureLongPressReachesPlugin) { event.x = 0; event.y = 0; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_EQ(WebInputEvent::Undefined, testPlugin->getLastInputEventType()); @@ -519,7 +519,7 @@ TEST_F(WebPluginContainerTest, GestureLongPressReachesPlugin) { event.x = rect.x + rect.width / 2; event.y = rect.y + rect.height / 2; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_EQ(WebInputEvent::GestureLongPress, @@ -557,7 +557,7 @@ TEST_F(WebPluginContainerTest, MouseWheelEventTranslated) { event.x = rect.x + rect.width / 2; event.y = rect.y + rect.height / 2; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_EQ(WebInputEvent::MouseWheel, testPlugin->getLastInputEventType()); diff --git a/third_party/WebKit/Source/web/tests/WebViewTest.cpp b/third_party/WebKit/Source/web/tests/WebViewTest.cpp index 579a2b22c190e5..1bf6e399b662dc 100644 --- a/third_party/WebKit/Source/web/tests/WebViewTest.cpp +++ b/third_party/WebKit/Source/web/tests/WebViewTest.cpp @@ -2022,7 +2022,7 @@ bool WebViewTest::tapElement(WebInputEvent::Type type, Element* element) { event.x = center.x(); event.y = center.y(); - m_webViewHelper.webView()->handleInputEvent(event); + m_webViewHelper.webView()->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); return true; } @@ -2083,7 +2083,7 @@ TEST_P(WebViewTest, DetectContentAroundPosition) { WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers, WebInputEvent::TimeStampForTesting); event.sourceDevice = WebGestureDeviceTouchscreen; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_TRUE(client.pendingIntentsCancelled()); @@ -2129,7 +2129,7 @@ TEST_P(WebViewTest, ClientTapHandling) { event.sourceDevice = WebGestureDeviceTouchscreen; event.x = 3; event.y = 8; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_EQ(3, client.tapX()); EXPECT_EQ(8, client.tapY()); @@ -2137,7 +2137,7 @@ TEST_P(WebViewTest, ClientTapHandling) { event.setType(WebInputEvent::GestureLongPress); event.x = 25; event.y = 7; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); runPendingTasks(); EXPECT_EQ(25, client.longpressX()); EXPECT_EQ(7, client.longpressY()); @@ -2164,7 +2164,8 @@ TEST_P(WebViewTest, ClientTapHandlingNullWebViewClient) { event.sourceDevice = WebGestureDeviceTouchscreen; event.x = 3; event.y = 8; - EXPECT_EQ(WebInputEventResult::NotHandled, webView->handleInputEvent(event)); + EXPECT_EQ(WebInputEventResult::NotHandled, + webView->handleInputEvent(WebCoalescedInputEvent(event))); webView->close(); } @@ -2187,7 +2188,8 @@ TEST_P(WebViewTest, LongPressEmptyDiv) { event.x = 250; event.y = 150; - EXPECT_EQ(WebInputEventResult::NotHandled, webView->handleInputEvent(event)); + EXPECT_EQ(WebInputEventResult::NotHandled, + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, LongPressEmptyDivAlwaysShow) { @@ -2210,7 +2212,7 @@ TEST_P(WebViewTest, LongPressEmptyDivAlwaysShow) { event.y = 150; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, LongPressObject) { @@ -2233,7 +2235,7 @@ TEST_P(WebViewTest, LongPressObject) { event.y = 10; EXPECT_NE(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); HTMLElement* element = toHTMLElement(webView->mainFrame()->document().getElementById("obj")); @@ -2260,7 +2262,7 @@ TEST_P(WebViewTest, LongPressObjectFallback) { event.y = 10; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); HTMLElement* element = toHTMLElement(webView->mainFrame()->document().getElementById("obj")); @@ -2287,7 +2289,7 @@ TEST_P(WebViewTest, LongPressImage) { event.y = 10; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, LongPressVideo) { @@ -2310,7 +2312,7 @@ TEST_P(WebViewTest, LongPressVideo) { event.y = 10; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, LongPressLink) { @@ -2333,7 +2335,7 @@ TEST_P(WebViewTest, LongPressLink) { event.y = 300; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, showContextMenuOnLongPressingLinks) { @@ -2383,7 +2385,7 @@ TEST_P(WebViewTest, LongPressEmptyEditableSelection) { event.y = 10; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); } TEST_P(WebViewTest, LongPressEmptyNonEditableSelection) { @@ -2406,7 +2408,7 @@ TEST_P(WebViewTest, LongPressEmptyNonEditableSelection) { WebLocalFrameImpl* frame = webView->mainFrameImpl(); EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(event)); + webView->handleInputEvent(WebCoalescedInputEvent(event))); EXPECT_TRUE(frame->selectionAsText().isEmpty()); } @@ -2460,7 +2462,7 @@ TEST_P(WebViewTest, TouchDoesntSelectEmptyTextarea) { event.y = 25; event.data.tap.tapCount = 2; - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); EXPECT_TRUE(frame->selectionAsText().isEmpty()); HTMLTextAreaElement* textAreaElement = toHTMLTextAreaElement( @@ -2473,7 +2475,7 @@ TEST_P(WebViewTest, TouchDoesntSelectEmptyTextarea) { EXPECT_TRUE(frame->selectionAsText().isEmpty()); // Double-tap past last word of textbox. - webView->handleInputEvent(event); + webView->handleInputEvent(WebCoalescedInputEvent(event)); EXPECT_TRUE(frame->selectionAsText().isEmpty()); } #endif @@ -2535,7 +2537,7 @@ TEST_P(WebViewTest, BlinkCaretOnClosingContextMenu) { mouseEvent.x = 1; mouseEvent.y = 1; mouseEvent.clickCount = 1; - webView->handleInputEvent(mouseEvent); + webView->handleInputEvent(WebCoalescedInputEvent(mouseEvent)); runPendingTasks(); WebLocalFrameImpl* mainFrame = webView->mainFrameImpl(); @@ -2590,60 +2592,60 @@ TEST_P(WebViewTest, KeyDownScrollsHandled) { // RawKeyDown pagedown should be handled. keyEvent.windowsKeyCode = VKEY_NEXT; EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); // Coalesced KeyDown arrow-down should be handled. keyEvent.windowsKeyCode = VKEY_DOWN; keyEvent.setType(WebInputEvent::KeyDown); EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); // Ctrl-Home should be handled... keyEvent.windowsKeyCode = VKEY_HOME; keyEvent.setModifiers(WebInputEvent::ControlKey); keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); // But Ctrl-Down should not. keyEvent.windowsKeyCode = VKEY_DOWN; keyEvent.setModifiers(WebInputEvent::ControlKey); keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); // Shift, meta, and alt should not be handled. keyEvent.windowsKeyCode = VKEY_NEXT; keyEvent.setModifiers(WebInputEvent::ShiftKey); keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); keyEvent.windowsKeyCode = VKEY_NEXT; keyEvent.setModifiers(WebInputEvent::MetaKey); keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); keyEvent.windowsKeyCode = VKEY_NEXT; keyEvent.setModifiers(WebInputEvent::AltKey); keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); // System-key labeled Alt-Down (as in Windows) should do nothing, // but non-system-key labeled Alt-Down (as in Mac) should be handled @@ -2653,18 +2655,18 @@ TEST_P(WebViewTest, KeyDownScrollsHandled) { keyEvent.isSystemKey = true; keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::NotHandled, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); keyEvent.windowsKeyCode = VKEY_DOWN; keyEvent.setModifiers(WebInputEvent::AltKey); keyEvent.isSystemKey = false; keyEvent.setType(WebInputEvent::RawKeyDown); EXPECT_EQ(WebInputEventResult::HandledSystem, - webView->handleInputEvent(keyEvent)); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent))); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); } static void configueCompositingWebView(WebSettings* settings) { @@ -2701,7 +2703,7 @@ TEST_P(WebViewTest, ShowPressOnTransformedLink) { event.y = 20; // Just make sure we don't hit any asserts. - webViewImpl->handleInputEvent(event); + webViewImpl->handleInputEvent(WebCoalescedInputEvent(event)); } class MockAutofillClient : public WebAutofillClient { @@ -2825,7 +2827,7 @@ TEST_P(WebViewTest, CompositionNotCancelledByBackspace) { WebInputEvent::TimeStampForTesting); keyEvent.domKey = Platform::current()->domKeyEnumFromString("\b"); keyEvent.windowsKeyCode = VKEY_BACK; - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); frame->setEditableSelectionOffsets(6, 6); EXPECT_TRUE(activeInputMethodController->setComposition( @@ -2835,7 +2837,7 @@ TEST_P(WebViewTest, CompositionNotCancelledByBackspace) { "after pressing Backspace"); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); webView->advanceFocus(false); } @@ -3030,10 +3032,10 @@ static void openDateTimeChooser(WebView* webView, WebInputEvent::TimeStampForTesting); keyEvent.domKey = Platform::current()->domKeyEnumFromString(" "); keyEvent.windowsKeyCode = VKEY_SPACE; - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); } // TODO(crbug.com/605112) This test is crashing on Android (Nexus 4) bot. @@ -3615,9 +3617,9 @@ TEST_P(WebViewTest, FirstUserGestureObservedKeyEvent) { WebInputEvent::TimeStampForTesting); keyEvent.domKey = Platform::current()->domKeyEnumFromString(" "); keyEvent.windowsKeyCode = VKEY_SPACE; - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); keyEvent.setType(WebInputEvent::KeyUp); - webView->handleInputEvent(keyEvent); + webView->handleInputEvent(WebCoalescedInputEvent(keyEvent)); EXPECT_EQ(1, client.getUserGestureNotificationsCount()); frame->setAutofillClient(0); @@ -3641,9 +3643,9 @@ TEST_P(WebViewTest, FirstUserGestureObservedMouseEvent) { mouseEvent.x = 1; mouseEvent.y = 1; mouseEvent.clickCount = 1; - webView->handleInputEvent(mouseEvent); + webView->handleInputEvent(WebCoalescedInputEvent(mouseEvent)); mouseEvent.setType(WebInputEvent::MouseUp); - webView->handleInputEvent(mouseEvent); + webView->handleInputEvent(WebCoalescedInputEvent(mouseEvent)); EXPECT_EQ(1, client.getUserGestureNotificationsCount()); frame->setAutofillClient(0); diff --git a/third_party/WebKit/public/platform/WebCoalescedInputEvent.h b/third_party/WebKit/public/platform/WebCoalescedInputEvent.h index 94dd15021d2ff3..e1a282a542c6f0 100644 --- a/third_party/WebKit/public/platform/WebCoalescedInputEvent.h +++ b/third_party/WebKit/public/platform/WebCoalescedInputEvent.h @@ -24,8 +24,8 @@ using WebScopedInputEvent = // coalesced events. The event could be any events defined in WebInputEvent.h. class BLINK_COMMON_EXPORT WebCoalescedInputEvent { public: - WebCoalescedInputEvent(WebScopedInputEvent); - WebCoalescedInputEvent(const WebInputEvent&); + explicit WebCoalescedInputEvent(WebScopedInputEvent); + explicit WebCoalescedInputEvent(const WebInputEvent&); WebCoalescedInputEvent(const WebInputEvent&, const std::vector&); @@ -33,7 +33,7 @@ class BLINK_COMMON_EXPORT WebCoalescedInputEvent { void addCoalescedEvent(const blink::WebInputEvent&); const WebInputEvent& event() const; size_t coalescedEventSize() const; - const WebInputEvent* coalescedEvent(int index) const; + const WebInputEvent& coalescedEvent(size_t index) const; std::vector getCoalescedEventsPointers() const; private: diff --git a/third_party/WebKit/public/web/WebWidget.h b/third_party/WebKit/public/web/WebWidget.h index 3e6f5889a0086c..278d64280af60a 100644 --- a/third_party/WebKit/public/web/WebWidget.h +++ b/third_party/WebKit/public/web/WebWidget.h @@ -47,7 +47,7 @@ namespace blink { class WebCompositeAndReadbackAsyncCallback; -class WebInputEvent; +class WebCoalescedInputEvent; class WebLayoutAndPaintAsyncCallback; class WebPagePopup; struct WebPoint; @@ -116,7 +116,7 @@ class WebWidget { virtual void themeChanged() {} // Called to inform the WebWidget of an input event. - virtual WebInputEventResult handleInputEvent(const WebInputEvent&) { + virtual WebInputEventResult handleInputEvent(const WebCoalescedInputEvent&) { return WebInputEventResult::NotHandled; }