81.0.4021.2

3 files changed, 1393 insertions, 39 deletions

diff --git a/.SRCINFO b/.SRCINFO
index 47a59635d918..55ffe82f8f9d 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,6 +1,6 @@
 pkgbase = chromium-ozone
 	pkgdesc = Chromium built with patches for wayland support via Ozone
-	pkgver = 80.0.3987.42
+	pkgver = 81.0.4021.2
 	pkgrel = 1
 	url = https://www.chromium.org/Home
 	install = chromium.install
@@ -55,42 +55,20 @@ pkgbase = chromium-ozone
 	conflicts = chromium
 	options = debug
 	options = !strip
-	source = https://commondatastorage.googleapis.com/chromium-browser-official/chromium-80.0.3987.42.tar.xz
+	source = https://commondatastorage.googleapis.com/chromium-browser-official/chromium-81.0.4021.2.tar.xz
 	source = chromium-launcher-6.tar.gz::https://github.com/foutrelis/chromium-launcher/archive/v6.tar.gz
-	source = 0001-Add-missing-algorithm-header-in-bitmap_cursor_factor.patch
-	source = 0001-cros-search-service-Include-cmath-for-std-pow.patch
-	source = 0001-BookmarkModelMerger-Move-RemoteTreeNode-declaration-.patch
-	source = 0001-ozone-wayland-Extract-ShellObjectFactory-to-a-separa.patch
-	source = 0002-ozone-Wayland-Add-WaylandWindow-factory-method.patch
-	source = 0003-ozone-Wayland-move-bounds-translation-util-to-utilit.patch
-	source = 0004-ozone-wayland-Fix-regression-with-hiding-nested-wind.patch
-	source = 0005-ozone-Wayland-extract-toplevel-surface-methods-into-.patch
-	source = 0006-ozone-wayland-extract-popup-methods-to-WaylandPopup.patch
-	source = 0007-ozone-wayland-Extract-subsurface-from-WaylandWindow.patch
-	source = 0008-ozone-wayland-Recreate-ShellSurface-and-ShellPopup-o.patch
-	source = 0009-ozone-wayland-window-state-change-must-be-synchronou.patch
 	source = chromium-system-icu.patch
 	source = chromium-system-zlib.patch
+	source = 0001-Modernize-WebInputEvent.patch
 	source = fix-spammy-unique-font-matching-log.patch
 	source = chromium-widevine.patch
 	source = chromium-skia-harmony.patch
-	sha256sums = 160c02ed00d45a074246c8984144a35b092102e9b9a31e2bc9c2dad49f297945
+	sha256sums = 45f1c7efacf0e628da2943725a155d1f9143b53c3d8e649de10d48c4f17c8b69
 	sha256sums = 04917e3cd4307d8e31bfb0027a5dce6d086edb10ff8a716024fbb8bb0c7dccf1
-	sha256sums = 716c28bed9f6e9c32e3617e125c1b04806700aef691763923cd4ed14b8d23279
-	sha256sums = 4c892f046ab10df609aa39d9985248d368c77306783a64d335ff713dabad60b0
-	sha256sums = a44ed59db5258221ee187dc2501040e5ebfc5c1353ac98d4313ac6a12ae32d1f
-	sha256sums = 01f7a6e098e105949ec6267d7293eef4b79a4f9d20ecbf3b53f5944cf64674db
-	sha256sums = 2f9fc85844350e86e8b8389a2b4d84cf7a49ae582ddb66d3248b308b46ed33a2
-	sha256sums = d05d9dbb9ac53614365182cb04d473e906e20cba72225122b4ae1c03e7e19395
-	sha256sums = 8577707001330b4da42828708da8cf85d122127c3c84b6531e60dcbe9c04c587
-	sha256sums = 3909026200bb2b7d017da5a638bfa5785586a20445e24da846fe97878204a1c5
-	sha256sums = 88153c36bc639bee8959721b5140b325178fe548e3d5bd5e3b4b57129a7a9a0e
-	sha256sums = ca681e32a34fea040357554bdded0aed82d61c10f07a2da5f23317f45f3295cf
-	sha256sums = 38a951ffe9a031241179163a71391c4aabbd31432c4fb6cbc35800b632bce747
-	sha256sums = 7566c0690786bd2092736f6a7e6ad4c4304515e8a65814574d16f065c8a7d8f4
 	sha256sums = e73cc2ee8d3ea35aab18c478d76fdfc68ca4463e1e10306fa1e738c03b3f26b5
 	sha256sums = eb67eda4945a89c3b90473fa8dc20637511ca4dcb58879a8ed6bf403700ca9c8
-	sha256sums = 71e63e2f4db01f7beecbbdc98f78134288429825dbef3412779506e51277fb80
+	sha256sums = 5bd56b41062eb3346a33a27e18954899118fe55d99330d917fea4a6d94dc3ce1
+	sha256sums = 6fbffe59b886195b92c9a55137cef83021c16593f49714acb20023633e3ebb19
 	sha256sums = 709e2fddba3c1f2ed4deb3a239fc0479bfa50c46e054e7f32db4fb1365fed070
 	sha256sums = 771292942c0901092a402cc60ee883877a99fb804cb54d568c8c6c94565a48e1
 
