From 3349026fb3a4656f48910ca38cd6c30cce8d19d4 Mon Sep 17 00:00:00 2001
From: "Michael[tm] Smith" <mike@w3.org>
Date: Sun, 26 May 2024 15:52:40 +0900
Subject: [PATCH] The beforeinput event should fire before textInput
 https://bugs.webkit.org/show_bug.cgi?id=268988
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reviewed by NOBODY (OOPS!).

This change (controlled by the ConformantBeforeinputEventFiringOrderEnabled,
preference, also introduced in this change) makes WebKit fire the beforeinput
and textInput events in the order: beforeinput first, textInput after —
conforming to the requirements at https://github.com/w3c/uievents/pull/362 and
https://w3c.github.io/uievents/event-algo.html#fire%20key%20input%20events
and consistent with the order in which the events are fired in Blink.

Otherwise, without this change, WebKit fires the events in the order:
textInput first, beforeinput after — which breaks conformance with the
spec requirements, and breaks compatibility with Blink.

Note also that this change makes WebKit conform to the requirements in
https://w3c.github.io/uievents/event-algo.html#fire%20key%20input%20events,
https://w3c.github.io/uievents/event-algo.html#handle%20native%20paste, and
https://w3c.github.io/uievents/event-algo.html#end%20composition — limiting
textInput to being fired only when ending a composition or when the input
type is insertText, insertParagraph, insertLineBreak, or insertFromPaste.

* LayoutTests/editing/execCommand/break-out-of-empty-list-item.html:
* LayoutTests/editing/inserting/typing-space-to-trigger-smart-link.html:
* LayoutTests/editing/pasteboard/paste-text-events-expected.txt:
* LayoutTests/editing/pasteboard/paste-text-events.html:
* LayoutTests/editing/style/highlight-insert-paragraph.html:
* LayoutTests/fast/events/input-events-fired-when-typing-expected.txt:
* LayoutTests/fast/events/input-events-fired-when-typing-nonconforming-expected.txt: Copied from LayoutTests/fast/events/input-events-fired-when-typing-expected.txt.
* LayoutTests/fast/events/input-events-fired-when-typing-nonconforming.html: Copied from LayoutTests/fast/events/input-events-fired-when-typing.html.
* LayoutTests/fast/events/input-events-fired-when-typing.html:
* LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path-expected.txt: Added.
* LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path.html: Added.
* LayoutTests/fast/forms/onchange-change-type.html:
* LayoutTests/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt:
* LayoutTests/http/tests/navigation/keyboard-events-during-provisional-subframe-navigation-expected.txt:
* LayoutTests/platform/ios/TestExpectations:
* LayoutTests/platform/mac-wk2/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt:
* Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml:
* Source/WebCore/editing/AlternativeTextController.cpp:
(WebCore::AlternativeTextController::insertDictatedText):
* Source/WebCore/editing/Editor.cpp:
(WebCore::dispatchTextInputEvent):
(WebCore::Editor::selectionForCommand):
(WebCore::Editor::handleTextEvent):
(WebCore::Editor::pasteAsPlainText):
(WebCore::Editor::pasteAsFragment):
(WebCore::dispatchTextInputEvents):
(WebCore::Editor::appliedEditing):
(WebCore::Editor::insertText):
(WebCore::Editor::insertTextForConfirmedComposition):
(WebCore::Editor::insertTextWithoutSendingTextEventNew):
(WebCore::Editor::insertTextWithoutSendingTextEventOld):
(WebCore::Editor::setComposition):
(WebCore::Editor::insertTextWithoutSendingTextEvent): Deleted.
* Source/WebCore/editing/Editor.h:
* Source/WebCore/editing/EditorCommand.cpp:
(WebCore::executeInsertBacktab):
(WebCore::executeInsertLineBreak):
(WebCore::executeInsertNewline):
(WebCore::executeInsertTab):
(WebCore::executeYank):
(WebCore::executeYankAndSelect):
(WebCore::enabledVisibleSelection):
(WebCore::enabledVisibleSelectionAndMark):
(WebCore::enableCaretInEditableText):
(WebCore::enabledInEditableText):
* Source/WebCore/html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::defaultEventHandler):
* Source/WebCore/page/EventHandler.cpp:
(WebCore::EventHandler::handleTextInput):
* Source/WebCore/page/EventHandler.h:
---
 .../break-out-of-empty-list-item.html         |  17 +--
 .../typing-space-to-trigger-smart-link.html   |  39 ++---
 .../pasteboard/paste-text-events-expected.txt |  13 --
 .../editing/pasteboard/paste-text-events.html |  18 ---
 .../style/highlight-insert-paragraph.html     |  18 +--
 ...nput-events-fired-when-typing-expected.txt |  41 ++++++
 ...red-when-typing-nonconforming-expected.txt |  86 +++++++++++
 ...vents-fired-when-typing-nonconforming.html |  99 +++++++++++++
 .../input-events-fired-when-typing.html       |  36 ++++-
 ...sing-return-key-old-code-path-expected.txt |  10 ++
 ...-blank-using-return-key-old-code-path.html |  51 +++++++
 .../fast/forms/onchange-change-type.html      |  10 +-
 ...during-provisional-navigation-expected.txt |   4 +-
 ...ovisional-subframe-navigation-expected.txt |   7 +-
 LayoutTests/platform/ios/TestExpectations     |   1 +
 ...during-provisional-navigation-expected.txt |   7 +-
 .../Preferences/UnifiedWebPreferences.yaml    |  14 ++
 .../editing/AlternativeTextController.cpp     |   2 +
 Source/WebCore/editing/Editor.cpp             | 137 ++++++++++++++++--
 Source/WebCore/editing/Editor.h               |   4 +-
 Source/WebCore/editing/EditorCommand.cpp      |  28 +++-
 Source/WebCore/html/HTMLInputElement.cpp      |   6 +-
 Source/WebCore/page/EventHandler.cpp          |  46 ++++++
 Source/WebCore/page/EventHandler.h            |   2 +
 24 files changed, 568 insertions(+), 128 deletions(-)
 create mode 100644 LayoutTests/fast/events/input-events-fired-when-typing-nonconforming-expected.txt
 create mode 100644 LayoutTests/fast/events/input-events-fired-when-typing-nonconforming.html
 create mode 100644 LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path-expected.txt
 create mode 100644 LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path.html

diff --git a/LayoutTests/editing/execCommand/break-out-of-empty-list-item.html b/LayoutTests/editing/execCommand/break-out-of-empty-list-item.html
index ca720207830df..babab38d3fbc2 100644
--- a/LayoutTests/editing/execCommand/break-out-of-empty-list-item.html
+++ b/LayoutTests/editing/execCommand/break-out-of-empty-list-item.html
@@ -11,20 +11,6 @@
 testContainer.contentEditable = true;
 document.body.appendChild(testContainer);
 
-function pressKey(key)
-{
-    if (window.KeyEvent) {
-        var ev = document.createEvent("KeyboardEvent");
-        ev.initKeyEvent("keypress", true, true, window,  0,0,0,0, 0, key.charCodeAt(0));
-        document.body.dispatchEvent(ev);
-    }
-    else {
-        var ev = document.createEvent("TextEvent");
-        ev.initTextEvent('textInput', true, true, null, key.charAt(0));
-        document.body.dispatchEvent(ev);
-    }
-}
-
 function enterAtTarget(initialContent)
 {
     testContainer.innerHTML = initialContent;
@@ -39,8 +25,7 @@
     s.removeAllRanges();
     s.addRange(r);
 
-    pressKey('\n');
-    
+    document.execCommand("InsertParagraph");
     return testContainer.innerHTML;
 }
 
