From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 11:22:09 +0200
Subject: Adding upstream version 110.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 ...e-across-editing-host-boundaries.tentative.html | 598 +++++++++++++++++++++
 1 file changed, 598 insertions(+)
 create mode 100644 testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-range-across-editing-host-boundaries.tentative.html

(limited to 'testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-range-across-editing-host-boundaries.tentative.html')
diff --git a/testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-range-across-editing-host-boundaries.tentative.html b/testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-range-across-editing-host-boundaries.tentative.html
new file mode 100644
index 0000000000..04f632a929
--- /dev/null
+++ b/testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-range-across-editing-host-boundaries.tentative.html
@@ -0,0 +1,598 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>InputEvent.getTargetRanges() of deleting  a range across editing host boundaries</title>
+<div contenteditable></div>
+<script src="input-events-get-target-ranges.js"></script>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/resources/testdriver.js"></script>
+<script src="/resources/testdriver-vendor.js"></script>
+<script src="/resources/testdriver-actions.js"></script>
+<script>
+"use strict";
+
+// This test just check whether the deleted content range(s) and target ranges of `beforeinput`
+// are match or different.  The behavior should be defined by editing API.
+// https://github.com/w3c/editing/issues/283
+
+promise_test(async () => {
+  initializeTest('<p>ab[c<span contenteditable="false">no]n-editable</span>def</p>');
+  await sendBackspaceKey();
+  const kNothingDeletedCase = '<p>abc<span contenteditable="false">non-editable</span>def</p>';
+  const kOnlyEditableTextDeletedCase = '<p>ab<span contenteditable="false">non-editable</span>def</p>';
+  const kNonEditableElementDeleteCase = '<p>abdef</p>';
+  if (gEditor.innerHTML === kNothingDeletedCase) {
+    if (gBeforeinput.length === 0) {
+      assert_true(true, "If nothing changed, `beforeinput` event may not be fired");
+      assert_equals(gInput.length, 0, "If nothing changed, `input` event should not be fired");
+      return;
+    }
+    assert_equals(gBeforeinput.length, 1,
+      "If nothing changed, `beforeinput` event can be fired for web apps can handle by themselves");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 0,
+      `If nothing changed but \`beforeinput\` event is fired, its target range should be empty array (got ${
+        getRangeDescription(gBeforeinput[0].cachedRanges[0])
+      })`);
+    assert_equals(gBeforeinput[0].inputType, "deleteContentBackward",
+      "If nothing changed but `beforeinput` event is fired, its input type should be deleteContentBackward");
+    assert_equals(gInput.length, 0,
+      "If nothing changed but `beforeinput` event is fired, `input` event should not be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kOnlyEditableTextDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If only editable text is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If only editable text is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild,
+        startOffset: 2,
+        endContainer: gEditor.firstChild.firstChild,
+        endOffset: 3,
+      }),
+      "If only editable text is deleted, its target range should be the deleted text range");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If only editable text is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If only editable text is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeleteCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    assert_in_array(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      [
+        getRangeDescription({
+          startContainer: gEditor.firstChild.firstChild,
+          startOffset: 2,
+          endContainer: gEditor.firstChild,
+          endOffset: 2,
+        }),
+        getRangeDescription({
+          startContainer: gEditor.firstChild.firstChild,
+          startOffset: 2,
+          endContainer: gEditor.firstChild.firstChild.nextSibling,
+          endOffset: 0,
+        }),
+      ],
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  assert_in_array(gEditor.innerHTML,
+    [
+      kNothingDeletedCase,
+      kOnlyEditableTextDeletedCase,
+      kNonEditableElementDeleteCase,
+    ], "The result content is unexpected");
+}, 'Backspace at "<p>ab[c<span contenteditable="false">no]n-editable</span>def</p>"');
+
+promise_test(async () => {
+  initializeTest('<p>abc<span contenteditable="false">non-[editable</span>de]f</p>');
+  await sendBackspaceKey();
+  const kNothingDeletedCase = '<p>abc<span contenteditable="false">non-editable</span>def</p>';
+  const kOnlyEditableTextDeletedCase = '<p>abc<span contenteditable="false">non-editable</span>f</p>';
+  const kNonEditableElementDeletedCase = '<p>abcf</p>';;
+  if (gEditor.innerHTML === kNothingDeletedCase) {
+    if (gBeforeinput.length === 0) {
+      assert_true(true, "If nothing changed, `beforeinput` event may not be fired");
+      assert_equals(gInput.length, 0, "If nothing changed, `input` event should not be fired");
+      return;
+    }
+    assert_equals(gBeforeinput.length, 1,
+      "If nothing changed, `beforeinput` event can be fired for web apps can handle by themselves");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 0,
+      `If nothing changed but \`beforeinput\` event is fired, its target range should be empty array (got ${
+        getRangeDescription(gBeforeinput[0].cachedRanges[0])
+      })`);
+    assert_equals(gBeforeinput[0].inputType, "deleteContentBackward",
+      "If nothing changed but `beforeinput` event is fired, its input type should be deleteContentBackward");
+    assert_equals(gInput.length, 0,
+      "If nothing changed but `beforeinput` event is fired, `input` event should not be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kOnlyEditableTextDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If only editable text is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If only editable text is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.lastChild,
+        startOffset: 0,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If only editable text is deleted, its target range should be the deleted text range");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If only editable text is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If only editable text is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  assert_in_array(gEditor.innerHTML,
+    [
+      kNothingDeletedCase,
+      kOnlyEditableTextDeletedCase,
+      kNonEditableElementDeletedCase,
+    ], "The result content is unexpected");
+}, 'Backspace at "<p>abc<span contenteditable="false">non-[editable</span>de]f</p>"');
+
+
+promise_test(async () => {
+  initializeTest('<p contenteditable="false"><span contenteditable>a[bc</span>non-editable<span contenteditable>de]f</span></p>');
+  let firstRange = gSelection.getRangeAt(0);
+  if (!firstRange ||
+      firstRange.startContainer != gEditor.firstChild.firstChild.firstChild ||
+      firstRange.startOffset != 1 ||
+      firstRange.endContainer != gEditor.firstChild.lastChild.firstChild ||
+      firstRange.endOffset != 2) {
+    assert_true(true, "Selection couldn't set across editing host boundaries");
+    return;
+  }
+  await sendBackspaceKey();
+  const kNothingDeletedCase = '<p contenteditable="false"><span contenteditable="">abc</span>non-editable<span contenteditable="">def</span></p>';
+  const kOnlyEditableContentDeletedCase = '<p contenteditable="false"><span contenteditable="">a</span>non-editable<span contenteditable="">f</span></p>';
+  const kNonEditableElementDeletedCase = '<p contenteditable="false"><span contenteditable="">af</span></p>';
+  const kDeleteEditableContentBeforeNonEditableContentCase = '<p contenteditable="false"><span contenteditable="">a</span>non-editable<span contenteditable="">def</span></p>';
+  const kDeleteEditableContentAfterNonEditableContentCase = '<p contenteditable="false"><span contenteditable="">abc</span>non-editable<span contenteditable="">f</span></p>';
+  if (gEditor.innerHTML === kNothingDeletedCase) {
+    if (gBeforeinput.length === 0) {
+      assert_true(true, "If nothing changed, `beforeinput` event may not be fired");
+      assert_equals(gInput.length, 0, "If nothing changed, `input` event should not be fired");
+      return;
+    }
+    assert_equals(gBeforeinput.length, 1,
+      "If nothing changed, `beforeinput` event can be fired for web apps can handle by themselves");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 0,
+      `If nothing changed but \`beforeinput\` event is fired, its target range should be empty array (got ${
+        getRangeDescription(gBeforeinput[0].cachedRanges[0])
+      })`);
+    assert_equals(gBeforeinput[0].inputType, "deleteContentBackward",
+      "If nothing changed but `beforeinput` event is fired, its input type should be deleteContentBackward");
+    assert_equals(gInput.length, 0,
+      "If nothing changed but `beforeinput` event is fired, `input` event should not be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kOnlyEditableContentDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If only editable text is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 2,
+      "If only editable text is deleted, `beforeinput` event should have 2 target ranges");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.lastChild,
+        endOffset: 3,
+      }),
+      "If only editable text is deleted, its first target range should be the deleted text range in the first text node");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[1]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.last.firstChild,
+        startOffset: 0,
+        endContainer: gEditor.firstChild.last.firstChild,
+        endOffset: 2,
+      }),
+      "If only editable text is deleted, its second target range should be the deleted text range in the last text node");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If only editable text is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If only editable text is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.lastChild.firstChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentBeforeNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.firstChild.firstChild,
+        endOffset: 3,
+      }),
+      "If editable text before non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text before non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text before non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentAfterNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.lastChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.lastChild.firstChild,
+        endOffset: 3,
+      }),
+      "If editable text after non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text after non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text after non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  assert_in_array(gEditor.innerHTML,
+    [
+      kNothingDeletedCase,
+      kOnlyEditableContentDeletedCase,
+      kNonEditableElementDeletedCase,
+      kDeleteEditableContentBeforeNonEditableContentCase,
+      kDeleteEditableContentAfterNonEditableContentCase,
+    ], "The result content is unexpected");
+}, 'Backspace at "<p contenteditable="false"><span contenteditable>a[bc</span>non-editable<span contenteditable>de]f</span></p>"');
+
+promise_test(async () => {
+  initializeTest('<p>a[bc<span contenteditable="false">non-editable<span contenteditable>de]f</span></span></p>');
+  let firstRange = gSelection.getRangeAt(0);
+  if (!firstRange ||
+      firstRange.startContainer != gEditor.firstChild.firstChild ||
+      firstRange.startOffset != 1 ||
+      firstRange.endContainer != gEditor.querySelector("span span").firstChild ||
+      firstRange.endOffset != 2) {
+    assert_true(true, "Selection couldn't set across editing host boundaries");
+    return;
+  }
+  await sendBackspaceKey();
+  const kNothingDeletedCase = '<p>abc<span contenteditable="false">non-editable<span contenteditable="">def</span></span></p>';
+  const kOnlyEditableContentDeletedCase = '<p>a<span contenteditable="false">non-editable<span contenteditable="">f</span></span></p>';
+  const kNonEditableElementDeletedCase1 = '<p>af</p>';
+  const kNonEditableElementDeletedCase2 = '<p>a<span contenteditable="">f</span></p>';
+  const kDeleteEditableContentBeforeNonEditableContentCase ='<p>a<span contenteditable="false">non-editable<span contenteditable="">def</span></span></p>';
+  const kDeleteEditableContentAfterNonEditableContentCase ='<p>abc<span contenteditable="false">non-editable<span contenteditable="">f</span></span></p>';
+  if (gEditor.innerHTML === kNothingDeletedCase) {
+    if (gBeforeinput.length === 0) {
+      assert_true(true, "If nothing changed, `beforeinput` event may not be fired");
+      assert_equals(gInput.length, 0, "If nothing changed, `input` event should not be fired");
+      return;
+    }
+    assert_equals(gBeforeinput.length, 1,
+      "If nothing changed, `beforeinput` event can be fired for web apps can handle by themselves");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 0,
+      `If nothing changed but \`beforeinput\` event is fired, its target range should be empty array (got ${
+        getRangeDescription(gBeforeinput[0].cachedRanges[0])
+      })`);
+    assert_equals(gBeforeinput[0].inputType, "deleteContentBackward",
+      "If nothing changed but `beforeinput` event is fired, its input type should be deleteContentBackward");
+    assert_equals(gInput.length, 0,
+      "If nothing changed but `beforeinput` event is fired, `input` event should not be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kOnlyEditableContentDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If only editable text is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 2,
+      "If only editable text is deleted, `beforeinput` event should have 2 target ranges");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.firstChild,
+        endOffset: 3,
+      }),
+      "If only editable text is deleted, its first target range should be the deleted text range in the first text node");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[1]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span span").firstChild,
+        startOffset: 0,
+        endContainer: gEditor.querySelector("span span").firstChild,
+        endOffset: 2,
+      }),
+      "If only editable text is deleted, its second target range should be the deleted text range in the last text node");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If only editable text is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If only editable text is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase1) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    // XXX If the text nodes are merged, we need to cache it for here.
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase2) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.querySelector("span").firstChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentBeforeNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.firstChild,
+        endOffset: 3,
+      }),
+      "If editable text before non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text before non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text before non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentAfterNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span").firstChild,
+        startOffset: 0,
+        endContainer: gEditor.querySelector("span").firstChild,
+        endOffset: 2,
+      }),
+      "If editable text after non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text after non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text after non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  assert_in_array(gEditor.innerHTML,
+    [
+      kNothingDeletedCase,
+      kOnlyEditableContentDeletedCase,
+      kNonEditableElementDeletedCase1,
+      kNonEditableElementDeletedCase2,
+      kDeleteEditableContentBeforeNonEditableContentCase,
+      kDeleteEditableContentAfterNonEditableContentCase,
+    ], "The result content is unexpected");
+}, 'Backspace at "<p>a[bc<span contenteditable="false">non-editable<span contenteditable>de]f</span></span></p>"');
+
+promise_test(async () => {
+  initializeTest('<p><span contenteditable="false"><span contenteditable>a[bc</span>non-editable</span>de]f</p>');
+  let firstRange = gSelection.getRangeAt(0);
+  if (!firstRange ||
+      firstRange.startContainer != gEditor.querySelector("span span").firstChild ||
+      firstRange.startOffset != 1 ||
+      firstRange.endContainer != gEditor.firstChild.lastChild.firstChild ||
+      firstRange.endOffset != 2) {
+    assert_true(true, "Selection couldn't set across editing host boundaries");
+    return;
+  }
+  await sendBackspaceKey();
+  const kNothingDeletedCase = '<p><span contenteditable="false"><span contenteditable="">abc</span>non-editable</span>def</p>';
+  const kOnlyEditableContentDeletedCase = '<p><span contenteditable="false"><span contenteditable="">a</span>non-editable</span>f</p>';
+  const kNonEditableElementDeletedCase1 = '<p><span contenteditable="false"><span contenteditable="">af</span></span></p>';
+  const kNonEditableElementDeletedCase2 = '<p><span contenteditable="false"><span contenteditable="">a</span></span>f</p>';
+  const kDeleteEditableContentBeforeNonEditableContentCase = '<p><span contenteditable="false"><span contenteditable="">a</span>non-editable</span>def</p>';
+  const kDeleteEditableContentAfterNonEditableContentCase = '<p><span contenteditable="false"><span contenteditable="">abc</span>non-editable</span>f</p>';
+  if (gEditor.innerHTML === kNothingDeletedCase) {
+    if (gBeforeinput.length === 0) {
+      assert_true(true, "If nothing changed, `beforeinput` event may not be fired");
+      assert_equals(gInput.length, 0, "If nothing changed, `input` event should not be fired");
+      return;
+    }
+    assert_equals(gBeforeinput.length, 1,
+      "If nothing changed, `beforeinput` event can be fired for web apps can handle by themselves");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 0,
+      `If nothing changed but \`beforeinput\` event is fired, its target range should be empty array (got ${
+        getRangeDescription(gBeforeinput[0].cachedRanges[0])
+      })`);
+    assert_equals(gBeforeinput[0].inputType, "deleteContentBackward",
+      "If nothing changed but `beforeinput` event is fired, its input type should be deleteContentBackward");
+    assert_equals(gInput.length, 0,
+      "If nothing changed but `beforeinput` event is fired, `input` event should not be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kOnlyEditableContentDeletedCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If only editable text is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 2,
+      "If only editable text is deleted, `beforeinput` event should have 2 target ranges");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span span").firstChild,
+        startOffset: 1,
+        endContainer: gEditor.querySelector("span span").firstChild,
+        endOffset: 3,
+      }),
+      "If only editable text is deleted, its first target range should be the deleted text range in the first text node");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[1]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.lastChild,
+        startOffset: 0,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If only editable text is deleted, its second target range should be the deleted text range in the last text node");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If only editable text is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If only editable text is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase1) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    // XXX If the text nodes are merged, we need to cache it for here.
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span span").firstChild,
+        startOffset: 1,
+        endContainer: gEditor.querySelector("span span").lastChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kNonEditableElementDeletedCase2) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text and non-editable element are deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span span").firstChild,
+        startOffset: 1,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If editable text and non-editable element are deleted, its target range should include the deleted non-editable element");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text and non-editable element are deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text and non-editable element are deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentBeforeNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text before non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.querySelector("span span").firstChild,
+        startOffset: 1,
+        endContainer: gEditor.querySelector("span span").firstChild,
+        endOffset: 3,
+      }),
+      "If editable text before non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text before non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text before non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  if (gEditor.innerHTML === kDeleteEditableContentAfterNonEditableContentCase) {
+    assert_equals(gBeforeinput.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should be fired");
+    assert_equals(gBeforeinput[0].cachedRanges.length, 1,
+      "If editable text after non-editable element is deleted, `beforeinput` event should have a target range");
+    assert_equals(getRangeDescription(gBeforeinput[0].cachedRanges[0]),
+      getRangeDescription({
+        startContainer: gEditor.firstChild.lastChild,
+        startOffset: 0,
+        endContainer: gEditor.firstChild.lastChild,
+        endOffset: 2,
+      }),
+      "If editable text after non-editable element is deleted, its target range should be only the deleted text");
+    assert_equals(gBeforeinput[0].inputType, "deleteContent",
+      "If editable text after non-editable element is deleted, its input type should be deleteContent");
+    assert_equals(gInput.length, 1,
+      "If editable text after non-editable element is deleted, `input` event should be fired");
+    return;
+  }
+  assert_in_array(gEditor.innerHTML,
+    [
+      kNothingDeletedCase,
+      kOnlyEditableContentDeletedCase,
+      kNonEditableElementDeletedCase1,
+      kNonEditableElementDeletedCase2,
+      kDeleteEditableContentBeforeNonEditableContentCase,
+      kDeleteEditableContentAfterNonEditableContentCase,
+    ], "The result content is unexpected");
+}, 'Backspace at "<p><span contenteditable="false"><span contenteditable>a[bc</span>non-editable</span>de]f</p>"');
+
+</script>
-- 
cgit v1.2.3

