diff options
Diffstat (limited to 'chromium/third_party/blink/common/input')
6 files changed, 897 insertions, 0 deletions
diff --git a/chromium/third_party/blink/common/input/OWNERS b/chromium/third_party/blink/common/input/OWNERS new file mode 100644 index 00000000000..d5fefd82012 --- /dev/null +++ b/chromium/third_party/blink/common/input/OWNERS @@ -0,0 +1,2 @@ +per-file *_mojom_traits*.*=set noparent +per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS diff --git a/chromium/third_party/blink/common/input/synthetic_web_input_event_builders.cc b/chromium/third_party/blink/common/input/synthetic_web_input_event_builders.cc new file mode 100644 index 00000000000..d274fc5e485 --- /dev/null +++ b/chromium/third_party/blink/common/input/synthetic_web_input_event_builders.cc @@ -0,0 +1,267 @@ +// Copyright 2013 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "third_party/blink/public/common/input/synthetic_web_input_event_builders.h" + +#include "base/check_op.h" +#include "ui/events/base_event_utils.h" + +namespace blink { + +WebMouseEvent SyntheticWebMouseEventBuilder::Build( + blink::WebInputEvent::Type type) { + return WebMouseEvent(type, WebInputEvent::kNoModifiers, + WebInputEvent::GetStaticTimeStampForTests()); +} + +WebMouseEvent SyntheticWebMouseEventBuilder::Build( + blink::WebInputEvent::Type type, + float window_x, + float window_y, + int modifiers, + blink::WebPointerProperties::PointerType pointer_type) { + DCHECK(WebInputEvent::IsMouseEventType(type)); + WebMouseEvent result(type, modifiers, + WebInputEvent::GetStaticTimeStampForTests()); + result.SetPositionInWidget(window_x, window_y); + result.SetPositionInScreen(window_x, window_y); + result.SetModifiers(modifiers); + result.pointer_type = pointer_type; + result.id = WebMouseEvent::kMousePointerId; + return result; +} + +WebMouseWheelEvent SyntheticWebMouseWheelEventBuilder::Build( + WebMouseWheelEvent::Phase phase) { + WebMouseWheelEvent result(WebInputEvent::Type::kMouseWheel, + WebInputEvent::kNoModifiers, + WebInputEvent::GetStaticTimeStampForTests()); + result.phase = phase; + result.event_action = + WebMouseWheelEvent::GetPlatformSpecificDefaultEventAction(result); + return result; +} + +WebMouseWheelEvent SyntheticWebMouseWheelEventBuilder::Build( + float x, + float y, + float dx, + float dy, + int modifiers, + ui::ScrollGranularity delta_units) { + return Build(x, y, 0, 0, dx, dy, modifiers, delta_units); +} + +WebMouseWheelEvent SyntheticWebMouseWheelEventBuilder::Build( + float x, + float y, + float global_x, + float global_y, + float dx, + float dy, + int modifiers, + ui::ScrollGranularity delta_units) { + WebMouseWheelEvent result(WebInputEvent::Type::kMouseWheel, modifiers, + WebInputEvent::GetStaticTimeStampForTests()); + result.SetPositionInScreen(global_x, global_y); + result.SetPositionInWidget(x, y); + result.delta_units = delta_units; + result.delta_x = dx; + result.delta_y = dy; + if (dx) + result.wheel_ticks_x = dx > 0.0f ? 1.0f : -1.0f; + if (dy) + result.wheel_ticks_y = dy > 0.0f ? 1.0f : -1.0f; + + result.event_action = + WebMouseWheelEvent::GetPlatformSpecificDefaultEventAction(result); + return result; +} + +WebGestureEvent SyntheticWebGestureEventBuilder::Build( + WebInputEvent::Type type, + blink::WebGestureDevice source_device, + int modifiers) { + DCHECK(WebInputEvent::IsGestureEventType(type)); + WebGestureEvent result(type, modifiers, + WebInputEvent::GetStaticTimeStampForTests(), + source_device); + if (type == WebInputEvent::Type::kGestureTap || + type == WebInputEvent::Type::kGestureTapUnconfirmed || + type == WebInputEvent::Type::kGestureDoubleTap) { + result.data.tap.tap_count = 1; + result.data.tap.width = 10; + result.data.tap.height = 10; + } + + result.SetNeedsWheelEvent(result.IsTouchpadZoomEvent()); + + return result; +} + +WebGestureEvent SyntheticWebGestureEventBuilder::BuildScrollBegin( + float dx_hint, + float dy_hint, + blink::WebGestureDevice source_device, + int pointer_count) { + WebGestureEvent result = + Build(WebInputEvent::Type::kGestureScrollBegin, source_device); + result.data.scroll_begin.delta_x_hint = dx_hint; + result.data.scroll_begin.delta_y_hint = dy_hint; + result.data.scroll_begin.pointer_count = pointer_count; + return result; +} + +WebGestureEvent SyntheticWebGestureEventBuilder::BuildScrollUpdate( + float dx, + float dy, + int modifiers, + blink::WebGestureDevice source_device) { + WebGestureEvent result = Build(WebInputEvent::Type::kGestureScrollUpdate, + source_device, modifiers); + result.data.scroll_update.delta_x = dx; + result.data.scroll_update.delta_y = dy; + return result; +} + +WebGestureEvent SyntheticWebGestureEventBuilder::BuildPinchUpdate( + float scale, + float anchor_x, + float anchor_y, + int modifiers, + blink::WebGestureDevice source_device) { + WebGestureEvent result = + Build(WebInputEvent::Type::kGesturePinchUpdate, source_device, modifiers); + result.data.pinch_update.scale = scale; + result.SetPositionInWidget(gfx::PointF(anchor_x, anchor_y)); + result.SetPositionInScreen(gfx::PointF(anchor_x, anchor_y)); + return result; +} + +WebGestureEvent SyntheticWebGestureEventBuilder::BuildFling( + float velocity_x, + float velocity_y, + blink::WebGestureDevice source_device) { + WebGestureEvent result = + Build(WebInputEvent::Type::kGestureFlingStart, source_device); + result.data.fling_start.velocity_x = velocity_x; + result.data.fling_start.velocity_y = velocity_y; + return result; +} + +SyntheticWebTouchEvent::SyntheticWebTouchEvent() : WebTouchEvent() { + unique_touch_event_id = ui::GetNextTouchEventId(); + SetTimestamp(WebInputEvent::GetStaticTimeStampForTests()); + pointer_id_ = 0; +} + +void SyntheticWebTouchEvent::ResetPoints() { + int activePointCount = 0; + unsigned count = 0; + for (unsigned int i = 0; i < kTouchesLengthCap; ++i) { + switch (touches[i].state) { + case WebTouchPoint::State::kStatePressed: + case WebTouchPoint::State::kStateMoved: + case WebTouchPoint::State::kStateStationary: + touches[i].state = WebTouchPoint::State::kStateStationary; + ++activePointCount; + ++count; + break; + case WebTouchPoint::State::kStateReleased: + case WebTouchPoint::State::kStateCancelled: + touches[i] = WebTouchPoint(); + ++count; + break; + case WebTouchPoint::State::kStateUndefined: + break; + } + if (count >= touches_length) + break; + } + touches_length = activePointCount; + type_ = WebInputEvent::Type::kUndefined; + moved_beyond_slop_region = false; + unique_touch_event_id = ui::GetNextTouchEventId(); +} + +int SyntheticWebTouchEvent::PressPoint(float x, + float y, + float radius_x, + float radius_y, + float rotation_angle, + float force) { + int index = FirstFreeIndex(); + if (index == -1) + return -1; + WebTouchPoint& point = touches[index]; + point.id = pointer_id_++; + point.SetPositionInWidget(x, y); + point.SetPositionInScreen(x, y); + point.state = WebTouchPoint::State::kStatePressed; + point.radius_x = radius_x; + point.radius_y = radius_y; + point.rotation_angle = rotation_angle; + point.force = force; + point.tilt_x = point.tilt_y = 0; + point.pointer_type = blink::WebPointerProperties::PointerType::kTouch; + ++touches_length; + SetType(WebInputEvent::Type::kTouchStart); + dispatch_type = WebInputEvent::DispatchType::kBlocking; + return index; +} + +void SyntheticWebTouchEvent::MovePoint(int index, + float x, + float y, + float radius_x, + float radius_y, + float rotation_angle, + float force) { + CHECK_GE(index, 0); + CHECK_LT(index, kTouchesLengthCap); + // Always set this bit to avoid otherwise unexpected touchmove suppression. + // The caller can opt-out explicitly, if necessary. + moved_beyond_slop_region = true; + WebTouchPoint& point = touches[index]; + point.SetPositionInWidget(x, y); + point.SetPositionInScreen(x, y); + point.state = WebTouchPoint::State::kStateMoved; + point.radius_x = radius_x; + point.radius_y = radius_y; + point.rotation_angle = rotation_angle; + point.force = force; + SetType(WebInputEvent::Type::kTouchMove); + dispatch_type = WebInputEvent::DispatchType::kBlocking; +} + +void SyntheticWebTouchEvent::ReleasePoint(int index) { + CHECK_GE(index, 0); + CHECK_LT(index, kTouchesLengthCap); + touches[index].state = WebTouchPoint::State::kStateReleased; + touches[index].force = 0.f; + SetType(WebInputEvent::Type::kTouchEnd); + dispatch_type = WebInputEvent::DispatchType::kBlocking; +} + +void SyntheticWebTouchEvent::CancelPoint(int index) { + CHECK_GE(index, 0); + CHECK_LT(index, kTouchesLengthCap); + touches[index].state = WebTouchPoint::State::kStateCancelled; + SetType(WebInputEvent::Type::kTouchCancel); + dispatch_type = WebInputEvent::DispatchType::kEventNonBlocking; +} + +void SyntheticWebTouchEvent::SetTimestamp(base::TimeTicks timestamp) { + SetTimeStamp(timestamp); +} + +int SyntheticWebTouchEvent::FirstFreeIndex() { + for (size_t i = 0; i < kTouchesLengthCap; ++i) { + if (touches[i].state == WebTouchPoint::State::kStateUndefined) + return i; + } + return -1; +} + +} // namespace blink diff --git a/chromium/third_party/blink/common/input/synthetic_web_input_event_builders_unittest.cc b/chromium/third_party/blink/common/input/synthetic_web_input_event_builders_unittest.cc new file mode 100644 index 00000000000..87e5dd776d3 --- /dev/null +++ b/chromium/third_party/blink/common/input/synthetic_web_input_event_builders_unittest.cc @@ -0,0 +1,56 @@ +// Copyright 2018 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "third_party/blink/public/common/input/synthetic_web_input_event_builders.h" + +#include "testing/gtest/include/gtest/gtest.h" + +namespace blink { + +TEST(SyntheticWebInputEventBuilders, BuildWebTouchEvent) { + SyntheticWebTouchEvent event; + + event.PressPoint(1, 2); + EXPECT_EQ(1U, event.touches_length); + EXPECT_EQ(0, event.touches[0].id); + EXPECT_EQ(WebTouchPoint::State::kStatePressed, event.touches[0].state); + EXPECT_EQ(gfx::PointF(1, 2), event.touches[0].PositionInWidget()); + event.ResetPoints(); + + event.PressPoint(3, 4); + EXPECT_EQ(2U, event.touches_length); + EXPECT_EQ(1, event.touches[1].id); + EXPECT_EQ(WebTouchPoint::State::kStatePressed, event.touches[1].state); + EXPECT_EQ(gfx::PointF(3, 4), event.touches[1].PositionInWidget()); + event.ResetPoints(); + + event.MovePoint(1, 5, 6); + EXPECT_EQ(2U, event.touches_length); + EXPECT_EQ(1, event.touches[1].id); + EXPECT_EQ(WebTouchPoint::State::kStateMoved, event.touches[1].state); + EXPECT_EQ(gfx::PointF(5, 6), event.touches[1].PositionInWidget()); + event.ResetPoints(); + + event.ReleasePoint(0); + EXPECT_EQ(2U, event.touches_length); + EXPECT_EQ(0, event.touches[0].id); + EXPECT_EQ(WebTouchPoint::State::kStateReleased, event.touches[0].state); + event.ResetPoints(); + + event.MovePoint(1, 7, 8); + EXPECT_EQ(1U, event.touches_length); + EXPECT_EQ(1, event.touches[1].id); + EXPECT_EQ(WebTouchPoint::State::kStateMoved, event.touches[1].state); + EXPECT_EQ(gfx::PointF(7, 8), event.touches[1].PositionInWidget()); + EXPECT_EQ(WebTouchPoint::State::kStateUndefined, event.touches[0].state); + event.ResetPoints(); + + event.PressPoint(9, 10); + EXPECT_EQ(2U, event.touches_length); + EXPECT_EQ(2, event.touches[0].id); + EXPECT_EQ(WebTouchPoint::State::kStatePressed, event.touches[0].state); + EXPECT_EQ(gfx::PointF(9, 10), event.touches[0].PositionInWidget()); +} + +} // namespace blink diff --git a/chromium/third_party/blink/common/input/web_coalesced_input_event.cc b/chromium/third_party/blink/common/input/web_coalesced_input_event.cc index ac9c083c1bc..05682411d0a 100644 --- a/chromium/third_party/blink/common/input/web_coalesced_input_event.cc +++ b/chromium/third_party/blink/common/input/web_coalesced_input_event.cc @@ -90,6 +90,8 @@ WebCoalescedInputEvent::WebCoalescedInputEvent( predicted_events_.emplace_back(predicted_event->Clone()); } +WebCoalescedInputEvent::~WebCoalescedInputEvent() = default; + bool WebCoalescedInputEvent::CanCoalesceWith( const WebCoalescedInputEvent& other) const { return event_->CanCoalesce(*other.event_); diff --git a/chromium/third_party/blink/common/input/web_coalesced_input_event_mojom_traits.cc b/chromium/third_party/blink/common/input/web_coalesced_input_event_mojom_traits.cc new file mode 100644 index 00000000000..5fa31403c3a --- /dev/null +++ b/chromium/third_party/blink/common/input/web_coalesced_input_event_mojom_traits.cc @@ -0,0 +1,542 @@ +// Copyright 2017 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "third_party/blink/public/common/input/web_coalesced_input_event_mojom_traits.h" + +#include "base/i18n/char_iterator.h" +#include "mojo/public/cpp/base/time_mojom_traits.h" +#include "third_party/blink/public/common/input/web_gesture_event.h" +#include "third_party/blink/public/common/input/web_keyboard_event.h" +#include "third_party/blink/public/common/input/web_mouse_wheel_event.h" +#include "ui/latency/mojom/latency_info_mojom_traits.h" + +namespace mojo { +namespace { + +void CopyString(base::char16* dst, const base::string16& text) { + base::i18n::UTF16CharIterator iter(&text); + size_t pos = 0; + while (!iter.end() && pos < blink::WebKeyboardEvent::kTextLengthCap - 1) { + dst[pos++] = iter.get(); + iter.Advance(); + } + dst[pos] = '\0'; +} + +blink::mojom::PointerDataPtr PointerDataFromPointerProperties( + const blink::WebPointerProperties& pointer, + blink::mojom::MouseDataPtr mouse_data) { + return blink::mojom::PointerData::New( + pointer.id, pointer.force, pointer.tilt_x, pointer.tilt_y, + pointer.tangential_pressure, pointer.twist, pointer.button, + pointer.pointer_type, pointer.movement_x, pointer.movement_y, + pointer.is_raw_movement_event, pointer.PositionInWidget(), + pointer.PositionInScreen(), std::move(mouse_data)); +} + +void PointerPropertiesFromPointerData( + const blink::mojom::PointerDataPtr& pointer_data, + blink::WebPointerProperties* pointer_properties) { + pointer_properties->id = pointer_data->pointer_id; + pointer_properties->force = pointer_data->force; + pointer_properties->tilt_x = pointer_data->tilt_x; + pointer_properties->tilt_y = pointer_data->tilt_y; + pointer_properties->tangential_pressure = pointer_data->tangential_pressure; + pointer_properties->twist = pointer_data->twist; + pointer_properties->button = pointer_data->button; + pointer_properties->pointer_type = pointer_data->pointer_type; + pointer_properties->movement_x = pointer_data->movement_x; + pointer_properties->movement_y = pointer_data->movement_y; + pointer_properties->is_raw_movement_event = + pointer_data->is_raw_movement_event; +} + +void TouchPointPropertiesFromPointerData( + const blink::mojom::TouchPointPtr& mojo_touch_point, + blink::WebTouchPoint* touch_point) { + PointerPropertiesFromPointerData(mojo_touch_point->pointer_data, touch_point); + touch_point->state = mojo_touch_point->state; + touch_point->radius_x = mojo_touch_point->radius_x; + touch_point->radius_y = mojo_touch_point->radius_y; + touch_point->rotation_angle = mojo_touch_point->rotation_angle; + touch_point->SetPositionInWidget( + mojo_touch_point->pointer_data->widget_position.x(), + mojo_touch_point->pointer_data->widget_position.y()); + touch_point->SetPositionInScreen( + mojo_touch_point->pointer_data->screen_position.x(), + mojo_touch_point->pointer_data->screen_position.y()); +} + +// TODO(dtapuska): Remove once SetPositionInXXX moves to WebPointerProperties. +void MouseEventPropertiesFromPointerData( + const blink::mojom::PointerDataPtr& pointer_data, + blink::WebMouseEvent* mouse_event) { + PointerPropertiesFromPointerData(pointer_data, mouse_event); + mouse_event->SetPositionInWidget(pointer_data->widget_position.x(), + pointer_data->widget_position.y()); + mouse_event->SetPositionInScreen(pointer_data->screen_position.x(), + pointer_data->screen_position.y()); +} + +} // namespace + +bool StructTraits<blink::mojom::EventDataView, + std::unique_ptr<blink::WebCoalescedInputEvent>>:: + Read(blink::mojom::EventDataView event, + std::unique_ptr<blink::WebCoalescedInputEvent>* out) { + DCHECK(!out->get()); + + blink::WebInputEvent::Type type; + if (!event.ReadType(&type)) + return false; + + base::TimeTicks timestamp; + if (!event.ReadTimestamp(×tamp)) + return false; + + std::unique_ptr<blink::WebInputEvent> input_event; + if (blink::WebInputEvent::IsKeyboardEventType(type)) { + blink::mojom::KeyDataPtr key_data; + if (!event.ReadKeyData<blink::mojom::KeyDataPtr>(&key_data)) + return false; + + input_event.reset( + new blink::WebKeyboardEvent(type, event.modifiers(), timestamp)); + + blink::WebKeyboardEvent* key_event = + static_cast<blink::WebKeyboardEvent*>(input_event.get()); + key_event->windows_key_code = key_data->windows_key_code; + key_event->native_key_code = key_data->native_key_code; + key_event->dom_code = key_data->dom_code; + key_event->dom_key = key_data->dom_key; + key_event->is_system_key = key_data->is_system_key; + key_event->is_browser_shortcut = key_data->is_browser_shortcut; + CopyString(key_event->text, key_data->text); + CopyString(key_event->unmodified_text, key_data->unmodified_text); + } else if (blink::WebInputEvent::IsGestureEventType(type)) { + blink::mojom::GestureDataPtr gesture_data; + if (!event.ReadGestureData<blink::mojom::GestureDataPtr>(&gesture_data)) + return false; + input_event.reset(new blink::WebGestureEvent( + type, event.modifiers(), timestamp, gesture_data->source_device)); + + blink::WebGestureEvent* gesture_event = + static_cast<blink::WebGestureEvent*>(input_event.get()); + gesture_event->SetPositionInWidget(gesture_data->widget_position); + gesture_event->SetPositionInScreen(gesture_data->screen_position); + gesture_event->is_source_touch_event_set_non_blocking = + gesture_data->is_source_touch_event_set_non_blocking; + gesture_event->primary_pointer_type = gesture_data->primary_pointer_type; + gesture_event->SetSourceDevice(gesture_data->source_device); + gesture_event->unique_touch_event_id = gesture_data->unique_touch_event_id; + + if (gesture_data->contact_size) { + switch (type) { + default: + break; + case blink::WebInputEvent::Type::kGestureTapDown: + gesture_event->data.tap_down.width = + gesture_data->contact_size->width(); + gesture_event->data.tap_down.height = + gesture_data->contact_size->height(); + break; + case blink::WebInputEvent::Type::kGestureShowPress: + gesture_event->data.show_press.width = + gesture_data->contact_size->width(); + gesture_event->data.show_press.height = + gesture_data->contact_size->height(); + break; + case blink::WebInputEvent::Type::kGestureTap: + case blink::WebInputEvent::Type::kGestureTapUnconfirmed: + case blink::WebInputEvent::Type::kGestureDoubleTap: + gesture_event->data.tap.width = gesture_data->contact_size->width(); + gesture_event->data.tap.height = gesture_data->contact_size->height(); + break; + case blink::WebInputEvent::Type::kGestureLongPress: + case blink::WebInputEvent::Type::kGestureLongTap: + gesture_event->data.long_press.width = + gesture_data->contact_size->width(); + gesture_event->data.long_press.height = + gesture_data->contact_size->height(); + break; + case blink::WebInputEvent::Type::kGestureTwoFingerTap: + gesture_event->data.two_finger_tap.first_finger_width = + gesture_data->contact_size->width(); + gesture_event->data.two_finger_tap.first_finger_height = + gesture_data->contact_size->height(); + break; + } + } + + if (gesture_data->scroll_data) { + switch (type) { + default: + break; + case blink::WebInputEvent::Type::kGestureScrollBegin: + gesture_event->data.scroll_begin.delta_x_hint = + gesture_data->scroll_data->delta_x; + gesture_event->data.scroll_begin.delta_y_hint = + gesture_data->scroll_data->delta_y; + gesture_event->data.scroll_begin.delta_hint_units = + gesture_data->scroll_data->delta_units; + gesture_event->data.scroll_begin.target_viewport = + gesture_data->scroll_data->target_viewport; + gesture_event->data.scroll_begin.inertial_phase = + gesture_data->scroll_data->inertial_phase; + gesture_event->data.scroll_begin.synthetic = + gesture_data->scroll_data->synthetic; + gesture_event->data.scroll_begin.pointer_count = + gesture_data->scroll_data->pointer_count; + break; + case blink::WebInputEvent::Type::kGestureScrollEnd: + gesture_event->data.scroll_end.delta_units = + gesture_data->scroll_data->delta_units; + gesture_event->data.scroll_end.inertial_phase = + gesture_data->scroll_data->inertial_phase; + gesture_event->data.scroll_end.synthetic = + gesture_data->scroll_data->synthetic; + break; + case blink::WebInputEvent::Type::kGestureScrollUpdate: + gesture_event->data.scroll_update.delta_x = + gesture_data->scroll_data->delta_x; + gesture_event->data.scroll_update.delta_y = + gesture_data->scroll_data->delta_y; + gesture_event->data.scroll_update.delta_units = + gesture_data->scroll_data->delta_units; + gesture_event->data.scroll_update.inertial_phase = + gesture_data->scroll_data->inertial_phase; + if (gesture_data->scroll_data->update_details) { + gesture_event->data.scroll_update.velocity_x = + gesture_data->scroll_data->update_details->velocity_x; + gesture_event->data.scroll_update.velocity_y = + gesture_data->scroll_data->update_details->velocity_y; + } + break; + } + } + + if (gesture_data->pinch_begin_data && + type == blink::WebInputEvent::Type::kGesturePinchBegin) { + gesture_event->data.pinch_begin.needs_wheel_event = + gesture_data->pinch_begin_data->needs_wheel_event; + } + + if (gesture_data->pinch_update_data && + type == blink::WebInputEvent::Type::kGesturePinchUpdate) { + gesture_event->data.pinch_update.zoom_disabled = + gesture_data->pinch_update_data->zoom_disabled; + gesture_event->data.pinch_update.scale = + gesture_data->pinch_update_data->scale; + gesture_event->data.pinch_update.needs_wheel_event = + gesture_data->pinch_update_data->needs_wheel_event; + } + + if (gesture_data->pinch_end_data && + type == blink::WebInputEvent::Type::kGesturePinchEnd) { + gesture_event->data.pinch_end.needs_wheel_event = + gesture_data->pinch_end_data->needs_wheel_event; + } + + if (gesture_data->tap_data) { + switch (type) { + default: + break; + case blink::WebInputEvent::Type::kGestureTap: + case blink::WebInputEvent::Type::kGestureTapUnconfirmed: + case blink::WebInputEvent::Type::kGestureDoubleTap: + gesture_event->data.tap.tap_count = gesture_data->tap_data->tap_count; + gesture_event->data.tap.needs_wheel_event = + gesture_data->tap_data->needs_wheel_event; + break; + } + } + + if (gesture_data->fling_data) { + switch (type) { + default: + break; + case blink::WebInputEvent::Type::kGestureFlingStart: + gesture_event->data.fling_start.velocity_x = + gesture_data->fling_data->velocity_x; + gesture_event->data.fling_start.velocity_y = + gesture_data->fling_data->velocity_y; + gesture_event->data.fling_start.target_viewport = + gesture_data->fling_data->target_viewport; + break; + case blink::WebInputEvent::Type::kGestureFlingCancel: + gesture_event->data.fling_cancel.target_viewport = + gesture_data->fling_data->target_viewport; + gesture_event->data.fling_cancel.prevent_boosting = + gesture_data->fling_data->prevent_boosting; + break; + } + } + + } else if (blink::WebInputEvent::IsTouchEventType(type)) { + blink::mojom::TouchDataPtr touch_data; + if (!event.ReadTouchData<blink::mojom::TouchDataPtr>(&touch_data)) + return false; + + input_event.reset( + new blink::WebTouchEvent(type, event.modifiers(), timestamp)); + + blink::WebTouchEvent* touch_event = + static_cast<blink::WebTouchEvent*>(input_event.get()); + std::vector<blink::mojom::TouchPointPtr> touches; + unsigned i; + for (i = 0; i < touch_data->touches.size() && + i < blink::WebTouchEvent::kTouchesLengthCap; + ++i) { + blink::WebTouchPoint& touch_point = touch_event->touches[i]; + TouchPointPropertiesFromPointerData(touch_data->touches[i], &touch_point); + } + + touch_event->touches_length = i; + touch_event->dispatch_type = touch_data->cancelable; + touch_event->moved_beyond_slop_region = + touch_data->moved_beyond_slop_region; + touch_event->hovering = touch_data->hovering; + touch_event->touch_start_or_first_touch_move = + touch_data->touch_start_or_first_move; + touch_event->unique_touch_event_id = touch_data->unique_touch_event_id; + } else if (blink::WebInputEvent::IsMouseEventType(type) || + type == blink::WebInputEvent::Type::kMouseWheel) { + blink::mojom::PointerDataPtr pointer_data; + if (!event.ReadPointerData<blink::mojom::PointerDataPtr>(&pointer_data)) + return false; + + if (blink::WebInputEvent::IsMouseEventType(type)) { + input_event.reset( + new blink::WebMouseEvent(type, event.modifiers(), timestamp)); + } else { + input_event.reset( + new blink::WebMouseWheelEvent(type, event.modifiers(), timestamp)); + } + + blink::WebMouseEvent* mouse_event = + static_cast<blink::WebMouseEvent*>(input_event.get()); + + MouseEventPropertiesFromPointerData(pointer_data, mouse_event); + if (pointer_data->mouse_data) { + mouse_event->click_count = pointer_data->mouse_data->click_count; + + if (type == blink::WebInputEvent::Type::kMouseWheel && + pointer_data->mouse_data->wheel_data) { + blink::WebMouseWheelEvent* wheel_event = + static_cast<blink::WebMouseWheelEvent*>(mouse_event); + blink::mojom::WheelDataPtr& wheel_data = + pointer_data->mouse_data->wheel_data; + wheel_event->delta_x = wheel_data->delta_x; + wheel_event->delta_y = wheel_data->delta_y; + wheel_event->wheel_ticks_x = wheel_data->wheel_ticks_x; + wheel_event->wheel_ticks_y = wheel_data->wheel_ticks_y; + wheel_event->acceleration_ratio_x = wheel_data->acceleration_ratio_x; + wheel_event->acceleration_ratio_y = wheel_data->acceleration_ratio_y; + wheel_event->phase = + static_cast<blink::WebMouseWheelEvent::Phase>(wheel_data->phase); + wheel_event->momentum_phase = + static_cast<blink::WebMouseWheelEvent::Phase>( + wheel_data->momentum_phase); + wheel_event->dispatch_type = wheel_data->cancelable; + wheel_event->event_action = + static_cast<blink::WebMouseWheelEvent::EventAction>( + wheel_data->event_action); + wheel_event->delta_units = + static_cast<ui::ScrollGranularity>(wheel_data->delta_units); + } + } + + } else { + return false; + } + + ui::LatencyInfo latency_info; + if (!event.ReadLatency(&latency_info)) + return false; + out->reset( + new blink::WebCoalescedInputEvent(std::move(input_event), latency_info)); + return true; +} + +// static +blink::mojom::KeyDataPtr +StructTraits<blink::mojom::EventDataView, + std::unique_ptr<blink::WebCoalescedInputEvent>>:: + key_data(const std::unique_ptr<blink::WebCoalescedInputEvent>& event) { + if (!blink::WebInputEvent::IsKeyboardEventType(event->Event().GetType())) + return nullptr; + const blink::WebKeyboardEvent* key_event = + static_cast<const blink::WebKeyboardEvent*>(event->EventPointer()); + return blink::mojom::KeyData::New( + key_event->dom_key, key_event->dom_code, key_event->windows_key_code, + key_event->native_key_code, key_event->is_system_key, + key_event->is_browser_shortcut, key_event->text, + key_event->unmodified_text); +} + +// static +blink::mojom::PointerDataPtr +StructTraits<blink::mojom::EventDataView, + std::unique_ptr<blink::WebCoalescedInputEvent>>:: + pointer_data(const std::unique_ptr<blink::WebCoalescedInputEvent>& event) { + bool is_wheel_event = + event->Event().GetType() == blink::WebInputEvent::Type::kMouseWheel; + if (!blink::WebInputEvent::IsMouseEventType(event->Event().GetType()) && + !is_wheel_event) { + return nullptr; + } + const blink::WebMouseEvent* mouse_event = + static_cast<const blink::WebMouseEvent*>(event->EventPointer()); + + blink::mojom::WheelDataPtr wheel_data; + if (is_wheel_event) { + const blink::WebMouseWheelEvent* wheel_event = + static_cast<const blink::WebMouseWheelEvent*>(mouse_event); + wheel_data = blink::mojom::WheelData::New( + wheel_event->delta_x, wheel_event->delta_y, wheel_event->wheel_ticks_x, + wheel_event->wheel_ticks_y, wheel_event->acceleration_ratio_x, + wheel_event->acceleration_ratio_y, wheel_event->phase, + wheel_event->momentum_phase, wheel_event->dispatch_type, + static_cast<uint8_t>(wheel_event->event_action), + static_cast<uint8_t>(wheel_event->delta_units)); + } + + return PointerDataFromPointerProperties( + *mouse_event, blink::mojom::MouseData::New(mouse_event->click_count, + std::move(wheel_data))); +} + +// static +blink::mojom::GestureDataPtr +StructTraits<blink::mojom::EventDataView, + std::unique_ptr<blink::WebCoalescedInputEvent>>:: + gesture_data(const std::unique_ptr<blink::WebCoalescedInputEvent>& event) { + if (!blink::WebInputEvent::IsGestureEventType(event->Event().GetType())) + return nullptr; + const blink::WebGestureEvent* gesture_event = + static_cast<const blink::WebGestureEvent*>(event->EventPointer()); + auto gesture_data = blink::mojom::GestureData::New(); + gesture_data->screen_position = gesture_event->PositionInScreen(); + gesture_data->widget_position = gesture_event->PositionInWidget(); + gesture_data->source_device = gesture_event->SourceDevice(); + gesture_data->is_source_touch_event_set_non_blocking = + gesture_event->is_source_touch_event_set_non_blocking; + gesture_data->primary_pointer_type = gesture_event->primary_pointer_type; + gesture_data->unique_touch_event_id = gesture_event->unique_touch_event_id; + switch (gesture_event->GetType()) { + default: + break; + case blink::WebInputEvent::Type::kGestureTapDown: + gesture_data->contact_size = + gfx::Size(gesture_event->data.tap_down.width, + gesture_event->data.tap_down.height); + break; + case blink::WebInputEvent::Type::kGestureShowPress: + gesture_data->contact_size = + gfx::Size(gesture_event->data.show_press.width, + gesture_event->data.show_press.height); + break; + case blink::WebInputEvent::Type::kGestureTap: + case blink::WebInputEvent::Type::kGestureTapUnconfirmed: + case blink::WebInputEvent::Type::kGestureDoubleTap: + gesture_data->contact_size = gfx::Size(gesture_event->data.tap.width, + gesture_event->data.tap.height); + gesture_data->tap_data = + blink::mojom::TapData::New(gesture_event->data.tap.tap_count, + gesture_event->data.tap.needs_wheel_event); + break; + case blink::WebInputEvent::Type::kGestureLongPress: + case blink::WebInputEvent::Type::kGestureLongTap: + gesture_data->contact_size = + gfx::Size(gesture_event->data.long_press.width, + gesture_event->data.long_press.height); + break; + + case blink::WebInputEvent::Type::kGestureTwoFingerTap: + gesture_data->contact_size = + gfx::Size(gesture_event->data.two_finger_tap.first_finger_width, + gesture_event->data.two_finger_tap.first_finger_height); + break; + case blink::WebInputEvent::Type::kGestureScrollBegin: + gesture_data->scroll_data = blink::mojom::ScrollData::New( + gesture_event->data.scroll_begin.delta_x_hint, + gesture_event->data.scroll_begin.delta_y_hint, + gesture_event->data.scroll_begin.delta_hint_units, + gesture_event->data.scroll_begin.target_viewport, + gesture_event->data.scroll_begin.inertial_phase, + gesture_event->data.scroll_begin.synthetic, + gesture_event->data.scroll_begin.pointer_count, nullptr); + break; + case blink::WebInputEvent::Type::kGestureScrollEnd: + gesture_data->scroll_data = blink::mojom::ScrollData::New( + 0, 0, gesture_event->data.scroll_end.delta_units, false, + gesture_event->data.scroll_end.inertial_phase, + gesture_event->data.scroll_end.synthetic, 0, nullptr); + break; + case blink::WebInputEvent::Type::kGestureScrollUpdate: + gesture_data->scroll_data = blink::mojom::ScrollData::New( + gesture_event->data.scroll_update.delta_x, + gesture_event->data.scroll_update.delta_y, + gesture_event->data.scroll_update.delta_units, false, + gesture_event->data.scroll_update.inertial_phase, false, 0, + blink::mojom::ScrollUpdate::New( + gesture_event->data.scroll_update.velocity_x, + gesture_event->data.scroll_update.velocity_y)); + break; + case blink::WebInputEvent::Type::kGestureFlingStart: + gesture_data->fling_data = blink::mojom::FlingData::New( + gesture_event->data.fling_start.velocity_x, + gesture_event->data.fling_start.velocity_y, + gesture_event->data.fling_start.target_viewport, false); + break; + case blink::WebInputEvent::Type::kGestureFlingCancel: + gesture_data->fling_data = blink::mojom::FlingData::New( + 0, 0, gesture_event->data.fling_cancel.target_viewport, + gesture_event->data.fling_cancel.prevent_boosting); + break; + case blink::WebInputEvent::Type::kGesturePinchBegin: + gesture_data->pinch_begin_data = blink::mojom::PinchBeginData::New( + gesture_event->data.pinch_begin.needs_wheel_event); + break; + case blink::WebInputEvent::Type::kGesturePinchUpdate: + gesture_data->pinch_update_data = blink::mojom::PinchUpdateData::New( + gesture_event->data.pinch_update.scale, + gesture_event->data.pinch_update.zoom_disabled, + gesture_event->data.pinch_update.needs_wheel_event); + break; + case blink::WebInputEvent::Type::kGesturePinchEnd: + gesture_data->pinch_end_data = blink::mojom::PinchEndData::New( + gesture_event->data.pinch_end.needs_wheel_event); + break; + } + return gesture_data; +} + +// static +blink::mojom::TouchDataPtr +StructTraits<blink::mojom::EventDataView, + std::unique_ptr<blink::WebCoalescedInputEvent>>:: + touch_data(const std::unique_ptr<blink::WebCoalescedInputEvent>& event) { + if (!blink::WebInputEvent::IsTouchEventType(event->Event().GetType())) + return nullptr; + + const blink::WebTouchEvent* touch_event = + static_cast<const blink::WebTouchEvent*>(event->EventPointer()); + auto touch_data = blink::mojom::TouchData::New( + touch_event->dispatch_type, touch_event->moved_beyond_slop_region, + touch_event->touch_start_or_first_touch_move, touch_event->hovering, + touch_event->unique_touch_event_id, + std::vector<blink::mojom::TouchPointPtr>()); + for (unsigned i = 0; i < touch_event->touches_length; ++i) { + blink::mojom::PointerDataPtr pointer_data = + PointerDataFromPointerProperties(touch_event->touches[i], nullptr); + touch_data->touches.emplace_back(blink::mojom::TouchPoint::New( + touch_event->touches[i].state, touch_event->touches[i].radius_x, + touch_event->touches[i].radius_y, + touch_event->touches[i].rotation_angle, std::move(pointer_data))); + } + return touch_data; +} + +} // namespace mojo diff --git a/chromium/third_party/blink/common/input/web_mouse_wheel_event.cc b/chromium/third_party/blink/common/input/web_mouse_wheel_event.cc index 2400f799bd7..a7f5411a38d 100644 --- a/chromium/third_party/blink/common/input/web_mouse_wheel_event.cc +++ b/chromium/third_party/blink/common/input/web_mouse_wheel_event.cc @@ -110,4 +110,32 @@ WebMouseWheelEvent WebMouseWheelEvent::FlattenTransform() const { return result; } +// static +WebMouseWheelEvent::EventAction +WebMouseWheelEvent::GetPlatformSpecificDefaultEventAction( + const WebMouseWheelEvent& event) { +#if defined(USE_AURA) + // Scroll events generated from the mouse wheel when the control key is held + // don't trigger scrolling. Instead, they may cause zooming. + if (event.delta_units != ui::ScrollGranularity::kScrollByPrecisePixel && + (event.GetModifiers() & WebInputEvent::kControlKey)) { + return blink::WebMouseWheelEvent::EventAction::kPageZoom; + } + + if (event.delta_x == 0 && (event.GetModifiers() & WebInputEvent::kShiftKey)) + return blink::WebMouseWheelEvent::EventAction::kScrollHorizontal; +#endif + if (event.rails_mode == WebInputEvent::kRailsModeHorizontal || + (event.delta_x != 0 && event.delta_y == 0)) { + return blink::WebMouseWheelEvent::EventAction::kScrollHorizontal; + } + + if (event.rails_mode == WebInputEvent::kRailsModeVertical || + (event.delta_x == 0 && event.delta_y != 0)) { + return blink::WebMouseWheelEvent::EventAction::kScrollVertical; + } + + return blink::WebMouseWheelEvent::EventAction::kScroll; +} + } // namespace blink |