diff --git a/LayoutTests/editing/inserting/typing-space-to-trigger-smart-link.html b/LayoutTests/editing/inserting/typing-space-to-trigger-smart-link.html
index e9ae04dc2107f..b3c2037c6054a 100644
--- a/LayoutTests/editing/inserting/typing-space-to-trigger-smart-link.html
+++ b/LayoutTests/editing/inserting/typing-space-to-trigger-smart-link.html
@@ -12,7 +12,7 @@
     var testTypeSpaceDiv = document.getElementById('testTypeSpace');
     var targetText = testTypeSpaceDiv.firstChild;
     window.getSelection().setPosition(targetText, 15);
-    pressKey(" ");
+    document.execCommand("InsertText", false, " ");
     var expectedContents = "The <a href=\"http://www.foo.com\">www.foo.com</a> should be underlined and there is an anchor node created for it.";
     if (expectedContents == testTypeSpaceDiv.innerHTML)
         document.getElementById('log').textContent = "PASS: the anchor for 'www.foo.com' has been created.\n"
@@ -22,18 +22,18 @@
     var testTypeLinkDiv = document.getElementById('testTypeLink');
     targetText = testTypeLinkDiv.firstChild;
     window.getSelection().setPosition(targetText, 4);
-    pressKey("w");
-    pressKey("w");
-    pressKey("w");
-    pressKey(".");
-    pressKey("b");
-    pressKey("a");
-    pressKey("r");
-    pressKey(".");
-    pressKey("c");
-    pressKey("o");
-    pressKey("m");
-    pressKey(" ");
+    document.execCommand("InsertText", false, "w");
+    document.execCommand("InsertText", false, "w");
+    document.execCommand("InsertText", false, "w");
+    document.execCommand("InsertText", false, ".");
+    document.execCommand("InsertText", false, "b");
+    document.execCommand("InsertText", false, "a");
+    document.execCommand("InsertText", false, "r");
+    document.execCommand("InsertText", false, ".");
+    document.execCommand("InsertText", false, "c");
+    document.execCommand("InsertText", false, "o");
+    document.execCommand("InsertText", false, "m");
+    document.execCommand("InsertText", false, " ");
     expectedContents = "The <a href=\"http://www.bar.com\">www.bar.com</a> should be underlined and there is an anchor node created for it.";
     if (expectedContents == testTypeLinkDiv.innerHTML)
         document.getElementById('log').textContent += "PASS: the anchor for 'www.bar.com' has been created."
@@ -43,19 +43,6 @@
     if (window.internals)
         internals.setAutomaticLinkDetectionEnabled(false);
 }
-
-function pressKey(key)
-{
-    if (window.KeyEvent) {
-        var ev = document.createEvent("KeyboardEvent");
-        ev.initKeyEvent("keypress", true, true, window,  0,0,0,0, 0, key.charCodeAt(0));
-        document.body.dispatchEvent(ev);
-    } else {
-        var ev = document.createEvent("TextEvent");
-        ev.initTextEvent('textInput', true, true, null, key.charAt(0));
-        document.body.dispatchEvent(ev);
-    }
-}
 </script>
 </head>
 <body>
diff --git a/LayoutTests/editing/pasteboard/paste-text-events-expected.txt b/LayoutTests/editing/pasteboard/paste-text-events-expected.txt
index c81e8e202da92..39e3371132b4f 100644
--- a/LayoutTests/editing/pasteboard/paste-text-events-expected.txt
+++ b/LayoutTests/editing/pasteboard/paste-text-events-expected.txt
@@ -16,19 +16,6 @@ PASS testTargetInput.value is 'RichHello'
 PASS event.data is ''
 PASS testTargetEditable.innerHTML is '<b>Rich</b>Hello'
 PASS textInputCount is proceedingTestCases.length
-PASS event.data is 'PlainHello'
-PASS testTargetTextarea.value is ''
-PASS event.data is 'PlainHello'
-PASS testTargetInput.value is ''
-PASS event.data is ''
-PASS testTargetEditable.innerHTML is ''
-PASS event.data is 'RichHello'
-PASS testTargetTextarea.value is ''
-PASS event.data is 'RichHello'
-PASS testTargetInput.value is ''
-PASS event.data is ''
-PASS testTargetEditable.innerHTML is ''
-PASS textInputCount is cancelingTestCases.length
 PASS successfullyParsed is true
 
 TEST COMPLETE
diff --git a/LayoutTests/editing/pasteboard/paste-text-events.html b/LayoutTests/editing/pasteboard/paste-text-events.html
index b1b375db35af1..694013d344c13 100644
--- a/LayoutTests/editing/pasteboard/paste-text-events.html
+++ b/LayoutTests/editing/pasteboard/paste-text-events.html
@@ -22,8 +22,6 @@
 {
     shouldBe("event.data", toStringLiteral(expectedTextEventData));
     textInputCount++;
-    if (willCancelTextInput)
-        evt.preventDefault();
 }
 
 var testSourceRoot = document.createElement("div");
@@ -112,15 +110,6 @@
     [copyRichText, pasteToTargetEditable, targetEditableShouldHave, "<b>Rich</b>Hello", ""],
 ];
 
-var cancelingTestCases = [
-    [copyPlainText, pasteToTargetTextarea, targetTextareaShouldHave, "", "PlainHello"],
-    [copyPlainText, pasteToTargetInput, targetInputShouldHave, "", "PlainHello"],
-    [copyPlainText, pasteToTargetEditable, targetEditableShouldHave, "", ""],
-    [copyRichText, pasteToTargetTextarea, targetTextareaShouldHave, "", "RichHello"],
-    [copyRichText, pasteToTargetInput, targetInputShouldHave, "", "RichHello"],
-    [copyRichText, pasteToTargetEditable, targetEditableShouldHave, "", ""],
-];
-
 function runSingleTest(caseData)
 {
     var copy = caseData[0];
@@ -136,17 +125,10 @@
 }
 
 textInputCount = 0;
-willCancelTextInput = false;
 for (var i = 0; i < proceedingTestCases.length; ++i)
     runSingleTest(proceedingTestCases[i]);
 shouldBe("textInputCount", "proceedingTestCases.length");
 
-textInputCount = 0;
-willCancelTextInput = true;
-for (var i = 0; i < cancelingTestCases.length; ++i)
-    runSingleTest(cancelingTestCases[i]);
-shouldBe("textInputCount", "cancelingTestCases.length");
-
 // Hides dataset to make dump clean.
 testTargetRoot.style.display = "none";
 testSourceRoot.style.display = "none";
diff --git a/LayoutTests/editing/style/highlight-insert-paragraph.html b/LayoutTests/editing/style/highlight-insert-paragraph.html
index e9c0ca01811b5..4174d9deb9e88 100644
--- a/LayoutTests/editing/style/highlight-insert-paragraph.html
+++ b/LayoutTests/editing/style/highlight-insert-paragraph.html
@@ -9,20 +9,6 @@
 <div id="console"></div>
 
 <script type="text/javascript">
-
-function pressKey( key ) {
-    if (window.KeyEvent) {
-        var ev = document.createEvent("KeyboardEvent");
-        ev.initKeyEvent("keypress", true, true, window,  0,0,0,0, 0, key.charCodeAt(0));
-        document.body.dispatchEvent(ev);
-    }
-    else {
-        var ev = document.createEvent("TextEvent");
-        ev.initTextEvent('textInput', true, true, null, key.charAt(0));
-        document.body.dispatchEvent(ev);
-    }
-}
-
 if (window.testRunner)
     testRunner.dumpAsText();
 