diff --git a/0001-Modernize-WebInputEvent.patch b/0001-Modernize-WebInputEvent.patch
new file mode 100644
index 000000000000..f402f951493d
--- /dev/null
+++ b/0001-Modernize-WebInputEvent.patch
@@ -0,0 +1,1381 @@
+From ba38c72a21a6ebde6abf8f19c00c5c4423534106 Mon Sep 17 00:00:00 2001
+From: Dave Tapuska <dtapuska@chromium.org>
+Date: Mon, 6 Jan 2020 23:48:47 +0000
+Subject: [PATCH] Modernize WebInputEvent
+
+Reland 547be4072d5ef59ba1eea93aa0ac6a294f1660d7. It was previously
+reverted because CFI bot started to fail. That was fixed here:
+crrev.com/2708646cd1a812a84200a1db6208732fe20d49b8
+
+Since the class is no longer memcopied between processes we can
+use virtuals.
+- Add virtual destructor
+- Add pure virtual cloning
+- Remove memset
+- Remove size attribute
+
+BUG=836826
+TBR=nasko@chromium.org,bokan@chromium.org,jbroman@chromium.org
+
+Change-Id: I091683184ada8d693c11f8cb7aff9dae3eaf93e4
+Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1988849
+Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
+Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
+Cr-Commit-Position: refs/heads/master@{#728694}
+---
+ .../devtools/protocol/input_handler.cc        |  2 +-
+ .../renderer_host/input/input_router_impl.cc  |  3 +-
+ .../renderer_host/render_widget_targeter.cc   |  2 +-
+ .../site_per_process_hit_test_browsertest.cc  |  2 +-
+ .../common/input/event_with_latency_info.h    |  3 -
+ content/common/input/input_event.cc           |  3 +-
+ .../browser/native_web_keyboard_event.h       |  2 +-
+ .../renderer/input/input_event_prediction.cc  |  3 +-
+ .../input/main_thread_event_queue_unittest.cc | 33 +---------
+ .../input/widget_input_handler_manager.cc     |  3 +-
+ third_party/blink/common/BUILD.gn             |  1 +
+ .../blink/common/input/web_gesture_event.cc   |  4 ++
+ .../blink/common/input/web_keyboard_event.cc  | 13 ++++
+ .../blink/common/input/web_mouse_event.cc     |  6 +-
+ .../common/input/web_mouse_wheel_event.cc     |  4 ++
+ .../blink/common/input/web_pointer_event.cc   | 12 ++--
+ .../blink/common/input/web_touch_event.cc     |  4 ++
+ .../public/common/input/web_gesture_event.h   | 17 +++---
+ .../public/common/input/web_input_event.h     | 53 ++++------------
+ .../public/common/input/web_keyboard_event.h  | 24 ++++----
+ .../public/common/input/web_mouse_event.h     | 31 +++-------
+ .../common/input/web_mouse_wheel_event.h      | 60 ++++++-------------
+ .../public/common/input/web_pointer_event.h   | 24 ++++----
+ .../common/input/web_pointer_properties.h     | 18 ++----
+ .../public/common/input/web_touch_event.h     | 22 +++----
+ .../public/common/input/web_touch_point.h     | 16 ++---
+ .../platform/web_coalesced_input_event.h      |  7 +--
+ .../core/events/web_input_event_conversion.cc |  4 +-
+ .../exported/web_coalesced_input_event.cc     | 40 -------------
+ .../main_thread_scheduler_impl_unittest.cc    |  7 ++-
+ .../blink/compositor_thread_event_queue.cc    |  4 +-
+ ui/events/blink/event_with_callback.cc        |  2 +-
+ .../blink/input_handler_proxy_unittest.cc     |  8 +--
+ ui/events/blink/scroll_predictor_unittest.cc  | 10 ++--
+ ui/events/blink/web_input_event_traits.cc     | 35 -----------
+ ui/events/blink/web_input_event_traits.h      |  8 +--
+ 36 files changed, 164 insertions(+), 326 deletions(-)
+ create mode 100644 third_party/blink/common/input/web_keyboard_event.cc
+
+diff --git a/content/browser/devtools/protocol/input_handler.cc b/content/browser/devtools/protocol/input_handler.cc
+index 3d20f3d4d410..c7a95973d938 100644
+--- a/content/browser/devtools/protocol/input_handler.cc
++++ b/content/browser/devtools/protocol/input_handler.cc
+@@ -672,7 +672,7 @@ void InputHandler::DispatchMouseEvent(
+   modifiers |= button_modifiers;
+   base::TimeTicks timestamp = GetEventTimeTicks(maybe_timestamp);
+ 
+-  std::unique_ptr<blink::WebMouseEvent, ui::WebInputEventDeleter> mouse_event;
++  std::unique_ptr<blink::WebMouseEvent> mouse_event;
+   blink::WebMouseWheelEvent* wheel_event = nullptr;
+ 
+   if (type == blink::WebInputEvent::kMouseWheel) {
+diff --git a/content/browser/renderer_host/input/input_router_impl.cc b/content/browser/renderer_host/input/input_router_impl.cc
+index 44c32d2368ee..4b3e15112bdb 100644
+--- a/content/browser/renderer_host/input/input_router_impl.cc
++++ b/content/browser/renderer_host/input/input_router_impl.cc
+@@ -66,8 +66,7 @@ std::unique_ptr<InputEvent> ScaleEvent(const WebInputEvent& event,
+         latency_info.ScaledBy(scale));
+   }
+ 
+-  return std::make_unique<InputEvent>(ui::WebInputEventTraits::Clone(event),
+-                                      latency_info);
++  return std::make_unique<InputEvent>(event.Clone(), latency_info);
+ }
+ 
+ }  // namespace
+diff --git a/content/browser/renderer_host/render_widget_targeter.cc b/content/browser/renderer_host/render_widget_targeter.cc
+index 5171535dbe68..dd2876a5233c 100644
+--- a/content/browser/renderer_host/render_widget_targeter.cc
++++ b/content/browser/renderer_host/render_widget_targeter.cc
+@@ -106,7 +106,7 @@ RenderWidgetTargeter::TargetingRequest::TargetingRequest(
+     const ui::LatencyInfo& latency) {
+   this->root_view = std::move(root_view);
+   this->location = ComputeEventLocation(event);
+-  this->event = ui::WebInputEventTraits::Clone(event);
++  this->event = event.Clone();
+   this->latency = latency;
+ }
+ 
+diff --git a/content/browser/site_per_process_hit_test_browsertest.cc b/content/browser/site_per_process_hit_test_browsertest.cc
+index 228c8cbc9f3e..48cb1ebc744c 100644
+--- a/content/browser/site_per_process_hit_test_browsertest.cc
++++ b/content/browser/site_per_process_hit_test_browsertest.cc
+@@ -95,7 +95,7 @@ class TestInputEventObserver : public RenderWidgetHost::InputEventObserver {
+ 
+   void OnInputEvent(const blink::WebInputEvent& event) override {
+     events_received_.push_back(event.GetType());
+-    event_ = ui::WebInputEventTraits::Clone(event);
++    event_ = event.Clone();
+   }
+ 
+   const std::vector<InputEventAckSource>& events_acked() {
+diff --git a/content/common/input/event_with_latency_info.h b/content/common/input/event_with_latency_info.h
+index e61aa653725e..58e8b8ca2de6 100644
+--- a/content/common/input/event_with_latency_info.h
++++ b/content/common/input/event_with_latency_info.h
+@@ -41,9 +41,6 @@ class EventWithLatencyInfo {
+     if (other.event.GetType() != event.GetType())
+       return false;
+ 
+-    DCHECK_EQ(sizeof(T), event.size());
+-    DCHECK_EQ(sizeof(T), other.event.size());
+-
+     return ui::CanCoalesce(other.event, event);
+   }
+ 
+diff --git a/content/common/input/input_event.cc b/content/common/input/input_event.cc
+index 5204dde65a54..4e11e69a36a1 100644
+--- a/content/common/input/input_event.cc
++++ b/content/common/input/input_event.cc
+@@ -16,8 +16,7 @@ InputEvent::InputEvent(ui::WebScopedInputEvent event,
+ 
+ InputEvent::InputEvent(const blink::WebInputEvent& web_event,
+                        const ui::LatencyInfo& latency_info)
+-    : web_event(ui::WebInputEventTraits::Clone(web_event)),
+-      latency_info(latency_info) {}
++    : web_event(web_event.Clone()), latency_info(latency_info) {}
+ 
+ InputEvent::~InputEvent() {}
+ 
+diff --git a/content/public/browser/native_web_keyboard_event.h b/content/public/browser/native_web_keyboard_event.h
+index 7b10a7402d59..8498d45e54b7 100644
+--- a/content/public/browser/native_web_keyboard_event.h
++++ b/content/public/browser/native_web_keyboard_event.h
+@@ -57,7 +57,7 @@ struct CONTENT_EXPORT NativeWebKeyboardEvent : public blink::WebKeyboardEvent {
+ #endif
+ 
+   NativeWebKeyboardEvent(const NativeWebKeyboardEvent& event);
+-  ~NativeWebKeyboardEvent();
++  ~NativeWebKeyboardEvent() override;
+ 
+   NativeWebKeyboardEvent& operator=(const NativeWebKeyboardEvent& event);
+ 
+diff --git a/content/renderer/input/input_event_prediction.cc b/content/renderer/input/input_event_prediction.cc
+index bd43bcb389e3..b8a79476e80c 100644
+--- a/content/renderer/input/input_event_prediction.cc
++++ b/content/renderer/input/input_event_prediction.cc
+@@ -168,8 +168,7 @@ void InputEventPrediction::AddPredictedEvents(
+       last_event_timestamp_ + mouse_predictor_->MaxPredictionTime();
+   bool success = true;
+   while (success) {
+-    ui::WebScopedInputEvent predicted_event =
+-        ui::WebInputEventTraits::Clone(coalesced_event.Event());
++    ui::WebScopedInputEvent predicted_event = coalesced_event.Event().Clone();
+     success = false;
+     if (predicted_event->GetType() == WebInputEvent::kTouchMove) {
+       WebTouchEvent& touch_event =
+diff --git a/content/renderer/input/main_thread_event_queue_unittest.cc b/content/renderer/input/main_thread_event_queue_unittest.cc
+index 35a467cf9af2..299833e08d7d 100644
+--- a/content/renderer/input/main_thread_event_queue_unittest.cc
++++ b/content/renderer/input/main_thread_event_queue_unittest.cc
+@@ -5,6 +5,7 @@
+ #include <stddef.h>
+ 
+ #include <new>
++#include <tuple>
+ #include <utility>
+ #include <vector>
+ 
+@@ -197,8 +198,8 @@ class MainThreadEventQueueTest : public testing::Test,
+   void HandleEvent(WebInputEvent& event, InputEventAckState ack_result) {
+     base::AutoReset<bool> in_handle_event(&handler_callback_->handling_event_,
+                                           true);
+-    queue_->HandleEvent(ui::WebInputEventTraits::Clone(event),
+-                        ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, ack_result,
++    queue_->HandleEvent(event.Clone(), ui::LatencyInfo(),
++                        DISPATCH_TYPE_BLOCKING, ack_result,
+                         handler_callback_->GetCallback());
+   }
+ 
+@@ -354,8 +355,6 @@ TEST_F(MainThreadEventQueueTest, NonBlockingWheel) {
+   }
+ 
+   {
+-    EXPECT_EQ(kEvents[0].size(),
+-              handled_tasks_.at(0)->taskAsEvent()->Event().size());
+     EXPECT_EQ(kEvents[0].GetType(),
+               handled_tasks_.at(0)->taskAsEvent()->Event().GetType());
+     const WebMouseWheelEvent* last_wheel_event =
+@@ -446,8 +445,6 @@ TEST_F(MainThreadEventQueueTest, NonBlockingTouch) {
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(3u, handled_tasks_.size());
+ 
+-  EXPECT_EQ(kEvents[0].size(),
+-            handled_tasks_.at(0)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents[0].GetType(),
+             handled_tasks_.at(0)->taskAsEvent()->Event().GetType());
+   const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+@@ -464,8 +461,6 @@ TEST_F(MainThreadEventQueueTest, NonBlockingTouch) {
+     EXPECT_TRUE(Equal(kEvents[0], *coalesced_touch_event));
+   }
+ 
+-  EXPECT_EQ(kEvents[1].size(),
+-            handled_tasks_.at(1)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents[1].GetType(),
+             handled_tasks_.at(1)->taskAsEvent()->Event().GetType());
+   last_touch_event = static_cast<const WebTouchEvent*>(
+@@ -482,8 +477,6 @@ TEST_F(MainThreadEventQueueTest, NonBlockingTouch) {
+     EXPECT_TRUE(Equal(kEvents[1], *coalesced_touch_event));
+   }
+ 
+-  EXPECT_EQ(kEvents[2].size(),
+-            handled_tasks_.at(1)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents[2].GetType(),
+             handled_tasks_.at(2)->taskAsEvent()->Event().GetType());
+   last_touch_event = static_cast<const WebTouchEvent*>(
+@@ -602,8 +595,6 @@ TEST_F(MainThreadEventQueueTest, InterleavedEvents) {
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(2u, handled_tasks_.size());
+   {
+-    EXPECT_EQ(kWheelEvents[0].size(),
+-              handled_tasks_.at(0)->taskAsEvent()->Event().size());
+     EXPECT_EQ(kWheelEvents[0].GetType(),
+               handled_tasks_.at(0)->taskAsEvent()->Event().GetType());
+     const WebMouseWheelEvent* last_wheel_event =
+@@ -618,8 +609,6 @@ TEST_F(MainThreadEventQueueTest, InterleavedEvents) {
+     EXPECT_TRUE(Equal(coalesced_event, *last_wheel_event));
+   }
+   {
+-    EXPECT_EQ(kTouchEvents[0].size(),
+-              handled_tasks_.at(1)->taskAsEvent()->Event().size());
+     EXPECT_EQ(kTouchEvents[0].GetType(),
+               handled_tasks_.at(1)->taskAsEvent()->Event().GetType());
+     const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+@@ -999,8 +988,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(1u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(0)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(0)->taskAsEvent()->Event().GetType());
+   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
+@@ -1020,8 +1007,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(2u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(1)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(1)->taskAsEvent()->Event().GetType());
+   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
+@@ -1040,8 +1025,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(3u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(2)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(2)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+@@ -1058,8 +1041,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(4u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(3)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(3)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+@@ -1086,8 +1067,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(1u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(0)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(0)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+@@ -1105,8 +1084,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(2u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(1)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(1)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+@@ -1124,8 +1101,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(3u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(2)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(2)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+@@ -1143,8 +1118,6 @@ TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
+   EXPECT_FALSE(main_task_runner_->HasPendingTask());
+   EXPECT_EQ(0u, event_queue().size());
+   EXPECT_EQ(4u, handled_tasks_.size());
+-  EXPECT_EQ(kEvents.size(),
+-            handled_tasks_.at(3)->taskAsEvent()->Event().size());
+   EXPECT_EQ(kEvents.GetType(),
+             handled_tasks_.at(3)->taskAsEvent()->Event().GetType());
+   EXPECT_EQ(kEvents.dispatch_type, WebInputEvent::kBlocking);
+diff --git a/content/renderer/input/widget_input_handler_manager.cc b/content/renderer/input/widget_input_handler_manager.cc
+index 21a11e35ece0..eafde289309f 100644
+--- a/content/renderer/input/widget_input_handler_manager.cc
++++ b/content/renderer/input/widget_input_handler_manager.cc
+@@ -258,8 +258,7 @@ void WidgetInputHandlerManager::GenerateScrollBeginAndSendToMainThread(
+   blink::WebGestureEvent scroll_begin =
+       ui::ScrollBeginFromScrollUpdate(update_event);
+ 
+-  DispatchNonBlockingEventToMainThread(
+-      ui::WebInputEventTraits::Clone(scroll_begin), ui::LatencyInfo());
++  DispatchNonBlockingEventToMainThread(scroll_begin.Clone(), ui::LatencyInfo());
+ }
+ 
+ void WidgetInputHandlerManager::SetWhiteListedTouchAction(
+diff --git a/third_party/blink/common/BUILD.gn b/third_party/blink/common/BUILD.gn
+index 2461000838d2..b003d6e6db93 100644
+--- a/third_party/blink/common/BUILD.gn
++++ b/third_party/blink/common/BUILD.gn
+@@ -48,6 +48,7 @@ jumbo_source_set("common") {
+     "indexeddb/indexeddb_key_range.cc",
+     "indexeddb/indexeddb_metadata.cc",
+     "input/web_gesture_event.cc",
++    "input/web_keyboard_event.cc",
+     "input/web_mouse_event.cc",
+     "input/web_mouse_wheel_event.cc",
+     "input/web_pointer_event.cc",
+diff --git a/third_party/blink/common/input/web_gesture_event.cc b/third_party/blink/common/input/web_gesture_event.cc
+index 512cd96b073d..85a0dc6acb0f 100644
+--- a/third_party/blink/common/input/web_gesture_event.cc
++++ b/third_party/blink/common/input/web_gesture_event.cc
+@@ -6,6 +6,10 @@
+ 
+ namespace blink {
+ 
++std::unique_ptr<WebInputEvent> WebGestureEvent::Clone() const {
++  return std::make_unique<WebGestureEvent>(*this);
++}
++
+ float WebGestureEvent::DeltaXInRootFrame() const {
+   if (type_ == WebInputEvent::kGestureScrollBegin)
+     return data.scroll_begin.delta_x_hint / frame_scale_;
+diff --git a/third_party/blink/common/input/web_keyboard_event.cc b/third_party/blink/common/input/web_keyboard_event.cc
+new file mode 100644
+index 000000000000..a75be6d05e3b
+--- /dev/null
++++ b/third_party/blink/common/input/web_keyboard_event.cc
+@@ -0,0 +1,13 @@
++// Copyright 2019 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_keyboard_event.h"
++
++namespace blink {
++
++std::unique_ptr<WebInputEvent> WebKeyboardEvent::Clone() const {
++  return std::make_unique<WebKeyboardEvent>(*this);
++}
++
++}  // namespace blink
+diff --git a/third_party/blink/common/input/web_mouse_event.cc b/third_party/blink/common/input/web_mouse_event.cc
+index 1942ad589062..5057d07b0afc 100644
+--- a/third_party/blink/common/input/web_mouse_event.cc
++++ b/third_party/blink/common/input/web_mouse_event.cc
+@@ -15,7 +15,7 @@ WebMouseEvent::WebMouseEvent(WebInputEvent::Type type,
+                              int modifiers,
+                              base::TimeTicks time_stamp,
+                              PointerId id_param)
+-    : WebInputEvent(sizeof(WebMouseEvent), type, modifiers, time_stamp),
++    : WebInputEvent(type, modifiers, time_stamp),
+       WebPointerProperties(id_param,
+                            WebPointerProperties::PointerType::kMouse,
+                            button_param),
+@@ -34,6 +34,10 @@ gfx::PointF WebMouseEvent::PositionInRootFrame() const {
+          frame_translate_;
+ }
+ 
++std::unique_ptr<WebInputEvent> WebMouseEvent::Clone() const {
++  return std::make_unique<WebMouseEvent>(*this);
++}
++
+ WebMouseEvent WebMouseEvent::FlattenTransform() const {
+   WebMouseEvent result = *this;
+   result.FlattenTransformSelf();
+diff --git a/third_party/blink/common/input/web_mouse_wheel_event.cc b/third_party/blink/common/input/web_mouse_wheel_event.cc
+index 7de30cb50a63..eea98f9a5387 100644
+--- a/third_party/blink/common/input/web_mouse_wheel_event.cc
++++ b/third_party/blink/common/input/web_mouse_wheel_event.cc
+@@ -6,6 +6,10 @@
+ 
+ namespace blink {
+ 
++std::unique_ptr<WebInputEvent> WebMouseWheelEvent::Clone() const {
++  return std::make_unique<WebMouseWheelEvent>(*this);
++}
++
+ float WebMouseWheelEvent::DeltaXInRootFrame() const {
+   return delta_x / frame_scale_;
+ }
+diff --git a/third_party/blink/common/input/web_pointer_event.cc b/third_party/blink/common/input/web_pointer_event.cc
+index 3cc2213dcb27..aa09d605a7d0 100644
+--- a/third_party/blink/common/input/web_pointer_event.cc
++++ b/third_party/blink/common/input/web_pointer_event.cc
+@@ -30,8 +30,7 @@ WebInputEvent::Type PointerEventTypeForTouchPointState(
+ 
+ WebPointerEvent::WebPointerEvent(const WebTouchEvent& touch_event,
+                                  const WebTouchPoint& touch_point)
+-    : WebInputEvent(sizeof(WebPointerEvent),
+-                    PointerEventTypeForTouchPointState(touch_point.state),
++    : WebInputEvent(PointerEventTypeForTouchPointState(touch_point.state),
+                     touch_event.GetModifiers(),
+                     touch_event.TimeStamp()),
+ 
+@@ -58,10 +57,7 @@ WebPointerEvent::WebPointerEvent(const WebTouchEvent& touch_event,
+ 
+ WebPointerEvent::WebPointerEvent(WebInputEvent::Type type,
+                                  const WebMouseEvent& mouse_event)
+-    : WebInputEvent(sizeof(WebPointerEvent),
+-                    type,
+-                    mouse_event.GetModifiers(),
+-                    mouse_event.TimeStamp()),
++    : WebInputEvent(type, mouse_event.GetModifiers(), mouse_event.TimeStamp()),
+       WebPointerProperties(mouse_event),
+       hovering(true),
+       width(std::numeric_limits<float>::quiet_NaN()),
+@@ -72,6 +68,10 @@ WebPointerEvent::WebPointerEvent(WebInputEvent::Type type,
+   SetFrameTranslate(mouse_event.FrameTranslate());
+ }
+ 
++std::unique_ptr<WebInputEvent> WebPointerEvent::Clone() const {
++  return std::make_unique<WebPointerEvent>(*this);
++}
++
+ WebPointerEvent WebPointerEvent::CreatePointerCausesUaActionEvent(
+     WebPointerProperties::PointerType type,
+     base::TimeTicks time_stamp) {
+diff --git a/third_party/blink/common/input/web_touch_event.cc b/third_party/blink/common/input/web_touch_event.cc
+index ed4904625db1..20a55c26329a 100644
+--- a/third_party/blink/common/input/web_touch_event.cc
++++ b/third_party/blink/common/input/web_touch_event.cc
+@@ -6,6 +6,10 @@
+ 
+ namespace blink {
+ 
++std::unique_ptr<WebInputEvent> WebTouchEvent::Clone() const {
++  return std::make_unique<WebTouchEvent>(*this);
++}
++
+ WebTouchEvent WebTouchEvent::FlattenTransform() const {
+   WebTouchEvent transformed_event = *this;
+   for (unsigned i = 0; i < touches_length; ++i) {
+diff --git a/third_party/blink/public/common/input/web_gesture_event.h b/third_party/blink/public/common/input/web_gesture_event.h
+index 581955550705..947c1b601916 100644
+--- a/third_party/blink/public/common/input/web_gesture_event.h
++++ b/third_party/blink/public/common/input/web_gesture_event.h
+@@ -26,7 +26,7 @@ class BLINK_COMMON_EXPORT WebGestureEvent : public WebInputEvent {
+     kMaxValue = kMomentum,
+   };
+ 
+-  bool is_source_touch_event_set_non_blocking;
++  bool is_source_touch_event_set_non_blocking = false;
+ 
+   // The pointer type for the first touch point in the gesture.
+   WebPointerProperties::PointerType primary_pointer_type =
+@@ -38,7 +38,7 @@ class BLINK_COMMON_EXPORT WebGestureEvent : public WebInputEvent {
+   // not released through a touch event (e.g. timer-released gesture events or
+   // gesture events with source_device != WebGestureDevice::kTouchscreen), the
+   // field contains 0. See crbug.com/618738.
+-  uint32_t unique_touch_event_id;
++  uint32_t unique_touch_event_id = 0;
+ 
+   union {
+     // Tap information must be set for GestureTap, GestureTapUnconfirmed,
+@@ -180,23 +180,24 @@ class BLINK_COMMON_EXPORT WebGestureEvent : public WebInputEvent {
+   // Screen coordinate
+   gfx::PointF position_in_screen_;
+ 
+-  WebGestureDevice source_device_;
++  WebGestureDevice source_device_ = WebGestureDevice::kUninitialized;
+ 
+  public:
+   WebGestureEvent(Type type,
+                   int modifiers,
+                   base::TimeTicks time_stamp,
+                   WebGestureDevice device = WebGestureDevice::kUninitialized)
+-      : WebInputEvent(sizeof(WebGestureEvent), type, modifiers, time_stamp),
+-        source_device_(device) {}
++      : WebInputEvent(type, modifiers, time_stamp), source_device_(device) {
++    memset(&data, 0, sizeof(data));
++  }
+ 
+-  WebGestureEvent()
+-      : WebInputEvent(sizeof(WebGestureEvent)),
+-        source_device_(WebGestureDevice::kUninitialized) {}
++  WebGestureEvent() { memset(&data, 0, sizeof(data)); }
+ 
+   const gfx::PointF& PositionInWidget() const { return position_in_widget_; }
+   const gfx::PointF& PositionInScreen() const { return position_in_screen_; }
+ 
++  std::unique_ptr<WebInputEvent> Clone() const override;
++
+   void SetPositionInWidget(const gfx::PointF& point) {
+     position_in_widget_ = point;
+   }
+diff --git a/third_party/blink/public/common/input/web_input_event.h b/third_party/blink/public/common/input/web_input_event.h
+index c137231c75f1..5d30b5eaab6a 100644
+--- a/third_party/blink/public/common/input/web_input_event.h
++++ b/third_party/blink/public/common/input/web_input_event.h
+@@ -42,7 +42,7 @@ namespace blink {
+ 
+ // WebInputEvent --------------------------------------------------------------
+ 
+-class WebInputEvent {
++class BLINK_COMMON_EXPORT WebInputEvent {
+  public:
+   // When we use an input method (or an input method editor), we receive
+   // two events for a keypress. The former event is a keydown, which
+@@ -426,61 +426,30 @@ class WebInputEvent {
+   base::TimeTicks TimeStamp() const { return time_stamp_; }
+   void SetTimeStamp(base::TimeTicks time_stamp) { time_stamp_ = time_stamp; }
+ 
+-  unsigned size() const { return size_; }
+-
+   void SetTargetFrameMovedRecently() {
+     modifiers_ |= kTargetFrameMovedRecently;
+   }
+ 
++  virtual ~WebInputEvent() = default;
++
++  virtual std::unique_ptr<WebInputEvent> Clone() const = 0;
++
+  protected:
+   // The root frame scale.
+-  float frame_scale_;
++  float frame_scale_ = 1;
+ 
+   // The root frame translation (applied post scale).
+   gfx::Vector2dF frame_translate_;
+ 
+-  WebInputEvent(unsigned size,
+-                Type type,
+-                int modifiers,
+-                base::TimeTicks time_stamp) {
+-    // TODO(dtapuska): Remove this memset when we remove the chrome IPC of this
+-    // struct.
+-    memset(this, 0, size);
+-    time_stamp_ = time_stamp;
+-    size_ = size;
+-    type_ = type;
+-    modifiers_ = modifiers;
+-#if DCHECK_IS_ON()
+-    // If dcheck is on force failures if frame scale is not initialized
+-    // correctly by causing DIV0.
+-    frame_scale_ = 0;
+-#else
+-    frame_scale_ = 1;
+-#endif
+-  }
++  WebInputEvent(Type type, int modifiers, base::TimeTicks time_stamp)
++      : time_stamp_(time_stamp), type_(type), modifiers_(modifiers) {}
+ 
+-  explicit WebInputEvent(unsigned size_param) {
+-    // TODO(dtapuska): Remove this memset when we remove the chrome IPC of this
+-    // struct.
+-    memset(this, 0, size_param);
+-    time_stamp_ = base::TimeTicks();
+-    size_ = size_param;
+-    type_ = kUndefined;
+-#if DCHECK_IS_ON()
+-    // If dcheck is on force failures if frame scale is not initialized
+-    // correctly by causing DIV0.
+-    frame_scale_ = 0;
+-#else
+-    frame_scale_ = 1;
+-#endif
+-  }
++  WebInputEvent() { time_stamp_ = base::TimeTicks(); }
+ 
+   // Event time since platform start with microsecond resolution.
+   base::TimeTicks time_stamp_;
+-  // The size of this structure, for serialization.
+-  unsigned size_;
+-  Type type_;
+-  int modifiers_;
++  Type type_ = kUndefined;
++  int modifiers_ = kNoModifiers;
+ };
+ 
+ }  // namespace blink
+diff --git a/third_party/blink/public/common/input/web_keyboard_event.h b/third_party/blink/public/common/input/web_keyboard_event.h
+index 18cfb20dbe32..5f38e9ec8fa0 100644
+--- a/third_party/blink/public/common/input/web_keyboard_event.h
++++ b/third_party/blink/public/common/input/web_keyboard_event.h
+@@ -12,7 +12,7 @@ namespace blink {
+ 
+ // WebKeyboardEvent -----------------------------------------------------------
+ 
+-class WebKeyboardEvent : public WebInputEvent {
++class BLINK_COMMON_EXPORT WebKeyboardEvent : public WebInputEvent {
+  public:
+   // Caps on string lengths so we can make them static arrays and keep
+   // them PODs.
+@@ -26,32 +26,32 @@ class WebKeyboardEvent : public WebInputEvent {
+   // what is returned by the Windows API. For example, it should
+   // store VK_SHIFT instead of VK_RSHIFT. The location information
+   // should be stored in |modifiers|.
+-  int windows_key_code;
++  int windows_key_code = 0;
+ 
+   // The actual key code genenerated by the platform. The DOM spec runs
+   // on Windows-equivalent codes (thus |windows_key_code| above) but it
+   // doesn't hurt to have this one around.
+-  int native_key_code;
++  int native_key_code = 0;
+ 
+   // The DOM code enum of the key pressed as passed by the embedder. DOM code
+   // enums are defined in ui/events/keycodes/dom/keycode_converter_data.inc.
+-  int dom_code;
++  int dom_code = 0;
+ 
+   // The DOM key enum of the key pressed as passed by the embedder. DOM
+   // key enums are defined in ui/events/keycodes/dom/dom_key_data.inc.
+-  int dom_key;
++  int dom_key = 0;
+ 
+   // This identifies whether this event was tagged by the system as being a
+   // "system key" event (see
+   // https://docs.microsoft.com/en-us/windows/desktop/inputdev/wm-syskeydown for
+   // details). Other platforms don't have this concept, but it's just
+   // easier to leave it always false than ifdef.
+-  bool is_system_key;
++  bool is_system_key = false;
+ 
+   // Whether the event forms part of a browser-handled keyboard shortcut.
+   // This can be used to conditionally suppress Char events after a
+   // shortcut-triggering RawKeyDown goes unhandled.
+-  bool is_browser_shortcut;
++  bool is_browser_shortcut = false;
+ 
+   // |text| is the text generated by this keystroke.  |unmodified_text| is
+   // |text|, but unmodified by an concurrently-held modifiers (except
+@@ -59,13 +59,15 @@ class WebKeyboardEvent : public WebInputEvent {
+   // Windows guarantee one character per event.  The Mac does not, but in
+   // reality that's all it ever gives.  We're generous, and cap it a bit
+   // longer.
+-  base::char16 text[kTextLengthCap];
+-  base::char16 unmodified_text[kTextLengthCap];
++  base::char16 text[kTextLengthCap] = {};
++  base::char16 unmodified_text[kTextLengthCap] = {};
+ 
+   WebKeyboardEvent(Type type, int modifiers, base::TimeTicks time_stamp)
+-      : WebInputEvent(sizeof(WebKeyboardEvent), type, modifiers, time_stamp) {}
++      : WebInputEvent(type, modifiers, time_stamp) {}
+ 
+-  WebKeyboardEvent() : WebInputEvent(sizeof(WebKeyboardEvent)) {}
++  WebKeyboardEvent() = default;
++
++  std::unique_ptr<WebInputEvent> Clone() const override;
+ 
+   // Please refer to bug http://b/issue?id=961192, which talks about Webkit
+   // keyboard event handling changes. It also mentions the list of keys
+diff --git a/third_party/blink/public/common/input/web_mouse_event.h b/third_party/blink/public/common/input/web_mouse_event.h
+index 25da4f16f58a..957e83c238b9 100644
+--- a/third_party/blink/public/common/input/web_mouse_event.h
++++ b/third_party/blink/public/common/input/web_mouse_event.h
+@@ -20,10 +20,10 @@ class BLINK_COMMON_EXPORT WebMouseEvent : public WebInputEvent,
+  public:
+   static constexpr PointerId kMousePointerId = std::numeric_limits<int>::max();
+ 
+-  int click_count;
++  int click_count = {};
+ 
+   // Only used for contextmenu events.
+-  WebMenuSourceType menu_source_type;
++  WebMenuSourceType menu_source_type = kMenuSourceNone;
+ 
+   WebMouseEvent(Type type_param,
+                 gfx::PointF position,
+@@ -34,10 +34,7 @@ class BLINK_COMMON_EXPORT WebMouseEvent : public WebInputEvent,
+                 base::TimeTicks time_stamp_param,
+                 WebMenuSourceType menu_source_type_param = kMenuSourceNone,
+                 PointerId id_param = kMousePointerId)
+-      : WebInputEvent(sizeof(WebMouseEvent),
+-                      type_param,
+-                      modifiers_param,
+-                      time_stamp_param),
++      : WebInputEvent(type_param, modifiers_param, time_stamp_param),
+         WebPointerProperties(id_param,
+                              PointerType::kMouse,
+                              button_param,
+@@ -53,13 +50,10 @@ class BLINK_COMMON_EXPORT WebMouseEvent : public WebInputEvent,
+                 int modifiers_param,
+                 base::TimeTicks time_stamp_param,
+                 PointerId id_param = kMousePointerId)
+-      : WebMouseEvent(sizeof(WebMouseEvent),
+-                      type_param,
+-                      modifiers_param,
+-                      time_stamp_param,
+-                      id_param) {}
++      : WebInputEvent(type_param, modifiers_param, time_stamp_param),
++        WebPointerProperties(id_param) {}
+ 
+-  WebMouseEvent() : WebMouseEvent(sizeof(WebMouseEvent), kMousePointerId) {}
++  WebMouseEvent() : WebMouseEvent(kMousePointerId) {}
+ 
+   bool FromTouch() const {
+     return (GetModifiers() & kIsCompatibilityEventForTouch) != 0;
+@@ -73,6 +67,8 @@ class BLINK_COMMON_EXPORT WebMouseEvent : public WebInputEvent,
+                 base::TimeTicks time_stamp_param,
+                 PointerId id_param = kMousePointerId);
+ 
++  std::unique_ptr<WebInputEvent> Clone() const override;
++
+   gfx::PointF PositionInRootFrame() const;
+ 
+   // Sets any scaled values to be their computed values and sets |frame_scale_|
+@@ -80,16 +76,7 @@ class BLINK_COMMON_EXPORT WebMouseEvent : public WebInputEvent,
+   WebMouseEvent FlattenTransform() const;
+ 
+  protected:
+-  WebMouseEvent(unsigned size_param, PointerId id_param)
+-      : WebInputEvent(size_param), WebPointerProperties(id_param) {}
+-
+-  WebMouseEvent(unsigned size_param,
+-                Type type,
+-                int modifiers,
+-                base::TimeTicks time_stamp,
+-                PointerId id_param)
+-      : WebInputEvent(size_param, type, modifiers, time_stamp),
+-        WebPointerProperties(id_param) {}
++  WebMouseEvent(PointerId id_param) : WebPointerProperties(id_param) {}
+ 
+   void FlattenTransformSelf();
+ 
+diff --git a/third_party/blink/public/common/input/web_mouse_wheel_event.h b/third_party/blink/public/common/input/web_mouse_wheel_event.h
+index 605740b8c01d..79697fe69e08 100644
+--- a/third_party/blink/public/common/input/web_mouse_wheel_event.h
++++ b/third_party/blink/public/common/input/web_mouse_wheel_event.h
+@@ -52,25 +52,25 @@ class BLINK_COMMON_EXPORT WebMouseWheelEvent : public WebMouseEvent {
+     kScrollVertical
+   };
+ 
+-  float delta_x;
+-  float delta_y;
+-  float wheel_ticks_x;
+-  float wheel_ticks_y;
++  float delta_x = 0.0f;
++  float delta_y = 0.0f;
++  float wheel_ticks_x = 0.0f;
++  float wheel_ticks_y = 0.0f;
+ 
+-  float acceleration_ratio_x;
+-  float acceleration_ratio_y;
++  float acceleration_ratio_x = 1.0f;
++  float acceleration_ratio_y = 1.0f;
+ 
+-  Phase phase;
+-  Phase momentum_phase;
++  Phase phase = kPhaseNone;
++  Phase momentum_phase = kPhaseNone;
+ 
+-  RailsMode rails_mode;
++  RailsMode rails_mode = kRailsModeFree;
+ 
+   // Whether the event is blocking, non-blocking, all event
+   // listeners were passive or was forced to be non-blocking.
+-  DispatchType dispatch_type;
++  DispatchType dispatch_type = kBlocking;
+ 
+   // The expected result of this wheel event (if not canceled).
+-  EventAction event_action;
++  EventAction event_action = EventAction::kPageZoom;
+ 
+   // True when phase information is added in mouse_wheel_phase_handler based
+   // on its timer.
+@@ -80,39 +80,13 @@ class BLINK_COMMON_EXPORT WebMouseWheelEvent : public WebMouseEvent {
+   // kScrollByPrecisePixel, kScrollByPixel, and kScrollByPage, as they are
+   // the only values expected after converting an OS event to a
+   // WebMouseWheelEvent.
+-  ui::input_types::ScrollGranularity delta_units;
++  ui::input_types::ScrollGranularity delta_units =
++      ui::input_types::ScrollGranularity::kScrollByPixel;
+ 
+   WebMouseWheelEvent(Type type, int modifiers, base::TimeTicks time_stamp)
+-      : WebMouseEvent(sizeof(WebMouseWheelEvent),
+-                      type,
+-                      modifiers,
+-                      time_stamp,
+-                      kMousePointerId),
+-        delta_x(0.0f),
+-        delta_y(0.0f),
+-        wheel_ticks_x(0.0f),
+-        wheel_ticks_y(0.0f),
+-        acceleration_ratio_x(1.0f),
+-        acceleration_ratio_y(1.0f),
+-        phase(kPhaseNone),
+-        momentum_phase(kPhaseNone),
+-        rails_mode(kRailsModeFree),
+-        dispatch_type(kBlocking),
+-        delta_units(ui::input_types::ScrollGranularity::kScrollByPixel) {}
+-
+-  WebMouseWheelEvent()
+-      : WebMouseEvent(sizeof(WebMouseWheelEvent), kMousePointerId),
+-        delta_x(0.0f),
+-        delta_y(0.0f),
+-        wheel_ticks_x(0.0f),
+-        wheel_ticks_y(0.0f),
+-        acceleration_ratio_x(1.0f),
+-        acceleration_ratio_y(1.0f),
+-        phase(kPhaseNone),
+-        momentum_phase(kPhaseNone),
+-        rails_mode(kRailsModeFree),
+-        dispatch_type(kBlocking),
+-        delta_units(ui::input_types::ScrollGranularity::kScrollByPixel) {}
++      : WebMouseEvent(type, modifiers, time_stamp, kMousePointerId) {}
++
++  WebMouseWheelEvent() : WebMouseEvent(kMousePointerId) {}
+ 
+   float DeltaXInRootFrame() const;
+   float DeltaYInRootFrame() const;
+@@ -122,6 +96,8 @@ class BLINK_COMMON_EXPORT WebMouseWheelEvent : public WebMouseEvent {
+   WebMouseWheelEvent FlattenTransform() const;
+ 
+   bool IsCancelable() const { return dispatch_type == kBlocking; }
++
++  std::unique_ptr<WebInputEvent> Clone() const override;
+ };
+ 
+ }  // namespace blink
+diff --git a/third_party/blink/public/common/input/web_pointer_event.h b/third_party/blink/public/common/input/web_pointer_event.h
+index cdf6b9984dcb..efb5847eb8ec 100644
+--- a/third_party/blink/public/common/input/web_pointer_event.h
++++ b/third_party/blink/public/common/input/web_pointer_event.h
+@@ -21,14 +21,12 @@ namespace blink {
+ class BLINK_COMMON_EXPORT WebPointerEvent : public WebInputEvent,
+                                             public WebPointerProperties {
+  public:
+-  WebPointerEvent()
+-      : WebInputEvent(sizeof(WebPointerEvent)), WebPointerProperties(0) {}
++  WebPointerEvent() : WebPointerProperties(0) {}
+   WebPointerEvent(WebInputEvent::Type type_param,
+                   WebPointerProperties web_pointer_properties_param,
+                   float width_param,
+                   float height_param)
+-      : WebInputEvent(sizeof(WebPointerEvent)),
+-        WebPointerProperties(web_pointer_properties_param),
++      : WebPointerProperties(web_pointer_properties_param),
+         width(width_param),
+         height(height_param) {
+     SetType(type_param);
+@@ -36,44 +34,46 @@ class BLINK_COMMON_EXPORT WebPointerEvent : public WebInputEvent,
+   WebPointerEvent(const WebTouchEvent&, const WebTouchPoint&);
+   WebPointerEvent(WebInputEvent::Type, const WebMouseEvent&);
+ 
++  std::unique_ptr<WebInputEvent> Clone() const override;
++
+   static WebPointerEvent CreatePointerCausesUaActionEvent(
+       WebPointerProperties::PointerType,
+       base::TimeTicks time_stamp);
+ 
+   // ------------ Touch Point Specific ------------
+ 
+-  float rotation_angle;
++  float rotation_angle = 0.0f;
+ 
+   // ------------ Touch Event Specific ------------
+ 
+   // A unique identifier for the touch event. Valid ids start at one and
+   // increase monotonically. Zero means an unknown id.
+-  uint32_t unique_touch_event_id;
++  uint32_t unique_touch_event_id = 0;
+ 
+   // Whether the event is blocking, non-blocking, all event
+   // listeners were passive or was forced to be non-blocking.
+-  DispatchType dispatch_type;
++  DispatchType dispatch_type = kBlocking;
+ 
+   // For a single touch, this is true after the touch-point has moved beyond
+   // the platform slop region. For a multitouch, this is true after any
+   // touch-point has moved (by whatever amount).
+-  bool moved_beyond_slop_region;
++  bool moved_beyond_slop_region = false;
+ 
+   // Whether this touch event is a touchstart or a first touchmove event per
+   // scroll.
+-  bool touch_start_or_first_touch_move;
++  bool touch_start_or_first_touch_move = false;
+ 
+   // ------------ Common fields across pointer types ------------
+ 
+   // True if this pointer was hovering and false otherwise. False value entails
+   // the event was processed as part of gesture detection and it may cause
+   // scrolling.
+-  bool hovering;
++  bool hovering = false;
+ 
+   // TODO(crbug.com/736014): We need a clarified definition of the scale and
+   // the coordinate space on these attributes.
+-  float width;
+-  float height;
++  float width = 0.0f;
++  float height = 0.0f;
+ 
+   bool IsCancelable() const { return dispatch_type == kBlocking; }
+   bool HasWidth() const { return !std::isnan(width); }
+diff --git a/third_party/blink/public/common/input/web_pointer_properties.h b/third_party/blink/public/common/input/web_pointer_properties.h
+index d122090fde30..c642fab9da4c 100644
+--- a/third_party/blink/public/common/input/web_pointer_properties.h
++++ b/third_party/blink/public/common/input/web_pointer_properties.h
+@@ -60,16 +60,10 @@ class WebPointerProperties {
+       int movement_x = 0,
+       int movement_y = 0)
+       : id(id_param),
+-        force(std::numeric_limits<float>::quiet_NaN()),
+-        tilt_x(0),
+-        tilt_y(0),
+-        tangential_pressure(0.0f),
+-        twist(0),
+         button(button_param),
+         pointer_type(pointer_type_param),
+         movement_x(movement_x),
+         movement_y(movement_y),
+-        is_raw_movement_event(false),
+         position_in_widget_(position_in_widget),
+         position_in_screen_(position_in_screen) {}
+ 
+@@ -96,23 +90,23 @@ class WebPointerProperties {
+ 
+   // The valid range is [0,1], with NaN meaning pressure is not supported by
+   // the input device.
+-  float force;
++  float force = std::numeric_limits<float>::quiet_NaN();
+ 
+   // Tilt of a pen stylus from surface normal as plane angles in degrees,
+   // Values lie in [-90,90]. A positive tiltX is to the right and a positive
+   // tiltY is towards the user.
+-  int tilt_x;
+-  int tilt_y;
++  int tilt_x = 0;
++  int tilt_y = 0;
+ 
+   // The normalized tangential pressure (or barrel pressure), typically set by
+   // an additional control of the stylus, which has a range of [-1,1], where 0
+   // is the neutral position of the control. Always 0 if the device does not
+   // support it.
+-  float tangential_pressure;
++  float tangential_pressure = 0.0f;
+ 
+   // The clockwise rotation of a pen stylus around its own major axis, in
+   // degrees in the range [0,359]. Always 0 if the device does not support it.
+-  int twist;
++  int twist = 0;
+ 
+   // - For pointerup/down events, the button of pointing device that triggered
+   // the event.
+@@ -128,7 +122,7 @@ class WebPointerProperties {
+ 
+   // True if this event has raw movement value from OS.
+   // TODO(crbug.com/982379): Figure out how to avoid using this boolean.
+-  bool is_raw_movement_event;
++  bool is_raw_movement_event = false;
+ 
+  protected:
+   // Widget coordinate, which is relative to the bound of current RenderWidget
+diff --git a/third_party/blink/public/common/input/web_touch_event.h b/third_party/blink/public/common/input/web_touch_event.h
+index 795976c6a8f8..9a59b3f63120 100644
+--- a/third_party/blink/public/common/input/web_touch_event.h
++++ b/third_party/blink/public/common/input/web_touch_event.h
+@@ -19,37 +19,37 @@ class BLINK_COMMON_EXPORT WebTouchEvent : public WebInputEvent {
+   // Ash/Aura.
+   enum { kTouchesLengthCap = 16 };
+ 
+-  unsigned touches_length;
++  unsigned touches_length = 0;
+   // List of all touches, regardless of state.
+-  WebTouchPoint touches[kTouchesLengthCap];
++  WebTouchPoint touches[kTouchesLengthCap] = {};
+ 
+   // Whether the event is blocking, non-blocking, all event
+   // listeners were passive or was forced to be non-blocking.
+-  DispatchType dispatch_type;
++  DispatchType dispatch_type = kBlocking;
+ 
+   // For a single touch, this is true after the touch-point has moved beyond
+   // the platform slop region. For a multitouch, this is true after any
+   // touch-point has moved (by whatever amount).
+-  bool moved_beyond_slop_region;
++  bool moved_beyond_slop_region = false;
+ 
+   // True for events from devices like some pens that support hovering
+   // over digitizer and the events are sent while the device was hovering.
+-  bool hovering;
++  bool hovering = false;
+ 
+   // Whether this touch event is a touchstart or a first touchmove event per
+   // scroll.
+-  bool touch_start_or_first_touch_move;
++  bool touch_start_or_first_touch_move = false;
+ 
+   // A unique identifier for the touch event. Valid ids start at one and
+   // increase monotonically. Zero means an unknown id.
+-  uint32_t unique_touch_event_id;
++  uint32_t unique_touch_event_id = 0;
+ 
+-  WebTouchEvent()
+-      : WebInputEvent(sizeof(WebTouchEvent)), dispatch_type(kBlocking) {}
++  WebTouchEvent() = default;
+ 
+   WebTouchEvent(Type type, int modifiers, base::TimeTicks time_stamp)
+-      : WebInputEvent(sizeof(WebTouchEvent), type, modifiers, time_stamp),
+-        dispatch_type(kBlocking) {}
++      : WebInputEvent(type, modifiers, time_stamp) {}
++
++  std::unique_ptr<WebInputEvent> Clone() const override;
+ 
+   // Sets any scaled values to be their computed values and sets |frame_scale_|
+   // back to 1 and |frame_translate_| X and Y coordinates back to 0.
+diff --git a/third_party/blink/public/common/input/web_touch_point.h b/third_party/blink/public/common/input/web_touch_point.h
+index de8971f66487..939142edb2bc 100644
+--- a/third_party/blink/public/common/input/web_touch_point.h
++++ b/third_party/blink/public/common/input/web_touch_point.h
+@@ -38,16 +38,12 @@ namespace blink {
+ 
+ // TODO(mustaq): Unify WebTouchPoint & WebMouseEvent into WebPointerEvent.
+ // crbug.com/508283
+-class WebTouchPoint : public WebPointerProperties {
++class BLINK_COMMON_EXPORT WebTouchPoint : public WebPointerProperties {
+  public:
+   WebTouchPoint() : WebTouchPoint(WebPointerProperties(0)) {}
+ 
+   WebTouchPoint(WebPointerProperties web_pointer_properties)
+-      : WebPointerProperties(web_pointer_properties),
+-        state(kStateUndefined),
+-        radius_x(0),
+-        radius_y(0),
+-        rotation_angle(0) {}
++      : WebPointerProperties(web_pointer_properties) {}
+ 
+   enum State {
+     kStateUndefined,
+@@ -59,11 +55,11 @@ class WebTouchPoint : public WebPointerProperties {
+     kStateMax = kStateCancelled
+   };
+ 
+-  State state;
++  State state = kStateUndefined;
+ 
+-  float radius_x;
+-  float radius_y;
+-  float rotation_angle;
++  float radius_x = 0.0f;
++  float radius_y = 0.0f;
++  float rotation_angle = 0.0f;
+ };
+ 
+ }  // namespace blink
+diff --git a/third_party/blink/public/platform/web_coalesced_input_event.h b/third_party/blink/public/platform/web_coalesced_input_event.h
+index bcf0359482c7..3095d0bb524d 100644
+--- a/third_party/blink/public/platform/web_coalesced_input_event.h
++++ b/third_party/blink/public/platform/web_coalesced_input_event.h
+@@ -42,12 +42,7 @@ class BLINK_PLATFORM_EXPORT WebCoalescedInputEvent {
+   WebVector<const WebInputEvent*> GetPredictedEventsPointers() const;
+ 
+  private:
+-  struct BLINK_PLATFORM_EXPORT WebInputEventDeleter {
+-    void operator()(blink::WebInputEvent*) const;
+-  };
+-
+-  using WebScopedInputEvent =
+-      std::unique_ptr<WebInputEvent, WebInputEventDeleter>;
++  using WebScopedInputEvent = std::unique_ptr<WebInputEvent>;
+ 
+   WebScopedInputEvent MakeWebScopedInputEvent(const blink::WebInputEvent&);
+ 
+diff --git a/third_party/blink/renderer/core/events/web_input_event_conversion.cc b/third_party/blink/renderer/core/events/web_input_event_conversion.cc
+index 716617985147..fcf3fc6b4aff 100644
+--- a/third_party/blink/renderer/core/events/web_input_event_conversion.cc
++++ b/third_party/blink/renderer/core/events/web_input_event_conversion.cc
+@@ -120,8 +120,8 @@ unsigned ToWebInputEventModifierFrom(WebMouseEvent::Button button) {
+ WebPointerEvent TransformWebPointerEvent(float frame_scale,
+                                          gfx::Vector2dF frame_translate,
+                                          const WebPointerEvent& event) {
+-  // frameScale is default initialized in debug builds to be 0.
+-  DCHECK_EQ(0, event.FrameScale());
++  // frameScale is default initialized to 1.
++  DCHECK_EQ(1, event.FrameScale());
+   DCHECK_EQ(0, event.FrameTranslate().x());
+   DCHECK_EQ(0, event.FrameTranslate().y());
+   WebPointerEvent result = event;
+diff --git a/third_party/blink/renderer/platform/exported/web_coalesced_input_event.cc b/third_party/blink/renderer/platform/exported/web_coalesced_input_event.cc
+index ac42cd792eb1..21edc5fe3070 100644
+--- a/third_party/blink/renderer/platform/exported/web_coalesced_input_event.cc
++++ b/third_party/blink/renderer/platform/exported/web_coalesced_input_event.cc
+@@ -12,46 +12,6 @@
+ 
+ namespace blink {
+ 
+-namespace {
+-
+-struct WebInputEventDelete {
+-  template <class EventType>
+-  bool Execute(WebInputEvent* event) const {
+-    if (!event)
+-      return false;
+-    DCHECK_EQ(sizeof(EventType), event->size());
+-    delete static_cast<EventType*>(event);
+-    return true;
+-  }
+-};
+-
+-template <typename Operator, typename ArgIn>
+-bool Apply(Operator op, WebInputEvent::Type type, const ArgIn& arg_in) {
+-  if (WebInputEvent::IsMouseEventType(type))
+-    return op.template Execute<WebMouseEvent>(arg_in);
+-  if (type == WebInputEvent::kMouseWheel)
+-    return op.template Execute<WebMouseWheelEvent>(arg_in);
+-  if (WebInputEvent::IsKeyboardEventType(type))
+-    return op.template Execute<WebKeyboardEvent>(arg_in);
+-  if (WebInputEvent::IsTouchEventType(type))
+-    return op.template Execute<WebTouchEvent>(arg_in);
+-  if (WebInputEvent::IsGestureEventType(type))
+-    return op.template Execute<WebGestureEvent>(arg_in);
+-  if (WebInputEvent::IsPointerEventType(type))
+-    return op.template Execute<WebPointerEvent>(arg_in);
+-
+-  NOTREACHED() << "Unknown webkit event type " << type;
+-  return false;
+-}
+-}
+-
+-void WebCoalescedInputEvent::WebInputEventDeleter::operator()(
+-    WebInputEvent* event) const {
+-  if (!event)
+-    return;
+-  Apply(WebInputEventDelete(), event->GetType(), event);
+-}
+-
+ WebInputEvent* WebCoalescedInputEvent::EventPointer() {
+   return event_.get();
+ }
+diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
+index 63d7ca8fb6e6..c44eecf2c2bd 100644
+--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
++++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
+@@ -58,10 +58,13 @@ class FakeInputEvent : public blink::WebInputEvent {
+  public:
+   explicit FakeInputEvent(blink::WebInputEvent::Type event_type,
+                           int modifiers = WebInputEvent::kNoModifiers)
+-      : WebInputEvent(sizeof(FakeInputEvent),
+-                      event_type,
++      : WebInputEvent(event_type,
+                       modifiers,
+                       WebInputEvent::GetStaticTimeStampForTests()) {}
++
++  std::unique_ptr<WebInputEvent> Clone() const override {
++    return std::make_unique<FakeInputEvent>(*this);
++  }
+ };
+ 
+ class FakeTouchEvent : public blink::WebTouchEvent {
+diff --git a/ui/events/blink/compositor_thread_event_queue.cc b/ui/events/blink/compositor_thread_event_queue.cc
+index f9c2b4609121..8d4e06475878 100644
+--- a/ui/events/blink/compositor_thread_event_queue.cc
++++ b/ui/events/blink/compositor_thread_event_queue.cc
+@@ -76,12 +76,12 @@ void CompositorThreadEventQueue::Queue(
+ 
+   std::unique_ptr<EventWithCallback> scroll_event =
+       std::make_unique<EventWithCallback>(
+-          WebInputEventTraits::Clone(coalesced_events.first), oldest_latency,
++          coalesced_events.first.Clone(), oldest_latency,
+           oldest_creation_timestamp, timestamp_now, nullptr);
+ 
+   std::unique_ptr<EventWithCallback> pinch_event =
+       std::make_unique<EventWithCallback>(
+-          WebInputEventTraits::Clone(coalesced_events.second), oldest_latency,
++          coalesced_events.second.Clone(), oldest_latency,
+           oldest_creation_timestamp, timestamp_now,
+           std::move(combined_original_events));
+ 
+diff --git a/ui/events/blink/event_with_callback.cc b/ui/events/blink/event_with_callback.cc
+index cbed00131204..c3c685dbae2c 100644
+--- a/ui/events/blink/event_with_callback.cc
++++ b/ui/events/blink/event_with_callback.cc
+@@ -19,7 +19,7 @@ EventWithCallback::EventWithCallback(
+     const LatencyInfo& latency,
+     base::TimeTicks timestamp_now,
+     InputHandlerProxy::EventDispositionCallback callback)
+-    : event_(WebInputEventTraits::Clone(*event)),
++    : event_(event->Clone()),
+       latency_(latency),
+       creation_timestamp_(timestamp_now),
+       last_coalesced_timestamp_(timestamp_now) {
+diff --git a/ui/events/blink/input_handler_proxy_unittest.cc b/ui/events/blink/input_handler_proxy_unittest.cc
+index cf89aaa43cf7..9b2b867f2944 100644
+--- a/ui/events/blink/input_handler_proxy_unittest.cc
++++ b/ui/events/blink/input_handler_proxy_unittest.cc
+@@ -94,7 +94,7 @@ WebScopedInputEvent CreateGestureScrollPinch(WebInputEvent::Type type,
+     gesture.data.pinch_update.scale = delta_y_or_scale;
+     gesture.SetPositionInWidget(gfx::PointF(x, y));
+   }
+-  return WebInputEventTraits::Clone(gesture);
++  return gesture.Clone();
+ }
+ 
+ class MockInputHandler : public cc::InputHandler {
+@@ -2640,14 +2640,14 @@ class InputHandlerProxyMomentumScrollJankTest : public testing::Test {
+     WebGestureEvent gesture(WebInputEvent::kGestureScrollBegin,
+                             WebInputEvent::kNoModifiers, tick_clock_.NowTicks(),
+                             blink::WebGestureDevice::kTouchscreen);
+-    HandleGesture(WebInputEventTraits::Clone(gesture));
++    HandleGesture(gesture.Clone());
+   }
+ 
+   void HandleScrollEnd() {
+     WebGestureEvent gesture(WebInputEvent::kGestureScrollEnd,
+                             WebInputEvent::kNoModifiers, tick_clock_.NowTicks(),
+                             blink::WebGestureDevice::kTouchscreen);
+-    HandleGesture(WebInputEventTraits::Clone(gesture));
++    HandleGesture(gesture.Clone());
+   }
+ 
+   void HandleScrollUpdate(bool is_momentum) {
+@@ -2659,7 +2659,7 @@ class InputHandlerProxyMomentumScrollJankTest : public testing::Test {
+       gesture.data.scroll_update.inertial_phase =
+           blink::WebGestureEvent::InertialPhaseState::kMomentum;
+     }
+-    HandleGesture(WebInputEventTraits::Clone(gesture));
++    HandleGesture(gesture.Clone());
+   }
+ 
+   void AdvanceClock(uint32_t milliseconds) {
+diff --git a/ui/events/blink/scroll_predictor_unittest.cc b/ui/events/blink/scroll_predictor_unittest.cc
+index cbf1b8830690..e8409d23eb4a 100644
+--- a/ui/events/blink/scroll_predictor_unittest.cc
++++ b/ui/events/blink/scroll_predictor_unittest.cc
+@@ -58,10 +58,10 @@ class ScrollPredictorTest : public testing::Test {
+     gesture.data.scroll_update.delta_y = delta_y;
+     gesture.data.scroll_update.inertial_phase = phase;
+ 
+-    original_events_.emplace_back(WebInputEventTraits::Clone(gesture),
+-                                  LatencyInfo(), base::NullCallback());
++    original_events_.emplace_back(gesture.Clone(), LatencyInfo(),
++                                  base::NullCallback());
+ 
+-    return WebInputEventTraits::Clone(gesture);
++    return gesture.Clone();
+   }
+ 
+   void CoalesceWith(const WebScopedInputEvent& new_event,
+@@ -90,7 +90,7 @@ class ScrollPredictorTest : public testing::Test {
+         WebInputEvent::GetStaticTimeStampForTests() +
+             base::TimeDelta::FromMillisecondsD(time_delta_in_milliseconds));
+ 
+-    event = WebInputEventTraits::Clone(event_with_callback->event());
++    event = event_with_callback->event().Clone();
+   }
+ 
+   std::unique_ptr<ui::InputPredictor::InputData> PredictionAvailable(
+@@ -203,7 +203,7 @@ TEST_F(ScrollPredictorTest, ScrollResamplingStates) {
+                               WebInputEvent::kNoModifiers,
+                               WebInputEvent::GetStaticTimeStampForTests(),
+                               blink::WebGestureDevice::kTouchscreen);
+-  WebScopedInputEvent event = WebInputEventTraits::Clone(gesture_end);
++  WebScopedInputEvent event = gesture_end.Clone();
+   HandleResampleScrollEvents(event);
+   EXPECT_FALSE(GetResamplingState());
+ }
+diff --git a/ui/events/blink/web_input_event_traits.cc b/ui/events/blink/web_input_event_traits.cc
+index 9734e1d0cd9d..19bd615be35b 100644
+--- a/ui/events/blink/web_input_event_traits.cc
++++ b/ui/events/blink/web_input_event_traits.cc
+@@ -105,17 +105,6 @@ void ApppendEventDetails(const WebPointerEvent& event, std::string* result) {
+       event.rotation_angle, event.tilt_x, event.tilt_y);
+ }
+ 
+-struct WebInputEventDelete {
+-  template <class EventType>
+-  bool Execute(WebInputEvent* event, void*) const {
+-    if (!event)
+-      return false;
+-    DCHECK_EQ(sizeof(EventType), event->size());
+-    delete static_cast<EventType*>(event);
+-    return true;
+-  }
+-};
+-
+ struct WebInputEventToString {
+   template <class EventType>
+   bool Execute(const WebInputEvent& event, std::string* result) const {
+@@ -129,17 +118,6 @@ struct WebInputEventToString {
+   }
+ };
+ 
+-struct WebInputEventClone {
+-  template <class EventType>
+-  bool Execute(const WebInputEvent& event,
+-               WebScopedInputEvent* scoped_event) const {
+-    DCHECK_EQ(sizeof(EventType), event.size());
+-    *scoped_event = WebScopedInputEvent(
+-        new EventType(static_cast<const EventType&>(event)));
+-    return true;
+-  }
+-};
+-
+ template <typename Operator, typename ArgIn, typename ArgOut>
+ bool Apply(Operator op,
+            WebInputEvent::Type type,
+@@ -164,25 +142,12 @@ bool Apply(Operator op,
+ 
+ }  // namespace
+ 
+-void WebInputEventDeleter::operator()(WebInputEvent* event) const {
+-  if (!event)
+-    return;
+-  void* temp = nullptr;
+-  Apply(WebInputEventDelete(), event->GetType(), event, temp);
+-}
+-
+ std::string WebInputEventTraits::ToString(const WebInputEvent& event) {
+   std::string result;
+   Apply(WebInputEventToString(), event.GetType(), event, &result);
+   return result;
+ }
+ 
+-WebScopedInputEvent WebInputEventTraits::Clone(const WebInputEvent& event) {
+-  WebScopedInputEvent scoped_event;
+-  Apply(WebInputEventClone(), event.GetType(), event, &scoped_event);
+-  return scoped_event;
+-}
+-
+ bool WebInputEventTraits::ShouldBlockEventStream(const WebInputEvent& event) {
+   switch (event.GetType()) {
+     case WebInputEvent::kContextMenu:
+diff --git a/ui/events/blink/web_input_event_traits.h b/ui/events/blink/web_input_event_traits.h
+index 19f9db8bd44c..10f60ba4eb0b 100644
+--- a/ui/events/blink/web_input_event_traits.h
++++ b/ui/events/blink/web_input_event_traits.h
+@@ -14,18 +14,12 @@ class WebGestureEvent;
+ 
+ namespace ui {
+ 
+-struct WebInputEventDeleter {
+-  void operator()(blink::WebInputEvent*) const;
+-};
+-
+-using WebScopedInputEvent =
+-    std::unique_ptr<blink::WebInputEvent, WebInputEventDeleter>;
++using WebScopedInputEvent = std::unique_ptr<blink::WebInputEvent>;
+ 
+ // Utility class for performing operations on and with WebInputEvents.
+ class WebInputEventTraits {
+  public:
+   static std::string ToString(const blink::WebInputEvent& event);
+-  static WebScopedInputEvent Clone(const blink::WebInputEvent& event);
+   static bool ShouldBlockEventStream(const blink::WebInputEvent& event);
+ 
+   // Return uniqueTouchEventId for WebTouchEvent, otherwise return 0.
+-- 
+2.24.1
+
diff --git a/PKGBUILD b/PKGBUILD
index db32f93c3f95..4b5e49bd2a15 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -5,7 +5,7 @@
 # Contributor: Daniel J Griffiths <ghost1227@archlinux.us>
 
 pkgname=chromium-ozone
-pkgver=80.0.3987.42
+pkgver=81.0.4021.2
 pkgrel=1
 _launcher_ver=6
 pkgdesc="Chromium built with patches for wayland support via Ozone"
@@ -27,21 +27,17 @@ optdepends=('pepper-flash: support for Flash content'
 install=chromium.install
 source=(https://commondatastorage.googleapis.com/chromium-browser-official/chromium-$pkgver.tar.xz
         chromium-launcher-$_launcher_ver.tar.gz::https://github.com/foutrelis/chromium-launcher/archive/v$_launcher_ver.tar.gz
-        0001-Add-missing-algorithm-header-in-bitmap_cursor_factor.patch
-        0001-cros-search-service-Include-cmath-for-std-pow.patch
-        0001-BookmarkModelMerger-Move-RemoteTreeNode-declaration-.patch
         chromium-system-icu.patch
         chromium-system-zlib.patch
+        0001-Modernize-WebInputEvent.patch
         fix-spammy-unique-font-matching-log.patch
         chromium-widevine.patch
         chromium-skia-harmony.patch)
-sha256sums=('160c02ed00d45a074246c8984144a35b092102e9b9a31e2bc9c2dad49f297945'
+sha256sums=('45f1c7efacf0e628da2943725a155d1f9143b53c3d8e649de10d48c4f17c8b69'
             '04917e3cd4307d8e31bfb0027a5dce6d086edb10ff8a716024fbb8bb0c7dccf1'
-            '716c28bed9f6e9c32e3617e125c1b04806700aef691763923cd4ed14b8d23279'
-            '4c892f046ab10df609aa39d9985248d368c77306783a64d335ff713dabad60b0'
-            'a44ed59db5258221ee187dc2501040e5ebfc5c1353ac98d4313ac6a12ae32d1f'
             'e73cc2ee8d3ea35aab18c478d76fdfc68ca4463e1e10306fa1e738c03b3f26b5'
             'eb67eda4945a89c3b90473fa8dc20637511ca4dcb58879a8ed6bf403700ca9c8'
+            '5bd56b41062eb3346a33a27e18954899118fe55d99330d917fea4a6d94dc3ce1'
             '6fbffe59b886195b92c9a55137cef83021c16593f49714acb20023633e3ebb19'
             '709e2fddba3c1f2ed4deb3a239fc0479bfa50c46e054e7f32db4fb1365fed070'
             '771292942c0901092a402cc60ee883877a99fb804cb54d568c8c6c94565a48e1')
@@ -103,9 +99,7 @@ prepare() {
     third_party/libxml/chromium/libxml_utils.cc
 
   # build fixes
-  patch -Np1 -i ../0001-Add-missing-algorithm-header-in-bitmap_cursor_factor.patch
-  patch -Np1 -i ../0001-cros-search-service-Include-cmath-for-std-pow.patch
-  patch -Np1 -i ../0001-BookmarkModelMerger-Move-RemoteTreeNode-declaration-.patch
+  patch -Np1 -R -i ../0001-Modernize-WebInputEvent.patch
   
   # Fixes from Gentoo
   patch -Np1 -i ../chromium-system-icu.patch
@@ -217,6 +211,7 @@ package() {
   cd "$srcdir/chromium-$pkgver"
 
   install -D out/Release/chrome "$pkgdir/usr/lib/chromium/chromium"
+  install -D out/Release/crashpad_handler "$pkgdir/usr/lib/chromium/crashpad_handler"
   install -Dm4755 out/Release/chrome_sandbox "$pkgdir/usr/lib/chromium/chrome-sandbox"
   ln -s /usr/lib/chromium/chromedriver "$pkgdir/usr/bin/chromedriver"