Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4325 insertions, 0 deletions

diff --git a/editor/libeditor/HTMLEditorDataTransfer.cpp b/editor/libeditor/HTMLEditorDataTransfer.cpp
new file mode 100644
index 0000000000..70110fd6a6
--- /dev/null
+++ b/editor/libeditor/HTMLEditorDataTransfer.cpp
@@ -0,0 +1,4325 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=78: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "HTMLEditor.h"
+
+#include <string.h>
+
+#include "EditAction.h"
+#include "EditorDOMPoint.h"
+#include "EditorUtils.h"
+#include "HTMLEditHelpers.h"
+#include "HTMLEditUtils.h"
+#include "InternetCiter.h"
+#include "PendingStyles.h"
+#include "SelectionState.h"
+#include "WSRunObject.h"
+
+#include "ErrorList.h"
+#include "mozilla/dom/Comment.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/DocumentFragment.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/FileBlobImpl.h"
+#include "mozilla/dom/FileReader.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/StaticRange.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Base64.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/OwningNonNull.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Result.h"
+#include "nsAString.h"
+#include "nsCOMPtr.h"
+#include "nsCRTGlue.h"  // for CRLF
+#include "nsComponentManagerUtils.h"
+#include "nsIScriptError.h"
+#include "nsContentUtils.h"
+#include "nsDebug.h"
+#include "nsDependentSubstring.h"
+#include "nsError.h"
+#include "nsFocusManager.h"
+#include "nsGkAtoms.h"
+#include "nsIClipboard.h"
+#include "nsIContent.h"
+#include "nsIDocumentEncoder.h"
+#include "nsIFile.h"
+#include "nsIInputStream.h"
+#include "nsIMIMEService.h"
+#include "nsINode.h"
+#include "nsIParserUtils.h"
+#include "nsIPrincipal.h"
+#include "nsISupportsImpl.h"
+#include "nsISupportsPrimitives.h"
+#include "nsISupportsUtils.h"
+#include "nsITransferable.h"
+#include "nsIVariant.h"
+#include "nsLinebreakConverter.h"
+#include "nsLiteralString.h"
+#include "nsNameSpaceManager.h"
+#include "nsNetUtil.h"
+#include "nsPrintfCString.h"
+#include "nsRange.h"
+#include "nsReadableUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsStreamUtils.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsStringIterator.h"
+#include "nsTreeSanitizer.h"
+#include "nsXPCOM.h"
+#include "nscore.h"
+#include "nsContentUtils.h"
+#include "nsQueryObject.h"
+
+class nsAtom;
+class nsILoadContext;
+
+namespace mozilla {
+
+using namespace dom;
+using EmptyCheckOption = HTMLEditUtils::EmptyCheckOption;
+using LeafNodeType = HTMLEditUtils::LeafNodeType;
+
+#define kInsertCookie "_moz_Insert Here_moz_"
+
+// some little helpers
+static bool FindIntegerAfterString(const char* aLeadingString,
+                                   const nsCString& aCStr,
+                                   int32_t& foundNumber);
+static void RemoveFragComments(nsCString& aStr);
+
+nsresult HTMLEditor::InsertDroppedDataTransferAsAction(
+    AutoEditActionDataSetter& aEditActionData, DataTransfer& aDataTransfer,
+    const EditorDOMPoint& aDroppedAt, nsIPrincipal* aSourcePrincipal) {
+  MOZ_ASSERT(aEditActionData.GetEditAction() == EditAction::eDrop);
+  MOZ_ASSERT(GetEditAction() == EditAction::eDrop);
+  MOZ_ASSERT(aDroppedAt.IsSet());
+  MOZ_ASSERT(aDataTransfer.MozItemCount() > 0);
+
+  if (IsReadonly()) {
+    return NS_OK;
+  }
+
+  aEditActionData.InitializeDataTransfer(&aDataTransfer);
+  RefPtr<StaticRange> targetRange = StaticRange::Create(
+      aDroppedAt.GetContainer(), aDroppedAt.Offset(), aDroppedAt.GetContainer(),
+      aDroppedAt.Offset(), IgnoreErrors());
+  NS_WARNING_ASSERTION(targetRange && targetRange->IsPositioned(),
+                       "Why did we fail to create collapsed static range at "
+                       "dropped position?");
+  if (targetRange && targetRange->IsPositioned()) {
+    aEditActionData.AppendTargetRange(*targetRange);
+  }
+  nsresult rv = aEditActionData.MaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "MaybeDispatchBeforeInputEvent() failed");
+    return rv;
+  }
+  uint32_t numItems = aDataTransfer.MozItemCount();
+  for (uint32_t i = 0; i < numItems; ++i) {
+    DebugOnly<nsresult> rvIgnored =
+        InsertFromDataTransfer(&aDataTransfer, i, aSourcePrincipal, aDroppedAt,
+                               DeleteSelectedContent::No);
+    if (NS_WARN_IF(Destroyed())) {
+      return NS_OK;
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "HTMLEditor::InsertFromDataTransfer("
+                         "DeleteSelectedContent::No) failed, but ignored");
+  }
+  return NS_OK;
+}
+
+nsresult HTMLEditor::LoadHTML(const nsAString& aInputString) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  if (NS_WARN_IF(!mInitSucceeded)) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  // force IME commit; set up rules sniffing and batching
+  DebugOnly<nsresult> rvIgnored = CommitComposition();
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "EditorBase::CommitComposition() failed, but ignored");
+  if (NS_WARN_IF(Destroyed())) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::eInsertHTMLSource, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+
+  nsresult rv = EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_FAILED(rv)) {
+    NS_WARNING("EditorBase::EnsureNoPaddingBRElementForEmptyEditor() failed");
+    return rv;
+  }
+
+  // Delete Selection, but only if it isn't collapsed, see bug #106269
+  if (!SelectionRef().IsCollapsed()) {
+    nsresult rv = DeleteSelectionAsSubAction(eNone, eStrip);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "EditorBase::DeleteSelectionAsSubAction(eNone, eStrip) failed");
+      return rv;
+    }
+  }
+
+  // Get the first range in the selection, for context:
+  RefPtr<const nsRange> range = SelectionRef().GetRangeAt(0);
+  if (NS_WARN_IF(!range)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Create fragment for pasted HTML.
+  ErrorResult error;
+  RefPtr<DocumentFragment> documentFragment =
+      range->CreateContextualFragment(aInputString, error);
+  if (error.Failed()) {
+    NS_WARNING("nsRange::CreateContextualFragment() failed");
+    return error.StealNSResult();
+  }
+
+  // Put the fragment into the document at start of selection.
+  EditorDOMPoint pointToInsert(range->StartRef());
+  // XXX We need to make pointToInsert store offset for keeping traditional
+  //     behavior since using only child node to pointing insertion point
+  //     changes the behavior when inserted child is moved by mutation
+  //     observer.  We need to investigate what we should do here.
+  Unused << pointToInsert.Offset();
+  EditorDOMPoint pointToPutCaret;
+  for (nsCOMPtr<nsIContent> contentToInsert = documentFragment->GetFirstChild();
+       contentToInsert; contentToInsert = documentFragment->GetFirstChild()) {
+    Result<CreateContentResult, nsresult> insertChildContentNodeResult =
+        InsertNodeWithTransaction(*contentToInsert, pointToInsert);
+    if (MOZ_UNLIKELY(insertChildContentNodeResult.isErr())) {
+      NS_WARNING("EditorBase::InsertNodeWithTransaction() failed");
+      return insertChildContentNodeResult.unwrapErr();
+    }
+    CreateContentResult unwrappedInsertChildContentNodeResult =
+        insertChildContentNodeResult.unwrap();
+    unwrappedInsertChildContentNodeResult.MoveCaretPointTo(
+        pointToPutCaret, *this,
+        {SuggestCaret::OnlyIfHasSuggestion,
+         SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+    // XXX If the inserted node has been moved by mutation observer,
+    //     incrementing offset will cause odd result.  Next new node
+    //     will be inserted after existing node and the offset will be
+    //     overflown from the container node.
+    pointToInsert.Set(pointToInsert.GetContainer(), pointToInsert.Offset() + 1);
+    if (NS_WARN_IF(!pointToInsert.Offset())) {
+      // Append the remaining children to the container if offset is
+      // overflown.
+      pointToInsert.SetToEndOf(pointToInsert.GetContainer());
+    }
+  }
+
+  if (pointToPutCaret.IsSet()) {
+    nsresult rv = CollapseSelectionTo(pointToPutCaret);
+    if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      NS_WARNING("EditorBase::CollapseSelectionTo() failed, but ignored");
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv),
+        "EditorBase::CollapseSelectionTo() failed, but ignored");
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP HTMLEditor::InsertHTML(const nsAString& aInString) {
+  nsresult rv = InsertHTMLAsAction(aInString);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertHTMLAsAction() failed");
+  return rv;
+}
+
+nsresult HTMLEditor::InsertHTMLAsAction(const nsAString& aInString,
+                                        nsIPrincipal* aPrincipal) {
+  // FIXME: This should keep handling inserting HTML if the caller is
+  // nsIHTMLEditor::InsertHTML.
+  if (IsReadonly()) {
+    return NS_OK;
+  }
+
+  AutoEditActionDataSetter editActionData(*this, EditAction::eInsertHTML,
+                                          aPrincipal);
+  nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  rv = InsertHTMLWithContextAsSubAction(aInString, u""_ns, u""_ns, u""_ns,
+                                        SafeToInsertData::Yes, EditorDOMPoint(),
+                                        DeleteSelectedContent::Yes,
+                                        InlineStylesAtInsertionPoint::Clear);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                       "SafeToInsertData::Yes, DeleteSelectedContent::Yes, "
+                       "InlineStylesAtInsertionPoint::Clear) failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+class MOZ_STACK_CLASS HTMLEditor::HTMLWithContextInserter final {
+ public:
+  MOZ_CAN_RUN_SCRIPT explicit HTMLWithContextInserter(HTMLEditor& aHTMLEditor)
+      : mHTMLEditor(aHTMLEditor) {}
+
+  HTMLWithContextInserter() = delete;
+  HTMLWithContextInserter(const HTMLWithContextInserter&) = delete;
+  HTMLWithContextInserter(HTMLWithContextInserter&&) = delete;
+
+  [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> Run(
+      const nsAString& aInputString, const nsAString& aContextStr,
+      const nsAString& aInfoStr, SafeToInsertData aSafeToInsertData,
+      InlineStylesAtInsertionPoint aInlineStylesAtInsertionPoint);
+
+ private:
+  class FragmentFromPasteCreator;
+  class FragmentParser;
+  /**
+   * CollectTopMostChildContentsCompletelyInRange() collects topmost child
+   * contents which are completely in the given range.
+   * For example, if the range points a node with its container node, the
+   * result is only the node (meaning does not include its descendants).
+   * If the range starts start of a node and ends end of it, and if the node
+   * does not have children, returns no nodes, otherwise, if the node has
+   * some children, the result includes its all children (not including their
+   * descendants).
+   *
+   * @param aStartPoint         Start point of the range.
+   * @param aEndPoint           End point of the range.
+   * @param aOutArrayOfContents [Out] Topmost children which are completely in
+   *                            the range.
+   */
+  static void CollectTopMostChildContentsCompletelyInRange(
+      const EditorRawDOMPoint& aStartPoint, const EditorRawDOMPoint& aEndPoint,
+      nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents);
+
+  /**
+   * @return nullptr, if there's no invisible `<br>`.
+   */
+  HTMLBRElement* GetInvisibleBRElementAtPoint(
+      const EditorDOMPoint& aPointToInsert) const;
+
+  EditorDOMPoint GetNewCaretPointAfterInsertingHTML(
+      const EditorDOMPoint& aLastInsertedPoint) const;
+
+  /**
+   * @return error result or the last inserted point. The latter is only set, if
+   *         content was inserted.
+   */
+  [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult>
+  InsertContents(
+      const EditorDOMPoint& aPointToInsert,
+      nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents,
+      const nsINode* aFragmentAsNode);
+
+  /**
+   * @param aContextStr as indicated by nsITransferable's kHTMLContext.
+   * @param aInfoStr as indicated by nsITransferable's kHTMLInfo.
+   */
+  nsresult CreateDOMFragmentFromPaste(
+      const nsAString& aInputString, const nsAString& aContextStr,
+      const nsAString& aInfoStr, nsCOMPtr<nsINode>* aOutFragNode,
+      nsCOMPtr<nsINode>* aOutStartNode, nsCOMPtr<nsINode>* aOutEndNode,
+      uint32_t* aOutStartOffset, uint32_t* aOutEndOffset,
+      SafeToInsertData aSafeToInsertData) const;
+
+  [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveCaretOutsideOfLink(
+      Element& aLinkElement, const EditorDOMPoint& aPointToPutCaret);
+
+  // MOZ_KNOWN_LIVE because this is set only by the constructor which is
+  // marked as MOZ_CAN_RUN_SCRIPT and this is allocated only in the stack.
+  MOZ_KNOWN_LIVE HTMLEditor& mHTMLEditor;
+};
+
+class MOZ_STACK_CLASS
+    HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator final {
+ public:
+  nsresult Run(const Document& aDocument, const nsAString& aInputString,
+               const nsAString& aContextStr, const nsAString& aInfoStr,
+               nsCOMPtr<nsINode>* aOutFragNode,
+               nsCOMPtr<nsINode>* aOutStartNode, nsCOMPtr<nsINode>* aOutEndNode,
+               SafeToInsertData aSafeToInsertData) const;
+
+ private:
+  nsresult CreateDocumentFragmentAndGetParentOfPastedHTMLInContext(
+      const Document& aDocument, const nsAString& aInputString,
+      const nsAString& aContextStr, SafeToInsertData aSafeToInsertData,
+      nsCOMPtr<nsINode>& aParentNodeOfPastedHTMLInContext,
+      RefPtr<DocumentFragment>& aDocumentFragmentToInsert) const;
+
+  static nsAtom* DetermineContextLocalNameForParsingPastedHTML(
+      const nsIContent* aParentContentOfPastedHTMLInContext);
+
+  static bool FindTargetNodeOfContextForPastedHTMLAndRemoveInsertionCookie(
+      nsINode& aStart, nsCOMPtr<nsINode>& aResult);
+
+  static bool IsInsertionCookie(const nsIContent& aContent);
+
+  /**
+   * @param aDocumentFragmentForContext contains the merged result.
+   */
+  static nsresult MergeAndPostProcessFragmentsForPastedHTMLAndContext(
+      DocumentFragment& aDocumentFragmentForPastedHTML,
+      DocumentFragment& aDocumentFragmentForContext,
+      nsIContent& aTargetContentOfContextForPastedHTML);
+
+  /**
+   * @param aInfoStr as indicated by nsITransferable's kHTMLInfo.
+   */
+  [[nodiscard]] static nsresult MoveStartAndEndAccordingToHTMLInfo(
+      const nsAString& aInfoStr, nsCOMPtr<nsINode>* aOutStartNode,
+      nsCOMPtr<nsINode>* aOutEndNode);
+
+  static nsresult PostProcessFragmentForPastedHTMLWithoutContext(
+      DocumentFragment& aDocumentFragmentForPastedHTML);
+
+  static nsresult PreProcessContextDocumentFragmentForMerging(
+      DocumentFragment& aDocumentFragmentForContext);
+
+  static void RemoveHeadChildAndStealBodyChildsChildren(nsINode& aNode);
+
+  /**
+   * This is designed for a helper class to remove disturbing nodes at inserting
+   * the HTML fragment into the DOM tree.  This walks the children and if some
+   * elements do not have enough children, e.g., list elements not having
+   * another visible list elements nor list item elements,
+   * will be removed.
+   *
+   * @param aNode       Should not be a node whose mutation may be observed by
+   *                    JS.
+   */
+  static void RemoveIncompleteDescendantsFromInsertingFragment(nsINode& aNode);
+
+  enum class NodesToRemove {
+    eAll,
+    eOnlyListItems /*!< List items are always block-level elements, hence such
+                     whitespace-only nodes are always invisible. */
+  };
+  static nsresult
+  RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+      nsIContent& aNode, NodesToRemove aNodesToRemove);
+};
+
+HTMLBRElement*
+HTMLEditor::HTMLWithContextInserter::GetInvisibleBRElementAtPoint(
+    const EditorDOMPoint& aPointToInsert) const {
+  WSRunScanner wsRunScannerAtInsertionPoint(mHTMLEditor.ComputeEditingHost(),
+                                            aPointToInsert);
+  if (wsRunScannerAtInsertionPoint.EndsByInvisibleBRElement()) {
+    return wsRunScannerAtInsertionPoint.EndReasonBRElementPtr();
+  }
+  return nullptr;
+}
+
+EditorDOMPoint
+HTMLEditor::HTMLWithContextInserter::GetNewCaretPointAfterInsertingHTML(
+    const EditorDOMPoint& aLastInsertedPoint) const {
+  EditorDOMPoint pointToPutCaret;
+
+  // but don't cross tables
+  nsIContent* containerContent = nullptr;
+  if (!HTMLEditUtils::IsTable(aLastInsertedPoint.GetChild())) {
+    containerContent = HTMLEditUtils::GetLastLeafContent(
+        *aLastInsertedPoint.GetChild(), {LeafNodeType::OnlyEditableLeafNode},
+        aLastInsertedPoint.GetChild()->GetAsElementOrParentElement());
+    if (containerContent) {
+      Element* mostDistantInclusiveAncestorTableElement = nullptr;
+      for (Element* maybeTableElement =
+               containerContent->GetAsElementOrParentElement();
+           maybeTableElement &&
+           maybeTableElement != aLastInsertedPoint.GetChild();
+           maybeTableElement = maybeTableElement->GetParentElement()) {
+        if (HTMLEditUtils::IsTable(maybeTableElement)) {
+          mostDistantInclusiveAncestorTableElement = maybeTableElement;
+        }
+      }
+      // If we're in table elements, we should put caret into the most ancestor
+      // table element.
+      if (mostDistantInclusiveAncestorTableElement) {
+        containerContent = mostDistantInclusiveAncestorTableElement;
+      }
+    }
+  }
+  // If we are not in table elements, we should put caret in the last inserted
+  // node.
+  if (!containerContent) {
+    containerContent = aLastInsertedPoint.GetChild();
+  }
+
+  // If the container is a text node or a container element except `<table>`
+  // element, put caret a end of it.
+  if (containerContent->IsText() ||
+      (HTMLEditUtils::IsContainerNode(*containerContent) &&
+       !HTMLEditUtils::IsTable(containerContent))) {
+    pointToPutCaret.SetToEndOf(containerContent);
+  }
+  // Otherwise, i.e., it's an atomic element, `<table>` element or data node,
+  // put caret after it.
+  else {
+    pointToPutCaret.Set(containerContent);
+    DebugOnly<bool> advanced = pointToPutCaret.AdvanceOffset();
+    NS_WARNING_ASSERTION(advanced, "Failed to advance offset from found node");
+  }
+
+  // Make sure we don't end up with selection collapsed after an invisible
+  // `<br>` element.
+  Element* editingHost = mHTMLEditor.ComputeEditingHost();
+  WSRunScanner wsRunScannerAtCaret(editingHost, pointToPutCaret);
+  if (wsRunScannerAtCaret
+          .ScanPreviousVisibleNodeOrBlockBoundaryFrom(pointToPutCaret)
+          .ReachedInvisibleBRElement()) {
+    WSRunScanner wsRunScannerAtStartReason(
+        editingHost,
+        EditorDOMPoint(wsRunScannerAtCaret.GetStartReasonContent()));
+    WSScanResult backwardScanFromPointToCaretResult =
+        wsRunScannerAtStartReason.ScanPreviousVisibleNodeOrBlockBoundaryFrom(
+            pointToPutCaret);
+    if (backwardScanFromPointToCaretResult.InVisibleOrCollapsibleCharacters()) {
+      pointToPutCaret =
+          backwardScanFromPointToCaretResult.Point<EditorDOMPoint>();
+    } else if (backwardScanFromPointToCaretResult.ReachedSpecialContent()) {
+      // XXX In my understanding, this is odd.  The end reason may not be
+      //     same as the reached special content because the equality is
+      //     guaranteed only when ReachedCurrentBlockBoundary() returns true.
+      //     However, looks like that this code assumes that
+      //     GetStartReasonContent() returns the content.
+      NS_ASSERTION(wsRunScannerAtStartReason.GetStartReasonContent() ==
+                       backwardScanFromPointToCaretResult.GetContent(),
+                   "Start reason is not the reached special content");
+      pointToPutCaret.SetAfter(
+          wsRunScannerAtStartReason.GetStartReasonContent());
+    }
+  }
+
+  return pointToPutCaret;
+}
+
+nsresult HTMLEditor::InsertHTMLWithContextAsSubAction(
+    const nsAString& aInputString, const nsAString& aContextStr,
+    const nsAString& aInfoStr, const nsAString& aFlavor,
+    SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert,
+    DeleteSelectedContent aDeleteSelectedContent,
+    InlineStylesAtInsertionPoint aInlineStylesAtInsertionPoint) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  if (NS_WARN_IF(!mInitSucceeded)) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  CommitComposition();
+
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::ePasteHTMLContent, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+  ignoredError.SuppressException();
+
+  {
+    Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result.unwrapErr();
+    }
+    if (result.inspect().Canceled()) {
+      return NS_OK;
+    }
+  }
+
+  // If we have a destination / target node, we want to insert there rather than
+  // in place of the selection.  Ignore aDeleteSelectedContent here if
+  // aPointToInsert is not set since deletion will also occur later in
+  // HTMLWithContextInserter and will be collapsed around there; this block
+  // is intended to cover the various scenarios where we are dropping in an
+  // editor (and may want to delete the selection before collapsing the
+  // selection in the new destination)
+  if (aPointToInsert.IsSet()) {
+    nsresult rv =
+        PrepareToInsertContent(aPointToInsert, aDeleteSelectedContent);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("EditorBase::PrepareToInsertContent() failed");
+      return rv;
+    }
+    aDeleteSelectedContent = DeleteSelectedContent::No;
+  }
+
+  HTMLWithContextInserter htmlWithContextInserter(*this);
+
+  Result<EditActionResult, nsresult> result = htmlWithContextInserter.Run(
+      aInputString, aContextStr, aInfoStr, aSafeToInsertData,
+      aInlineStylesAtInsertionPoint);
+  if (MOZ_UNLIKELY(result.isErr())) {
+    return result.unwrapErr();
+  }
+
+  // If nothing is inserted and delete selection is required, we need to
+  // delete selection right now.
+  if (result.inspect().Ignored() &&
+      aDeleteSelectedContent == DeleteSelectedContent::Yes) {
+    nsresult rv = DeleteSelectionAsSubAction(eNone, eStrip);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "EditorBase::DeleteSelectionAsSubAction(eNone, eStrip) failed");
+      return rv;
+    }
+  }
+  return NS_OK;
+}
+
+Result<EditActionResult, nsresult> HTMLEditor::HTMLWithContextInserter::Run(
+    const nsAString& aInputString, const nsAString& aContextStr,
+    const nsAString& aInfoStr, SafeToInsertData aSafeToInsertData,
+    InlineStylesAtInsertionPoint aInlineStylesAtInsertionPoint) {
+  MOZ_ASSERT(mHTMLEditor.IsEditActionDataAvailable());
+
+  // create a dom document fragment that represents the structure to paste
+  nsCOMPtr<nsINode> fragmentAsNode, streamStartParent, streamEndParent;
+  uint32_t streamStartOffset = 0, streamEndOffset = 0;
+
+  nsresult rv = CreateDOMFragmentFromPaste(
+      aInputString, aContextStr, aInfoStr, address_of(fragmentAsNode),
+      address_of(streamStartParent), address_of(streamEndParent),
+      &streamStartOffset, &streamEndOffset, aSafeToInsertData);
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::CreateDOMFragmentFromPaste() "
+        "failed");
+    return Err(rv);
+  }
+
+  // we need to recalculate various things based on potentially new offsets
+  // this is work to be completed at a later date (probably by jfrancis)
+
+  AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfTopMostChildContents;
+  // If we have stream start point information, lets use it and end point.
+  // Otherwise, we should make a range all over the document fragment.
+  EditorRawDOMPoint streamStartPoint =
+      streamStartParent
+          ? EditorRawDOMPoint(streamStartParent,
+                              AssertedCast<uint32_t>(streamStartOffset))
+          : EditorRawDOMPoint(fragmentAsNode, 0);
+  EditorRawDOMPoint streamEndPoint =
+      streamStartParent ? EditorRawDOMPoint(streamEndParent, streamEndOffset)
+                        : EditorRawDOMPoint::AtEndOf(fragmentAsNode);
+
+  Unused << streamStartPoint;
+  Unused << streamEndPoint;
+
+  HTMLWithContextInserter::CollectTopMostChildContentsCompletelyInRange(
+      EditorRawDOMPoint(streamStartParent,
+                        AssertedCast<uint32_t>(streamStartOffset)),
+      EditorRawDOMPoint(streamEndParent,
+                        AssertedCast<uint32_t>(streamEndOffset)),
+      arrayOfTopMostChildContents);
+
+  if (arrayOfTopMostChildContents.IsEmpty()) {
+    return EditActionResult::IgnoredResult();  // Nothing to insert.
+  }
+
+  // Are there any table elements in the list?
+  // check for table cell selection mode
+  bool cellSelectionMode =
+      HTMLEditUtils::IsInTableCellSelectionMode(mHTMLEditor.SelectionRef());
+
+  if (cellSelectionMode) {
+    // do we have table content to paste?  If so, we want to delete
+    // the selected table cells and replace with new table elements;
+    // but if not we want to delete _contents_ of cells and replace
+    // with non-table elements.  Use cellSelectionMode bool to
+    // indicate results.
+    if (!HTMLEditUtils::IsAnyTableElement(arrayOfTopMostChildContents[0])) {
+      cellSelectionMode = false;
+    }
+  }
+
+  if (!cellSelectionMode) {
+    rv = mHTMLEditor.DeleteSelectionAndPrepareToCreateNode();
+    if (NS_FAILED(rv)) {
+      NS_WARNING("HTMLEditor::DeleteSelectionAndPrepareToCreateNode() failed");
+      return Err(rv);
+    }
+
+    if (aInlineStylesAtInsertionPoint == InlineStylesAtInsertionPoint::Clear) {
+      // pasting does not inherit local inline styles
+      Result<EditorDOMPoint, nsresult> pointToPutCaretOrError =
+          mHTMLEditor.ClearStyleAt(
+              EditorDOMPoint(mHTMLEditor.SelectionRef().AnchorRef()),
+              EditorInlineStyle::RemoveAllStyles(), SpecifiedStyle::Preserve);
+      if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) {
+        NS_WARNING("HTMLEditor::ClearStyleAt() failed");
+        return pointToPutCaretOrError.propagateErr();
+      }
+      if (pointToPutCaretOrError.inspect().IsSetAndValid()) {
+        nsresult rv =
+            mHTMLEditor.CollapseSelectionTo(pointToPutCaretOrError.unwrap());
+        if (NS_FAILED(rv)) {
+          NS_WARNING("EditorBase::CollapseSelectionTo() failed");
+          return Err(rv);
+        }
+      }
+    }
+  } else {
+    // Delete whole cells: we will replace with new table content.
+
+    // Braces for artificial block to scope AutoSelectionRestorer.
+    // Save current selection since DeleteTableCellWithTransaction() perturbs
+    // it.
+    {
+      AutoSelectionRestorer restoreSelectionLater(mHTMLEditor);
+      rv = mHTMLEditor.DeleteTableCellWithTransaction(1);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("HTMLEditor::DeleteTableCellWithTransaction(1) failed");
+        return Err(rv);
+      }
+    }
+    // collapse selection to beginning of deleted table content
+    IgnoredErrorResult ignoredError;
+    mHTMLEditor.SelectionRef().CollapseToStart(ignoredError);
+    NS_WARNING_ASSERTION(!ignoredError.Failed(),
+                         "Selection::Collapse() failed, but ignored");
+  }
+
+  {
+    Result<EditActionResult, nsresult> result =
+        mHTMLEditor.CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result;
+    }
+    if (result.inspect().Canceled()) {
+      return result;
+    }
+  }
+
+  mHTMLEditor.UndefineCaretBidiLevel();
+
+  rv = mHTMLEditor.EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    return Err(NS_ERROR_EDITOR_DESTROYED);
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() "
+                       "failed, but ignored");
+
+  if (NS_SUCCEEDED(rv) && mHTMLEditor.SelectionRef().IsCollapsed()) {
+    nsresult rv = mHTMLEditor.EnsureCaretNotAfterInvisibleBRElement();
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return Err(NS_ERROR_EDITOR_DESTROYED);
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() "
+                         "failed, but ignored");
+    if (NS_SUCCEEDED(rv)) {
+      nsresult rv = mHTMLEditor.PrepareInlineStylesForCaret();
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return Err(NS_ERROR_EDITOR_DESTROYED);
+      }
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored");
+    }
+  }
+
+  Element* editingHost =
+      mHTMLEditor.ComputeEditingHost(HTMLEditor::LimitInBodyElement::No);
+  if (NS_WARN_IF(!editingHost)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  // Adjust position based on the first node we are going to insert.
+  EditorDOMPoint pointToInsert =
+      HTMLEditUtils::GetBetterInsertionPointFor<EditorDOMPoint>(
+          arrayOfTopMostChildContents[0],
+          mHTMLEditor.GetFirstSelectionStartPoint<EditorRawDOMPoint>(),
+          *editingHost);
+  if (!pointToInsert.IsSet()) {
+    NS_WARNING("HTMLEditor::GetBetterInsertionPointFor() failed");
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  // Remove invisible `<br>` element at the point because if there is a `<br>`
+  // element at end of what we paste, it will make the existing invisible
+  // `<br>` element visible.
+  if (HTMLBRElement* invisibleBRElement =
+          GetInvisibleBRElementAtPoint(pointToInsert)) {
+    AutoEditorDOMPointChildInvalidator lockOffset(pointToInsert);
+    nsresult rv = mHTMLEditor.DeleteNodeWithTransaction(
+        MOZ_KnownLive(*invisibleBRElement));
+    if (NS_FAILED(rv)) {
+      NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed.");
+      return Err(rv);
+    }
+  }
+
+  const bool insertionPointWasInLink =
+      !!HTMLEditor::GetLinkElement(pointToInsert.GetContainer());
+
+  if (pointToInsert.IsInTextNode()) {
+    Result<SplitNodeResult, nsresult> splitNodeResult =
+        mHTMLEditor.SplitNodeDeepWithTransaction(
+            MOZ_KnownLive(*pointToInsert.ContainerAs<nsIContent>()),
+            pointToInsert, SplitAtEdges::eAllowToCreateEmptyContainer);
+    if (MOZ_UNLIKELY(splitNodeResult.isErr())) {
+      NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed");
+      return splitNodeResult.propagateErr();
+    }
+    nsresult rv = splitNodeResult.inspect().SuggestCaretPointTo(
+        mHTMLEditor, {SuggestCaret::OnlyIfHasSuggestion,
+                      SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+    if (NS_FAILED(rv)) {
+      NS_WARNING("SplitNodeResult::SuggestCaretPointTo() failed");
+      return Err(rv);
+    }
+    pointToInsert = splitNodeResult.inspect().AtSplitPoint<EditorDOMPoint>();
+    if (MOZ_UNLIKELY(!pointToInsert.IsSet())) {
+      NS_WARNING(
+          "HTMLEditor::SplitNodeDeepWithTransaction() didn't return split "
+          "point");
+      return Err(NS_ERROR_FAILURE);
+    }
+  }
+
+  {  // Block only for AutoHTMLFragmentBoundariesFixer to hide it from the
+     // following code. Note that it may modify arrayOfTopMostChildContents.
+    AutoHTMLFragmentBoundariesFixer fixPiecesOfTablesAndLists(
+        arrayOfTopMostChildContents);
+  }
+
+  MOZ_ASSERT(pointToInsert.GetContainer()->GetChildAt_Deprecated(
+                 pointToInsert.Offset()) == pointToInsert.GetChild());
+
+  Result<EditorDOMPoint, nsresult> lastInsertedPoint = InsertContents(
+      pointToInsert, arrayOfTopMostChildContents, fragmentAsNode);
+  if (lastInsertedPoint.isErr()) {
+    NS_WARNING("HTMLWithContextInserter::InsertContents() failed.");
+    return lastInsertedPoint.propagateErr();
+  }
+
+  mHTMLEditor.TopLevelEditSubActionDataRef().mNeedsToCleanUpEmptyElements =
+      false;
+
+  if (MOZ_UNLIKELY(!lastInsertedPoint.inspect().IsInComposedDoc())) {
+    return EditActionResult::HandledResult();
+  }
+
+  const EditorDOMPoint pointToPutCaret =
+      GetNewCaretPointAfterInsertingHTML(lastInsertedPoint.inspect());
+  // Now collapse the selection to the end of what we just inserted.
+  rv = mHTMLEditor.CollapseSelectionTo(pointToPutCaret);
+  if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    NS_WARNING(
+        "EditorBase::CollapseSelectionTo() caused destroying the editor");
+    return Err(NS_ERROR_EDITOR_DESTROYED);
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::CollapseSelectionTo() failed, but ignored");
+
+  // If we didn't start from an `<a href>` element, we should not keep
+  // caret in the link to make users type something outside the link.
+  if (insertionPointWasInLink) {
+    return EditActionResult::HandledResult();
+  }
+  RefPtr<Element> linkElement = GetLinkElement(pointToPutCaret.GetContainer());
+
+  if (!linkElement) {
+    return EditActionResult::HandledResult();
+  }
+
+  rv = MoveCaretOutsideOfLink(*linkElement, pointToPutCaret);
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::MoveCaretOutsideOfLink "
+        "failed.");
+    return Err(rv);
+  }
+
+  return EditActionResult::HandledResult();
+}
+
+Result<EditorDOMPoint, nsresult>
+HTMLEditor::HTMLWithContextInserter::InsertContents(
+    const EditorDOMPoint& aPointToInsert,
+    nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents,
+    const nsINode* aFragmentAsNode) {
+  MOZ_ASSERT(aPointToInsert.IsSetAndValidInComposedDoc());
+
+  EditorDOMPoint pointToInsert{aPointToInsert};
+
+  // Loop over the node list and paste the nodes:
+  const RefPtr<const Element> maybeNonEditableBlockElement =
+      pointToInsert.IsInContentNode()
+          ? HTMLEditUtils::GetInclusiveAncestorElement(
+                *pointToInsert.ContainerAs<nsIContent>(),
+                HTMLEditUtils::ClosestBlockElement)
+          : nullptr;
+
+  EditorDOMPoint lastInsertedPoint;
+  nsCOMPtr<nsIContent> insertedContextParentContent;
+  for (OwningNonNull<nsIContent>& content : aArrayOfTopMostChildContents) {
+    if (NS_WARN_IF(content == aFragmentAsNode) ||
+        NS_WARN_IF(content->IsHTMLElement(nsGkAtoms::body))) {
+      return Err(NS_ERROR_FAILURE);
+    }
+
+    if (insertedContextParentContent) {
+      // If we had to insert something higher up in the paste hierarchy,
+      // we want to skip any further paste nodes that descend from that.
+      // Else we will paste twice.
+      // XXX This check may be really expensive.  Cannot we check whether
+      //     the node's `ownerDocument` is the `aFragmentAsNode` or not?
+      // XXX If content was moved to outside of insertedContextParentContent
+      //     by mutation event listeners, we will anyway duplicate it.
+      if (EditorUtils::IsDescendantOf(*content,
+                                      *insertedContextParentContent)) {
+        continue;
+      }
+    }
+
+    // If a `<table>` or `<tr>` element on the clipboard, and pasting it into
+    // a `<table>` or `<tr>` element, insert only the appropriate children
+    // instead.
+    bool inserted = false;
+    if (HTMLEditUtils::IsTableRow(content) &&
+        HTMLEditUtils::IsTableRow(pointToInsert.GetContainer()) &&
+        (HTMLEditUtils::IsTable(content) ||
+         HTMLEditUtils::IsTable(pointToInsert.GetContainer()))) {
+      // Move children of current node to the insertion point.
+      AutoTArray<OwningNonNull<nsIContent>, 24> children;
+      HTMLEditUtils::CollectAllChildren(*content, children);
+      EditorDOMPoint pointToPutCaret;
+      for (const OwningNonNull<nsIContent>& child : children) {
+        // MOZ_KnownLive(child) because of bug 1622253
+        Result<CreateContentResult, nsresult> moveChildResult =
+            mHTMLEditor.InsertNodeIntoProperAncestorWithTransaction<nsIContent>(
+                MOZ_KnownLive(child), pointToInsert,
+                SplitAtEdges::eDoNotCreateEmptyContainer);
+        if (MOZ_UNLIKELY(moveChildResult.isErr())) {
+          // If moving node is moved to different place, we should ignore
+          // this result and keep trying to insert next content node to same
+          // position.
+          if (moveChildResult.inspectErr() ==
+              NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE) {
+            inserted = true;
+            continue;  // the inner `for` loop
+          }
+          NS_WARNING(
+              "HTMLEditor::InsertNodeIntoProperAncestorWithTransaction("
+              "SplitAtEdges::eDoNotCreateEmptyContainer) failed, maybe "
+              "ignored");
+          break;  // from the inner `for` loop
+        }
+        if (MOZ_UNLIKELY(!moveChildResult.inspect().Handled())) {
+          continue;
+        }
+        inserted = true;
+        lastInsertedPoint.Set(child);
+        pointToInsert = lastInsertedPoint.NextPoint();
+        MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+        CreateContentResult unwrappedMoveChildResult = moveChildResult.unwrap();
+        unwrappedMoveChildResult.MoveCaretPointTo(
+            pointToPutCaret, mHTMLEditor,
+            {SuggestCaret::OnlyIfHasSuggestion,
+             SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+      }  // end of the inner `for` loop
+
+      if (pointToPutCaret.IsSet()) {
+        nsresult rv = mHTMLEditor.CollapseSelectionTo(pointToPutCaret);
+        if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+          NS_WARNING(
+              "EditorBase::CollapseSelectionTo() caused destroying the editor");
+          return Err(NS_ERROR_EDITOR_DESTROYED);
+        }
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rv),
+            "EditorBase::CollapseSelectionTo() failed, but ignored");
+      }
+    }
+    // If a list element on the clipboard, and pasting it into a list or
+    // list item element, insert the appropriate children instead.  I.e.,
+    // merge the list elements instead of pasting as a sublist.
+    else if (HTMLEditUtils::IsAnyListElement(content) &&
+             (HTMLEditUtils::IsAnyListElement(pointToInsert.GetContainer()) ||
+              HTMLEditUtils::IsListItem(pointToInsert.GetContainer()))) {
+      AutoTArray<OwningNonNull<nsIContent>, 24> children;
+      HTMLEditUtils::CollectAllChildren(*content, children);
+      EditorDOMPoint pointToPutCaret;
+      for (const OwningNonNull<nsIContent>& child : children) {
+        if (HTMLEditUtils::IsListItem(child) ||
+            HTMLEditUtils::IsAnyListElement(child)) {
+          // If we're pasting into empty list item, we should remove it
+          // and past current node into the parent list directly.
+          // XXX This creates invalid structure if current list item element
+          //     is not proper child of the parent element, or current node
+          //     is a list element.
+          if (HTMLEditUtils::IsListItem(pointToInsert.GetContainer()) &&
+              HTMLEditUtils::IsEmptyNode(*pointToInsert.GetContainer())) {
+            NS_WARNING_ASSERTION(pointToInsert.GetContainerParent(),
+                                 "Insertion point is out of the DOM tree");
+            if (pointToInsert.GetContainerParent()) {
+              pointToInsert.Set(pointToInsert.GetContainer());
+              MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+              AutoEditorDOMPointChildInvalidator lockOffset(pointToInsert);
+              nsresult rv = mHTMLEditor.DeleteNodeWithTransaction(
+                  MOZ_KnownLive(*pointToInsert.GetChild()));
+              if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+                NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed");
+                return Err(NS_ERROR_EDITOR_DESTROYED);
+              }
+              NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                                   "EditorBase::DeleteNodeWithTransaction() "
+                                   "failed, but ignored");
+            }
+          }
+          // MOZ_KnownLive(child) because of bug 1622253
+          Result<CreateContentResult, nsresult> moveChildResult =
+              mHTMLEditor
+                  .InsertNodeIntoProperAncestorWithTransaction<nsIContent>(
+                      MOZ_KnownLive(child), pointToInsert,
+                      SplitAtEdges::eDoNotCreateEmptyContainer);
+          if (MOZ_UNLIKELY(moveChildResult.isErr())) {
+            // If moving node is moved to different place, we should ignore
+            // this result and keep trying to insert next content node to
+            // same position.
+            if (moveChildResult.inspectErr() ==
+                NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE) {
+              inserted = true;
+              continue;  // the inner `for` loop
+            }
+            if (NS_WARN_IF(moveChildResult.inspectErr() ==
+                           NS_ERROR_EDITOR_DESTROYED)) {
+              return Err(NS_ERROR_EDITOR_DESTROYED);
+            }
+            NS_WARNING(
+                "HTMLEditor::InsertNodeIntoProperAncestorWithTransaction("
+                "SplitAtEdges::eDoNotCreateEmptyContainer) failed, but maybe "
+                "ignored");
+            break;  // from the inner `for` loop
+          }
+          if (MOZ_UNLIKELY(!moveChildResult.inspect().Handled())) {
+            continue;
+          }
+          inserted = true;
+          lastInsertedPoint.Set(child);
+          pointToInsert = lastInsertedPoint.NextPoint();
+          MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+          CreateContentResult unwrappedMoveChildResult =
+              moveChildResult.unwrap();
+          unwrappedMoveChildResult.MoveCaretPointTo(
+              pointToPutCaret, mHTMLEditor,
+              {SuggestCaret::OnlyIfHasSuggestion,
+               SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+        }
+        // If the child of current node is not list item nor list element,
+        // we should remove it from the DOM tree.
+        else if (HTMLEditUtils::IsRemovableNode(child)) {
+          AutoEditorDOMPointChildInvalidator lockOffset(pointToInsert);
+          IgnoredErrorResult ignoredError;
+          content->RemoveChild(child, ignoredError);
+          if (MOZ_UNLIKELY(mHTMLEditor.Destroyed())) {
+            NS_WARNING(
+                "nsIContent::RemoveChild() caused destroying the editor");
+            return Err(NS_ERROR_EDITOR_DESTROYED);
+          }
+          NS_WARNING_ASSERTION(!ignoredError.Failed(),
+                               "nsINode::RemoveChild() failed, but ignored");
+        } else {
+          NS_WARNING(
+              "Failed to delete the first child of a list element because the "
+              "list element non-editable");
+          break;  // from the inner `for` loop
+        }
+      }  // end of the inner `for` loop
+
+      if (MOZ_UNLIKELY(mHTMLEditor.Destroyed())) {
+        NS_WARNING("The editor has been destroyed");
+        return Err(NS_ERROR_EDITOR_DESTROYED);
+      }
+      if (pointToPutCaret.IsSet()) {
+        nsresult rv = mHTMLEditor.CollapseSelectionTo(pointToPutCaret);
+        if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+          NS_WARNING(
+              "EditorBase::CollapseSelectionTo() caused destroying the editor");
+          return Err(NS_ERROR_EDITOR_DESTROYED);
+        }
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rv),
+            "EditorBase::CollapseSelectionTo() failed, but ignored");
+      }
+    }
+    // If pasting into a `<pre>` element and current node is a `<pre>` element,
+    // move only its children.
+    else if (HTMLEditUtils::IsPre(maybeNonEditableBlockElement) &&
+             HTMLEditUtils::IsPre(content)) {
+      // Check for pre's going into pre's.
+      AutoTArray<OwningNonNull<nsIContent>, 24> children;
+      HTMLEditUtils::CollectAllChildren(*content, children);
+      EditorDOMPoint pointToPutCaret;
+      for (const OwningNonNull<nsIContent>& child : children) {
+        // MOZ_KnownLive(child) because of bug 1622253
+        Result<CreateContentResult, nsresult> moveChildResult =
+            mHTMLEditor.InsertNodeIntoProperAncestorWithTransaction<nsIContent>(
+                MOZ_KnownLive(child), pointToInsert,
+                SplitAtEdges::eDoNotCreateEmptyContainer);
+        if (MOZ_UNLIKELY(moveChildResult.isErr())) {
+          // If moving node is moved to different place, we should ignore
+          // this result and keep trying to insert next content node there.
+          if (moveChildResult.inspectErr() ==
+              NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE) {
+            inserted = true;
+            continue;  // the inner `for` loop
+          }
+          if (NS_WARN_IF(moveChildResult.inspectErr() ==
+                         NS_ERROR_EDITOR_DESTROYED)) {
+            return moveChildResult.propagateErr();
+          }
+          NS_WARNING(
+              "HTMLEditor::InsertNodeIntoProperAncestorWithTransaction("
+              "SplitAtEdges::eDoNotCreateEmptyContainer) failed, but maybe "
+              "ignored");
+          break;  // from the inner `for` loop
+        }
+        if (MOZ_UNLIKELY(!moveChildResult.inspect().Handled())) {
+          continue;
+        }
+        CreateContentResult unwrappedMoveChildResult = moveChildResult.unwrap();
+        inserted = true;
+        lastInsertedPoint.Set(child);
+        pointToInsert = lastInsertedPoint.NextPoint();
+        MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+        unwrappedMoveChildResult.MoveCaretPointTo(
+            pointToPutCaret, mHTMLEditor,
+            {SuggestCaret::OnlyIfHasSuggestion,
+             SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+      }  // end of the inner `for` loop
+
+      if (pointToPutCaret.IsSet()) {
+        nsresult rv = mHTMLEditor.CollapseSelectionTo(pointToPutCaret);
+        if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+          NS_WARNING(
+              "EditorBase::CollapseSelectionTo() caused destroying the editor");
+          return Err(NS_ERROR_EDITOR_DESTROYED);
+        }
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rv),
+            "EditorBase::CollapseSelectionTo() failed, but ignored");
+      }
+    }
+
+    // TODO: For making the above code clearer, we should move this fallback
+    //       path into a lambda and call it in each if/else-if block.
+    // If we haven't inserted current node nor its children, move current node
+    // to the insertion point.
+    if (!inserted) {
+      // MOZ_KnownLive(content) because 'aArrayOfTopMostChildContents' is
+      // guaranteed to keep it alive.
+      Result<CreateContentResult, nsresult> moveContentResult =
+          mHTMLEditor.InsertNodeIntoProperAncestorWithTransaction<nsIContent>(
+              MOZ_KnownLive(content), pointToInsert,
+              SplitAtEdges::eDoNotCreateEmptyContainer);
+      if (MOZ_LIKELY(moveContentResult.isOk())) {
+        if (MOZ_UNLIKELY(!moveContentResult.inspect().Handled())) {
+          continue;
+        }
+        lastInsertedPoint.Set(content);
+        pointToInsert = lastInsertedPoint;
+        MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+        nsresult rv = moveContentResult.inspect().SuggestCaretPointTo(
+            mHTMLEditor, {SuggestCaret::OnlyIfHasSuggestion,
+                          SuggestCaret::OnlyIfTransactionsAllowedToDoIt,
+                          SuggestCaret::AndIgnoreTrivialError});
+        if (NS_FAILED(rv)) {
+          NS_WARNING("CreateContentResult::SuggestCaretPointTo() failed");
+          return Err(rv);
+        }
+        NS_WARNING_ASSERTION(
+            rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR,
+            "CreateContentResult::SuggestCaretPointTo() failed, but ignored");
+      } else if (moveContentResult.inspectErr() ==
+                 NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE) {
+        // Moving node is moved to different place, we should keep trying to
+        // insert the next content to same position.
+      } else {
+        NS_WARNING(
+            "HTMLEditor::InsertNodeIntoProperAncestorWithTransaction("
+            "SplitAtEdges::eDoNotCreateEmptyContainer) failed, but ignored");
+        // Assume failure means no legal parent in the document hierarchy,
+        // try again with the parent of content in the paste hierarchy.
+        // FYI: We cannot use `InclusiveAncestorOfType` here because of
+        //      calling `InsertNodeIntoProperAncestorWithTransaction()`.
+        for (nsCOMPtr<nsIContent> childContent = content; childContent;
+             childContent = childContent->GetParent()) {
+          if (NS_WARN_IF(!childContent->GetParent()) ||
+              NS_WARN_IF(
+                  childContent->GetParent()->IsHTMLElement(nsGkAtoms::body))) {
+            break;  // for the inner `for` loop
+          }
+          const OwningNonNull<nsIContent> oldParentContent =
+              *childContent->GetParent();
+          Result<CreateContentResult, nsresult> moveParentResult =
+              mHTMLEditor
+                  .InsertNodeIntoProperAncestorWithTransaction<nsIContent>(
+                      oldParentContent, pointToInsert,
+                      SplitAtEdges::eDoNotCreateEmptyContainer);
+          if (MOZ_UNLIKELY(moveParentResult.isErr())) {
+            // Moving node is moved to different place, we should keep trying to
+            // insert the next content to same position.
+            if (moveParentResult.inspectErr() ==
+                NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE) {
+              break;  // from the inner `for` loop
+            }
+            if (NS_WARN_IF(moveParentResult.inspectErr() ==
+                           NS_ERROR_EDITOR_DESTROYED)) {
+              return Err(NS_ERROR_EDITOR_DESTROYED);
+            }
+            NS_WARNING(
+                "HTMLEditor::InsertNodeInToProperAncestorWithTransaction("
+                "SplitAtEdges::eDoNotCreateEmptyContainer) failed, but "
+                "ignored");
+            continue;  // the inner `for` loop
+          }
+          if (MOZ_UNLIKELY(!moveParentResult.inspect().Handled())) {
+            continue;
+          }
+          insertedContextParentContent = oldParentContent;
+          pointToInsert.Set(oldParentContent);
+          MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+          nsresult rv = moveParentResult.inspect().SuggestCaretPointTo(
+              mHTMLEditor, {SuggestCaret::OnlyIfHasSuggestion,
+                            SuggestCaret::OnlyIfTransactionsAllowedToDoIt,
+                            SuggestCaret::AndIgnoreTrivialError});
+          if (NS_FAILED(rv)) {
+            NS_WARNING("CreateContentResult::SuggestCaretPointTo() failed");
+            return Err(rv);
+          }
+          NS_WARNING_ASSERTION(
+              rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR,
+              "CreateContentResult::SuggestCaretPointTo() failed, but ignored");
+          break;  // from the inner `for` loop
+        }         // end of the inner `for` loop
+      }
+    }
+    if (lastInsertedPoint.IsSet()) {
+      if (MOZ_UNLIKELY(lastInsertedPoint.GetContainer() !=
+                       lastInsertedPoint.GetChild()->GetParentNode())) {
+        NS_WARNING(
+            "HTMLEditor::InsertHTMLWithContextAsSubAction() got lost insertion "
+            "point");
+        return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE);
+      }
+      pointToInsert = lastInsertedPoint.NextPoint();
+      MOZ_ASSERT(pointToInsert.IsSetAndValidInComposedDoc());
+    }
+  }  // end of the `for` loop
+
+  return lastInsertedPoint;
+}
+
+nsresult HTMLEditor::HTMLWithContextInserter::MoveCaretOutsideOfLink(
+    Element& aLinkElement, const EditorDOMPoint& aPointToPutCaret) {
+  MOZ_ASSERT(HTMLEditUtils::IsLink(&aLinkElement));
+
+  // The reason why do that instead of just moving caret after it is, the
+  // link might have ended in an invisible `<br>` element.  If so, the code
+  // above just placed selection inside that.  So we need to split it instead.
+  // XXX Sounds like that it's not really expensive comparing with the reason
+  //     to use SplitNodeDeepWithTransaction() here.
+  Result<SplitNodeResult, nsresult> splitLinkResult =
+      mHTMLEditor.SplitNodeDeepWithTransaction(
+          aLinkElement, aPointToPutCaret,
+          SplitAtEdges::eDoNotCreateEmptyContainer);
+  if (MOZ_UNLIKELY(splitLinkResult.isErr())) {
+    if (splitLinkResult.inspectErr() == NS_ERROR_EDITOR_DESTROYED) {
+      NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed");
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING(
+        "HTMLEditor::SplitNodeDeepWithTransaction() failed, but ignored");
+  }
+
+  if (nsIContent* previousContentOfSplitPoint =
+          splitLinkResult.inspect().GetPreviousContent()) {
+    splitLinkResult.inspect().IgnoreCaretPointSuggestion();
+    nsresult rv = mHTMLEditor.CollapseSelectionTo(
+        EditorRawDOMPoint::After(*previousContentOfSplitPoint));
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv),
+        "EditorBase::CollapseSelectionTo() failed, but ignored");
+    return NS_OK;
+  }
+
+  nsresult rv = splitLinkResult.inspect().SuggestCaretPointTo(
+      mHTMLEditor, {SuggestCaret::OnlyIfHasSuggestion,
+                    SuggestCaret::OnlyIfTransactionsAllowedToDoIt});
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "SplitNodeResult::SuggestCaretPointTo() failed");
+  return rv;
+}
+
+// static
+Element* HTMLEditor::GetLinkElement(nsINode* aNode) {
+  if (NS_WARN_IF(!aNode)) {
+    return nullptr;
+  }
+  nsINode* node = aNode;
+  while (node) {
+    if (HTMLEditUtils::IsLink(node)) {
+      return node->AsElement();
+    }
+    node = node->GetParentNode();
+  }
+  return nullptr;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+        nsIContent& aNode, NodesToRemove aNodesToRemove) {
+  if (aNode.TextIsOnlyWhitespace()) {
+    nsCOMPtr<nsINode> parent = aNode.GetParentNode();
+    // TODO: presumably, if the parent is a `<pre>` element, the node
+    // shouldn't be removed.
+    if (parent) {
+      if (aNodesToRemove == NodesToRemove::eAll ||
+          HTMLEditUtils::IsAnyListElement(parent)) {
+        ErrorResult error;
+        parent->RemoveChild(aNode, error);
+        NS_WARNING_ASSERTION(!error.Failed(), "nsINode::RemoveChild() failed");
+        return error.StealNSResult();
+      }
+      return NS_OK;
+    }
+  }
+
+  if (!aNode.IsHTMLElement(nsGkAtoms::pre)) {
+    nsCOMPtr<nsIContent> child = aNode.GetLastChild();
+    while (child) {
+      nsCOMPtr<nsIContent> previous = child->GetPreviousSibling();
+      nsresult rv = FragmentFromPasteCreator::
+          RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+              *child, aNodesToRemove);
+      if (NS_FAILED(rv)) {
+        NS_WARNING(
+            "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+            "RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces"
+            "() "
+            "failed");
+        return rv;
+      }
+      child = std::move(previous);
+    }
+  }
+  return NS_OK;
+}
+
+class MOZ_STACK_CLASS HTMLEditor::HTMLTransferablePreparer {
+ public:
+  HTMLTransferablePreparer(const HTMLEditor& aHTMLEditor,
+                           nsITransferable** aTransferable);
+
+  nsresult Run();
+
+ private:
+  void AddDataFlavorsInBestOrder(nsITransferable& aTransferable) const;
+
+  const HTMLEditor& mHTMLEditor;
+  nsITransferable** mTransferable;
+};
+
+HTMLEditor::HTMLTransferablePreparer::HTMLTransferablePreparer(
+    const HTMLEditor& aHTMLEditor, nsITransferable** aTransferable)
+    : mHTMLEditor{aHTMLEditor}, mTransferable{aTransferable} {
+  MOZ_ASSERT(mTransferable);
+  MOZ_ASSERT(!*mTransferable);
+}
+
+nsresult HTMLEditor::PrepareHTMLTransferable(
+    nsITransferable** aTransferable) const {
+  HTMLTransferablePreparer htmlTransferablePreparer{*this, aTransferable};
+  return htmlTransferablePreparer.Run();
+}
+
+nsresult HTMLEditor::HTMLTransferablePreparer::Run() {
+  // Create generic Transferable for getting the data
+  nsresult rv;
+  RefPtr<nsITransferable> transferable =
+      do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("do_CreateInstance() failed to create nsITransferable instance");
+    return rv;
+  }
+
+  if (!transferable) {
+    NS_WARNING("do_CreateInstance() returned nullptr, but ignored");
+    return NS_OK;
+  }
+
+  // Get the nsITransferable interface for getting the data from the clipboard
+  RefPtr<Document> destdoc = mHTMLEditor.GetDocument();
+  nsILoadContext* loadContext = destdoc ? destdoc->GetLoadContext() : nullptr;
+  DebugOnly<nsresult> rvIgnored = transferable->Init(loadContext);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "nsITransferable::Init() failed, but ignored");
+
+  // See `HTMLEditor::InsertFromTransferableAtSelection`.
+  AddDataFlavorsInBestOrder(*transferable);
+
+  transferable.forget(mTransferable);
+
+  return NS_OK;
+}
+
+void HTMLEditor::HTMLTransferablePreparer::AddDataFlavorsInBestOrder(
+    nsITransferable& aTransferable) const {
+  // Create the desired DataFlavor for the type of data
+  // we want to get out of the transferable
+  // This should only happen in html editors, not plaintext
+  if (!mHTMLEditor.IsInPlaintextMode()) {
+    DebugOnly<nsresult> rvIgnored =
+        aTransferable.AddDataFlavor(kNativeHTMLMime);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "nsITransferable::AddDataFlavor(kNativeHTMLMime) failed, but ignored");
+    rvIgnored = aTransferable.AddDataFlavor(kHTMLMime);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "nsITransferable::AddDataFlavor(kHTMLMime) failed, but ignored");
+    rvIgnored = aTransferable.AddDataFlavor(kFileMime);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "nsITransferable::AddDataFlavor(kFileMime) failed, but ignored");
+
+    switch (Preferences::GetInt("clipboard.paste_image_type", 1)) {
+      case 0:  // prefer JPEG over PNG over GIF encoding
+        rvIgnored = aTransferable.AddDataFlavor(kJPEGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPEGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kJPGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kPNGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kPNGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kGIFImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kGIFImageMime) "
+                             "failed, but ignored");
+        break;
+      case 1:  // prefer PNG over JPEG over GIF encoding (default)
+      default:
+        rvIgnored = aTransferable.AddDataFlavor(kPNGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kPNGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kJPEGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPEGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kJPGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kGIFImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kGIFImageMime) "
+                             "failed, but ignored");
+        break;
+      case 2:  // prefer GIF over JPEG over PNG encoding
+        rvIgnored = aTransferable.AddDataFlavor(kGIFImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kGIFImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kJPEGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPEGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kJPGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kJPGImageMime) "
+                             "failed, but ignored");
+        rvIgnored = aTransferable.AddDataFlavor(kPNGImageMime);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsITransferable::AddDataFlavor(kPNGImageMime) "
+                             "failed, but ignored");
+        break;
+    }
+  }
+  DebugOnly<nsresult> rvIgnored = aTransferable.AddDataFlavor(kTextMime);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rvIgnored),
+      "nsITransferable::AddDataFlavor(kTextMime) failed, but ignored");
+  rvIgnored = aTransferable.AddDataFlavor(kMozTextInternal);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rvIgnored),
+      "nsITransferable::AddDataFlavor(kMozTextInternal) failed, but ignored");
+}
+
+bool FindIntegerAfterString(const char* aLeadingString, const nsCString& aCStr,
+                            int32_t& foundNumber) {
+  // first obtain offsets from cfhtml str
+  int32_t numFront = aCStr.Find(aLeadingString);
+  if (numFront == -1) {
+    return false;
+  }
+  numFront += strlen(aLeadingString);
+
+  int32_t numBack = aCStr.FindCharInSet(CRLF, numFront);
+  if (numBack == -1) {
+    return false;
+  }
+
+  nsAutoCString numStr(Substring(aCStr, numFront, numBack - numFront));
+  nsresult errorCode;
+  foundNumber = numStr.ToInteger(&errorCode);
+  return true;
+}
+
+void RemoveFragComments(nsCString& aStr) {
+  // remove the StartFragment/EndFragment comments from the str, if present
+  int32_t startCommentIndx = aStr.Find("<!--StartFragment");
+  if (startCommentIndx >= 0) {
+    int32_t startCommentEnd = aStr.Find("-->", startCommentIndx);
+    if (startCommentEnd > startCommentIndx) {
+      aStr.Cut(startCommentIndx, (startCommentEnd + 3) - startCommentIndx);
+    }
+  }
+  int32_t endCommentIndx = aStr.Find("<!--EndFragment");
+  if (endCommentIndx >= 0) {
+    int32_t endCommentEnd = aStr.Find("-->", endCommentIndx);
+    if (endCommentEnd > endCommentIndx) {
+      aStr.Cut(endCommentIndx, (endCommentEnd + 3) - endCommentIndx);
+    }
+  }
+}
+
+nsresult HTMLEditor::ParseCFHTML(const nsCString& aCfhtml,
+                                 char16_t** aStuffToPaste,
+                                 char16_t** aCfcontext) {
+  // First obtain offsets from cfhtml str.
+  int32_t startHTML, endHTML, startFragment, endFragment;
+  if (!FindIntegerAfterString("StartHTML:", aCfhtml, startHTML) ||
+      startHTML < -1) {
+    return NS_ERROR_FAILURE;
+  }
+  if (!FindIntegerAfterString("EndHTML:", aCfhtml, endHTML) || endHTML < -1) {
+    return NS_ERROR_FAILURE;
+  }
+  if (!FindIntegerAfterString("StartFragment:", aCfhtml, startFragment) ||
+      startFragment < 0) {
+    return NS_ERROR_FAILURE;
+  }
+  if (!FindIntegerAfterString("EndFragment:", aCfhtml, endFragment) ||
+      startFragment < 0) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // The StartHTML and EndHTML markers are allowed to be -1 to include
+  // everything.
+  //   See Reference: MSDN doc entitled "HTML Clipboard Format"
+  //   http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx#unknown_854
+  if (startHTML == -1) {
+    startHTML = aCfhtml.Find("<!--StartFragment-->");
+    if (startHTML == -1) {
+      return NS_OK;
+    }
+  }
+  if (endHTML == -1) {
+    const char endFragmentMarker[] = "<!--EndFragment-->";
+    endHTML = aCfhtml.Find(endFragmentMarker);
+    if (endHTML == -1) {
+      return NS_OK;
+    }
+    endHTML += ArrayLength(endFragmentMarker) - 1;
+  }
+
+  // create context string
+  nsAutoCString contextUTF8(
+      Substring(aCfhtml, startHTML, startFragment - startHTML) +
+      "<!--" kInsertCookie "-->"_ns +
+      Substring(aCfhtml, endFragment, endHTML - endFragment));
+
+  // validate startFragment
+  // make sure it's not in the middle of a HTML tag
+  // see bug #228879 for more details
+  int32_t curPos = startFragment;
+  while (curPos > startHTML) {
+    if (aCfhtml[curPos] == '>') {
+      // working backwards, the first thing we see is the end of a tag
+      // so StartFragment is good, so do nothing.
+      break;
+    }
+    if (aCfhtml[curPos] == '<') {
+      // if we are at the start, then we want to see the '<'
+      if (curPos != startFragment) {
+        // working backwards, the first thing we see is the start of a tag
+        // so StartFragment is bad, so we need to update it.
+        NS_ERROR(
+            "StartFragment byte count in the clipboard looks bad, see bug "
+            "#228879");
+        startFragment = curPos - 1;
+      }
+      break;
+    }
+    curPos--;
+  }
+
+  // create fragment string
+  nsAutoCString fragmentUTF8(
+      Substring(aCfhtml, startFragment, endFragment - startFragment));
+
+  // remove the StartFragment/EndFragment comments from the fragment, if present
+  RemoveFragComments(fragmentUTF8);
+
+  // remove the StartFragment/EndFragment comments from the context, if present
+  RemoveFragComments(contextUTF8);
+
+  // convert both strings to usc2
+  const nsString& fragUcs2Str = NS_ConvertUTF8toUTF16(fragmentUTF8);
+  const nsString& cntxtUcs2Str = NS_ConvertUTF8toUTF16(contextUTF8);
+
+  // translate platform linebreaks for fragment
+  int32_t oldLengthInChars =
+      fragUcs2Str.Length() + 1;  // +1 to include null terminator
+  int32_t newLengthInChars = 0;
+  *aStuffToPaste = nsLinebreakConverter::ConvertUnicharLineBreaks(
+      fragUcs2Str.get(), nsLinebreakConverter::eLinebreakAny,
+      nsLinebreakConverter::eLinebreakContent, oldLengthInChars,
+      &newLengthInChars);
+  if (!*aStuffToPaste) {
+    NS_WARNING("nsLinebreakConverter::ConvertUnicharLineBreaks() failed");
+    return NS_ERROR_FAILURE;
+  }
+
+  // translate platform linebreaks for context
+  oldLengthInChars =
+      cntxtUcs2Str.Length() + 1;  // +1 to include null terminator
+  newLengthInChars = 0;
+  *aCfcontext = nsLinebreakConverter::ConvertUnicharLineBreaks(
+      cntxtUcs2Str.get(), nsLinebreakConverter::eLinebreakAny,
+      nsLinebreakConverter::eLinebreakContent, oldLengthInChars,
+      &newLengthInChars);
+  // it's ok for context to be empty.  frag might be whole doc and contain all
+  // its context.
+
+  // we're done!
+  return NS_OK;
+}
+
+static nsresult ImgFromData(const nsACString& aType, const nsACString& aData,
+                            nsString& aOutput) {
+  aOutput.AssignLiteral("<IMG src=\"data:");
+  AppendUTF8toUTF16(aType, aOutput);
+  aOutput.AppendLiteral(";base64,");
+  nsresult rv = Base64EncodeAppend(aData, aOutput);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Base64Encode() failed");
+    return rv;
+  }
+  aOutput.AppendLiteral("\" alt=\"\" >");
+  return NS_OK;
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLEditor::BlobReader)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(HTMLEditor::BlobReader)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBlob)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mHTMLEditor)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPointToInsert)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(HTMLEditor::BlobReader)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBlob)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHTMLEditor)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPointToInsert)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+HTMLEditor::BlobReader::BlobReader(BlobImpl* aBlob, HTMLEditor* aHTMLEditor,
+                                   SafeToInsertData aSafeToInsertData,
+                                   const EditorDOMPoint& aPointToInsert,
+                                   DeleteSelectedContent aDeleteSelectedContent)
+    : mBlob(aBlob),
+      mHTMLEditor(aHTMLEditor),
+      // "beforeinput" event should've been dispatched before we read blob,
+      // but anyway, we need to clone dataTransfer for "input" event.
+      mDataTransfer(mHTMLEditor->GetInputEventDataTransfer()),
+      mPointToInsert(aPointToInsert),
+      mEditAction(aHTMLEditor->GetEditAction()),
+      mSafeToInsertData(aSafeToInsertData),
+      mDeleteSelectedContent(aDeleteSelectedContent),
+      mNeedsToDispatchBeforeInputEvent(
+          !mHTMLEditor->HasTriedToDispatchBeforeInputEvent()) {
+  MOZ_ASSERT(mBlob);
+  MOZ_ASSERT(mHTMLEditor);
+  MOZ_ASSERT(mHTMLEditor->IsEditActionDataAvailable());
+  MOZ_ASSERT(mDataTransfer);
+
+  // Take only offset here since it's our traditional behavior.
+  if (mPointToInsert.IsSet()) {
+    AutoEditorDOMPointChildInvalidator storeOnlyWithOffset(mPointToInsert);
+  }
+}
+
+nsresult HTMLEditor::BlobReader::OnResult(const nsACString& aResult) {
+  AutoEditActionDataSetter editActionData(*mHTMLEditor, mEditAction);
+  editActionData.InitializeDataTransfer(mDataTransfer);
+  if (NS_WARN_IF(!editActionData.CanHandle())) {
+    return EditorBase::ToGenericNSResult(NS_ERROR_FAILURE);
+  }
+
+  if (NS_WARN_IF(mNeedsToDispatchBeforeInputEvent)) {
+    nsresult rv = editActionData.MaybeDispatchBeforeInputEvent();
+    if (NS_FAILED(rv)) {
+      NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                           "MaybeDispatchBeforeInputEvent(), failed");
+      return EditorBase::ToGenericNSResult(rv);
+    }
+  } else {
+    editActionData.MarkAsBeforeInputHasBeenDispatched();
+  }
+
+  nsString blobType;
+  mBlob->GetType(blobType);
+
+  // TODO: This does not work well.
+  // * If the data is not an image file, this inserts <img> element with odd
+  //   data URI (bug 1610220).
+  // * If the data is valid image file data, an <img> file is inserted with
+  //   data URI, but it's not loaded (bug 1610219).
+  NS_ConvertUTF16toUTF8 type(blobType);
+  nsAutoString stuffToPaste;
+  nsresult rv = ImgFromData(type, aResult, stuffToPaste);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("ImgFormData() failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  RefPtr<HTMLEditor> htmlEditor = std::move(mHTMLEditor);
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *htmlEditor, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  EditorDOMPoint pointToInsert = std::move(mPointToInsert);
+  rv = htmlEditor->InsertHTMLWithContextAsSubAction(
+      stuffToPaste, u""_ns, u""_ns, NS_LITERAL_STRING_FROM_CSTRING(kFileMime),
+      mSafeToInsertData, pointToInsert, mDeleteSelectedContent,
+      InlineStylesAtInsertionPoint::Preserve);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                       "InlineStylesAtInsertionPoint::Preserve) failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+nsresult HTMLEditor::BlobReader::OnError(const nsAString& aError) {
+  AutoTArray<nsString, 1> error;
+  error.AppendElement(aError);
+  nsContentUtils::ReportToConsole(
+      nsIScriptError::warningFlag, "Editor"_ns, mHTMLEditor->GetDocument(),
+      nsContentUtils::eDOM_PROPERTIES, "EditorFileDropFailed", error);
+  return NS_OK;
+}
+
+class SlurpBlobEventListener final : public nsIDOMEventListener {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS(SlurpBlobEventListener)
+
+  explicit SlurpBlobEventListener(HTMLEditor::BlobReader* aListener)
+      : mListener(aListener) {}
+
+  MOZ_CAN_RUN_SCRIPT NS_IMETHOD HandleEvent(Event* aEvent) override;
+
+ private:
+  ~SlurpBlobEventListener() = default;
+
+  RefPtr<HTMLEditor::BlobReader> mListener;
+};
+
+NS_IMPL_CYCLE_COLLECTION(SlurpBlobEventListener, mListener)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SlurpBlobEventListener)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(SlurpBlobEventListener)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(SlurpBlobEventListener)
+
+NS_IMETHODIMP SlurpBlobEventListener::HandleEvent(Event* aEvent) {
+  EventTarget* target = aEvent->GetTarget();
+  if (!target || !mListener) {
+    return NS_OK;
+  }
+
+  RefPtr<FileReader> reader = do_QueryObject(target);
+  if (!reader) {
+    return NS_OK;
+  }
+
+  EventMessage message = aEvent->WidgetEventPtr()->mMessage;
+
+  RefPtr<HTMLEditor::BlobReader> listener(mListener);
+  if (message == eLoad) {
+    MOZ_ASSERT(reader->DataFormat() == FileReader::FILE_AS_BINARY);
+
+    // The original data has been converted from Latin1 to UTF-16, this just
+    // undoes that conversion.
+    DebugOnly<nsresult> rvIgnored =
+        listener->OnResult(NS_LossyConvertUTF16toASCII(reader->Result()));
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "HTMLEditor::BlobReader::OnResult() failed, but ignored");
+    return NS_OK;
+  }
+
+  if (message == eLoadError) {
+    nsAutoString errorMessage;
+    reader->GetError()->GetErrorMessage(errorMessage);
+    DebugOnly<nsresult> rvIgnored = listener->OnError(errorMessage);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "HTMLEditor::BlobReader::OnError() failed, but ignored");
+    return NS_OK;
+  }
+
+  return NS_OK;
+}
+
+// static
+nsresult HTMLEditor::SlurpBlob(Blob* aBlob, nsIGlobalObject* aGlobal,
+                               BlobReader* aBlobReader) {
+  MOZ_ASSERT(aBlob);
+  MOZ_ASSERT(aGlobal);
+  MOZ_ASSERT(aBlobReader);
+
+  RefPtr<WeakWorkerRef> workerRef;
+  RefPtr<FileReader> reader = new FileReader(aGlobal, workerRef);
+
+  RefPtr<SlurpBlobEventListener> eventListener =
+      new SlurpBlobEventListener(aBlobReader);
+
+  nsresult rv = reader->AddEventListener(u"load"_ns, eventListener, false);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("FileReader::AddEventListener(load) failed");
+    return rv;
+  }
+
+  rv = reader->AddEventListener(u"error"_ns, eventListener, false);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("FileReader::AddEventListener(error) failed");
+    return rv;
+  }
+
+  ErrorResult error;
+  reader->ReadAsBinaryString(*aBlob, error);
+  NS_WARNING_ASSERTION(!error.Failed(),
+                       "FileReader::ReadAsBinaryString() failed");
+  return error.StealNSResult();
+}
+
+nsresult HTMLEditor::InsertObject(
+    const nsACString& aType, nsISupports* aObject,
+    SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert,
+    DeleteSelectedContent aDeleteSelectedContent) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  // Check to see if we the file is actually an image.
+  nsAutoCString type(aType);
+  if (type.EqualsLiteral(kFileMime)) {
+    if (nsCOMPtr<nsIFile> file = do_QueryInterface(aObject)) {
+      nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1");
+      if (NS_WARN_IF(!mime)) {
+        return NS_ERROR_FAILURE;
+      }
+
+      nsresult rv = mime->GetTypeFromFile(file, type);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("nsIMIMEService::GetTypeFromFile() failed");
+        return rv;
+      }
+    }
+  }
+
+  nsCOMPtr<nsISupports> object = aObject;
+  if (type.EqualsLiteral(kJPEGImageMime) || type.EqualsLiteral(kJPGImageMime) ||
+      type.EqualsLiteral(kPNGImageMime) || type.EqualsLiteral(kGIFImageMime)) {
+    if (nsCOMPtr<nsIFile> file = do_QueryInterface(object)) {
+      object = new FileBlobImpl(file);
+      // Fallthrough to BlobImpl code below.
+    } else if (RefPtr<Blob> blob = do_QueryObject(object)) {
+      object = blob->Impl();
+      // Fallthrough.
+    } else if (nsCOMPtr<nsIInputStream> imageStream =
+                   do_QueryInterface(object)) {
+      nsCString imageData;
+      nsresult rv = NS_ConsumeStream(imageStream, UINT32_MAX, imageData);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("NS_ConsumeStream() failed");
+        return rv;
+      }
+
+      rv = imageStream->Close();
+      if (NS_FAILED(rv)) {
+        NS_WARNING("nsIInputStream::Close() failed");
+        return rv;
+      }
+
+      nsAutoString stuffToPaste;
+      rv = ImgFromData(type, imageData, stuffToPaste);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("ImgFromData() failed");
+        return rv;
+      }
+
+      AutoPlaceholderBatch treatAsOneTransaction(
+          *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+      rv = InsertHTMLWithContextAsSubAction(
+          stuffToPaste, u""_ns, u""_ns,
+          NS_LITERAL_STRING_FROM_CSTRING(kFileMime), aSafeToInsertData,
+          aPointToInsert, aDeleteSelectedContent,
+          InlineStylesAtInsertionPoint::Preserve);
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::InsertHTMLWithContextAsSubAction("
+          "InlineStylesAtInsertionPoint::Preserve) failed, but ignored");
+      return NS_OK;
+    } else {
+      NS_WARNING("HTMLEditor::InsertObject: Unexpected type for image mime");
+      return NS_OK;
+    }
+  }
+
+  // We always try to insert BlobImpl even without a known image mime.
+  nsCOMPtr<BlobImpl> blob = do_QueryInterface(object);
+  if (!blob) {
+    return NS_OK;
+  }
+
+  RefPtr<BlobReader> br = new BlobReader(
+      blob, this, aSafeToInsertData, aPointToInsert, aDeleteSelectedContent);
+
+  nsCOMPtr<nsPIDOMWindowInner> inner = GetInnerWindow();
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(inner);
+  if (!global) {
+    NS_WARNING("Could not get global");
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<Blob> domBlob = Blob::Create(global, blob);
+  if (!domBlob) {
+    NS_WARNING("Blob::Create() failed");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv = SlurpBlob(domBlob, global, br);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::::SlurpBlob() failed");
+  return rv;
+}
+
+static bool GetString(nsISupports* aData, nsAString& aText) {
+  if (nsCOMPtr<nsISupportsString> str = do_QueryInterface(aData)) {
+    DebugOnly<nsresult> rvIgnored = str->GetData(aText);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "nsISupportsString::GetData() failed, but ignored");
+    return !aText.IsEmpty();
+  }
+
+  return false;
+}
+
+static bool GetCString(nsISupports* aData, nsACString& aText) {
+  if (nsCOMPtr<nsISupportsCString> str = do_QueryInterface(aData)) {
+    DebugOnly<nsresult> rvIgnored = str->GetData(aText);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "nsISupportsString::GetData() failed, but ignored");
+    return !aText.IsEmpty();
+  }
+
+  return false;
+}
+
+nsresult HTMLEditor::InsertFromTransferableAtSelection(
+    nsITransferable* aTransferable, const nsAString& aContextStr,
+    const nsAString& aInfoStr, HavePrivateHTMLFlavor aHavePrivateHTMLFlavor) {
+  nsAutoCString bestFlavor;
+  nsCOMPtr<nsISupports> genericDataObj;
+
+  // See `HTMLTransferablePreparer::AddDataFlavorsInBestOrder`.
+  nsresult rv = aTransferable->GetAnyTransferData(
+      bestFlavor, getter_AddRefs(genericDataObj));
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "nsITransferable::GetAnyTransferData() failed, but ignored");
+  if (NS_SUCCEEDED(rv)) {
+    AutoTransactionsConserveSelection dontChangeMySelection(*this);
+    nsAutoString flavor;
+    CopyASCIItoUTF16(bestFlavor, flavor);
+    const SafeToInsertData safeToInsertData = IsSafeToInsertData(nullptr);
+
+    if (bestFlavor.EqualsLiteral(kFileMime) ||
+        bestFlavor.EqualsLiteral(kJPEGImageMime) ||
+        bestFlavor.EqualsLiteral(kJPGImageMime) ||
+        bestFlavor.EqualsLiteral(kPNGImageMime) ||
+        bestFlavor.EqualsLiteral(kGIFImageMime)) {
+      nsresult rv = InsertObject(bestFlavor, genericDataObj, safeToInsertData,
+                                 EditorDOMPoint(), DeleteSelectedContent::Yes);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("HTMLEditor::InsertObject() failed");
+        return rv;
+      }
+    } else if (bestFlavor.EqualsLiteral(kNativeHTMLMime)) {
+      // note cf_html uses utf8
+      nsAutoCString cfhtml;
+      if (GetCString(genericDataObj, cfhtml)) {
+        // cfselection left emtpy for now.
+        nsString cfcontext, cffragment, cfselection;
+        nsresult rv = ParseCFHTML(cfhtml, getter_Copies(cffragment),
+                                  getter_Copies(cfcontext));
+        if (NS_SUCCEEDED(rv) && !cffragment.IsEmpty()) {
+          // If we have our private HTML flavor, we will only use the fragment
+          // from the CF_HTML. The rest comes from the clipboard.
+          if (aHavePrivateHTMLFlavor == HavePrivateHTMLFlavor::Yes) {
+            AutoPlaceholderBatch treatAsOneTransaction(
+                *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+            rv = InsertHTMLWithContextAsSubAction(
+                cffragment, aContextStr, aInfoStr, flavor, safeToInsertData,
+                EditorDOMPoint(), DeleteSelectedContent::Yes,
+                InlineStylesAtInsertionPoint::Clear);
+            if (NS_FAILED(rv)) {
+              NS_WARNING(
+                  "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                  "DeleteSelectedContent::Yes, "
+                  "InlineStylesAtInsertionPoint::Clear) failed");
+              return rv;
+            }
+          } else {
+            AutoPlaceholderBatch treatAsOneTransaction(
+                *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+            rv = InsertHTMLWithContextAsSubAction(
+                cffragment, cfcontext, cfselection, flavor, safeToInsertData,
+                EditorDOMPoint(), DeleteSelectedContent::Yes,
+                InlineStylesAtInsertionPoint::Clear);
+            if (NS_FAILED(rv)) {
+              NS_WARNING(
+                  "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                  "DeleteSelectedContent::Yes, "
+                  "InlineStylesAtInsertionPoint::Clear) failed");
+              return rv;
+            }
+          }
+        } else {
+          // In some platforms (like Linux), the clipboard might return data
+          // requested for unknown flavors (for example:
+          // application/x-moz-nativehtml).  In this case, treat the data
+          // to be pasted as mere HTML to get the best chance of pasting it
+          // correctly.
+          bestFlavor.AssignLiteral(kHTMLMime);
+          // Fall through the next case
+        }
+      }
+    }
+    if (bestFlavor.EqualsLiteral(kHTMLMime) ||
+        bestFlavor.EqualsLiteral(kTextMime) ||
+        bestFlavor.EqualsLiteral(kMozTextInternal)) {
+      nsAutoString stuffToPaste;
+      if (!GetString(genericDataObj, stuffToPaste)) {
+        nsAutoCString text;
+        if (GetCString(genericDataObj, text)) {
+          CopyUTF8toUTF16(text, stuffToPaste);
+        }
+      }
+
+      if (!stuffToPaste.IsEmpty()) {
+        if (bestFlavor.EqualsLiteral(kHTMLMime)) {
+          AutoPlaceholderBatch treatAsOneTransaction(
+              *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+          nsresult rv = InsertHTMLWithContextAsSubAction(
+              stuffToPaste, aContextStr, aInfoStr, flavor, safeToInsertData,
+              EditorDOMPoint(), DeleteSelectedContent::Yes,
+              InlineStylesAtInsertionPoint::Clear);
+          if (NS_FAILED(rv)) {
+            NS_WARNING(
+                "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                "DeleteSelectedContent::Yes, "
+                "InlineStylesAtInsertionPoint::Clear) failed");
+            return rv;
+          }
+        } else {
+          AutoPlaceholderBatch treatAsOneTransaction(
+              *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+          nsresult rv =
+              InsertTextAsSubAction(stuffToPaste, SelectionHandling::Delete);
+          if (NS_FAILED(rv)) {
+            NS_WARNING("EditorBase::InsertTextAsSubAction() failed");
+            return rv;
+          }
+        }
+      }
+    }
+  }
+
+  // Try to scroll the selection into view if the paste succeeded
+  DebugOnly<nsresult> rvIgnored = ScrollSelectionFocusIntoView();
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rvIgnored),
+      "EditorBase::ScrollSelectionFocusIntoView() failed, but ignored");
+  return NS_OK;
+}
+
+static void GetStringFromDataTransfer(const DataTransfer* aDataTransfer,
+                                      const nsAString& aType, uint32_t aIndex,
+                                      nsString& aOutputString) {
+  nsCOMPtr<nsIVariant> variant;
+  DebugOnly<nsresult> rvIgnored = aDataTransfer->GetDataAtNoSecurityCheck(
+      aType, aIndex, getter_AddRefs(variant));
+  if (!variant) {
+    MOZ_ASSERT(aOutputString.IsEmpty());
+    return;
+  }
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rvIgnored),
+      "DataTransfer::GetDataAtNoSecurityCheck() failed, but ignored");
+  variant->GetAsAString(aOutputString);
+  nsContentUtils::PlatformToDOMLineBreaks(aOutputString);
+}
+
+nsresult HTMLEditor::InsertFromDataTransfer(
+    const DataTransfer* aDataTransfer, uint32_t aIndex,
+    nsIPrincipal* aSourcePrincipal, const EditorDOMPoint& aDroppedAt,
+    DeleteSelectedContent aDeleteSelectedContent) {
+  MOZ_ASSERT(GetEditAction() == EditAction::eDrop ||
+             GetEditAction() == EditAction::ePaste);
+  MOZ_ASSERT(mPlaceholderBatch,
+             "HTMLEditor::InsertFromDataTransfer() should be called by "
+             "HandleDropEvent() or paste action and there should've already "
+             "been placeholder transaction");
+  MOZ_ASSERT_IF(GetEditAction() == EditAction::eDrop, aDroppedAt.IsSet());
+
+  ErrorResult error;
+  RefPtr<DOMStringList> types = aDataTransfer->MozTypesAt(aIndex, error);
+  if (error.Failed()) {
+    NS_WARNING("DataTransfer::MozTypesAt() failed");
+    return error.StealNSResult();
+  }
+
+  const bool hasPrivateHTMLFlavor =
+      types->Contains(NS_LITERAL_STRING_FROM_CSTRING(kHTMLContext));
+
+  const bool isPlaintextEditor = IsInPlaintextMode();
+  const SafeToInsertData safeToInsertData =
+      IsSafeToInsertData(aSourcePrincipal);
+
+  uint32_t length = types->Length();
+  for (uint32_t i = 0; i < length; i++) {
+    nsAutoString type;
+    types->Item(i, type);
+
+    if (!isPlaintextEditor) {
+      if (type.EqualsLiteral(kFileMime) || type.EqualsLiteral(kJPEGImageMime) ||
+          type.EqualsLiteral(kJPGImageMime) ||
+          type.EqualsLiteral(kPNGImageMime) ||
+          type.EqualsLiteral(kGIFImageMime)) {
+        nsCOMPtr<nsIVariant> variant;
+        DebugOnly<nsresult> rvIgnored = aDataTransfer->GetDataAtNoSecurityCheck(
+            type, aIndex, getter_AddRefs(variant));
+        if (variant) {
+          NS_WARNING_ASSERTION(
+              NS_SUCCEEDED(rvIgnored),
+              "DataTransfer::GetDataAtNoSecurityCheck() failed, but ignored");
+          nsCOMPtr<nsISupports> object;
+          rvIgnored = variant->GetAsISupports(getter_AddRefs(object));
+          NS_WARNING_ASSERTION(
+              NS_SUCCEEDED(rvIgnored),
+              "nsIVariant::GetAsISupports() failed, but ignored");
+          nsresult rv = InsertObject(NS_ConvertUTF16toUTF8(type), object,
+                                     safeToInsertData, aDroppedAt,
+                                     aDeleteSelectedContent);
+          NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                               "HTMLEditor::InsertObject() failed");
+          return rv;
+        }
+      } else if (type.EqualsLiteral(kNativeHTMLMime)) {
+        // Windows only clipboard parsing.
+        nsAutoString text;
+        GetStringFromDataTransfer(aDataTransfer, type, aIndex, text);
+        NS_ConvertUTF16toUTF8 cfhtml(text);
+
+        nsString cfcontext, cffragment,
+            cfselection;  // cfselection left emtpy for now
+
+        nsresult rv = ParseCFHTML(cfhtml, getter_Copies(cffragment),
+                                  getter_Copies(cfcontext));
+        if (NS_SUCCEEDED(rv) && !cffragment.IsEmpty()) {
+          if (hasPrivateHTMLFlavor) {
+            // If we have our private HTML flavor, we will only use the fragment
+            // from the CF_HTML. The rest comes from the clipboard.
+            nsAutoString contextString, infoString;
+            GetStringFromDataTransfer(
+                aDataTransfer, NS_LITERAL_STRING_FROM_CSTRING(kHTMLContext),
+                aIndex, contextString);
+            GetStringFromDataTransfer(aDataTransfer,
+                                      NS_LITERAL_STRING_FROM_CSTRING(kHTMLInfo),
+                                      aIndex, infoString);
+            AutoPlaceholderBatch treatAsOneTransaction(
+                *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+            nsresult rv = InsertHTMLWithContextAsSubAction(
+                cffragment, contextString, infoString, type, safeToInsertData,
+                aDroppedAt, aDeleteSelectedContent,
+                InlineStylesAtInsertionPoint::Clear);
+            NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                                 "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                                 "InlineStylesAtInsertionPoint::Clear) failed");
+            return rv;
+          }
+          AutoPlaceholderBatch treatAsOneTransaction(
+              *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+          nsresult rv = InsertHTMLWithContextAsSubAction(
+              cffragment, cfcontext, cfselection, type, safeToInsertData,
+              aDroppedAt, aDeleteSelectedContent,
+              InlineStylesAtInsertionPoint::Clear);
+          NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                               "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                               "InlineStylesAtInsertionPoint::Clear) failed");
+          return rv;
+        }
+      } else if (type.EqualsLiteral(kHTMLMime)) {
+        nsAutoString text, contextString, infoString;
+        GetStringFromDataTransfer(aDataTransfer, type, aIndex, text);
+        GetStringFromDataTransfer(aDataTransfer,
+                                  NS_LITERAL_STRING_FROM_CSTRING(kHTMLContext),
+                                  aIndex, contextString);
+        GetStringFromDataTransfer(aDataTransfer,
+                                  NS_LITERAL_STRING_FROM_CSTRING(kHTMLInfo),
+                                  aIndex, infoString);
+        if (type.EqualsLiteral(kHTMLMime)) {
+          AutoPlaceholderBatch treatAsOneTransaction(
+              *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+          nsresult rv = InsertHTMLWithContextAsSubAction(
+              text, contextString, infoString, type, safeToInsertData,
+              aDroppedAt, aDeleteSelectedContent,
+              InlineStylesAtInsertionPoint::Clear);
+          NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                               "HTMLEditor::InsertHTMLWithContextAsSubAction("
+                               "InlineStylesAtInsertionPoint::Clear) failed");
+          return rv;
+        }
+      }
+    }
+
+    if (type.EqualsLiteral(kTextMime) || type.EqualsLiteral(kMozTextInternal)) {
+      nsAutoString text;
+      GetStringFromDataTransfer(aDataTransfer, type, aIndex, text);
+      AutoPlaceholderBatch treatAsOneTransaction(
+          *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+      nsresult rv = InsertTextAt(text, aDroppedAt, aDeleteSelectedContent);
+      NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                           "EditorBase::InsertTextAt() failed");
+      return rv;
+    }
+  }
+
+  return NS_OK;
+}
+
+// static
+HTMLEditor::HavePrivateHTMLFlavor HTMLEditor::ClipboardHasPrivateHTMLFlavor(
+    nsIClipboard* aClipboard) {
+  if (NS_WARN_IF(!aClipboard)) {
+    return HavePrivateHTMLFlavor::No;
+  }
+
+  // check the clipboard for our special kHTMLContext flavor.  If that is there,
+  // we know we have our own internal html format on clipboard.
+  bool hasPrivateHTMLFlavor = false;
+  AutoTArray<nsCString, 1> flavArray = {nsDependentCString(kHTMLContext)};
+  nsresult rv = aClipboard->HasDataMatchingFlavors(
+      flavArray, nsIClipboard::kGlobalClipboard, &hasPrivateHTMLFlavor);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "nsIClipboard::HasDataMatchingFlavors(nsIClipboard::"
+                       "kGlobalClipboard) failed");
+  return NS_SUCCEEDED(rv) && hasPrivateHTMLFlavor ? HavePrivateHTMLFlavor::Yes
+                                                  : HavePrivateHTMLFlavor::No;
+}
+
+nsresult HTMLEditor::HandlePaste(AutoEditActionDataSetter& aEditActionData,
+                                 int32_t aClipboardType) {
+  aEditActionData.InitializeDataTransferWithClipboard(
+      SettingDataTransfer::eWithFormat, aClipboardType);
+  nsresult rv = aEditActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent() failed");
+    return rv;
+  }
+  rv = PasteInternal(aClipboardType);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::PasteInternal() failed");
+  return rv;
+}
+
+nsresult HTMLEditor::PasteInternal(int32_t aClipboardType) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  // Get Clipboard Service
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIClipboard> clipboard =
+      do_GetService("@mozilla.org/widget/clipboard;1", &rv);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to get nsIClipboard service");
+    return rv;
+  }
+
+  // Get the nsITransferable interface for getting the data from the clipboard
+  nsCOMPtr<nsITransferable> transferable;
+  rv = PrepareHTMLTransferable(getter_AddRefs(transferable));
+  if (NS_FAILED(rv)) {
+    NS_WARNING("HTMLEditor::PrepareHTMLTransferable() failed");
+    return rv;
+  }
+  if (!transferable) {
+    NS_WARNING("HTMLEditor::PrepareHTMLTransferable() returned nullptr");
+    return NS_ERROR_FAILURE;
+  }
+  // Get the Data from the clipboard
+  rv = clipboard->GetData(transferable, aClipboardType);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("nsIClipboard::GetData() failed");
+    return rv;
+  }
+
+  // XXX Why don't you check this first?
+  if (!IsModifiable()) {
+    return NS_OK;
+  }
+
+  // also get additional html copy hints, if present
+  nsAutoString contextStr, infoStr;
+
+  // If we have our internal html flavor on the clipboard, there is special
+  // context to use instead of cfhtml context.
+  const HavePrivateHTMLFlavor clipboardHasPrivateHTMLFlavor =
+      ClipboardHasPrivateHTMLFlavor(clipboard);
+  if (clipboardHasPrivateHTMLFlavor == HavePrivateHTMLFlavor::Yes) {
+    nsCOMPtr<nsITransferable> contextTransferable =
+        do_CreateInstance("@mozilla.org/widget/transferable;1");
+    if (!contextTransferable) {
+      NS_WARNING(
+          "do_CreateInstance() failed to create nsITransferable instance");
+      return NS_ERROR_FAILURE;
+    }
+    DebugOnly<nsresult> rvIgnored = contextTransferable->Init(nullptr);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "nsITransferable::Init() failed, but ignored");
+    contextTransferable->SetIsPrivateData(transferable->GetIsPrivateData());
+    rvIgnored = contextTransferable->AddDataFlavor(kHTMLContext);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "nsITransferable::AddDataFlavor(kHTMLContext) failed, but ignored");
+    rvIgnored = clipboard->GetData(contextTransferable, aClipboardType);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "nsIClipboard::GetData() failed, but ignored");
+    nsCOMPtr<nsISupports> contextDataObj;
+    rv = contextTransferable->GetTransferData(kHTMLContext,
+                                              getter_AddRefs(contextDataObj));
+    if (NS_SUCCEEDED(rv) && contextDataObj) {
+      if (nsCOMPtr<nsISupportsString> str = do_QueryInterface(contextDataObj)) {
+        DebugOnly<nsresult> rvIgnored = str->GetData(contextStr);
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rvIgnored),
+            "nsISupportsString::GetData() failed, but ignored");
+      }
+    }
+
+    nsCOMPtr<nsITransferable> infoTransferable =
+        do_CreateInstance("@mozilla.org/widget/transferable;1");
+    if (!infoTransferable) {
+      NS_WARNING(
+          "do_CreateInstance() failed to create nsITransferable instance");
+      return NS_ERROR_FAILURE;
+    }
+    rvIgnored = infoTransferable->Init(nullptr);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "nsITransferable::Init() failed, but ignored");
+    contextTransferable->SetIsPrivateData(transferable->GetIsPrivateData());
+    rvIgnored = infoTransferable->AddDataFlavor(kHTMLInfo);
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rvIgnored),
+        "nsITransferable::AddDataFlavor(kHTMLInfo) failed, but ignored");
+    clipboard->GetData(infoTransferable, aClipboardType);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "nsIClipboard::GetData() failed, but ignored");
+    nsCOMPtr<nsISupports> infoDataObj;
+    rv = infoTransferable->GetTransferData(kHTMLInfo,
+                                           getter_AddRefs(infoDataObj));
+    if (NS_SUCCEEDED(rv) && infoDataObj) {
+      if (nsCOMPtr<nsISupportsString> str = do_QueryInterface(infoDataObj)) {
+        DebugOnly<nsresult> rvIgnored = str->GetData(infoStr);
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rvIgnored),
+            "nsISupportsString::GetData() failed, but ignored");
+      }
+    }
+  }
+
+  rv = InsertFromTransferableAtSelection(transferable, contextStr, infoStr,
+                                         clipboardHasPrivateHTMLFlavor);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "HTMLEditor::InsertFromTransferableAtSelection() failed");
+  return rv;
+}
+
+nsresult HTMLEditor::HandlePasteTransferable(
+    AutoEditActionDataSetter& aEditActionData, nsITransferable& aTransferable) {
+  // InitializeDataTransfer may fetch input stream in aTransferable, so it
+  // may be invalid after calling this.
+  aEditActionData.InitializeDataTransfer(&aTransferable);
+
+  nsresult rv = aEditActionData.MaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "MaybeDispatchBeforeInputEvent(), failed");
+    return rv;
+  }
+
+  RefPtr<DataTransfer> dataTransfer = GetInputEventDataTransfer();
+  if (dataTransfer->HasFile() && dataTransfer->MozItemCount() > 0) {
+    // Now aTransferable has moved to DataTransfer. Use DataTransfer.
+    AutoPlaceholderBatch treatAsOneTransaction(
+        *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+
+    rv = InsertFromDataTransfer(dataTransfer, 0, nullptr, EditorDOMPoint(),
+                                DeleteSelectedContent::Yes);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::InsertFromDataTransfer("
+                         "DeleteSelectedContent::Yes) failed");
+    return rv;
+  }
+
+  nsAutoString contextStr, infoStr;
+  rv = InsertFromTransferableAtSelection(&aTransferable, contextStr, infoStr,
+                                         HavePrivateHTMLFlavor::No);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertFromTransferableAtSelection("
+                       "HavePrivateHTMLFlavor::No) failed");
+  return rv;
+}
+
+nsresult HTMLEditor::PasteNoFormattingAsAction(
+    int32_t aClipboardType, DispatchPasteEvent aDispatchPasteEvent,
+    nsIPrincipal* aPrincipal) {
+  if (IsReadonly()) {
+    return NS_OK;
+  }
+
+  AutoEditActionDataSetter editActionData(*this, EditAction::ePaste,
+                                          aPrincipal);
+  if (NS_WARN_IF(!editActionData.CanHandle())) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  editActionData.InitializeDataTransferWithClipboard(
+      SettingDataTransfer::eWithoutFormat, aClipboardType);
+
+  if (aDispatchPasteEvent == DispatchPasteEvent::Yes) {
+    RefPtr<nsFocusManager> focusManager = nsFocusManager::GetFocusManager();
+    if (NS_WARN_IF(!focusManager)) {
+      return NS_ERROR_UNEXPECTED;
+    }
+    const RefPtr<Element> focusedElement = focusManager->GetFocusedElement();
+
+    Result<ClipboardEventResult, nsresult> ret =
+        DispatchClipboardEventAndUpdateClipboard(ePasteNoFormatting,
+                                                 aClipboardType);
+    if (MOZ_UNLIKELY(ret.isErr())) {
+      NS_WARNING(
+          "EditorBase::DispatchClipboardEventAndUpdateClipboard("
+          "ePasteNoFormatting) failed");
+      return EditorBase::ToGenericNSResult(ret.unwrapErr());
+    }
+    switch (ret.inspect()) {
+      case ClipboardEventResult::DoDefault:
+        break;
+      case ClipboardEventResult::DefaultPreventedOfPaste:
+      case ClipboardEventResult::IgnoredOrError:
+        return EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_ACTION_CANCELED);
+      case ClipboardEventResult::CopyOrCutHandled:
+        MOZ_ASSERT_UNREACHABLE("Invalid result for ePaste");
+    }
+
+    // If focus is changed by a "paste" event listener, we should keep handling
+    // the "pasting" in new focused editor because Chrome works as so.
+    const RefPtr<Element> newFocusedElement = focusManager->GetFocusedElement();
+    if (MOZ_UNLIKELY(focusedElement != newFocusedElement)) {
+      // For the privacy reason, let's top handling it if new focused element is
+      // in different document.
+      if (focusManager->GetFocusedWindow() != GetWindow()) {
+        return EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_ACTION_CANCELED);
+      }
+      RefPtr<EditorBase> editorBase =
+          nsContentUtils::GetActiveEditor(GetPresContext());
+      if (!editorBase || (editorBase->IsHTMLEditor() &&
+                          !editorBase->AsHTMLEditor()->IsActiveInDOMWindow())) {
+        return EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_ACTION_CANCELED);
+      }
+      if (editorBase != this) {
+        if (editorBase->IsHTMLEditor()) {
+          nsresult rv =
+              MOZ_KnownLive(editorBase->AsHTMLEditor())
+                  ->PasteNoFormattingAsAction(
+                      aClipboardType, DispatchPasteEvent::No, aPrincipal);
+          NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                               "HTMLEditor::PasteNoFormattingAsAction("
+                               "DispatchPasteEvent::No) failed");
+          return EditorBase::ToGenericNSResult(rv);
+        }
+        nsresult rv = editorBase->PasteAsAction(
+            aClipboardType, DispatchPasteEvent::No, aPrincipal);
+        NS_WARNING_ASSERTION(
+            NS_SUCCEEDED(rv),
+            "EditorBase::PasteAsAction(DispatchPasteEvent::No) failed");
+        return EditorBase::ToGenericNSResult(rv);
+      }
+    }
+  }
+
+  // Dispatch "beforeinput" event after "paste" event.  And perhaps, before
+  // committing composition because if pasting is canceled, we don't need to
+  // commit the active composition.
+  nsresult rv = editActionData.MaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "MaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  DebugOnly<nsresult> rvIgnored = CommitComposition();
+  if (NS_WARN_IF(Destroyed())) {
+    return EditorBase::ToGenericNSResult(NS_ERROR_EDITOR_DESTROYED);
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::CommitComposition() failed, but ignored");
+
+  // Get Clipboard Service
+  nsCOMPtr<nsIClipboard> clipboard(
+      do_GetService("@mozilla.org/widget/clipboard;1", &rv));
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to get nsIClipboard service");
+    return rv;
+  }
+
+  if (!GetDocument()) {
+    NS_WARNING("Editor didn't have document, but ignored");
+    return NS_OK;
+  }
+
+  Result<nsCOMPtr<nsITransferable>, nsresult> maybeTransferable =
+      EditorUtils::CreateTransferableForPlainText(*GetDocument());
+  if (maybeTransferable.isErr()) {
+    NS_WARNING("EditorUtils::CreateTransferableForPlainText() failed");
+    return EditorBase::ToGenericNSResult(maybeTransferable.unwrapErr());
+  }
+  nsCOMPtr<nsITransferable> transferable(maybeTransferable.unwrap());
+  if (!transferable) {
+    NS_WARNING(
+        "EditorUtils::CreateTransferableForPlainText() returned nullptr, but "
+        "ignored");
+    return NS_OK;
+  }
+
+  if (!IsModifiable()) {
+    return NS_OK;
+  }
+
+  // Get the Data from the clipboard
+  rv = clipboard->GetData(transferable, aClipboardType);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("nsIClipboard::GetData() failed");
+    return rv;
+  }
+
+  rv = InsertFromTransferableAtSelection(transferable, u""_ns, u""_ns,
+                                         HavePrivateHTMLFlavor::No);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertFromTransferableAtSelection("
+                       "HavePrivateHTMLFlavor::No) failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+// The following arrays contain the MIME types that we can paste. The arrays
+// are used by CanPaste() and CanPasteTransferable() below.
+
+static const char* textEditorFlavors[] = {kTextMime};
+static const char* textHtmlEditorFlavors[] = {kTextMime,      kHTMLMime,
+                                              kJPEGImageMime, kJPGImageMime,
+                                              kPNGImageMime,  kGIFImageMime};
+
+bool HTMLEditor::CanPaste(int32_t aClipboardType) const {
+  if (AreClipboardCommandsUnconditionallyEnabled()) {
+    return true;
+  }
+
+  // can't paste if readonly
+  if (!IsModifiable()) {
+    return false;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard(
+      do_GetService("@mozilla.org/widget/clipboard;1", &rv));
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to get nsIClipboard service");
+    return false;
+  }
+
+  // Use the flavors depending on the current editor mask
+  if (IsInPlaintextMode()) {
+    AutoTArray<nsCString, ArrayLength(textEditorFlavors)> flavors;
+    flavors.AppendElements<const char*>(Span<const char*>(textEditorFlavors));
+    bool haveFlavors;
+    nsresult rv = clipboard->HasDataMatchingFlavors(flavors, aClipboardType,
+                                                    &haveFlavors);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "nsIClipboard::HasDataMatchingFlavors() failed");
+    return NS_SUCCEEDED(rv) && haveFlavors;
+  }
+
+  AutoTArray<nsCString, ArrayLength(textHtmlEditorFlavors)> flavors;
+  flavors.AppendElements<const char*>(Span<const char*>(textHtmlEditorFlavors));
+  bool haveFlavors;
+  rv = clipboard->HasDataMatchingFlavors(flavors, aClipboardType, &haveFlavors);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "nsIClipboard::HasDataMatchingFlavors() failed");
+  return NS_SUCCEEDED(rv) && haveFlavors;
+}
+
+bool HTMLEditor::CanPasteTransferable(nsITransferable* aTransferable) {
+  // can't paste if readonly
+  if (!IsModifiable()) {
+    return false;
+  }
+
+  // If |aTransferable| is null, assume that a paste will succeed.
+  if (!aTransferable) {
+    return true;
+  }
+
+  // Peek in |aTransferable| to see if it contains a supported MIME type.
+
+  // Use the flavors depending on the current editor mask
+  const char** flavors;
+  size_t length;
+  if (IsInPlaintextMode()) {
+    flavors = textEditorFlavors;
+    length = ArrayLength(textEditorFlavors);
+  } else {
+    flavors = textHtmlEditorFlavors;
+    length = ArrayLength(textHtmlEditorFlavors);
+  }
+
+  for (size_t i = 0; i < length; i++, flavors++) {
+    nsCOMPtr<nsISupports> data;
+    nsresult rv =
+        aTransferable->GetTransferData(*flavors, getter_AddRefs(data));
+    if (NS_SUCCEEDED(rv) && data) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+nsresult HTMLEditor::HandlePasteAsQuotation(
+    AutoEditActionDataSetter& aEditActionData, int32_t aClipboardType) {
+  MOZ_ASSERT(aClipboardType == nsIClipboard::kGlobalClipboard ||
+             aClipboardType == nsIClipboard::kSelectionClipboard);
+  aEditActionData.InitializeDataTransferWithClipboard(
+      SettingDataTransfer::eWithFormat, aClipboardType);
+  if (NS_WARN_IF(!aEditActionData.CanHandle())) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  nsresult rv = aEditActionData.MaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "MaybeDispatchBeforeInputEvent(), failed");
+    return rv;
+  }
+
+  if (IsInPlaintextMode()) {
+    nsresult rv = PasteAsPlaintextQuotation(aClipboardType);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::PasteAsPlaintextQuotation() failed");
+    return rv;
+  }
+
+  // If it's not in plain text edit mode, paste text into new
+  // <blockquote type="cite"> element after removing selection.
+
+  {
+    // XXX Why don't we test these first?
+    Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result.unwrapErr();
+    }
+    if (result.inspect().Canceled()) {
+      return NS_OK;
+    }
+  }
+
+  UndefineCaretBidiLevel();
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::eInsertQuotation, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+
+  rv = EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() "
+                       "failed, but ignored");
+
+  if (NS_SUCCEEDED(rv) && SelectionRef().IsCollapsed()) {
+    nsresult rv = EnsureCaretNotAfterInvisibleBRElement();
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() "
+                         "failed, but ignored");
+    if (NS_SUCCEEDED(rv)) {
+      nsresult rv = PrepareInlineStylesForCaret();
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return NS_ERROR_EDITOR_DESTROYED;
+      }
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored");
+    }
+  }
+
+  // Remove Selection and create `<blockquote type="cite">` now.
+  // XXX Why don't we insert the `<blockquote>` into the DOM tree after
+  //     pasting the content in clipboard into it?
+  Result<RefPtr<Element>, nsresult> blockquoteElementOrError =
+      DeleteSelectionAndCreateElement(
+          *nsGkAtoms::blockquote,
+          // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868
+          [](HTMLEditor&, Element& aBlockquoteElement, const EditorDOMPoint&)
+              MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+                DebugOnly<nsresult> rvIgnored = aBlockquoteElement.SetAttr(
+                    kNameSpaceID_None, nsGkAtoms::type, u"cite"_ns,
+                    aBlockquoteElement.IsInComposedDoc());
+                NS_WARNING_ASSERTION(
+                    NS_SUCCEEDED(rvIgnored),
+                    nsPrintfCString(
+                        "Element::SetAttr(nsGkAtoms::type, \"cite\", %s) "
+                        "failed, but ignored",
+                        aBlockquoteElement.IsInComposedDoc() ? "true" : "false")
+                        .get());
+                return NS_OK;
+              });
+  if (MOZ_UNLIKELY(blockquoteElementOrError.isErr()) ||
+      NS_WARN_IF(Destroyed())) {
+    NS_WARNING(
+        "HTMLEditor::DeleteSelectionAndCreateElement(nsGkAtoms::blockquote) "
+        "failed");
+    return Destroyed() ? NS_ERROR_EDITOR_DESTROYED
+                       : blockquoteElementOrError.unwrapErr();
+  }
+  MOZ_ASSERT(blockquoteElementOrError.inspect());
+
+  // Collapse Selection in the new `<blockquote>` element.
+  rv = CollapseSelectionToStartOf(
+      MOZ_KnownLive(*blockquoteElementOrError.inspect()));
+  if (NS_FAILED(rv)) {
+    NS_WARNING("EditorBase::CollapseSelectionToStartOf() failed");
+    return rv;
+  }
+
+  rv = PasteInternal(aClipboardType);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HTMLEditor::PasteInternal() failed");
+  return rv;
+}
+
+nsresult HTMLEditor::PasteAsPlaintextQuotation(int32_t aSelectionType) {
+  // Get Clipboard Service
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard =
+      do_GetService("@mozilla.org/widget/clipboard;1", &rv);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Failed to get nsIClipboard service");
+    return rv;
+  }
+
+  // Create generic Transferable for getting the data
+  nsCOMPtr<nsITransferable> transferable =
+      do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("do_CreateInstance() failed to create nsITransferable instance");
+    return rv;
+  }
+  if (!transferable) {
+    NS_WARNING("do_CreateInstance() returned nullptr");
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<Document> destdoc = GetDocument();
+  nsILoadContext* loadContext = destdoc ? destdoc->GetLoadContext() : nullptr;
+  DebugOnly<nsresult> rvIgnored = transferable->Init(loadContext);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "nsITransferable::Init() failed, but ignored");
+
+  // We only handle plaintext pastes here
+  rvIgnored = transferable->AddDataFlavor(kTextMime);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rvIgnored),
+      "nsITransferable::AddDataFlavor(kTextMime) failed, but ignored");
+
+  // Get the Data from the clipboard
+  rvIgnored = clipboard->GetData(transferable, aSelectionType);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "nsIClipboard::GetData() failed, but ignored");
+
+  // Now we ask the transferable for the data
+  // it still owns the data, we just have a pointer to it.
+  // If it can't support a "text" output of the data the call will fail
+  nsCOMPtr<nsISupports> genericDataObj;
+  nsAutoCString flavor;
+  rv = transferable->GetAnyTransferData(flavor, getter_AddRefs(genericDataObj));
+  if (NS_FAILED(rv)) {
+    NS_WARNING("nsITransferable::GetAnyTransferData() failed");
+    return rv;
+  }
+
+  if (!flavor.EqualsLiteral(kTextMime)) {
+    return NS_OK;
+  }
+
+  nsAutoString stuffToPaste;
+  if (!GetString(genericDataObj, stuffToPaste)) {
+    return NS_OK;
+  }
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  rv = InsertAsPlaintextQuotation(stuffToPaste, true, 0);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertAsPlaintextQuotation() failed");
+  return rv;
+}
+
+nsresult HTMLEditor::InsertWithQuotationsAsSubAction(
+    const nsAString& aQuotedText) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  {
+    Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result.unwrapErr();
+    }
+    if (result.inspect().Canceled()) {
+      return NS_OK;
+    }
+  }
+
+  UndefineCaretBidiLevel();
+
+  // Let the citer quote it for us:
+  nsString quotedStuff;
+  InternetCiter::GetCiteString(aQuotedText, quotedStuff);
+
+  // It's best to put a blank line after the quoted text so that mails
+  // written without thinking won't be so ugly.
+  if (!aQuotedText.IsEmpty() &&
+      (aQuotedText.Last() != HTMLEditUtils::kNewLine)) {
+    quotedStuff.Append(HTMLEditUtils::kNewLine);
+  }
+
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::eInsertText, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+
+  nsresult rv = EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() "
+                       "failed, but ignored");
+
+  if (NS_SUCCEEDED(rv) && SelectionRef().IsCollapsed()) {
+    nsresult rv = EnsureCaretNotAfterInvisibleBRElement();
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() "
+                         "failed, but ignored");
+    if (NS_SUCCEEDED(rv)) {
+      nsresult rv = PrepareInlineStylesForCaret();
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return NS_ERROR_EDITOR_DESTROYED;
+      }
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored");
+    }
+  }
+
+  rv = InsertTextAsSubAction(quotedStuff, SelectionHandling::Delete);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::InsertTextAsSubAction() failed");
+  return rv;
+}
+
+NS_IMETHODIMP HTMLEditor::InsertTextWithQuotations(
+    const nsAString& aStringToInsert) {
+  AutoEditActionDataSetter editActionData(*this, EditAction::eInsertText);
+  MOZ_ASSERT(!aStringToInsert.IsVoid());
+  editActionData.SetData(aStringToInsert);
+  nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+  if (aStringToInsert.IsEmpty()) {
+    return NS_OK;
+  }
+
+  // The whole operation should be undoable in one transaction:
+  // XXX Why isn't enough to use only AutoPlaceholderBatch here?
+  AutoTransactionBatch bundleAllTransactions(*this, __FUNCTION__);
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+
+  rv = InsertTextWithQuotationsInternal(aStringToInsert);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertTextWithQuotationsInternal() failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+nsresult HTMLEditor::InsertTextWithQuotationsInternal(
+    const nsAString& aStringToInsert) {
+  MOZ_ASSERT(!aStringToInsert.IsEmpty());
+  // We're going to loop over the string, collecting up a "hunk"
+  // that's all the same type (quoted or not),
+  // Whenever the quotedness changes (or we reach the string's end)
+  // we will insert the hunk all at once, quoted or non.
+  static const char16_t cite('>');
+  bool curHunkIsQuoted = (aStringToInsert.First() == cite);
+
+  nsAString::const_iterator hunkStart, strEnd;
+  aStringToInsert.BeginReading(hunkStart);
+  aStringToInsert.EndReading(strEnd);
+
+  // In the loop below, we only look for DOM newlines (\n),
+  // because we don't have a FindChars method that can look
+  // for both \r and \n.  \r is illegal in the dom anyway,
+  // but in debug builds, let's take the time to verify that
+  // there aren't any there:
+#ifdef DEBUG
+  nsAString::const_iterator dbgStart(hunkStart);
+  if (FindCharInReadable(HTMLEditUtils::kCarriageReturn, dbgStart, strEnd)) {
+    NS_ASSERTION(
+        false,
+        "Return characters in DOM! InsertTextWithQuotations may be wrong");
+  }
+#endif /* DEBUG */
+
+  // Loop over lines:
+  nsresult rv = NS_OK;
+  nsAString::const_iterator lineStart(hunkStart);
+  // We will break from inside when we run out of newlines.
+  for (;;) {
+    // Search for the end of this line (dom newlines, see above):
+    bool found = FindCharInReadable(HTMLEditUtils::kNewLine, lineStart, strEnd);
+    bool quoted = false;
+    if (found) {
+      // if there's another newline, lineStart now points there.
+      // Loop over any consecutive newline chars:
+      nsAString::const_iterator firstNewline(lineStart);
+      while (*lineStart == HTMLEditUtils::kNewLine) {
+        ++lineStart;
+      }
+      quoted = (*lineStart == cite);
+      if (quoted == curHunkIsQuoted) {
+        continue;
+      }
+      // else we're changing state, so we need to insert
+      // from curHunk to lineStart then loop around.
+
+      // But if the current hunk is quoted, then we want to make sure
+      // that any extra newlines on the end do not get included in
+      // the quoted section: blank lines flaking a quoted section
+      // should be considered unquoted, so that if the user clicks
+      // there and starts typing, the new text will be outside of
+      // the quoted block.
+      if (curHunkIsQuoted) {
+        lineStart = firstNewline;
+
+        // 'firstNewline' points to the first '\n'. We want to
+        // ensure that this first newline goes into the hunk
+        // since quoted hunks can be displayed as blocks
+        // (and the newline should become invisible in this case).
+        // So the next line needs to start at the next character.
+        lineStart++;
+      }
+    }
+
+    // If no newline found, lineStart is now strEnd and we can finish up,
+    // inserting from curHunk to lineStart then returning.
+    const nsAString& curHunk = Substring(hunkStart, lineStart);
+    nsCOMPtr<nsINode> dummyNode;
+    if (curHunkIsQuoted) {
+      rv =
+          InsertAsPlaintextQuotation(curHunk, false, getter_AddRefs(dummyNode));
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return NS_ERROR_EDITOR_DESTROYED;
+      }
+      NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                           "HTMLEditor::InsertAsPlaintextQuotation() failed, "
+                           "but might be ignored");
+    } else {
+      rv = InsertTextAsSubAction(curHunk, SelectionHandling::Delete);
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "EditorBase::InsertTextAsSubAction() failed, but might be ignored");
+    }
+    if (!found) {
+      break;
+    }
+    curHunkIsQuoted = quoted;
+    hunkStart = lineStart;
+  }
+
+  // XXX This returns the last result of InsertAsPlaintextQuotation() or
+  //     InsertTextAsSubAction() in the loop.  This must be a bug.
+  return rv;
+}
+
+nsresult HTMLEditor::InsertAsQuotation(const nsAString& aQuotedText,
+                                       nsINode** aNodeInserted) {
+  if (IsInPlaintextMode()) {
+    AutoEditActionDataSetter editActionData(*this, EditAction::eInsertText);
+    MOZ_ASSERT(!aQuotedText.IsVoid());
+    editActionData.SetData(aQuotedText);
+    nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+    if (NS_FAILED(rv)) {
+      NS_WARNING_ASSERTION(
+          rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+          "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+      return EditorBase::ToGenericNSResult(rv);
+    }
+    AutoPlaceholderBatch treatAsOneTransaction(
+        *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+    rv = InsertAsPlaintextQuotation(aQuotedText, true, aNodeInserted);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::InsertAsPlaintextQuotation() failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  AutoEditActionDataSetter editActionData(*this,
+                                          EditAction::eInsertBlockquoteElement);
+  nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  nsAutoString citation;
+  rv = InsertAsCitedQuotationInternal(aQuotedText, citation, false,
+                                      aNodeInserted);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertAsCitedQuotationInternal() failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+// Insert plaintext as a quotation, with cite marks (e.g. "> ").
+// This differs from its corresponding method in TextEditor
+// in that here, quoted material is enclosed in a <pre> tag
+// in order to preserve the original line wrapping.
+nsresult HTMLEditor::InsertAsPlaintextQuotation(const nsAString& aQuotedText,
+                                                bool aAddCites,
+                                                nsINode** aNodeInserted) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+
+  if (aNodeInserted) {
+    *aNodeInserted = nullptr;
+  }
+
+  {
+    Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result.unwrapErr();
+    }
+    if (result.inspect().Canceled()) {
+      return NS_OK;
+    }
+  }
+
+  UndefineCaretBidiLevel();
+
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::eInsertQuotation, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+
+  nsresult rv = EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() "
+                       "failed, but ignored");
+
+  if (NS_SUCCEEDED(rv) && SelectionRef().IsCollapsed()) {
+    nsresult rv = EnsureCaretNotAfterInvisibleBRElement();
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() "
+                         "failed, but ignored");
+    if (NS_SUCCEEDED(rv)) {
+      nsresult rv = PrepareInlineStylesForCaret();
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return NS_ERROR_EDITOR_DESTROYED;
+      }
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored");
+    }
+  }
+
+  // Wrap the inserted quote in a <span> so we can distinguish it. If we're
+  // inserting into the <body>, we use a <span> which is displayed as a block
+  // and sized to the screen using 98 viewport width units.
+  // We could use 100vw, but 98vw avoids a horizontal scroll bar where possible.
+  // All this is done to wrap overlong lines to the screen and not to the
+  // container element, the width-restricted body.
+  Result<RefPtr<Element>, nsresult> spanElementOrError =
+      DeleteSelectionAndCreateElement(
+          *nsGkAtoms::span, [](HTMLEditor&, Element& aSpanElement,
+                               const EditorDOMPoint& aPointToInsert) {
+            // Add an attribute on the pre node so we'll know it's a quotation.
+            DebugOnly<nsresult> rvIgnored = aSpanElement.SetAttr(
+                kNameSpaceID_None, nsGkAtoms::mozquote, u"true"_ns,
+                aSpanElement.IsInComposedDoc());
+            NS_WARNING_ASSERTION(
+                NS_SUCCEEDED(rvIgnored),
+                nsPrintfCString(
+                    "Element::SetAttr(nsGkAtoms::mozquote, \"true\", %s) "
+                    "failed",
+                    aSpanElement.IsInComposedDoc() ? "true" : "false")
+                    .get());
+            // Allow wrapping on spans so long lines get wrapped to the screen.
+            if (aPointToInsert.IsContainerHTMLElement(nsGkAtoms::body)) {
+              DebugOnly<nsresult> rvIgnored = aSpanElement.SetAttr(
+                  kNameSpaceID_None, nsGkAtoms::style,
+                  nsLiteralString(u"white-space: pre-wrap; display: block; "
+                                  u"width: 98vw;"),
+                  false);
+              NS_WARNING_ASSERTION(
+                  NS_SUCCEEDED(rvIgnored),
+                  "Element::SetAttr(nsGkAtoms::style, \"pre-wrap, block\", "
+                  "false) failed, but ignored");
+            } else {
+              DebugOnly<nsresult> rvIgnored =
+                  aSpanElement.SetAttr(kNameSpaceID_None, nsGkAtoms::style,
+                                       u"white-space: pre-wrap;"_ns, false);
+              NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                                   "Element::SetAttr(nsGkAtoms::style, "
+                                   "\"pre-wrap\", false) failed, but ignored");
+            }
+            return NS_OK;
+          });
+  NS_WARNING_ASSERTION(spanElementOrError.isOk(),
+                       "HTMLEditor::DeleteSelectionAndCreateElement(nsGkAtoms::"
+                       "span) failed, but ignored");
+
+  // If this succeeded, then set selection inside the pre
+  // so the inserted text will end up there.
+  // If it failed, we don't care what the return value was,
+  // but we'll fall through and try to insert the text anyway.
+  if (spanElementOrError.isOk()) {
+    MOZ_ASSERT(spanElementOrError.inspect());
+    rv = CollapseSelectionToStartOf(
+        MOZ_KnownLive(*spanElementOrError.inspect()));
+    if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      NS_WARNING(
+          "EditorBase::CollapseSelectionToStartOf() caused destroying the "
+          "editor");
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv),
+        "EditorBase::CollapseSelectionToStartOf() failed, but ignored");
+  }
+
+  // TODO: We should insert text at specific point rather than at selection.
+  //       Then, we can do this before inserting the <span> element.
+  if (aAddCites) {
+    rv = InsertWithQuotationsAsSubAction(aQuotedText);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("HTMLEditor::InsertWithQuotationsAsSubAction() failed");
+      return rv;
+    }
+  } else {
+    rv = InsertTextAsSubAction(aQuotedText, SelectionHandling::Delete);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("EditorBase::InsertTextAsSubAction() failed");
+      return rv;
+    }
+  }
+
+  // XXX Why don't we check this before inserting the quoted text?
+  if (spanElementOrError.isErr()) {
+    return NS_OK;
+  }
+
+  // Set the selection to just after the inserted node:
+  EditorRawDOMPoint afterNewSpanElement(
+      EditorRawDOMPoint::After(*spanElementOrError.inspect()));
+  NS_WARNING_ASSERTION(
+      afterNewSpanElement.IsSet(),
+      "Failed to set after the new <span> element, but ignored");
+  if (afterNewSpanElement.IsSet()) {
+    nsresult rv = CollapseSelectionTo(afterNewSpanElement);
+    if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      NS_WARNING(
+          "EditorBase::CollapseSelectionTo() caused destroying the editor");
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv),
+        "EditorBase::CollapseSelectionTo() failed, but ignored");
+  }
+
+  // Note that if !aAddCites, aNodeInserted isn't set.
+  // That's okay because the routines that use aAddCites
+  // don't need to know the inserted node.
+  if (aNodeInserted) {
+    spanElementOrError.unwrap().forget(aNodeInserted);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP HTMLEditor::Rewrap(bool aRespectNewlines) {
+  AutoEditActionDataSetter editActionData(*this, EditAction::eRewrap);
+  nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  // Rewrap makes no sense if there's no wrap column; default to 72.
+  int32_t wrapWidth = WrapWidth();
+  if (wrapWidth <= 0) {
+    wrapWidth = 72;
+  }
+
+  nsAutoString current;
+  const bool isCollapsed = SelectionRef().IsCollapsed();
+  uint32_t flags = nsIDocumentEncoder::OutputFormatted |
+                   nsIDocumentEncoder::OutputLFLineBreak;
+  if (!isCollapsed) {
+    flags |= nsIDocumentEncoder::OutputSelectionOnly;
+  }
+  rv = ComputeValueInternal(u"text/plain"_ns, flags, current);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("EditorBase::ComputeValueInternal(text/plain) failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  if (current.IsEmpty()) {
+    return NS_OK;
+  }
+
+  nsString wrapped;
+  uint32_t firstLineOffset = 0;  // XXX need to reset this if there is a
+                                 //     selection
+  InternetCiter::Rewrap(current, wrapWidth, firstLineOffset, aRespectNewlines,
+                        wrapped);
+
+  if (wrapped.IsEmpty()) {
+    return NS_OK;
+  }
+
+  if (isCollapsed) {
+    DebugOnly<nsresult> rvIgnored = SelectAllInternal();
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                         "HTMLEditor::SelectAllInternal() failed");
+  }
+
+  // The whole operation in InsertTextWithQuotationsInternal() should be
+  // undoable in one transaction.
+  // XXX Why isn't enough to use only AutoPlaceholderBatch here?
+  AutoTransactionBatch bundleAllTransactions(*this, __FUNCTION__);
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  rv = InsertTextWithQuotationsInternal(wrapped);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertTextWithQuotationsInternal() failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+NS_IMETHODIMP HTMLEditor::InsertAsCitedQuotation(const nsAString& aQuotedText,
+                                                 const nsAString& aCitation,
+                                                 bool aInsertHTML,
+                                                 nsINode** aNodeInserted) {
+  // Don't let anyone insert HTML when we're in plaintext mode.
+  if (IsInPlaintextMode()) {
+    NS_ASSERTION(
+        !aInsertHTML,
+        "InsertAsCitedQuotation: trying to insert html into plaintext editor");
+
+    AutoEditActionDataSetter editActionData(*this, EditAction::eInsertText);
+    MOZ_ASSERT(!aQuotedText.IsVoid());
+    editActionData.SetData(aQuotedText);
+    nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+    if (NS_FAILED(rv)) {
+      NS_WARNING_ASSERTION(
+          rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+          "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+      return EditorBase::ToGenericNSResult(rv);
+    }
+
+    AutoPlaceholderBatch treatAsOneTransaction(
+        *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+    rv = InsertAsPlaintextQuotation(aQuotedText, true, aNodeInserted);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::InsertAsPlaintextQuotation() failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  AutoEditActionDataSetter editActionData(*this,
+                                          EditAction::eInsertBlockquoteElement);
+  nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+  if (NS_FAILED(rv)) {
+    NS_WARNING_ASSERTION(rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+                         "CanHandleAndMaybeDispatchBeforeInputEvent(), failed");
+    return EditorBase::ToGenericNSResult(rv);
+  }
+
+  AutoPlaceholderBatch treatAsOneTransaction(
+      *this, ScrollSelectionIntoView::Yes, __FUNCTION__);
+  rv = InsertAsCitedQuotationInternal(aQuotedText, aCitation, aInsertHTML,
+                                      aNodeInserted);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "HTMLEditor::InsertAsCitedQuotationInternal() failed");
+  return EditorBase::ToGenericNSResult(rv);
+}
+
+nsresult HTMLEditor::InsertAsCitedQuotationInternal(
+    const nsAString& aQuotedText, const nsAString& aCitation, bool aInsertHTML,
+    nsINode** aNodeInserted) {
+  MOZ_ASSERT(IsEditActionDataAvailable());
+  MOZ_ASSERT(!IsInPlaintextMode());
+
+  {
+    Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction();
+    if (MOZ_UNLIKELY(result.isErr())) {
+      NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed");
+      return result.unwrapErr();
+    }
+    if (result.inspect().Canceled()) {
+      return NS_OK;
+    }
+  }
+
+  UndefineCaretBidiLevel();
+
+  IgnoredErrorResult ignoredError;
+  AutoEditSubActionNotifier startToHandleEditSubAction(
+      *this, EditSubAction::eInsertQuotation, nsIEditor::eNext, ignoredError);
+  if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) {
+    return ignoredError.StealNSResult();
+  }
+  NS_WARNING_ASSERTION(
+      !ignoredError.Failed(),
+      "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored");
+
+  nsresult rv = EnsureNoPaddingBRElementForEmptyEditor();
+  if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::EnsureNoPaddingBRElementForEmptyEditor() "
+                       "failed, but ignored");
+
+  if (NS_SUCCEEDED(rv) && SelectionRef().IsCollapsed()) {
+    nsresult rv = EnsureCaretNotAfterInvisibleBRElement();
+    if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() "
+                         "failed, but ignored");
+    if (NS_SUCCEEDED(rv)) {
+      nsresult rv = PrepareInlineStylesForCaret();
+      if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
+        return NS_ERROR_EDITOR_DESTROYED;
+      }
+      NS_WARNING_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "HTMLEditor::PrepareInlineStylesForCaret() failed, but ignored");
+    }
+  }
+
+  Result<RefPtr<Element>, nsresult> blockquoteElementOrError =
+      DeleteSelectionAndCreateElement(
+          *nsGkAtoms::blockquote,
+          // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868
+          [&aCitation](HTMLEditor&, Element& aBlockquoteElement,
+                       const EditorDOMPoint&) MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+            // Try to set type=cite.  Ignore it if this fails.
+            DebugOnly<nsresult> rvIgnored = aBlockquoteElement.SetAttr(
+                kNameSpaceID_None, nsGkAtoms::type, u"cite"_ns,
+                aBlockquoteElement.IsInComposedDoc());
+            NS_WARNING_ASSERTION(
+                NS_SUCCEEDED(rvIgnored),
+                nsPrintfCString(
+                    "Element::SetAttr(nsGkAtoms::type, \"cite\", %s) failed, "
+                    "but ignored",
+                    aBlockquoteElement.IsInComposedDoc() ? "true" : "false")
+                    .get());
+            if (!aCitation.IsEmpty()) {
+              DebugOnly<nsresult> rvIgnored = aBlockquoteElement.SetAttr(
+                  kNameSpaceID_None, nsGkAtoms::cite, aCitation,
+                  aBlockquoteElement.IsInComposedDoc());
+              NS_WARNING_ASSERTION(
+                  NS_SUCCEEDED(rvIgnored),
+                  nsPrintfCString(
+                      "Element::SetAttr(nsGkAtoms::cite, \"...\", %s) failed, "
+                      "but ignored",
+                      aBlockquoteElement.IsInComposedDoc() ? "true" : "false")
+                      .get());
+            }
+            return NS_OK;
+          });
+  if (MOZ_UNLIKELY(blockquoteElementOrError.isErr() ||
+                   NS_WARN_IF(Destroyed()))) {
+    NS_WARNING(
+        "HTMLEditor::DeleteSelectionAndCreateElement(nsGkAtoms::blockquote) "
+        "failed");
+    return Destroyed() ? NS_ERROR_EDITOR_DESTROYED
+                       : blockquoteElementOrError.unwrapErr();
+  }
+  MOZ_ASSERT(blockquoteElementOrError.inspect());
+
+  // Set the selection inside the blockquote so aQuotedText will go there:
+  rv = CollapseSelectionTo(
+      EditorRawDOMPoint(blockquoteElementOrError.inspect(), 0u));
+  if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+    NS_WARNING(
+        "EditorBase::CollapseSelectionTo() caused destroying the editor");
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::CollapseSelectionTo() failed, but ignored");
+
+  // TODO: We should insert text at specific point rather than at selection.
+  //       Then, we can do this before inserting the <blockquote> element.
+  if (aInsertHTML) {
+    rv = LoadHTML(aQuotedText);
+    if (NS_WARN_IF(Destroyed())) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    if (NS_FAILED(rv)) {
+      NS_WARNING("HTMLEditor::LoadHTML() failed");
+      return rv;
+    }
+  } else {
+    rv = InsertTextAsSubAction(
+        aQuotedText, SelectionHandling::Delete);  // XXX ignore charset
+    if (NS_WARN_IF(Destroyed())) {
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    if (NS_FAILED(rv)) {
+      NS_WARNING("HTMLEditor::LoadHTML() failed");
+      return rv;
+    }
+  }
+
+  // Set the selection to just after the inserted node:
+  EditorRawDOMPoint afterNewBlockquoteElement(
+      EditorRawDOMPoint::After(blockquoteElementOrError.inspect()));
+  NS_WARNING_ASSERTION(
+      afterNewBlockquoteElement.IsSet(),
+      "Failed to set after new <blockquote> element, but ignored");
+  if (afterNewBlockquoteElement.IsSet()) {
+    nsresult rv = CollapseSelectionTo(afterNewBlockquoteElement);
+    if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) {
+      NS_WARNING(
+          "EditorBase::CollapseSelectionTo() caused destroying the editor");
+      return NS_ERROR_EDITOR_DESTROYED;
+    }
+    NS_WARNING_ASSERTION(
+        NS_SUCCEEDED(rv),
+        "EditorBase::CollapseSelectionTo() failed, but ignored");
+  }
+
+  if (aNodeInserted) {
+    blockquoteElementOrError.unwrap().forget(aNodeInserted);
+  }
+
+  return NS_OK;
+}
+
+void HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    RemoveHeadChildAndStealBodyChildsChildren(nsINode& aNode) {
+  nsCOMPtr<nsIContent> body, head;
+  // find the body and head nodes if any.
+  // look only at immediate children of aNode.
+  for (nsCOMPtr<nsIContent> child = aNode.GetFirstChild(); child;
+       child = child->GetNextSibling()) {
+    if (child->IsHTMLElement(nsGkAtoms::body)) {
+      body = child;
+    } else if (child->IsHTMLElement(nsGkAtoms::head)) {
+      head = child;
+    }
+  }
+  if (head) {
+    ErrorResult ignored;
+    aNode.RemoveChild(*head, ignored);
+  }
+  if (body) {
+    nsCOMPtr<nsIContent> child = body->GetFirstChild();
+    while (child) {
+      ErrorResult ignored;
+      aNode.InsertBefore(*child, body, ignored);
+      child = body->GetFirstChild();
+    }
+
+    ErrorResult ignored;
+    aNode.RemoveChild(*body, ignored);
+  }
+}
+
+// static
+void HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    RemoveIncompleteDescendantsFromInsertingFragment(nsINode& aNode) {
+  nsIContent* child = aNode.GetFirstChild();
+  while (child) {
+    bool isEmptyNodeShouldNotInserted = false;
+    if (HTMLEditUtils::IsAnyListElement(child)) {
+      // Current limitation of HTMLEditor:
+      //   Cannot put caret in a list element which does not have list item
+      //   element even as a descendant.  I.e., HTMLEditor does not support
+      //   editing in such empty list element, and does not support to delete
+      //   it from outside.  Therefore, HTMLWithContextInserter should not
+      //   insert empty list element.
+      isEmptyNodeShouldNotInserted = HTMLEditUtils::IsEmptyNode(
+          *child,
+          {// Although we don't check relation between list item element
+           // and parent list element, but it should not be a problem in the
+           // wild because appearing such invalid list element is an edge case
+           // and anyway HTMLEditor supports editing in them.
+           EmptyCheckOption::TreatListItemAsVisible,
+           // Ignore editable state because non-editable list item element
+           // may make the list element visible.  Although HTMLEditor does not
+           // support to edit list elements which have only non-editable list
+           // item elements, but it should be deleted from outside.
+           // TODO: Currently, HTMLEditor does not support deleting such list
+           //       element with Backspace.  We should fix this.
+           EmptyCheckOption::IgnoreEditableState});
+    }
+    // TODO: Perhaps, we should delete <table>s if they have no <td>/<th>
+    //       element, or something other elements which must have specific
+    //       children but they don't.
+    if (isEmptyNodeShouldNotInserted) {
+      nsIContent* nextChild = child->GetNextSibling();
+      OwningNonNull<nsIContent> removingChild(*child);
+      removingChild->Remove();
+      child = nextChild;
+      continue;
+    }
+    if (child->HasChildNodes()) {
+      RemoveIncompleteDescendantsFromInsertingFragment(*child);
+    }
+    child = child->GetNextSibling();
+  }
+}
+
+// static
+bool HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    IsInsertionCookie(const nsIContent& aContent) {
+  // Is this child the magical cookie?
+  if (const auto* comment = Comment::FromNode(&aContent)) {
+    nsAutoString data;
+    comment->GetData(data);
+
+    return data.EqualsLiteral(kInsertCookie);
+  }
+
+  return false;
+}
+
+/**
+ * This function finds the target node that we will be pasting into. aStart is
+ * the context that we're given and aResult will be the target. Initially,
+ * *aResult must be nullptr.
+ *
+ * The target for a paste is found by either finding the node that contains
+ * the magical comment node containing kInsertCookie or, failing that, the
+ * firstChild of the firstChild (until we reach a leaf).
+ */
+bool HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    FindTargetNodeOfContextForPastedHTMLAndRemoveInsertionCookie(
+        nsINode& aStart, nsCOMPtr<nsINode>& aResult) {
+  nsIContent* firstChild = aStart.GetFirstChild();
+  if (!firstChild) {
+    // If the current result is nullptr, then aStart is a leaf, and is the
+    // fallback result.
+    if (!aResult) {
+      aResult = &aStart;
+    }
+    return false;
+  }
+
+  for (nsCOMPtr<nsIContent> child = firstChild; child;
+       child = child->GetNextSibling()) {
+    if (FragmentFromPasteCreator::IsInsertionCookie(*child)) {
+      // Yes it is! Return an error so we bubble out and short-circuit the
+      // search.
+      aResult = &aStart;
+
+      child->Remove();
+
+      return true;
+    }
+
+    if (FindTargetNodeOfContextForPastedHTMLAndRemoveInsertionCookie(*child,
+                                                                     aResult)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+class MOZ_STACK_CLASS HTMLEditor::HTMLWithContextInserter::FragmentParser
+    final {
+ public:
+  FragmentParser(const Document& aDocument, SafeToInsertData aSafeToInsertData);
+
+  [[nodiscard]] nsresult ParseContext(const nsAString& aContextString,
+                                      DocumentFragment** aFragment);
+
+  [[nodiscard]] nsresult ParsePastedHTML(const nsAString& aInputString,
+                                         nsAtom* aContextLocalNameAtom,
+                                         DocumentFragment** aFragment);
+
+ private:
+  static nsresult ParseFragment(const nsAString& aStr,
+                                nsAtom* aContextLocalName,
+                                const Document* aTargetDoc,
+                                dom::DocumentFragment** aFragment,
+                                SafeToInsertData aSafeToInsertData);
+
+  const Document& mDocument;
+  const SafeToInsertData mSafeToInsertData;
+};
+
+HTMLEditor::HTMLWithContextInserter::FragmentParser::FragmentParser(
+    const Document& aDocument, SafeToInsertData aSafeToInsertData)
+    : mDocument{aDocument}, mSafeToInsertData{aSafeToInsertData} {}
+
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentParser::ParseContext(
+    const nsAString& aContextStr, DocumentFragment** aFragment) {
+  return FragmentParser::ParseFragment(aContextStr, nullptr, &mDocument,
+                                       aFragment, mSafeToInsertData);
+}
+
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentParser::ParsePastedHTML(
+    const nsAString& aInputString, nsAtom* aContextLocalNameAtom,
+    DocumentFragment** aFragment) {
+  return FragmentParser::ParseFragment(aInputString, aContextLocalNameAtom,
+                                       &mDocument, aFragment,
+                                       mSafeToInsertData);
+}
+
+nsresult HTMLEditor::HTMLWithContextInserter::CreateDOMFragmentFromPaste(
+    const nsAString& aInputString, const nsAString& aContextStr,
+    const nsAString& aInfoStr, nsCOMPtr<nsINode>* aOutFragNode,
+    nsCOMPtr<nsINode>* aOutStartNode, nsCOMPtr<nsINode>* aOutEndNode,
+    uint32_t* aOutStartOffset, uint32_t* aOutEndOffset,
+    SafeToInsertData aSafeToInsertData) const {
+  if (NS_WARN_IF(!aOutFragNode) || NS_WARN_IF(!aOutStartNode) ||
+      NS_WARN_IF(!aOutEndNode) || NS_WARN_IF(!aOutStartOffset) ||
+      NS_WARN_IF(!aOutEndOffset)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<const Document> document = mHTMLEditor.GetDocument();
+  if (NS_WARN_IF(!document)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  FragmentFromPasteCreator fragmentFromPasteCreator;
+
+  const nsresult rv = fragmentFromPasteCreator.Run(
+      *document, aInputString, aContextStr, aInfoStr, aOutFragNode,
+      aOutStartNode, aOutEndNode, aSafeToInsertData);
+
+  *aOutStartOffset = 0;
+  *aOutEndOffset = (*aOutEndNode)->Length();
+
+  return rv;
+}
+
+// static
+nsAtom* HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    DetermineContextLocalNameForParsingPastedHTML(
+        const nsIContent* aParentContentOfPastedHTMLInContext) {
+  if (!aParentContentOfPastedHTMLInContext) {
+    return nsGkAtoms::body;
+  }
+
+  nsAtom* contextLocalNameAtom =
+      aParentContentOfPastedHTMLInContext->NodeInfo()->NameAtom();
+
+  return (aParentContentOfPastedHTMLInContext->IsHTMLElement(nsGkAtoms::html))
+             ? nsGkAtoms::body
+             : contextLocalNameAtom;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    MergeAndPostProcessFragmentsForPastedHTMLAndContext(
+        DocumentFragment& aDocumentFragmentForPastedHTML,
+        DocumentFragment& aDocumentFragmentForContext,
+        nsIContent& aTargetContentOfContextForPastedHTML) {
+  FragmentFromPasteCreator::RemoveHeadChildAndStealBodyChildsChildren(
+      aDocumentFragmentForPastedHTML);
+
+  FragmentFromPasteCreator::RemoveIncompleteDescendantsFromInsertingFragment(
+      aDocumentFragmentForPastedHTML);
+
+  // unite the two trees
+  IgnoredErrorResult ignoredError;
+  aTargetContentOfContextForPastedHTML.AppendChild(
+      aDocumentFragmentForPastedHTML, ignoredError);
+  NS_WARNING_ASSERTION(!ignoredError.Failed(),
+                       "nsINode::AppendChild() failed, but ignored");
+  const nsresult rv = FragmentFromPasteCreator::
+      RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+          aDocumentFragmentForContext, NodesToRemove::eOnlyListItems);
+
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+        "RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces()"
+        " failed");
+    return rv;
+  }
+
+  return rv;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    PostProcessFragmentForPastedHTMLWithoutContext(
+        DocumentFragment& aDocumentFragmentForPastedHTML) {
+  FragmentFromPasteCreator::RemoveHeadChildAndStealBodyChildsChildren(
+      aDocumentFragmentForPastedHTML);
+
+  FragmentFromPasteCreator::RemoveIncompleteDescendantsFromInsertingFragment(
+      aDocumentFragmentForPastedHTML);
+
+  const nsresult rv = FragmentFromPasteCreator::
+      RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+          aDocumentFragmentForPastedHTML, NodesToRemove::eOnlyListItems);
+
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+        "RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces() "
+        "failed");
+    return rv;
+  }
+
+  return rv;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    PreProcessContextDocumentFragmentForMerging(
+        DocumentFragment& aDocumentFragmentForContext) {
+  // The context is expected to contain text nodes only in block level
+  // elements. Hence, if they contain only whitespace, they're invisible.
+  const nsresult rv = FragmentFromPasteCreator::
+      RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces(
+          aDocumentFragmentForContext, NodesToRemove::eAll);
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+        "RemoveNonPreWhiteSpaceOnlyTextNodesForIgnoringInvisibleWhiteSpaces() "
+        "failed");
+    return rv;
+  }
+
+  FragmentFromPasteCreator::RemoveHeadChildAndStealBodyChildsChildren(
+      aDocumentFragmentForContext);
+
+  return rv;
+}
+
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    CreateDocumentFragmentAndGetParentOfPastedHTMLInContext(
+        const Document& aDocument, const nsAString& aInputString,
+        const nsAString& aContextStr, SafeToInsertData aSafeToInsertData,
+        nsCOMPtr<nsINode>& aParentNodeOfPastedHTMLInContext,
+        RefPtr<DocumentFragment>& aDocumentFragmentToInsert) const {
+  // if we have context info, create a fragment for that
+  RefPtr<DocumentFragment> documentFragmentForContext;
+
+  FragmentParser fragmentParser{aDocument, aSafeToInsertData};
+  if (!aContextStr.IsEmpty()) {
+    nsresult rv = fragmentParser.ParseContext(
+        aContextStr, getter_AddRefs(documentFragmentForContext));
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentParser::ParseContext() "
+          "failed");
+      return rv;
+    }
+    if (!documentFragmentForContext) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentParser::ParseContext() "
+          "returned nullptr");
+      return NS_ERROR_FAILURE;
+    }
+
+    rv = FragmentFromPasteCreator::PreProcessContextDocumentFragmentForMerging(
+        *documentFragmentForContext);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+          "PreProcessContextDocumentFragmentForMerging() failed.");
+      return rv;
+    }
+
+    FragmentFromPasteCreator::
+        FindTargetNodeOfContextForPastedHTMLAndRemoveInsertionCookie(
+            *documentFragmentForContext, aParentNodeOfPastedHTMLInContext);
+    MOZ_ASSERT(aParentNodeOfPastedHTMLInContext);
+  }
+
+  nsCOMPtr<nsIContent> parentContentOfPastedHTMLInContext =
+      nsIContent::FromNodeOrNull(aParentNodeOfPastedHTMLInContext);
+  MOZ_ASSERT_IF(aParentNodeOfPastedHTMLInContext,
+                parentContentOfPastedHTMLInContext);
+
+  nsAtom* contextLocalNameAtom =
+      FragmentFromPasteCreator::DetermineContextLocalNameForParsingPastedHTML(
+          parentContentOfPastedHTMLInContext);
+  RefPtr<DocumentFragment> documentFragmentForPastedHTML;
+  nsresult rv = fragmentParser.ParsePastedHTML(
+      aInputString, contextLocalNameAtom,
+      getter_AddRefs(documentFragmentForPastedHTML));
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentParser::ParsePastedHTML()"
+        " failed");
+    return rv;
+  }
+  if (!documentFragmentForPastedHTML) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentParser::ParsePastedHTML()"
+        " returned nullptr");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aParentNodeOfPastedHTMLInContext) {
+    const nsresult rv = FragmentFromPasteCreator::
+        MergeAndPostProcessFragmentsForPastedHTMLAndContext(
+            *documentFragmentForPastedHTML, *documentFragmentForContext,
+            *parentContentOfPastedHTMLInContext);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+          "MergeAndPostProcessFragmentsForPastedHTMLAndContext() failed.");
+      return rv;
+    }
+    aDocumentFragmentToInsert = std::move(documentFragmentForContext);
+  } else {
+    const nsresult rv = PostProcessFragmentForPastedHTMLWithoutContext(
+        *documentFragmentForPastedHTML);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+          "PostProcessFragmentForPastedHTMLWithoutContext() failed.");
+      return rv;
+    }
+
+    aDocumentFragmentToInsert = std::move(documentFragmentForPastedHTML);
+  }
+
+  return rv;
+}
+
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::Run(
+    const Document& aDocument, const nsAString& aInputString,
+    const nsAString& aContextStr, const nsAString& aInfoStr,
+    nsCOMPtr<nsINode>* aOutFragNode, nsCOMPtr<nsINode>* aOutStartNode,
+    nsCOMPtr<nsINode>* aOutEndNode, SafeToInsertData aSafeToInsertData) const {
+  MOZ_ASSERT(aOutFragNode);
+  MOZ_ASSERT(aOutStartNode);
+  MOZ_ASSERT(aOutEndNode);
+
+  nsCOMPtr<nsINode> parentNodeOfPastedHTMLInContext;
+  RefPtr<DocumentFragment> documentFragmentToInsert;
+  nsresult rv = CreateDocumentFragmentAndGetParentOfPastedHTMLInContext(
+      aDocument, aInputString, aContextStr, aSafeToInsertData,
+      parentNodeOfPastedHTMLInContext, documentFragmentToInsert);
+  if (NS_FAILED(rv)) {
+    NS_WARNING(
+        "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+        "CreateDocumentFragmentAndGetParentOfPastedHTMLInContext() failed.");
+    return rv;
+  }
+
+  // If there was no context, then treat all of the data we did get as the
+  // pasted data.
+  if (parentNodeOfPastedHTMLInContext) {
+    *aOutEndNode = *aOutStartNode = parentNodeOfPastedHTMLInContext;
+  } else {
+    *aOutEndNode = *aOutStartNode = documentFragmentToInsert;
+  }
+
+  *aOutFragNode = std::move(documentFragmentToInsert);
+
+  if (!aInfoStr.IsEmpty()) {
+    const nsresult rv =
+        FragmentFromPasteCreator::MoveStartAndEndAccordingToHTMLInfo(
+            aInfoStr, aOutStartNode, aOutEndNode);
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::"
+          "MoveStartAndEndAccordingToHTMLInfo() failed");
+      return rv;
+    }
+  }
+
+  return NS_OK;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentFromPasteCreator::
+    MoveStartAndEndAccordingToHTMLInfo(const nsAString& aInfoStr,
+                                       nsCOMPtr<nsINode>* aOutStartNode,
+                                       nsCOMPtr<nsINode>* aOutEndNode) {
+  int32_t sep = aInfoStr.FindChar((char16_t)',');
+  nsAutoString numstr1(Substring(aInfoStr, 0, sep));
+  nsAutoString numstr2(
+      Substring(aInfoStr, sep + 1, aInfoStr.Length() - (sep + 1)));
+
+  // Move the start and end children.
+  nsresult rvIgnored;
+  int32_t num = numstr1.ToInteger(&rvIgnored);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                       "nsAString::ToInteger() failed, but ignored");
+  while (num--) {
+    nsINode* tmp = (*aOutStartNode)->GetFirstChild();
+    if (!tmp) {
+      NS_WARNING("aOutStartNode did not have children");
+      return NS_ERROR_FAILURE;
+    }
+    *aOutStartNode = tmp;
+  }
+
+  num = numstr2.ToInteger(&rvIgnored);
+  while (num--) {
+    nsINode* tmp = (*aOutEndNode)->GetLastChild();
+    if (!tmp) {
+      NS_WARNING("aOutEndNode did not have children");
+      return NS_ERROR_FAILURE;
+    }
+    *aOutEndNode = tmp;
+  }
+
+  return NS_OK;
+}
+
+// static
+nsresult HTMLEditor::HTMLWithContextInserter::FragmentParser::ParseFragment(
+    const nsAString& aFragStr, nsAtom* aContextLocalName,
+    const Document* aTargetDocument, DocumentFragment** aFragment,
+    SafeToInsertData aSafeToInsertData) {
+  nsAutoScriptBlockerSuppressNodeRemoved autoBlocker;
+
+  nsCOMPtr<Document> doc =
+      nsContentUtils::CreateInertHTMLDocument(aTargetDocument);
+  if (!doc) {
+    return NS_ERROR_FAILURE;
+  }
+  RefPtr<DocumentFragment> fragment =
+      new (doc->NodeInfoManager()) DocumentFragment(doc->NodeInfoManager());
+  nsresult rv = nsContentUtils::ParseFragmentHTML(
+      aFragStr, fragment,
+      aContextLocalName ? aContextLocalName : nsGkAtoms::body,
+      kNameSpaceID_XHTML, false, true);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "nsContentUtils::ParseFragmentHTML() failed");
+  if (aSafeToInsertData == SafeToInsertData::No) {
+    nsTreeSanitizer sanitizer(aContextLocalName
+                                  ? nsIParserUtils::SanitizerAllowStyle
+                                  : nsIParserUtils::SanitizerAllowComments);
+    sanitizer.Sanitize(fragment);
+  }
+  fragment.forget(aFragment);
+  return rv;
+}
+
+// static
+void HTMLEditor::HTMLWithContextInserter::
+    CollectTopMostChildContentsCompletelyInRange(
+        const EditorRawDOMPoint& aStartPoint,
+        const EditorRawDOMPoint& aEndPoint,
+        nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents) {
+  MOZ_ASSERT(aStartPoint.IsSetAndValid());
+  MOZ_ASSERT(aEndPoint.IsSetAndValid());
+
+  RefPtr<nsRange> range =
+      nsRange::Create(aStartPoint.ToRawRangeBoundary(),
+                      aEndPoint.ToRawRangeBoundary(), IgnoreErrors());
+  if (!range) {
+    NS_WARNING("nsRange::Create() failed");
+    return;
+  }
+  DOMSubtreeIterator iter;
+  if (NS_FAILED(iter.Init(*range))) {
+    NS_WARNING("DOMSubtreeIterator::Init() failed, but ignored");
+    return;
+  }
+
+  iter.AppendAllNodesToArray(aOutArrayOfContents);
+}
+
+/******************************************************************************
+ * HTMLEditor::AutoHTMLFragmentBoundariesFixer
+ ******************************************************************************/
+
+HTMLEditor::AutoHTMLFragmentBoundariesFixer::AutoHTMLFragmentBoundariesFixer(
+    nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents) {
+  EnsureBeginsOrEndsWithValidContent(StartOrEnd::start,
+                                     aArrayOfTopMostChildContents);
+  EnsureBeginsOrEndsWithValidContent(StartOrEnd::end,
+                                     aArrayOfTopMostChildContents);
+}
+
+// static
+void HTMLEditor::AutoHTMLFragmentBoundariesFixer::
+    CollectTableAndAnyListElementsOfInclusiveAncestorsAt(
+        nsIContent& aContent,
+        nsTArray<OwningNonNull<Element>>& aOutArrayOfListAndTableElements) {
+  for (Element* element = aContent.GetAsElementOrParentElement(); element;
+       element = element->GetParentElement()) {
+    if (HTMLEditUtils::IsAnyListElement(element) ||
+        HTMLEditUtils::IsTable(element)) {
+      aOutArrayOfListAndTableElements.AppendElement(*element);
+    }
+  }
+}
+
+// static
+Element* HTMLEditor::AutoHTMLFragmentBoundariesFixer::
+    GetMostDistantAncestorListOrTableElement(
+        const nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents,
+        const nsTArray<OwningNonNull<Element>>&
+            aInclusiveAncestorsTableOrListElements) {
+  Element* lastFoundAncestorListOrTableElement = nullptr;
+  for (auto& content : aArrayOfTopMostChildContents) {
+    if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) {
+      Element* tableElement =
+          HTMLEditUtils::GetClosestAncestorTableElement(*content);
+      if (!tableElement) {
+        continue;
+      }
+      // If we find a `<table>` element which is an ancestor of a table
+      // related element and is not an acestor of first nor last of
+      // aArrayOfNodes, return the last found list or `<table>` element.
+      // XXX Is that really expected that this returns a list element in this
+      //     case?
+      if (!aInclusiveAncestorsTableOrListElements.Contains(tableElement)) {
+        return lastFoundAncestorListOrTableElement;
+      }
+      // If we find a `<table>` element which is topmost list or `<table>`
+      // element at first or last of aArrayOfNodes, return it.
+      if (aInclusiveAncestorsTableOrListElements.LastElement().get() ==
+          tableElement) {
+        return tableElement;
+      }
+      // Otherwise, store the `<table>` element which is an ancestor but
+      // not topmost ancestor of first or last of aArrayOfNodes.
+      lastFoundAncestorListOrTableElement = tableElement;
+      continue;
+    }
+
+    if (!HTMLEditUtils::IsListItem(content)) {
+      continue;
+    }
+    Element* listElement =
+        HTMLEditUtils::GetClosestAncestorAnyListElement(*content);
+    if (!listElement) {
+      continue;
+    }
+    // If we find a list element which is ancestor of a list item element and
+    // is not an acestor of first nor last of aArrayOfNodes, return the last
+    // found list or `<table>` element.
+    // XXX Is that really expected that this returns a `<table>` element in
+    //     this case?
+    if (!aInclusiveAncestorsTableOrListElements.Contains(listElement)) {
+      return lastFoundAncestorListOrTableElement;
+    }
+    // If we find a list element which is topmost list or `<table>` element at
+    // first or last of aArrayOfNodes, return it.
+    if (aInclusiveAncestorsTableOrListElements.LastElement().get() ==
+        listElement) {
+      return listElement;
+    }
+    // Otherwise, store the list element which is an ancestor but not topmost
+    // ancestor of first or last of aArrayOfNodes.
+    lastFoundAncestorListOrTableElement = listElement;
+  }
+
+  // If we find only non-topmost list or `<table>` element, returns the last
+  // found one (meaning bottommost one).  Otherwise, nullptr.
+  return lastFoundAncestorListOrTableElement;
+}
+
+Element*
+HTMLEditor::AutoHTMLFragmentBoundariesFixer::FindReplaceableTableElement(
+    Element& aTableElement, nsIContent& aContentMaybeInTableElement) const {
+  MOZ_ASSERT(aTableElement.IsHTMLElement(nsGkAtoms::table));
+  // Perhaps, this is designed for climbing up the DOM tree from
+  // aContentMaybeInTableElement to aTableElement and making sure that
+  // aContentMaybeInTableElement itself or its ancestor is a `<td>`, `<th>`,
+  // `<tr>`, `<thead>`, `<tbody>`, `<tfoot>` or `<caption>`.
+  // But this looks really buggy because this loop may skip aTableElement
+  // as the following NS_ASSERTION.  We should write automated tests and
+  // check right behavior.
+  for (Element* element =
+           aContentMaybeInTableElement.GetAsElementOrParentElement();
+       element; element = element->GetParentElement()) {
+    if (!HTMLEditUtils::IsAnyTableElement(element) ||
+        element->IsHTMLElement(nsGkAtoms::table)) {
+      // XXX Perhaps, the original developer of this method assumed that
+      //     aTableElement won't be skipped because if it's assumed, we can
+      //     stop climbing up the tree in that case.
+      NS_ASSERTION(element != &aTableElement,
+                   "The table element which is looking for is ignored");
+      continue;
+    }
+    Element* tableElement = nullptr;
+    for (Element* maybeTableElement = element->GetParentElement();
+         maybeTableElement;
+         maybeTableElement = maybeTableElement->GetParentElement()) {
+      if (maybeTableElement->IsHTMLElement(nsGkAtoms::table)) {
+        tableElement = maybeTableElement;
+        break;
+      }
+    }
+    if (tableElement == &aTableElement) {
+      return element;
+    }
+    // XXX If we find another `<table>` element, why don't we keep searching
+    //     from its parent?
+  }
+  return nullptr;
+}
+
+bool HTMLEditor::AutoHTMLFragmentBoundariesFixer::IsReplaceableListElement(
+    Element& aListElement, nsIContent& aContentMaybeInListElement) const {
+  MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+  // Perhaps, this is designed for climbing up the DOM tree from
+  // aContentMaybeInListElement to aListElement and making sure that
+  // aContentMaybeInListElement itself or its ancestor is an list item.
+  // But this looks really buggy because this loop may skip aListElement
+  // as the following NS_ASSERTION.  We should write automated tests and
+  // check right behavior.
+  for (Element* element =
+           aContentMaybeInListElement.GetAsElementOrParentElement();
+       element; element = element->GetParentElement()) {
+    if (!HTMLEditUtils::IsListItem(element)) {
+      // XXX Perhaps, the original developer of this method assumed that
+      //     aListElement won't be skipped because if it's assumed, we can
+      //     stop climbing up the tree in that case.
+      NS_ASSERTION(element != &aListElement,
+                   "The list element which is looking for is ignored");
+      continue;
+    }
+    Element* listElement =
+        HTMLEditUtils::GetClosestAncestorAnyListElement(*element);
+    if (listElement == &aListElement) {
+      return true;
+    }
+    // XXX If we find another list element, why don't we keep searching
+    //     from its parent?
+  }
+  return false;
+}
+
+void HTMLEditor::AutoHTMLFragmentBoundariesFixer::
+    EnsureBeginsOrEndsWithValidContent(StartOrEnd aStartOrEnd,
+                                       nsTArray<OwningNonNull<nsIContent>>&
+                                           aArrayOfTopMostChildContents) const {
+  MOZ_ASSERT(!aArrayOfTopMostChildContents.IsEmpty());
+
+  // Collect list elements and table related elements at first or last node
+  // in aArrayOfTopMostChildContents.
+  AutoTArray<OwningNonNull<Element>, 4> inclusiveAncestorsListOrTableElements;
+  CollectTableAndAnyListElementsOfInclusiveAncestorsAt(
+      aStartOrEnd == StartOrEnd::end
+          ? aArrayOfTopMostChildContents.LastElement()
+          : aArrayOfTopMostChildContents[0],
+      inclusiveAncestorsListOrTableElements);
+  if (inclusiveAncestorsListOrTableElements.IsEmpty()) {
+    return;
+  }
+
+  // Get most ancestor list or `<table>` element in
+  // inclusiveAncestorsListOrTableElements which contains earlier
+  // node in aArrayOfTopMostChildContents as far as possible.
+  // XXX With inclusiveAncestorsListOrTableElements, this returns a
+  //     list or `<table>` element which contains first or last node of
+  //     aArrayOfTopMostChildContents.  However, this seems slow when
+  //     aStartOrEnd is StartOrEnd::end and only the last node is in
+  //     different list or `<table>`.  But I'm not sure whether it's
+  //     possible case or not.  We need to add tests to
+  //     test_content_iterator_subtree.html for checking how
+  //     SubtreeContentIterator works.
+  Element* listOrTableElement = GetMostDistantAncestorListOrTableElement(
+      aArrayOfTopMostChildContents, inclusiveAncestorsListOrTableElements);
+  if (!listOrTableElement) {
+    return;
+  }
+
+  // If we have pieces of tables or lists to be inserted, let's force the
+  // insertion to deal with table elements right away, so that it doesn't
+  // orphan some table or list contents outside the table or list.
+
+  OwningNonNull<nsIContent>& firstOrLastChildContent =
+      aStartOrEnd == StartOrEnd::end
+          ? aArrayOfTopMostChildContents.LastElement()
+          : aArrayOfTopMostChildContents[0];
+
+  // Find substructure of list or table that must be included in paste.
+  Element* replaceElement;
+  if (HTMLEditUtils::IsAnyListElement(listOrTableElement)) {
+    if (!IsReplaceableListElement(*listOrTableElement,
+                                  firstOrLastChildContent)) {
+      return;
+    }
+    replaceElement = listOrTableElement;
+  } else {
+    MOZ_ASSERT(listOrTableElement->IsHTMLElement(nsGkAtoms::table));
+    replaceElement = FindReplaceableTableElement(*listOrTableElement,
+                                                 firstOrLastChildContent);
+    if (!replaceElement) {
+      return;
+    }
+  }
+
+  // If we can replace the given list element or found a table related element
+  // in the `<table>` element, insert it into aArrayOfTopMostChildContents which
+  // is tompost children to be inserted instead of descendants of them in
+  // aArrayOfTopMostChildContents.
+  for (size_t i = 0; i < aArrayOfTopMostChildContents.Length();) {
+    OwningNonNull<nsIContent>& content = aArrayOfTopMostChildContents[i];
+    if (content == replaceElement) {
+      // If the element is n aArrayOfTopMostChildContents, its descendants must
+      // not be in the array.  Therefore, we don't need to optimize this case.
+      // XXX Perhaps, we can break this loop right now.
+      aArrayOfTopMostChildContents.RemoveElementAt(i);
+      continue;
+    }
+    if (!EditorUtils::IsDescendantOf(content, *replaceElement)) {
+      i++;
+      continue;
+    }
+    // For saving number of calls of EditorUtils::IsDescendantOf(), we should
+    // remove its siblings in the array.
+    nsIContent* parent = content->GetParent();
+    aArrayOfTopMostChildContents.RemoveElementAt(i);
+    while (i < aArrayOfTopMostChildContents.Length() &&
+           aArrayOfTopMostChildContents[i]->GetParent() == parent) {
+      aArrayOfTopMostChildContents.RemoveElementAt(i);
+    }
+  }
+
+  // Now replace the removed nodes with the structural parent
+  if (aStartOrEnd == StartOrEnd::end) {
+    aArrayOfTopMostChildContents.AppendElement(*replaceElement);
+  } else {
+    aArrayOfTopMostChildContents.InsertElementAt(0, *replaceElement);
+  }
+}
+
+}  // namespace mozilla