@@ -41,8 +27,8 @@
 r.setEnd(e.firstChild.firstChild,5);
 s.removeAllRanges();
 s.addRange(r);
-pressKey('\n');
-pressKey('e');
+document.execCommand("InsertParagraph");
+document.execCommand('InsertText', false, 'e')
 
 document.getElementById('console').appendChild(document.createTextNode(e.innerHTML));
 
diff --git a/LayoutTests/fast/events/input-events-fired-when-typing-expected.txt b/LayoutTests/fast/events/input-events-fired-when-typing-expected.txt
index 05dc9fd61a77c..628eaae61bf37 100644
--- a/LayoutTests/fast/events/input-events-fired-when-typing-expected.txt
+++ b/LayoutTests/fast/events/input-events-fired-when-typing-expected.txt
@@ -1,6 +1,7 @@
 PASS successfullyParsed is true
 
 TEST COMPLETE
+Typing into contenteditable div element
 Fired `onbeforeinput`!
 PASS event.__lookupGetter__('inputType') is defined.
 PASS event.__lookupGetter__('data') is defined.
@@ -11,6 +12,12 @@ PASS event.bubbles is true
 PASS event.cancelable is true
 PASS event.composed is true
 PASS event.isComposing is false
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
 Fired `oninput`!
 PASS event.__lookupGetter__('inputType') is defined.
 PASS event.__lookupGetter__('data') is defined.
@@ -21,6 +28,7 @@ PASS event.bubbles is true
 PASS event.cancelable is false
 PASS event.composed is true
 PASS event.isComposing is false
+Typing into input element
 Fired `onbeforeinput`!
 PASS event.__lookupGetter__('inputType') is defined.
 PASS event.__lookupGetter__('data') is defined.
@@ -31,6 +39,39 @@ PASS event.bubbles is true
 PASS event.cancelable is true
 PASS event.composed is true
 PASS event.isComposing is false
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+Fired `oninput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is false
+PASS event.composed is true
+PASS event.isComposing is false
+Typing into textarea element
+Fired `onbeforeinput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+PASS event.isComposing is false
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
 Fired `oninput`!
 PASS event.__lookupGetter__('inputType') is defined.
 PASS event.__lookupGetter__('data') is defined.
diff --git a/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming-expected.txt b/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming-expected.txt
new file mode 100644
index 0000000000000..94fdc5789ea3f
--- /dev/null
+++ b/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming-expected.txt
@@ -0,0 +1,86 @@
+PASS successfullyParsed is true
+
+TEST COMPLETE
+Typing into contenteditable div element
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+Fired `onbeforeinput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+PASS event.isComposing is false
+Fired `oninput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is false
+PASS event.composed is true
+PASS event.isComposing is false
+Typing into input element
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+Fired `onbeforeinput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+PASS event.isComposing is false
+Fired `oninput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is false
+PASS event.composed is true
+PASS event.isComposing is false
+Typing into textarea element
+Fired `textInput`!
+PASS event.__lookupGetter__('data') is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+Fired `onbeforeinput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is true
+PASS event.composed is true
+PASS event.isComposing is false
+Fired `oninput`!
+PASS event.__lookupGetter__('inputType') is defined.
+PASS event.__lookupGetter__('data') is defined.
+PASS event.__lookupGetter__('dataTransfer') is defined.
+PASS event.getTargetRanges is defined.
+PASS event.target.id is expectedTargetID
+PASS event.bubbles is true
+PASS event.cancelable is false
+PASS event.composed is true
+PASS event.isComposing is false
+a
+
diff --git a/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming.html b/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming.html
new file mode 100644
index 0000000000000..c56140c641019
--- /dev/null
+++ b/LayoutTests/fast/events/input-events-fired-when-typing-nonconforming.html
@@ -0,0 +1,99 @@
+<!DOCTYPE html><!-- webkit-test-runner [ ConformantBeforeinputEventFiringOrderEnabled=false ] -->
+<html>
+
+<head>
+    <script src="../../resources/js-test-pre.js"></script>
+    <script>
+        var expectedTargetID = "foo";
+
+        function contentEditable()
+        {
+            return document.querySelector("#foo");
+        }
+
+        function inputElement()
+        {
+            return document.querySelector("#bar");
+        }
+
+        function textareaElement()
+        {
+            return document.querySelector("#baz");
+        }
+
+        function beginTest()
+        {
+            if (!window.eventSender || !window.internals || !window.testRunner)
+                return;
+
+            testRunner.dumpAsText();
+
+            debug("Typing into contenteditable div element");
+            contentEditable().focus();
+            eventSender.keyDown("a", []);
+
+            debug("Typing into input element");
+            expectedTargetID = "bar";
+            inputElement().focus();
+            eventSender.keyDown("b", []);
+
+            debug("Typing into textarea element");
+            expectedTargetID = "baz";
+            textareaElement().focus();
+            eventSender.keyDown("c", []);
+        }
+
+        function checkInputEvent(event)
+        {
+            debug("Fired `oninput`!");
+            shouldBeDefined("event.__lookupGetter__('inputType')");
+            shouldBeDefined("event.__lookupGetter__('data')");
+            shouldBeDefined("event.__lookupGetter__('dataTransfer')");
+            shouldBeDefined("event.getTargetRanges");
+            shouldBe("event.target.id", "expectedTargetID");
+            shouldBe("event.bubbles", "true");
+            shouldBe("event.cancelable", "false");
+            shouldBe("event.composed", "true");
+            shouldBe("event.isComposing", "false");
+        }
+
+        function checkBeforeInputEvent(event)
+        {
+            debug("Fired `onbeforeinput`!");
+            shouldBeDefined("event.__lookupGetter__('inputType')");
+            shouldBeDefined("event.__lookupGetter__('data')");
+            shouldBeDefined("event.__lookupGetter__('dataTransfer')");
+            shouldBeDefined("event.getTargetRanges");
+            shouldBe("event.target.id", "expectedTargetID");
+            shouldBe("event.bubbles", "true");
+            shouldBe("event.cancelable", "true");
+            shouldBe("event.composed", "true");
+            shouldBe("event.isComposing", "false");
+        }
+
+        function checkTextInputEvent(event)
+        {
+            debug("Fired `textInput`!");
+            shouldBeDefined("event.__lookupGetter__('data')");
+            shouldBe("event.target.id", "expectedTargetID");
+            shouldBe("event.bubbles", "true");
+            shouldBe("event.cancelable", "true");
+            shouldBe("event.composed", "true");
+        }
+
+    </script>
+</head>
+
+<body onload=beginTest()>
+    <div id="foo" contenteditable oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></div>
+    <input id="bar" oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></input>
+    <textarea id="baz" oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></textarea>
+    <script>
+        document.querySelector("#foo").addEventListener("textInput", checkTextInputEvent, false);
+        document.querySelector("#bar").addEventListener("textInput", checkTextInputEvent, false);
+        document.querySelector("#baz").addEventListener("textInput", checkTextInputEvent, false);
+    </script>
+    <script src="../../resources/js-test-post.js"></script>
+</body>
+
+</html>
diff --git a/LayoutTests/fast/events/input-events-fired-when-typing.html b/LayoutTests/fast/events/input-events-fired-when-typing.html
index 114e97f4557f5..6441cbd2f69a5 100644
--- a/LayoutTests/fast/events/input-events-fired-when-typing.html
+++ b/LayoutTests/fast/events/input-events-fired-when-typing.html
@@ -1,4 +1,4 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<!DOCTYPE html><!-- webkit-test-runner [ ConformantBeforeinputEventFiringOrderEnabled=true ] -->
 <html>
 
 <head>
@@ -11,23 +11,36 @@
             return document.querySelector("#foo");
         }
 
-        function plainText()
+        function inputElement()
         {
             return document.querySelector("#bar");
         }
 
+        function textareaElement()
+        {
+            return document.querySelector("#baz");
+        }
+
         function beginTest()
         {
             if (!window.eventSender || !window.internals || !window.testRunner)
                 return;
 
             testRunner.dumpAsText();
+
+            debug("Typing into contenteditable div element");
             contentEditable().focus();
             eventSender.keyDown("a", []);
 
+            debug("Typing into input element");
             expectedTargetID = "bar";
-            plainText().focus();
+            inputElement().focus();
             eventSender.keyDown("b", []);
+
+            debug("Typing into textarea element");
+            expectedTargetID = "baz";
+            textareaElement().focus();
+            eventSender.keyDown("c", []);
         }
 
         function checkInputEvent(event)
@@ -57,12 +70,29 @@
             shouldBe("event.composed", "true");
             shouldBe("event.isComposing", "false");
         }
+
+        function checkTextInputEvent(event)
+        {
+            debug("Fired `textInput`!");
+            shouldBeDefined("event.__lookupGetter__('data')");
+            shouldBe("event.target.id", "expectedTargetID");
+            shouldBe("event.bubbles", "true");
+            shouldBe("event.cancelable", "true");
+            shouldBe("event.composed", "true");
+        }
+
     </script>
 </head>
 
 <body onload=beginTest()>
     <div id="foo" contenteditable oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></div>
     <input id="bar" oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></input>
+    <textarea id="baz" oninput=checkInputEvent(event) onbeforeinput=checkBeforeInputEvent(event)></textarea>
+    <script>
+        document.querySelector("#foo").addEventListener("textInput", checkTextInputEvent, false);
+        document.querySelector("#bar").addEventListener("textInput", checkTextInputEvent, false);
+        document.querySelector("#baz").addEventListener("textInput", checkTextInputEvent, false);
+    </script>
     <script src="../../resources/js-test-post.js"></script>
 </body>
 
diff --git a/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path-expected.txt b/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path-expected.txt
new file mode 100644
index 0000000000000..18183b82100ee
--- /dev/null
+++ b/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path-expected.txt
@@ -0,0 +1,10 @@
+Tests that pressing the Return key in a text field with an associated form implicitly submits the form. To run this test by hand, focus the text field below and press the Return key.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS event.key is "Enter"
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path.html b/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path.html
new file mode 100644
index 0000000000000..cc81158322180
--- /dev/null
+++ b/LayoutTests/fast/events/ios/submit-form-target-blank-using-return-key-old-code-path.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html><!-- webkit-test-runner [ JavaScriptCanOpenWindowsAutomatically=false ConformantBeforeinputEventFiringOrderEnabled=false ] -->
+<html>
+<head>
+<script src="../../../resources/js-test.js"></script>
+<script src="../../../resources/ui-helper.js"></script>
+</head>
+<body>
+<p id="description"></p>
+<form action="resources/submit-form-target-blank-using-return-key.html" target="_blank" rel="opener">
+    <input type="text" id="test">
+</form>
+<div id="console"></div>
+<script>
+window.jsTestIsAsync = true;
+
+function done()
+{
+    document.body.removeChild(document.querySelector("form"));
+    finishJSTest();
+}
+
+function checkInputEvent()
+{
+    testFailed("Should not have dispatched input event.");
+    done();
+}
+
+function checkKeypressAndDone()
+{
+    shouldBeEqualToString("event.key", "Enter");
+}
+
+function runTest()
+{
+    function handleFocus(event) {
+        event.target.addEventListener("input", checkInputEvent, { once: true });
+        event.target.addEventListener("keypress", checkKeypressAndDone, { once: true });
+        if (window.testRunner)
+            UIHelper.keyDown("return");
+    }
+    let test = document.getElementById("test");
+    test.addEventListener("focus", handleFocus, { once: true });
+    if (window.testRunner)
+        UIHelper.activateElement(test);
+}
+
+description("Tests that pressing the Return key in a text field with an associated form implicitly submits the form. To run this test by hand, focus the text field below and press the <key>Return<key> key.");
+runTest();
+</script>
+</body>
+</html>
diff --git a/LayoutTests/fast/forms/onchange-change-type.html b/LayoutTests/fast/forms/onchange-change-type.html
index 27eb1590a05de..42f706a42d71b 100644
--- a/LayoutTests/fast/forms/onchange-change-type.html
+++ b/LayoutTests/fast/forms/onchange-change-type.html
@@ -2,12 +2,6 @@
 <head>
     <script src="../../resources/js-test-pre.js"></script>
     <script>
-    function sendText(element, text) {
-        var event = document.createEvent('TextEvent');
-        event.initTextEvent('textInput', true, true, document.defaultView, text);
-        element.dispatchEvent(event);
-    }
-
     function test() {
         var tf = document.getElementById('tf');
 
@@ -21,7 +15,7 @@
         }
 
         tf.focus();
-        sendText(tf, 'input value');
+        document.execCommand('InsertText', false, 'input value');
         tf.blur();
 
         debug('Should fire change event when type does not change.');
@@ -29,7 +23,7 @@
 
         didFireOnChange = false;
         tf.focus();
-        sendText(tf, 'new input value');
+        document.execCommand('InsertText', false, 'new input value');
         tf.setAttribute('type', 'password');
         tf.blur();
 
diff --git a/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt b/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
index b99e1fa6928cd..72067eaebd3f0 100644
--- a/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
+++ b/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
@@ -23,8 +23,8 @@ CONSOLE MESSAGE: Active element after pressing tab: [object HTMLInputElement].
 CONSOLE MESSAGE: Pressing "a".
 CONSOLE MESSAGE: keydownevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keypressevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keyupevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Setting marked text to "b".
@@ -35,9 +35,9 @@ CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Inserting text "c".
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: compositionendevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Pasting text "d".
 CONSOLE MESSAGE: pasteevent dispatched (isTrusted: true).
diff --git a/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-subframe-navigation-expected.txt b/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-subframe-navigation-expected.txt
index b99e1fa6928cd..8fefb52c70d2a 100644
--- a/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-subframe-navigation-expected.txt
+++ b/LayoutTests/http/tests/navigation/keyboard-events-during-provisional-subframe-navigation-expected.txt
@@ -9,7 +9,6 @@ CONSOLE MESSAGE: Setting marked text to "b".
 CONSOLE MESSAGE: Inserting text "c".
 CONSOLE MESSAGE: Pasting text "d".
 CONSOLE MESSAGE: pasteevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Input element value after text input events: "".
 CONSOLE MESSAGE: Pressing "z" with access key modifiers should navigate to resources/keyboard-events-after-navigation.html.
 CONSOLE MESSAGE: Finished navigating to resources/keyboard-events-after-navigation.html.
@@ -23,8 +22,8 @@ CONSOLE MESSAGE: Active element after pressing tab: [object HTMLInputElement].
 CONSOLE MESSAGE: Pressing "a".
 CONSOLE MESSAGE: keydownevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keypressevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keyupevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Setting marked text to "b".
@@ -35,14 +34,14 @@ CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Inserting text "c".
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: compositionendevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Pasting text "d".
 CONSOLE MESSAGE: pasteevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Input element value after text input events: "acd".
 
diff --git a/LayoutTests/platform/ios/TestExpectations b/LayoutTests/platform/ios/TestExpectations
index 62a618f36aaae..b0e04a55810f4 100644
--- a/LayoutTests/platform/ios/TestExpectations
+++ b/LayoutTests/platform/ios/TestExpectations
@@ -1094,6 +1094,7 @@ fast/events/focus-change-crash2.html [ Skip ]
 fast/events/imagemap-norender-crash.html [ Skip ]
 fast/events/input-event-insert-replacement.html
 fast/events/input-events-fired-when-typing.html [ Skip ]
+fast/events/input-events-fired-when-typing-nonconforming.html [ Skip ]
 fast/events/input-events-insert-newlines-after-mutation.html [ Skip ]
 fast/events/input-events-typing-data.html [ Skip ]
 fast/events/input-tab-focus-no-duplicate-events.html [ Skip ]
diff --git a/LayoutTests/platform/mac-wk2/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt b/LayoutTests/platform/mac-wk2/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
index 127ce5665ad82..fc745b32ce9d7 100644
--- a/LayoutTests/platform/mac-wk2/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
+++ b/LayoutTests/platform/mac-wk2/http/tests/navigation/keyboard-events-during-provisional-navigation-expected.txt
@@ -9,7 +9,6 @@ CONSOLE MESSAGE: Setting marked text to "b".
 CONSOLE MESSAGE: Inserting text "c".
 CONSOLE MESSAGE: Pasting text "d".
 CONSOLE MESSAGE: pasteevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Input element value after text input events: "".
 CONSOLE MESSAGE: Pressing "z" with access key modifiers should navigate to resources/keyboard-events-after-navigation.html.
 CONSOLE MESSAGE: keydownevent dispatched (isTrusted: true).
@@ -25,8 +24,8 @@ CONSOLE MESSAGE: Active element after pressing tab: [object HTMLInputElement].
 CONSOLE MESSAGE: Pressing "a".
 CONSOLE MESSAGE: keydownevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keypressevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: keyupevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Setting marked text to "b".
@@ -37,14 +36,14 @@ CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Inserting text "c".
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: compositionendevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Pasting text "d".
 CONSOLE MESSAGE: pasteevent dispatched (isTrusted: true).
-CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: beforeinputevent dispatched (isTrusted: true).
+CONSOLE MESSAGE: textInputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: inputevent dispatched (isTrusted: true).
 CONSOLE MESSAGE: Input element value after text input events: "acd".
 
diff --git a/Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml b/Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml
index fb138f57c904e..af397e4ff9c77 100644
--- a/Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml
+++ b/Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml
@@ -1582,6 +1582,20 @@ CompressionStreamEnabled:
     WebCore:
       default: false
 
+ConformantBeforeinputEventFiringOrderEnabled:
+  type: bool
+  status: stable
+  category: dom
+  humanReadableName: "Conformant firing order for the beforeinput event"
+  humanReadableDescription: "Enable conformant firing order for the beforeinput event"
+  defaultValue:
+    WebKitLegacy:
+      default: true
+    WebKit:
+      default: true
+    WebCore:
+      default: true
+
 ContactPickerAPIEnabled:
   type: bool
   status: testable
diff --git a/Source/WebCore/editing/AlternativeTextController.cpp b/Source/WebCore/editing/AlternativeTextController.cpp
index 064466b627c49..8685093d60b79 100644
--- a/Source/WebCore/editing/AlternativeTextController.cpp
+++ b/Source/WebCore/editing/AlternativeTextController.cpp
@@ -710,6 +710,8 @@ bool AlternativeTextController::insertDictatedText(const String& text, const Vec
     if (!target)
         return false;
 
+    if (document->settings().conformantBeforeinputEventFiringOrderEnabled())
+        return document->frame()->editor().insertTextWithoutSendingTextEventNew(text, false, target.get(), TextEventInputDictation, &dictationAlternatives);
     Ref windowProxy = document->frame()->windowProxy();
     auto event = TextEvent::createForDictation(windowProxy.ptr(), text, dictationAlternatives);
     event->setUnderlyingEvent(triggeringEvent);
diff --git a/Source/WebCore/editing/Editor.cpp b/Source/WebCore/editing/Editor.cpp
index 0abe4c1b73591..9485cb96bf551 100644
--- a/Source/WebCore/editing/Editor.cpp
+++ b/Source/WebCore/editing/Editor.cpp
@@ -152,6 +152,13 @@ static bool dispatchBeforeInputEvent(Element& element, const AtomString& inputTy
     return !event->defaultPrevented();
 }
 
+static void dispatchTextInputEvent(Element& element, const String& text)
+{
+    auto event = TextEvent::create(element.document().windowProxy(), text);
+    event->preventDefault();
+    element.dispatchEvent(event);
+}
+
 static void dispatchInputEvent(Element& element, const AtomString& inputType, IsInputMethodComposing isInputMethodComposing, const String& data = { },
     RefPtr<DataTransfer>&& dataTransfer = nullptr, const Vector<RefPtr<StaticRange>>& targetRanges = { })
 {
@@ -300,6 +307,23 @@ void TemporarySelectionChange::setSelection(const VisibleSelection& selection, I
 
 // When an event handler has moved the selection outside of a text control
 // we should use the target control's selection for this editing operation.
+VisibleSelection Editor::selectionForCommand(EventTarget* eventTarget)
+{
+    auto selection = document().selection().selection();
+    if (!eventTarget)
+        return selection;
+    // If the target is a text control, and the current selection is outside of its shadow tree,
+    // then use the saved selection for that text control.
+    if (RefPtr target = dynamicDowncast<HTMLTextFormControlElement>(eventTarget); target && target->isTextField()) {
+        auto start = selection.start();
+        if (start.isNull() || eventTarget != enclosingTextFormControl(start)) {
+            if (auto range = target->selection())
+                return { *range, Affinity::Downstream, selection.isDirectional() };
+        }
+    }
+    return selection;
+}
+
 VisibleSelection Editor::selectionForCommand(Event* event)
 {
     auto selection = document().selection().selection();
@@ -383,7 +407,7 @@ bool Editor::handleTextEvent(TextEvent& event)
         return insertParagraphSeparator();
     }
 
-    return insertTextWithoutSendingTextEvent(data, false, &event);
+    return insertTextWithoutSendingTextEventOld(data, false, &event);
 }
 
 bool Editor::canEdit() const
@@ -642,7 +666,10 @@ void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace)
     Ref document = protectedDocument();
     if (auto* page = document->page())
         sanitizedText = page->applyLinkDecorationFiltering(sanitizedText, LinkDecorationFilteringTrigger::Paste);
-    target->dispatchEvent(TextEvent::createForPlainTextPaste(document->windowProxy(), WTFMove(sanitizedText), smartReplace));
+    if (document->settings().conformantBeforeinputEventFiringOrderEnabled())
+        document->frame()->eventHandler().handleTextInput(WTFMove(sanitizedText), nullptr, TextEventInputPaste, nullptr, smartReplace);
+    else
+        target->dispatchEvent(TextEvent::createForPlainTextPaste(document->windowProxy(), WTFMove(sanitizedText), smartReplace));
 }
 
 void Editor::pasteAsFragment(Ref<DocumentFragment>&& pastingFragment, bool smartReplace, bool matchStyle, MailBlockquoteHandling respectsMailBlockquote, EditAction action)
@@ -653,7 +680,10 @@ void Editor::pasteAsFragment(Ref<DocumentFragment>&& pastingFragment, bool smart
 
     ASSERT(action == EditAction::RemoveBackground || action == EditAction::Paste);
     auto type = action == EditAction::RemoveBackground ? TextEventInputRemoveBackground : TextEventInputPaste;
-    target->dispatchEvent(TextEvent::createForFragmentPaste(document().windowProxy(), WTFMove(pastingFragment), type, smartReplace, matchStyle, respectsMailBlockquote));
+    if (document().settings().conformantBeforeinputEventFiringOrderEnabled())
+        document().frame()->eventHandler().handleTextInput(emptyString(), nullptr, type, &pastingFragment.get(), smartReplace, matchStyle, respectsMailBlockquote);
+    else
+        target->dispatchEvent(TextEvent::createForFragmentPaste(document().windowProxy(), WTFMove(pastingFragment), type, smartReplace, matchStyle, respectsMailBlockquote));
 }
 
 void Editor::pasteAsPlainTextBypassingDHTML()
@@ -1181,6 +1211,14 @@ static bool dispatchBeforeInputEvents(RefPtr<Element> startRoot, RefPtr<Element>
     return continueWithDefaultBehavior;
 }
 
+static void dispatchTextInputEvents(RefPtr<Element> startRoot, RefPtr<Element> endRoot, const String& data)
+{
+    if (startRoot)
+        dispatchTextInputEvent(*startRoot, data);
+    if (endRoot && endRoot != startRoot)
+        dispatchTextInputEvent(*endRoot, data);
+}
+
 static void dispatchInputEvents(RefPtr<Element> startRoot, RefPtr<Element> endRoot, const AtomString& inputTypeName, IsInputMethodComposing isInputMethodComposing,
     const String& data = { }, RefPtr<DataTransfer>&& dataTransfer = nullptr, const Vector<RefPtr<StaticRange>>& targetRanges = { })
 {
@@ -1219,8 +1257,19 @@ void Editor::appliedEditing(CompositeEditCommand& command)
     ASSERT(command.composition());
     Ref composition = *command.composition();
     VisibleSelection newSelection(command.endingSelection());
+    auto startRoot = composition->startingRootEditableElement();
+    auto endRoot = composition->endingRootEditableElement();
+    auto inputType = command.inputEventTypeName();
+    auto data = command.inputEventData();
 
-    notifyTextFromControls(composition->startingRootEditableElement(), composition->endingRootEditableElement());
+    // https://w3c.github.io/uievents/event-algo.html#fire%20key%20input%20events
+    // and https://w3c.github.io/uievents/event-algo.html#handle%20native%20paste
+    // limit textInput to being fired only when the input type is insertText,
+    // insertParagraph, insertLineBreak, or insertFromPaste.
+    if (document->settings().conformantBeforeinputEventFiringOrderEnabled() && (inputType == "insertText"_s || inputType == "insertParagraph"_s || inputType == "insertLineBreak"_s || inputType == "insertFromPaste"_s))
+        dispatchTextInputEvents(startRoot, endRoot, data);
+
+    notifyTextFromControls(startRoot, endRoot);
 
     if (command.isTopLevelCommand()) {
         // Don't clear the typing style with this selection change. We do those things elsewhere if necessary.
@@ -1232,10 +1281,8 @@ void Editor::appliedEditing(CompositeEditCommand& command)
     }
 
     auto isInputMethodComposing = command.isInputMethodComposing() ? IsInputMethodComposing::Yes : IsInputMethodComposing::No;
-    if (command.shouldDispatchInputEvents()) {
-        dispatchInputEvents(composition->startingRootEditableElement(), composition->endingRootEditableElement(), command.inputEventTypeName(), isInputMethodComposing,
-            command.inputEventData(), command.inputEventDataTransfer());
-    }
+    if (command.shouldDispatchInputEvents())
+        dispatchInputEvents(startRoot, endRoot, inputType, isInputMethodComposing, data, command.inputEventDataTransfer());
 
     if (command.isTopLevelCommand()) {
         updateEditorUINowIfScheduled();
@@ -1351,11 +1398,15 @@ void Editor::clear()
 
 bool Editor::insertText(const String& text, Event* triggeringEvent, TextEventInputType inputType)
 {
+    if (document().settings().conformantBeforeinputEventFiringOrderEnabled())
+        return document().frame()->eventHandler().handleTextInput(text, triggeringEvent, inputType);
     return document().frame()->eventHandler().handleTextInputEvent(text, triggeringEvent, inputType);
 }
 
 bool Editor::insertTextForConfirmedComposition(const String& text)
 {
+    if (document().settings().conformantBeforeinputEventFiringOrderEnabled())
+        return document().frame()->eventHandler().handleTextInput(text, 0, TextEventInputComposition);
     return document().frame()->eventHandler().handleTextInputEvent(text, 0, TextEventInputComposition);
 }
 
@@ -1364,7 +1415,70 @@ bool Editor::insertDictatedText(const String& text, const Vector<DictationAltern
     return m_alternativeTextController->insertDictatedText(text, dictationAlternatives, triggeringEvent);
 }
 
-bool Editor::insertTextWithoutSendingTextEvent(const String& text, bool selectInsertedText, TextEvent* triggeringEvent)
+bool Editor::insertTextWithoutSendingTextEventNew(const String& text, bool selectInsertedText, EventTarget* eventTarget, TextEventInputType inputType, const Vector<DictationAlternative>* dictationAlternatives)
+{
+    if (text.isEmpty())
+        return false;
+
+    // Get the selection to use for the event that triggered this insertText.
+    // If the event handler changed the selection, we may want to use a different
+    // selection that is contained in the event target.
+    //
+    VisibleSelection selection = selectionForCommand(eventTarget);
+    if (!selection.isContentEditable())
+        return false;
+
+    if (!shouldInsertText(text, selection.toNormalizedRange(), EditorInsertAction::Typed))
+        return true;
+
+    // FIXME: Should pass false to updateMarkersForWordsAffectedByEditing() to not remove markers if
+    // a leading or trailing no-break space is being inserted. See <https://webkit.org/b/212098>.
+    bool isStartOfNewWord = deprecatedIsSpaceOrNewline(selection.visibleStart().characterBefore());
+    updateMarkersForWordsAffectedByEditing(deprecatedIsSpaceOrNewline(text[0]) || isStartOfNewWord);
+
+    bool shouldConsiderApplyingAutocorrection = false;
+    if (text == " "_s || text == "\t"_s)
+        shouldConsiderApplyingAutocorrection = true;
+
+    if (text.length() == 1 && u_ispunct(text[0]) && !isAmbiguousBoundaryCharacter(text[0]))
+        shouldConsiderApplyingAutocorrection = true;
+
+    bool autocorrectionWasApplied = shouldConsiderApplyingAutocorrection && didApplyAutocorrection(document(), *m_alternativeTextController);
+
+    if (selection.isContentEditable()) {
+        if (auto selectionStart = selection.start().protectedDeprecatedNode()) {
+            Ref<Document> document(selectionStart->document());
+
+            // Insert the text
+            if (dictationAlternatives)
+                DictationCommand::insertText(document.copyRef(), text, *dictationAlternatives, selection);
+            else {
+                auto options = OptionSet { TypingCommand::Option::RetainAutocorrectionIndicator };
+                if (selectInsertedText)
+                    options.add(TypingCommand::Option::SelectInsertedText);
+                if (inputType == TextEventInputAutocompletion)
+                    options.add(TypingCommand::Option::IsAutocompletion);
+                if (shouldRemoveAutocorrectionIndicator(shouldConsiderApplyingAutocorrection, autocorrectionWasApplied, options.contains(TypingCommand::Option::IsAutocompletion)))
+                    options.remove(TypingCommand::Option::RetainAutocorrectionIndicator);
+                TypingCommand::insertText(document.copyRef(), text, selection, options, inputType == TextEventInputComposition ? TypingCommand::TextCompositionType::Final : TypingCommand::TextCompositionType::None);
+            }
+
+            // Reveal the current selection. Note that focus may have changed after insertion.
+            // FIXME: Selection is allowed even if setIgnoreSelectionChanges(true). Ideally setIgnoreSelectionChanges()
+            // should be moved from Editor to a page-level like object. If it must remain a frame-specific concept
+            // then this code should conditionalize revealing selection on whether the ignoreSelectionChanges() bit
+            // is set for the newly focused frame.
+            if (client() && client()->shouldRevealCurrentSelectionAfterInsertion()) {
+                if (auto* page = document->page())
+                    page->revealCurrentSelection();
+            }
+        }
+    }
+
+    return true;
+}
+
+bool Editor::insertTextWithoutSendingTextEventOld(const String& text, bool selectInsertedText, TextEvent* triggeringEvent)
 {
     if (text.isEmpty())
         return false;
@@ -2251,8 +2365,11 @@ void Editor::setComposition(const String& text, SetCompositionMode mode)
 
     insertTextForConfirmedComposition(text);
 
-    if (RefPtr target = document->focusedElement())
+    if (RefPtr target = document->focusedElement()) {
+        if (document->settings().conformantBeforeinputEventFiringOrderEnabled())
+            dispatchTextInputEvent(*target, text);
         target->dispatchEvent(CompositionEvent::create(eventNames().compositionendEvent, document->windowProxy(), text));
+    }
 
     if (mode == CancelComposition) {
         // An open typing command that disagrees about current selection would cause issues with typing later on.
diff --git a/Source/WebCore/editing/Editor.h b/Source/WebCore/editing/Editor.h
index ec9b355d39ace..1b396e167ba82 100644
--- a/Source/WebCore/editing/Editor.h
+++ b/Source/WebCore/editing/Editor.h
@@ -328,7 +328,8 @@ class Editor final : public CanMakeCheckedPtr<Editor> {
     WEBCORE_EXPORT bool insertText(const String&, Event* triggeringEvent, TextEventInputType = TextEventInputKeyboard);
     bool insertTextForConfirmedComposition(const String& text);
     WEBCORE_EXPORT bool insertDictatedText(const String&, const Vector<DictationAlternative>& dictationAlternatives, Event* triggeringEvent);
-    bool insertTextWithoutSendingTextEvent(const String&, bool selectInsertedText, TextEvent* triggeringEvent);
+    bool insertTextWithoutSendingTextEventNew(const String&, bool selectInsertedText, EventTarget* = nullptr, TextEventInputType = TextEventInputKeyboard, const Vector<DictationAlternative>* dictationAlternatives = nullptr);
+    bool insertTextWithoutSendingTextEventOld(const String&, bool selectInsertedText, TextEvent* triggeringEvent);
     bool insertLineBreak();
     bool insertParagraphSeparator();
     WEBCORE_EXPORT bool insertParagraphSeparatorInQuotedContent();
@@ -433,6 +434,7 @@ class Editor final : public CanMakeCheckedPtr<Editor> {
 
     void clear();
 
+    VisibleSelection selectionForCommand(EventTarget*);
     VisibleSelection selectionForCommand(Event*);
 
     PAL::KillRing& killRing() const { return *m_killRing; }
diff --git a/Source/WebCore/editing/EditorCommand.cpp b/Source/WebCore/editing/EditorCommand.cpp
index 4b9af97eec24b..7cc0259749984 100644
--- a/Source/WebCore/editing/EditorCommand.cpp
+++ b/Source/WebCore/editing/EditorCommand.cpp
@@ -460,7 +460,9 @@ static bool executeIndent(LocalFrame& frame, Event*, EditorCommandSource, const
 
 static bool executeInsertBacktab(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
 {
-    return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\t"_s, event, TextEventInputBackTab);
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        return targetFrame(frame, event)->eventHandler().handleTextInput("\t"_s, event, TextEventInputBackTab);
+    return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\t"_s, event);
 }
 
 static bool executeInsertHorizontalRule(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
@@ -489,6 +491,8 @@ static bool executeInsertLineBreak(LocalFrame& frame, Event* event, EditorComman
 {
     switch (source) {
     case EditorCommandSource::MenuOrKeyBinding:
+        if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+            return targetFrame(frame, event)->eventHandler().handleTextInput("\n"_s, event, TextEventInputLineBreak);
         return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\n"_s, event, TextEventInputLineBreak);
     case EditorCommandSource::DOM:
     case EditorCommandSource::DOMWithUserInterface:
@@ -505,6 +509,8 @@ static bool executeInsertLineBreak(LocalFrame& frame, Event* event, EditorComman
 static bool executeInsertNewline(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
 {
     RefPtr targetFrame = WebCore::targetFrame(frame, event);
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        return targetFrame->eventHandler().handleTextInput("\n"_s, event, targetFrame->editor().canEditRichly() ? TextEventInputKeyboard : TextEventInputLineBreak);
     return targetFrame->eventHandler().handleTextInputEvent("\n"_s, event, targetFrame->editor().canEditRichly() ? TextEventInputKeyboard : TextEventInputLineBreak);
 }
 
@@ -529,6 +535,8 @@ static bool executeInsertParagraph(LocalFrame& frame, Event*, EditorCommandSourc
 
 static bool executeInsertTab(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
 {
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        return targetFrame(frame, event)->eventHandler().handleTextInput("\t"_s, event);
     return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\t"_s, event);
 }
 
@@ -1211,14 +1219,20 @@ static bool executeUnselect(LocalFrame& frame, Event*, EditorCommandSource, cons
 
 static bool executeYank(LocalFrame& frame, Event*, EditorCommandSource, const String&)
 {
-    frame.editor().insertTextWithoutSendingTextEvent(frame.editor().killRing().yank(), false, 0);
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        frame.editor().insertTextWithoutSendingTextEventNew(frame.editor().killRing().yank(), false);
+    else
+        frame.editor().insertTextWithoutSendingTextEventOld(frame.editor().killRing().yank(), false, 0);
     frame.editor().killRing().setToYankedState();
     return true;
 }
 
 static bool executeYankAndSelect(LocalFrame& frame, Event*, EditorCommandSource, const String&)
 {
-    frame.editor().insertTextWithoutSendingTextEvent(frame.editor().killRing().yank(), true, 0);
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        frame.editor().insertTextWithoutSendingTextEventNew(frame.editor().killRing().yank(), true);
+    else
+        frame.editor().insertTextWithoutSendingTextEventOld(frame.editor().killRing().yank(), true, 0);
     frame.editor().killRing().setToYankedState();
     return true;
 }
@@ -1294,7 +1308,7 @@ static bool enabled(LocalFrame&, Event*, EditorCommandSource)
 static bool enabledVisibleSelection(LocalFrame& frame, Event* event, EditorCommandSource)
 {
     // The term "visible" here includes a caret in editable text or a range in any text.
-    const VisibleSelection& selection = frame.editor().selectionForCommand(event);
+    const VisibleSelection& selection = frame.settings().conformantBeforeinputEventFiringOrderEnabled() ? frame.editor().selectionForCommand(event ? event->target() : nullptr) : frame.editor().selectionForCommand(event);
     return (selection.isCaret() && selection.isContentEditable()) || selection.isRange();
 }
 
@@ -1313,14 +1327,14 @@ static bool enabledVisibleSelectionOrCaretBrowsing(LocalFrame& frame, Event* eve
 
 static bool enabledVisibleSelectionAndMark(LocalFrame& frame, Event* event, EditorCommandSource)
 {
-    const VisibleSelection& selection = frame.editor().selectionForCommand(event);
+    const VisibleSelection& selection = frame.settings().conformantBeforeinputEventFiringOrderEnabled() ? frame.editor().selectionForCommand(event ? event->target() : nullptr) : frame.editor().selectionForCommand(event);
     return ((selection.isCaret() && selection.isContentEditable()) || selection.isRange())
         && frame.editor().mark().isCaretOrRange();
 }
 
 static bool enableCaretInEditableText(LocalFrame& frame, Event* event, EditorCommandSource)
 {
-    const VisibleSelection& selection = frame.editor().selectionForCommand(event);
+    const VisibleSelection& selection = frame.settings().conformantBeforeinputEventFiringOrderEnabled() ? frame.editor().selectionForCommand(event ? event->target() : nullptr) : frame.editor().selectionForCommand(event);
     return selection.isCaret() && selection.isContentEditable();
 }
 
@@ -1391,6 +1405,8 @@ static bool enabledClearText(LocalFrame& frame, Event*, EditorCommandSource)
 
 static bool enabledInEditableText(LocalFrame& frame, Event* event, EditorCommandSource)
 {
+    if (frame.settings().conformantBeforeinputEventFiringOrderEnabled())
+        return frame.editor().selectionForCommand(event ? event->target() : nullptr).rootEditableElement();
     return frame.editor().selectionForCommand(event).rootEditableElement();
 }
 
diff --git a/Source/WebCore/html/HTMLInputElement.cpp b/Source/WebCore/html/HTMLInputElement.cpp
index 7619bc8f194db..6b32501167324 100644
--- a/Source/WebCore/html/HTMLInputElement.cpp
+++ b/Source/WebCore/html/HTMLInputElement.cpp
@@ -1320,7 +1320,11 @@ void HTMLInputElement::defaultEventHandler(Event& event)
 
     // Call the base event handler before any of our own event handling for almost all events in text fields.
     // Makes editing keyboard handling take precedence over the keydown and keypress handling in this function.
-    bool callBaseClassEarly = isTextField() && (event.type() == eventNames().keydownEvent || event.type() == eventNames().keypressEvent);
+    bool callBaseClassEarly;
+    if (document().settings().conformantBeforeinputEventFiringOrderEnabled())
+        callBaseClassEarly = isTextField() && (event.type() == eventNames().keydownEvent || (event.type() == eventNames().keypressEvent && !m_inputType->shouldSubmitImplicitly(event)));
+    else
+        callBaseClassEarly = isTextField() && (event.type() == eventNames().keydownEvent || (event.type() == eventNames().keypressEvent));
     if (callBaseClassEarly) {
         HTMLTextFormControlElement::defaultEventHandler(event);
         if (event.defaultHandled())
diff --git a/Source/WebCore/page/EventHandler.cpp b/Source/WebCore/page/EventHandler.cpp
index ff5f86a7c24bd..18ccb256bedf8 100644
--- a/Source/WebCore/page/EventHandler.cpp
+++ b/Source/WebCore/page/EventHandler.cpp
@@ -4435,6 +4435,52 @@ bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEve
     target->dispatchEvent(event);
     return event->defaultHandled();
 }
+
+bool EventHandler::handleTextInput(const String& text, Event* underlyingEvent, TextEventInputType inputType, DocumentFragment* pastingFragment, bool shouldSmartReplace, bool shouldMatchStyle, MailBlockquoteHandling mailBlockquoteHandling)
+{
+    LOG(Editing, "EventHandler %p handleTextInput (text %s)", this, text.utf8().data());
+
+    // Platforms should differentiate real commands like selectAll from text input in disguise (like insertNewline),
+    // and avoid dispatching text input events from keydown default handlers.
+    ASSERT(!is<KeyboardEvent>(underlyingEvent) || downcast<KeyboardEvent>(*underlyingEvent).type() == eventNames().keypressEvent);
+
+    Ref frame = m_frame.get();
+
+    EventTarget* target;
+    if (underlyingEvent)
+        target = underlyingEvent->target();
+    else
+        target = eventTargetElementForDocument(frame->protectedDocument().get());
+    if (!target)
+        return false;
+
+    // Default event handling for Drag and Drop will be handled by DragController
+    if (inputType == TextEventInputDrop)
+        return false;
+
+    if (inputType == TextEventInputPaste || inputType == TextEventInputRemoveBackground) {
+        auto action = inputType == TextEventInputRemoveBackground ? EditAction::RemoveBackground : EditAction::Paste;
+        if (pastingFragment) {
+#if PLATFORM(IOS_FAMILY)
+            if (frame->editor().client()->performsTwoStepPaste(pastingFragment))
+                return true;
+#endif
+            frame->editor().replaceSelectionWithFragment(*pastingFragment, Editor::SelectReplacement::No, shouldSmartReplace ? Editor::SmartReplace::Yes : Editor::SmartReplace::No, shouldMatchStyle ? Editor::MatchStyle::Yes : Editor::MatchStyle::No, action, mailBlockquoteHandling);
+        } else
+            frame->editor().replaceSelectionWithText(text, Editor::SelectReplacement::No, shouldSmartReplace ? Editor::SmartReplace::Yes : Editor::SmartReplace::No, action);
+        return true;
+    }
+
+    if (text == "\n"_s) {
+        if (is<HTMLInputElement>(target))
+            return false;
+        if (inputType == TextEventInputLineBreak)
+            return frame->editor().insertLineBreak();
+        return frame->editor().insertParagraphSeparator();
+    }
+
+    return frame->editor().insertTextWithoutSendingTextEventNew(text, false, target, inputType);
+}
     
 bool EventHandler::isKeyboardOptionTab(KeyboardEvent& event)
 {
diff --git a/Source/WebCore/page/EventHandler.h b/Source/WebCore/page/EventHandler.h
index 904ff2214a81e..2067bbbf5160a 100644
--- a/Source/WebCore/page/EventHandler.h
+++ b/Source/WebCore/page/EventHandler.h
@@ -27,6 +27,7 @@
 
 #include "Cursor.h"
 #include "DragActions.h"
+#include "Editor.h"
 #include "FocusDirection.h"
 #include "HitTestRequest.h"
 #include "LayoutPoint.h"
@@ -283,6 +284,7 @@ class EventHandler final : public CanMakeCheckedPtr<EventHandler> {
     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent&);
 
     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
+    bool handleTextInput(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard, DocumentFragment* = nullptr, bool shouldSmartReplace = false, bool shouldMatchStyle = false, MailBlockquoteHandling = MailBlockquoteHandling::RespectBlockquote);
     void defaultTextInputEventHandler(TextEvent&);
 
 #if ENABLE(DRAG_SUPPORT)