diff options
Diffstat (limited to 'editor/libeditor/HTMLEditSubActionHandler.cpp')
| -rw-r--r-- | editor/libeditor/HTMLEditSubActionHandler.cpp | 11794 |
1 files changed, 11794 insertions, 0 deletions
diff --git a/editor/libeditor/HTMLEditSubActionHandler.cpp b/editor/libeditor/HTMLEditSubActionHandler.cpp new file mode 100644 index 0000000000..8e89d26d46 --- /dev/null +++ b/editor/libeditor/HTMLEditSubActionHandler.cpp @@ -0,0 +1,11794 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 sw=2 et tw=80: */ +/* 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 "HTMLEditorInlines.h" +#include "HTMLEditorNestedClasses.h" + +#include <algorithm> +#include <utility> + +#include "AutoRangeArray.h" +#include "CSSEditUtils.h" +#include "EditAction.h" +#include "EditorDOMPoint.h" +#include "EditorUtils.h" +#include "HTMLEditHelpers.h" +#include "HTMLEditUtils.h" +#include "PendingStyles.h" // for SpecifiedStyle +#include "WSRunObject.h" + +#include "ErrorList.h" +#include "mozilla/Assertions.h" +#include "mozilla/Attributes.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/ContentIterator.h" +#include "mozilla/IntegerRange.h" +#include "mozilla/InternalMutationEvent.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/Maybe.h" +#include "mozilla/OwningNonNull.h" +#include "mozilla/Preferences.h" +#include "mozilla/PresShell.h" +#include "mozilla/RangeUtils.h" +#include "mozilla/StaticPrefs_editor.h" // for StaticPrefs::editor_* +#include "mozilla/TextComposition.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/AncestorIterator.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/HTMLBRElement.h" +#include "mozilla/dom/RangeBinding.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/dom/StaticRange.h" +#include "mozilla/mozalloc.h" +#include "nsAString.h" +#include "nsAlgorithm.h" +#include "nsAtom.h" +#include "nsCRT.h" +#include "nsCRTGlue.h" +#include "nsComponentManagerUtils.h" +#include "nsContentUtils.h" +#include "nsDebug.h" +#include "nsError.h" +#include "nsFrameSelection.h" +#include "nsGkAtoms.h" +#include "nsHTMLDocument.h" +#include "nsIContent.h" +#include "nsID.h" +#include "nsIFrame.h" +#include "nsINode.h" +#include "nsLiteralString.h" +#include "nsPrintfCString.h" +#include "nsRange.h" +#include "nsReadableUtils.h" +#include "nsString.h" +#include "nsStringFwd.h" +#include "nsStyledElement.h" +#include "nsTArray.h" +#include "nsTextNode.h" +#include "nsThreadUtils.h" +#include "nsUnicharUtils.h" + +class nsISupports; + +namespace mozilla { + +using namespace dom; +using EmptyCheckOption = HTMLEditUtils::EmptyCheckOption; +using EmptyCheckOptions = HTMLEditUtils::EmptyCheckOptions; +using LeafNodeType = HTMLEditUtils::LeafNodeType; +using LeafNodeTypes = HTMLEditUtils::LeafNodeTypes; +using WalkTextOption = HTMLEditUtils::WalkTextOption; +using WalkTreeDirection = HTMLEditUtils::WalkTreeDirection; +using WalkTreeOption = HTMLEditUtils::WalkTreeOption; + +/******************************************************** + * first some helpful functors we will use + ********************************************************/ + +static bool IsPendingStyleCachePreservingSubAction( + EditSubAction aEditSubAction) { + switch (aEditSubAction) { + case EditSubAction::eDeleteSelectedContent: + case EditSubAction::eInsertLineBreak: + case EditSubAction::eInsertParagraphSeparator: + case EditSubAction::eCreateOrChangeList: + case EditSubAction::eIndent: + case EditSubAction::eOutdent: + case EditSubAction::eSetOrClearAlignment: + case EditSubAction::eCreateOrRemoveBlock: + case EditSubAction::eMergeBlockContents: + case EditSubAction::eRemoveList: + case EditSubAction::eCreateOrChangeDefinitionListItem: + case EditSubAction::eInsertElement: + case EditSubAction::eInsertQuotation: + case EditSubAction::eInsertQuotedText: + return true; + default: + return false; + } +} + +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMRange& aRange); +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorRawDOMRange& aRange); +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMPoint& aStartPoint, const EditorDOMPoint& aEndPoint); +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorRawDOMPoint& aStartPoint, const EditorDOMPoint& aEndPoint); +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMPoint& aStartPoint, const EditorRawDOMPoint& aEndPoint); +template already_AddRefed<nsRange> +HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorRawDOMPoint& aStartPoint, const EditorRawDOMPoint& aEndPoint); + +nsresult HTMLEditor::InitEditorContentAndSelection() { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // We should do nothing with the result of GetRoot() if only a part of the + // document is editable. + if (!EntireDocumentIsEditable()) { + return NS_OK; + } + + nsresult rv = MaybeCreatePaddingBRElementForEmptyEditor(); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::MaybeCreatePaddingBRElementForEmptyEditor() failed"); + return rv; + } + + // If the selection hasn't been set up yet, set it up collapsed to the end of + // our editable content. + // XXX I think that this shouldn't do it in `HTMLEditor` because it maybe + // removed by the web app and if they call `Selection::AddRange()` without + // checking the range count, it may cause multiple selection ranges. + if (!SelectionRef().RangeCount()) { + nsresult rv = CollapseSelectionToEndOfLastLeafNodeOfDocument(); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::CollapseSelectionToEndOfLastLeafNodeOfDocument() " + "failed"); + return rv; + } + } + + if (IsInPlaintextMode()) { + // XXX Should we do this in HTMLEditor? It's odd to guarantee that last + // empty line is visible only when it's in the plain text mode. + nsresult rv = EnsurePaddingBRElementInMultilineEditor(); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::EnsurePaddingBRElementInMultilineEditor() failed"); + return rv; + } + } + + Element* bodyOrDocumentElement = GetRoot(); + if (NS_WARN_IF(!bodyOrDocumentElement && !GetDocument())) { + return NS_ERROR_FAILURE; + } + + if (!bodyOrDocumentElement) { + return NS_OK; + } + + rv = InsertBRElementToEmptyListItemsAndTableCellsInRange( + RawRangeBoundary(bodyOrDocumentElement, 0u), + RawRangeBoundary(bodyOrDocumentElement, + bodyOrDocumentElement->GetChildCount())); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::InsertBRElementToEmptyListItemsAndTableCellsInRange() " + "failed, but ignored"); + return NS_OK; +} + +void HTMLEditor::OnStartToHandleTopLevelEditSubAction( + EditSubAction aTopLevelEditSubAction, + nsIEditor::EDirection aDirectionOfTopLevelEditSubAction, ErrorResult& aRv) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!aRv.Failed()); + + EditorBase::OnStartToHandleTopLevelEditSubAction( + aTopLevelEditSubAction, aDirectionOfTopLevelEditSubAction, aRv); + + MOZ_ASSERT(GetTopLevelEditSubAction() == aTopLevelEditSubAction); + MOZ_ASSERT(GetDirectionOfTopLevelEditSubAction() == + aDirectionOfTopLevelEditSubAction); + + if (NS_WARN_IF(Destroyed())) { + aRv.Throw(NS_ERROR_EDITOR_DESTROYED); + return; + } + + if (!mInitSucceeded) { + return; // We should do nothing if we're being initialized. + } + + NS_WARNING_ASSERTION( + !aRv.Failed(), + "EditorBase::OnStartToHandleTopLevelEditSubAction() failed"); + + // Let's work with the latest layout information after (maybe) dispatching + // `beforeinput` event. + RefPtr<Document> document = GetDocument(); + if (NS_WARN_IF(!document)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return; + } + document->FlushPendingNotifications(FlushType::Frames); + if (NS_WARN_IF(Destroyed())) { + aRv.Throw(NS_ERROR_EDITOR_DESTROYED); + return; + } + + // Remember where our selection was before edit action took place: + const auto atCompositionStart = + GetFirstIMESelectionStartPoint<EditorRawDOMPoint>(); + if (atCompositionStart.IsSet()) { + // If there is composition string, let's remember current composition + // range. + TopLevelEditSubActionDataRef().mSelectedRange->StoreRange( + atCompositionStart, GetLastIMESelectionEndPoint<EditorRawDOMPoint>()); + } else { + // Get the selection location + // XXX This may occur so that I think that we shouldn't throw exception + // in this case. + if (NS_WARN_IF(!SelectionRef().RangeCount())) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return; + } + if (const nsRange* range = SelectionRef().GetRangeAt(0)) { + TopLevelEditSubActionDataRef().mSelectedRange->StoreRange(*range); + } + } + + // Register with range updater to track this as we perturb the doc + RangeUpdaterRef().RegisterRangeItem( + *TopLevelEditSubActionDataRef().mSelectedRange); + + // Remember current inline styles for deletion and normal insertion ops + const bool cacheInlineStyles = [&]() { + switch (aTopLevelEditSubAction) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eDeleteSelectedContent: + return true; + default: + return IsPendingStyleCachePreservingSubAction(aTopLevelEditSubAction); + } + }(); + if (cacheInlineStyles) { + const RefPtr<Element> editingHost = + ComputeEditingHost(LimitInBodyElement::No); + if (NS_WARN_IF(!editingHost)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + nsIContent* const startContainer = + HTMLEditUtils::GetContentToPreserveInlineStyles( + TopLevelEditSubActionDataRef() + .mSelectedRange->StartPoint<EditorRawDOMPoint>(), + *editingHost); + if (NS_WARN_IF(!startContainer)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + if (const RefPtr<Element> startContainerElement = + startContainer->GetAsElementOrParentElement()) { + nsresult rv = CacheInlineStyles(*startContainerElement); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::CacheInlineStyles() failed"); + aRv.Throw(rv); + return; + } + } + } + + // Stabilize the document against contenteditable count changes + if (document->GetEditingState() == Document::EditingState::eContentEditable) { + document->ChangeContentEditableCount(nullptr, +1); + TopLevelEditSubActionDataRef().mRestoreContentEditableCount = true; + } + + // Check that selection is in subtree defined by body node + nsresult rv = EnsureSelectionInBodyOrDocumentElement(); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + aRv.Throw(NS_ERROR_EDITOR_DESTROYED); + return; + } + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "HTMLEditor::EnsureSelectionInBodyOrDocumentElement() " + "failed, but ignored"); +} + +nsresult HTMLEditor::OnEndHandlingTopLevelEditSubAction() { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + nsresult rv; + while (true) { + if (NS_WARN_IF(Destroyed())) { + rv = NS_ERROR_EDITOR_DESTROYED; + break; + } + + if (!mInitSucceeded) { + rv = NS_OK; // We should do nothing if we're being initialized. + break; + } + + // Do all the tricky stuff + rv = OnEndHandlingTopLevelEditSubActionInternal(); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::OnEndHandlingTopLevelEditSubActionInternal() failied"); + // Perhaps, we need to do the following jobs even if the editor has been + // destroyed since they adjust some states of HTML document but don't + // modify the DOM tree nor Selection. + + // Free up selectionState range item + if (TopLevelEditSubActionDataRef().mSelectedRange) { + RangeUpdaterRef().DropRangeItem( + *TopLevelEditSubActionDataRef().mSelectedRange); + } + + // Reset the contenteditable count to its previous value + if (TopLevelEditSubActionDataRef().mRestoreContentEditableCount) { + Document* document = GetDocument(); + if (NS_WARN_IF(!document)) { + rv = NS_ERROR_FAILURE; + break; + } + if (document->GetEditingState() == + Document::EditingState::eContentEditable) { + document->ChangeContentEditableCount(nullptr, -1); + } + } + break; + } + DebugOnly<nsresult> rvIgnored = + EditorBase::OnEndHandlingTopLevelEditSubAction(); + NS_WARNING_ASSERTION( + NS_FAILED(rv) || NS_SUCCEEDED(rvIgnored), + "EditorBase::OnEndHandlingTopLevelEditSubAction() failed, but ignored"); + MOZ_ASSERT(!GetTopLevelEditSubAction()); + MOZ_ASSERT(GetDirectionOfTopLevelEditSubAction() == eNone); + return rv; +} + +nsresult HTMLEditor::OnEndHandlingTopLevelEditSubActionInternal() { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + nsresult rv = EnsureSelectionInBodyOrDocumentElement(); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "HTMLEditor::EnsureSelectionInBodyOrDocumentElement() " + "failed, but ignored"); + + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eReplaceHeadWithHTMLSource: + case EditSubAction::eCreatePaddingBRElementForEmptyEditor: + return NS_OK; + default: + break; + } + + if (TopLevelEditSubActionDataRef().mChangedRange->IsPositioned() && + GetTopLevelEditSubAction() != EditSubAction::eUndo && + GetTopLevelEditSubAction() != EditSubAction::eRedo) { + // don't let any txns in here move the selection around behind our back. + // Note that this won't prevent explicit selection setting from working. + AutoTransactionsConserveSelection dontChangeMySelection(*this); + + { + EditorDOMRange changedRange( + *TopLevelEditSubActionDataRef().mChangedRange); + if (changedRange.IsPositioned() && + changedRange.EnsureNotInNativeAnonymousSubtree()) { + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eInsertLineBreak: + case EditSubAction::eInsertParagraphSeparator: + case EditSubAction::eDeleteText: { + // XXX We should investigate whether this is really needed because + // it seems that the following code does not handle the + // white-spaces. + RefPtr<nsRange> extendedChangedRange = + CreateRangeIncludingAdjuscentWhiteSpaces(changedRange); + if (extendedChangedRange) { + MOZ_ASSERT(extendedChangedRange->IsPositioned()); + // Use extended range temporarily. + TopLevelEditSubActionDataRef().mChangedRange = + std::move(extendedChangedRange); + } + break; + } + default: { + if (Element* editingHost = ComputeEditingHost()) { + if (RefPtr<nsRange> extendedChangedRange = AutoRangeArray:: + CreateRangeWrappingStartAndEndLinesContainingBoundaries( + changedRange, GetTopLevelEditSubAction(), + *editingHost)) { + MOZ_ASSERT(extendedChangedRange->IsPositioned()); + // Use extended range temporarily. + TopLevelEditSubActionDataRef().mChangedRange = + std::move(extendedChangedRange); + } + break; + } + } + } + } + } + + // if we did a ranged deletion or handling backspace key, make sure we have + // a place to put caret. + // Note we only want to do this if the overall operation was deletion, + // not if deletion was done along the way for + // EditSubAction::eInsertHTMLSource, EditSubAction::eInsertText, etc. + // That's why this is here rather than DeleteSelectionAsSubAction(). + // However, we shouldn't insert <br> elements if we've already removed + // empty block parents because users may want to disappear the line by + // the deletion. + // XXX We should make HandleDeleteSelection() store expected container + // for handling this here since we cannot trust current selection is + // collapsed at deleted point. + if (GetTopLevelEditSubAction() == EditSubAction::eDeleteSelectedContent && + TopLevelEditSubActionDataRef().mDidDeleteNonCollapsedRange && + !TopLevelEditSubActionDataRef().mDidDeleteEmptyParentBlocks) { + const auto newCaretPosition = + GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (!newCaretPosition.IsSet()) { + NS_WARNING("There was no selection range"); + return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; + } + Result<CaretPoint, nsresult> caretPointOrError = + InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( + newCaretPosition); + if (MOZ_UNLIKELY(caretPointOrError.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary() " + "failed"); + return caretPointOrError.unwrapErr(); + } + nsresult rv = caretPointOrError.unwrap().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion}); + if (NS_FAILED(rv)) { + NS_WARNING("CaretPoint::SuggestCaretPointTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CaretPoint::SuggestCaretPointTo() failed, but ignored"); + } + + // add in any needed <br>s, and remove any unneeded ones. + nsresult rv = InsertBRElementToEmptyListItemsAndTableCellsInRange( + TopLevelEditSubActionDataRef().mChangedRange->StartRef().AsRaw(), + TopLevelEditSubActionDataRef().mChangedRange->EndRef().AsRaw()); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::InsertBRElementToEmptyListItemsAndTableCellsInRange()" + " failed, but ignored"); + + // merge any adjacent text nodes + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + break; + default: { + nsresult rv = CollapseAdjacentTextNodes( + MOZ_KnownLive(*TopLevelEditSubActionDataRef().mChangedRange)); + if (NS_WARN_IF(Destroyed())) { + return NS_ERROR_EDITOR_DESTROYED; + } + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::CollapseAdjacentTextNodes() failed"); + return rv; + } + break; + } + } + + // Clean up any empty nodes in the changed range unless they are inserted + // intentionally. + if (TopLevelEditSubActionDataRef().mNeedsToCleanUpEmptyElements) { + nsresult rv = RemoveEmptyNodesIn( + EditorDOMRange(*TopLevelEditSubActionDataRef().mChangedRange)); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::RemoveEmptyNodesIn() failed"); + return rv; + } + } + + // attempt to transform any unneeded nbsp's into spaces after doing various + // operations + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eDeleteSelectedContent: + if (TopLevelEditSubActionDataRef().mDidNormalizeWhitespaces) { + break; + } + [[fallthrough]]; + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eInsertLineBreak: + case EditSubAction::eInsertParagraphSeparator: + case EditSubAction::ePasteHTMLContent: + case EditSubAction::eInsertHTMLSource: { + // Due to the replacement of white-spaces in + // WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt(), + // selection ranges may be changed since DOM ranges track the DOM + // mutation by themselves. However, we want to keep selection as-is. + // Therefore, we should restore `Selection` after replacing + // white-spaces. + AutoSelectionRestorer restoreSelection(*this); + // TODO: Temporarily, WhiteSpaceVisibilityKeeper replaces ASCII + // white-spaces with NPSPs and then, we'll replace them with ASCII + // white-spaces here. We should avoid this overwriting things as + // far as possible because replacing characters in text nodes + // causes running mutation event listeners which are really + // expensive. + // Adjust end of composition string if there is composition string. + auto pointToAdjust = GetLastIMESelectionEndPoint<EditorDOMPoint>(); + if (!pointToAdjust.IsInContentNode()) { + // Otherwise, adjust current selection start point. + pointToAdjust = GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToAdjust.IsInContentNode())) { + return NS_ERROR_FAILURE; + } + } + if (EditorUtils::IsEditableContent( + *pointToAdjust.ContainerAs<nsIContent>(), EditorType::HTML)) { + AutoTrackDOMPoint trackPointToAdjust(RangeUpdaterRef(), + &pointToAdjust); + nsresult rv = + WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt( + *this, pointToAdjust); + if (NS_FAILED(rv)) { + NS_WARNING( + "WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt() " + "failed"); + return rv; + } + } + + // also do this for original selection endpoints. + // XXX Hmm, if `NormalizeVisibleWhiteSpacesAt()` runs mutation event + // listener and that causes changing `mSelectedRange`, what we + // should do? + if (NS_WARN_IF(!TopLevelEditSubActionDataRef() + .mSelectedRange->IsPositioned())) { + return NS_ERROR_FAILURE; + } + + EditorDOMPoint atStart = + TopLevelEditSubActionDataRef().mSelectedRange->StartPoint(); + if (atStart != pointToAdjust && atStart.IsInContentNode() && + EditorUtils::IsEditableContent(*atStart.ContainerAs<nsIContent>(), + EditorType::HTML)) { + AutoTrackDOMPoint trackPointToAdjust(RangeUpdaterRef(), + &pointToAdjust); + AutoTrackDOMPoint trackStartPoint(RangeUpdaterRef(), &atStart); + nsresult rv = + WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt( + *this, atStart); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt() " + "failed, but ignored"); + } + // we only need to handle old selection endpoint if it was different + // from start + EditorDOMPoint atEnd = + TopLevelEditSubActionDataRef().mSelectedRange->EndPoint(); + if (!TopLevelEditSubActionDataRef().mSelectedRange->Collapsed() && + atEnd != pointToAdjust && atEnd != atStart && + atEnd.IsInContentNode() && + EditorUtils::IsEditableContent(*atEnd.ContainerAs<nsIContent>(), + EditorType::HTML)) { + nsresult rv = + WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt(*this, + atEnd); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "WhiteSpaceVisibilityKeeper::NormalizeVisibleWhiteSpacesAt() " + "failed, but ignored"); + } + break; + } + default: + break; + } + + // Adjust selection for insert text, html paste, and delete actions if + // we haven't removed new empty blocks. Note that if empty block parents + // are removed, Selection should've been adjusted by the method which + // did it. + if (!TopLevelEditSubActionDataRef().mDidDeleteEmptyParentBlocks && + SelectionRef().IsCollapsed()) { + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eDeleteSelectedContent: + case EditSubAction::eInsertLineBreak: + case EditSubAction::eInsertParagraphSeparator: + case EditSubAction::ePasteHTMLContent: + case EditSubAction::eInsertHTMLSource: + // XXX AdjustCaretPositionAndEnsurePaddingBRElement() intentionally + // does not create padding `<br>` element for empty editor. + // Investigate which is better that whether this should does it + // or wait MaybeCreatePaddingBRElementForEmptyEditor(). + rv = AdjustCaretPositionAndEnsurePaddingBRElement( + GetDirectionOfTopLevelEditSubAction()); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::AdjustCaretPositionAndEnsurePaddingBRElement() " + "failed"); + return rv; + } + break; + default: + break; + } + } + + // check for any styles which were removed inappropriately + bool reapplyCachedStyle; + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eDeleteSelectedContent: + reapplyCachedStyle = true; + break; + default: + reapplyCachedStyle = + IsPendingStyleCachePreservingSubAction(GetTopLevelEditSubAction()); + break; + } + + // If the selection is in empty inline HTML elements, we should delete + // them unless it's inserted intentionally. + if (mPlaceholderBatch && + TopLevelEditSubActionDataRef().mNeedsToCleanUpEmptyElements && + SelectionRef().IsCollapsed() && SelectionRef().GetFocusNode()) { + RefPtr<Element> mostDistantEmptyInlineAncestor = nullptr; + for (Element* ancestor : + SelectionRef().GetFocusNode()->InclusiveAncestorsOfType<Element>()) { + if (!ancestor->IsHTMLElement() || + !HTMLEditUtils::IsRemovableFromParentNode(*ancestor) || + !HTMLEditUtils::IsEmptyInlineContainer( + *ancestor, {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + break; + } + mostDistantEmptyInlineAncestor = ancestor; + } + if (mostDistantEmptyInlineAncestor) { + nsresult rv = + DeleteNodeWithTransaction(*mostDistantEmptyInlineAncestor); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::DeleteNodeWithTransaction() failed at deleting " + "empty inline ancestors"); + return rv; + } + } + } + + // But the cached inline styles should be restored from type-in-state later. + if (reapplyCachedStyle) { + DebugOnly<nsresult> rvIgnored = + mPendingStylesToApplyToNewContent->UpdateSelState(*this); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "PendingStyles::UpdateSelState() failed, but ignored"); + rvIgnored = ReapplyCachedStyles(); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "HTMLEditor::ReapplyCachedStyles() failed, but ignored"); + TopLevelEditSubActionDataRef().mCachedPendingStyles->Clear(); + } + } + + rv = HandleInlineSpellCheck( + TopLevelEditSubActionDataRef().mSelectedRange->StartPoint(), + TopLevelEditSubActionDataRef().mChangedRange); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::HandleInlineSpellCheck() failed"); + return rv; + } + + // detect empty doc + // XXX Need to investigate when the padding <br> element is removed because + // I don't see the <br> element with testing manually. If it won't be + // used, we can get rid of this cost. + rv = MaybeCreatePaddingBRElementForEmptyEditor(); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::MaybeCreatePaddingBRElementForEmptyEditor() failed"); + return rv; + } + + // adjust selection HINT if needed + if (!TopLevelEditSubActionDataRef().mDidExplicitlySetInterLine && + SelectionRef().IsCollapsed()) { + SetSelectionInterlinePosition(); + } + + return NS_OK; +} + +Result<EditActionResult, nsresult> HTMLEditor::CanHandleHTMLEditSubAction( + CheckSelectionInReplacedElement aCheckSelectionInReplacedElement + /* = CheckSelectionInReplacedElement::Yes */) const { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + + // If there is not selection ranges, we should ignore the result. + if (!SelectionRef().RangeCount()) { + return EditActionResult::CanceledResult(); + } + + const nsRange* range = SelectionRef().GetRangeAt(0); + nsINode* selStartNode = range->GetStartContainer(); + if (NS_WARN_IF(!selStartNode) || NS_WARN_IF(!selStartNode->IsContent())) { + return Err(NS_ERROR_FAILURE); + } + + if (!HTMLEditUtils::IsSimplyEditableNode(*selStartNode)) { + return EditActionResult::CanceledResult(); + } + + nsINode* selEndNode = range->GetEndContainer(); + if (NS_WARN_IF(!selEndNode) || NS_WARN_IF(!selEndNode->IsContent())) { + return Err(NS_ERROR_FAILURE); + } + + if (selStartNode == selEndNode) { + if (aCheckSelectionInReplacedElement == + CheckSelectionInReplacedElement::Yes && + HTMLEditUtils::IsNonEditableReplacedContent( + *selStartNode->AsContent())) { + return EditActionResult::CanceledResult(); + } + return EditActionResult::IgnoredResult(); + } + + if (HTMLEditUtils::IsNonEditableReplacedContent(*selStartNode->AsContent()) || + HTMLEditUtils::IsNonEditableReplacedContent(*selEndNode->AsContent())) { + return EditActionResult::CanceledResult(); + } + + if (!HTMLEditUtils::IsSimplyEditableNode(*selEndNode)) { + return EditActionResult::CanceledResult(); + } + + // If anchor node is in an HTML element which has inert attribute, we should + // do nothing. + // XXX HTMLEditor typically uses first range instead of anchor/focus range. + // Therefore, referring first range here is more reasonable than + // anchor/focus range of Selection. + nsIContent* const selAnchorContent = SelectionRef().GetDirection() == eDirNext + ? nsIContent::FromNode(selStartNode) + : nsIContent::FromNode(selEndNode); + if (selAnchorContent && + HTMLEditUtils::ContentIsInert(*selAnchorContent->AsContent())) { + return EditActionResult::CanceledResult(); + } + + // XXX What does it mean the common ancestor is editable? I have no idea. + // It should be in same (active) editing host, and even if it's editable, + // there may be non-editable contents in the range. + nsINode* commonAncestor = range->GetClosestCommonInclusiveAncestor(); + if (MOZ_UNLIKELY(!commonAncestor)) { + NS_WARNING( + "AbstractRange::GetClosestCommonInclusiveAncestor() returned nullptr"); + return Err(NS_ERROR_FAILURE); + } + return HTMLEditUtils::IsSimplyEditableNode(*commonAncestor) + ? EditActionResult::IgnoredResult() + : EditActionResult::CanceledResult(); +} + +MOZ_CAN_RUN_SCRIPT static nsStaticAtom& MarginPropertyAtomForIndent( + nsIContent& aContent) { + nsAutoString direction; + DebugOnly<nsresult> rvIgnored = CSSEditUtils::GetComputedProperty( + aContent, *nsGkAtoms::direction, direction); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetComputedProperty(nsGkAtoms::direction)" + " failed, but ignored"); + return direction.EqualsLiteral("rtl") ? *nsGkAtoms::marginRight + : *nsGkAtoms::marginLeft; +} + +nsresult HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(SelectionRef().IsCollapsed()); + + // If we are after a padding `<br>` element for empty last line in the same + // block, then move selection to be before it + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return NS_ERROR_FAILURE; + } + + EditorRawDOMPoint atSelectionStart(firstRange->StartRef()); + if (NS_WARN_IF(!atSelectionStart.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atSelectionStart.IsSetAndValid()); + + if (!atSelectionStart.IsInContentNode()) { + return NS_OK; + } + + Element* editingHost = ComputeEditingHost(); + if (!editingHost) { + NS_WARNING( + "HTMLEditor::EnsureCaretNotAfterInvisibleBRElement() did nothing " + "because of no editing host"); + return NS_OK; + } + + nsIContent* previousBRElement = + HTMLEditUtils::GetPreviousContent(atSelectionStart, {}, editingHost); + if (!previousBRElement || !previousBRElement->IsHTMLElement(nsGkAtoms::br) || + !previousBRElement->GetParent() || + !EditorUtils::IsEditableContent(*previousBRElement->GetParent(), + EditorType::HTML) || + !HTMLEditUtils::IsInvisibleBRElement(*previousBRElement)) { + return NS_OK; + } + + const RefPtr<const Element> blockElementAtSelectionStart = + HTMLEditUtils::GetInclusiveAncestorElement( + *atSelectionStart.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestBlockElement); + const RefPtr<const Element> parentBlockElementOfBRElement = + HTMLEditUtils::GetAncestorElement(*previousBRElement, + HTMLEditUtils::ClosestBlockElement); + + if (!blockElementAtSelectionStart || + blockElementAtSelectionStart != parentBlockElementOfBRElement) { + return NS_OK; + } + + // If we are here then the selection is right after a padding <br> + // element for empty last line that is in the same block as the + // selection. We need to move the selection start to be before the + // padding <br> element. + EditorRawDOMPoint atInvisibleBRElement(previousBRElement); + nsresult rv = CollapseSelectionTo(atInvisibleBRElement); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; +} + +nsresult HTMLEditor::MaybeCreatePaddingBRElementForEmptyEditor() { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (mPaddingBRElementForEmptyEditor) { + return NS_OK; + } + + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eCreatePaddingBRElementForEmptyEditor, + nsIEditor::eNone, 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(); + + RefPtr<Element> rootElement = GetRoot(); + if (!rootElement) { + return NS_OK; + } + + // Now we've got the body element. Iterate over the body element's children, + // looking for editable content. If no editable content is found, insert the + // padding <br> element. + EditorType editorType = GetEditorType(); + bool isRootEditable = + EditorUtils::IsEditableContent(*rootElement, editorType); + for (nsIContent* rootChild = rootElement->GetFirstChild(); rootChild; + rootChild = rootChild->GetNextSibling()) { + if (EditorUtils::IsPaddingBRElementForEmptyEditor(*rootChild) || + !isRootEditable || + EditorUtils::IsEditableContent(*rootChild, editorType) || + HTMLEditUtils::IsBlockElement(*rootChild)) { + return NS_OK; + } + } + + // Skip adding the padding <br> element for empty editor if body + // is read-only. + if (IsHTMLEditor() && !HTMLEditUtils::IsSimplyEditableNode(*rootElement)) { + return NS_OK; + } + + // Create a br. + RefPtr<Element> newBRElement = CreateHTMLContent(nsGkAtoms::br); + if (NS_WARN_IF(Destroyed())) { + return NS_ERROR_EDITOR_DESTROYED; + } + if (NS_WARN_IF(!newBRElement)) { + return NS_ERROR_FAILURE; + } + + mPaddingBRElementForEmptyEditor = + static_cast<HTMLBRElement*>(newBRElement.get()); + + // Give it a special attribute. + newBRElement->SetFlags(NS_PADDING_FOR_EMPTY_EDITOR); + + // Put the node in the document. + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertNodeWithTransaction<Element>(*newBRElement, + EditorDOMPoint(rootElement, 0u)); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("EditorBase::InsertNodeWithTransaction() failed"); + return insertBRElementResult.unwrapErr(); + } + + // Set selection. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + nsresult rv = CollapseSelectionToStartOf(*rootElement); + 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"); + return NS_OK; +} + +nsresult HTMLEditor::EnsureNoPaddingBRElementForEmptyEditor() { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (!mPaddingBRElementForEmptyEditor) { + return NS_OK; + } + + // If we're an HTML editor, a mutation event listener may recreate padding + // <br> element for empty editor again during the call of + // DeleteNodeWithTransaction(). So, move it first. + RefPtr<HTMLBRElement> paddingBRElement( + std::move(mPaddingBRElementForEmptyEditor)); + nsresult rv = DeleteNodeWithTransaction(*paddingBRElement); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::DeleteNodeWithTransaction() failed"); + return rv; +} + +nsresult HTMLEditor::ReflectPaddingBRElementForEmptyEditor() { + if (NS_WARN_IF(!mRootElement)) { + NS_WARNING("Failed to handle padding BR element due to no root element"); + return NS_ERROR_FAILURE; + } + // The idea here is to see if the magic empty node has suddenly reappeared. If + // it has, set our state so we remember it. There is a tradeoff between doing + // here and at redo, or doing it everywhere else that might care. Since undo + // and redo are relatively rare, it makes sense to take the (small) + // performance hit here. + nsIContent* firstLeafChild = HTMLEditUtils::GetFirstLeafContent( + *mRootElement, {LeafNodeType::OnlyLeafNode}); + if (firstLeafChild && + EditorUtils::IsPaddingBRElementForEmptyEditor(*firstLeafChild)) { + mPaddingBRElementForEmptyEditor = + static_cast<HTMLBRElement*>(firstLeafChild); + } else { + mPaddingBRElementForEmptyEditor = nullptr; + } + return NS_OK; +} + +nsresult HTMLEditor::PrepareInlineStylesForCaret() { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(SelectionRef().IsCollapsed()); + + // XXX This method works with the top level edit sub-action, but this + // must be wrong if we are handling nested edit action. + + if (TopLevelEditSubActionDataRef().mDidDeleteSelection) { + switch (GetTopLevelEditSubAction()) { + case EditSubAction::eInsertText: + case EditSubAction::eInsertTextComingFromIME: + case EditSubAction::eDeleteSelectedContent: { + nsresult rv = ReapplyCachedStyles(); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::ReapplyCachedStyles() failed"); + return rv; + } + break; + } + default: + break; + } + } + // For most actions we want to clear the cached styles, but there are + // exceptions + if (!IsPendingStyleCachePreservingSubAction(GetTopLevelEditSubAction())) { + TopLevelEditSubActionDataRef().mCachedPendingStyles->Clear(); + } + return NS_OK; +} + +Result<EditActionResult, nsresult> HTMLEditor::HandleInsertText( + EditSubAction aEditSubAction, const nsAString& aInsertionString, + SelectionHandling aSelectionHandling) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(aEditSubAction == EditSubAction::eInsertText || + aEditSubAction == EditSubAction::eInsertTextComingFromIME); + MOZ_ASSERT_IF(aSelectionHandling == SelectionHandling::Ignore, + aEditSubAction == EditSubAction::eInsertTextComingFromIME); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + UndefineCaretBidiLevel(); + + // If the selection isn't collapsed, delete it. Don't delete existing inline + // tags, because we're hopefully going to insert text (bug 787432). + if (!SelectionRef().IsCollapsed() && + aSelectionHandling == SelectionHandling::Delete) { + nsresult rv = + DeleteSelectionAsSubAction(nsIEditor::eNone, nsIEditor::eNoStrip); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::DeleteSelectionAsSubAction(nsIEditor::eNone, " + "nsIEditor::eNoStrip) failed"); + return Err(rv); + } + } + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + RefPtr<Document> document = GetDocument(); + if (NS_WARN_IF(!document)) { + return Err(NS_ERROR_FAILURE); + } + + const RefPtr<Element> editingHost = ComputeEditingHost( + GetDocument()->IsXMLDocument() ? LimitInBodyElement::No + : LimitInBodyElement::Yes); + if (NS_WARN_IF(!editingHost)) { + return Err(NS_ERROR_FAILURE); + } + + auto pointToInsert = GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (MOZ_UNLIKELY(!pointToInsert.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + + // for every property that is set, insert a new inline style node + Result<EditorDOMPoint, nsresult> setStyleResult = + CreateStyleForInsertText(pointToInsert, *editingHost); + if (MOZ_UNLIKELY(setStyleResult.isErr())) { + NS_WARNING("HTMLEditor::CreateStyleForInsertText() failed"); + return setStyleResult.propagateErr(); + } + if (setStyleResult.inspect().IsSet()) { + pointToInsert = setStyleResult.unwrap(); + } + + if (NS_WARN_IF(!pointToInsert.IsSetAndValid()) || + NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_FAILURE); + } + MOZ_ASSERT(pointToInsert.IsSetAndValid()); + + // If the point is not in an element which can contain text nodes, climb up + // the DOM tree. + if (!pointToInsert.IsInTextNode()) { + while (!HTMLEditUtils::CanNodeContain(*pointToInsert.GetContainer(), + *nsGkAtoms::textTagName)) { + if (NS_WARN_IF(pointToInsert.GetContainer() == editingHost) || + NS_WARN_IF(!pointToInsert.GetContainerParentAs<nsIContent>())) { + NS_WARNING("Selection start point couldn't have text nodes"); + return Err(NS_ERROR_FAILURE); + } + pointToInsert.Set(pointToInsert.ContainerAs<nsIContent>()); + } + } + + if (aEditSubAction == EditSubAction::eInsertTextComingFromIME) { + auto compositionStartPoint = + GetFirstIMESelectionStartPoint<EditorDOMPoint>(); + if (!compositionStartPoint.IsSet()) { + compositionStartPoint = pointToInsert; + } + + if (aInsertionString.IsEmpty()) { + // Right now the WhiteSpaceVisibilityKeeper code bails on empty strings, + // but IME needs the InsertTextWithTransaction() call to still happen + // since empty strings are meaningful there. + Result<InsertTextResult, nsresult> insertTextResult = + InsertTextWithTransaction(*document, aInsertionString, + compositionStartPoint); + if (MOZ_UNLIKELY(insertTextResult.isErr())) { + NS_WARNING("HTMLEditor::InsertTextWithTransaction() failed"); + return insertTextResult.propagateErr(); + } + nsresult rv = insertTextResult.unwrap().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CaretPoint::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CaretPoint::SuggestCaretPointTo() failed, but ignored"); + return EditActionResult::HandledResult(); + } + + auto compositionEndPoint = GetLastIMESelectionEndPoint<EditorDOMPoint>(); + if (!compositionEndPoint.IsSet()) { + compositionEndPoint = compositionStartPoint; + } + Result<InsertTextResult, nsresult> replaceTextResult = + WhiteSpaceVisibilityKeeper::ReplaceText( + *this, aInsertionString, + EditorDOMRange(compositionStartPoint, compositionEndPoint), + *editingHost); + if (MOZ_UNLIKELY(replaceTextResult.isErr())) { + NS_WARNING("WhiteSpaceVisibilityKeeper::ReplaceText() failed"); + return replaceTextResult.propagateErr(); + } + // CompositionTransaction should've set selection so that we should ignore + // caret suggestion. + replaceTextResult.unwrap().IgnoreCaretPointSuggestion(); + + compositionStartPoint = GetFirstIMESelectionStartPoint<EditorDOMPoint>(); + compositionEndPoint = GetLastIMESelectionEndPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!compositionStartPoint.IsSet()) || + NS_WARN_IF(!compositionEndPoint.IsSet())) { + // Mutation event listener has changed the DOM tree... + return EditActionResult::HandledResult(); + } + nsresult rv = TopLevelEditSubActionDataRef().mChangedRange->SetStartAndEnd( + compositionStartPoint.ToRawRangeBoundary(), + compositionEndPoint.ToRawRangeBoundary()); + if (NS_FAILED(rv)) { + NS_WARNING("nsRange::SetStartAndEnd() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + + MOZ_ASSERT(aEditSubAction == EditSubAction::eInsertText); + + // find where we are + EditorDOMPoint currentPoint(pointToInsert); + + // is our text going to be PREformatted? + // We remember this so that we know how to handle tabs. + const bool isWhiteSpaceCollapsible = !EditorUtils::IsWhiteSpacePreformatted( + *pointToInsert.ContainerAs<nsIContent>()); + + // turn off the edit listener: we know how to + // build the "doc changed range" ourselves, and it's + // must faster to do it once here than to track all + // the changes one at a time. + AutoRestore<bool> disableListener( + EditSubActionDataRef().mAdjustChangedRangeFromListener); + EditSubActionDataRef().mAdjustChangedRangeFromListener = false; + + // don't change my selection in subtransactions + AutoTransactionsConserveSelection dontChangeMySelection(*this); + int32_t pos = 0; + constexpr auto newlineStr = NS_LITERAL_STRING_FROM_CSTRING(LFSTR); + + { + AutoTrackDOMPoint tracker(RangeUpdaterRef(), &pointToInsert); + + // for efficiency, break out the pre case separately. This is because + // its a lot cheaper to search the input string for only newlines than + // it is to search for both tabs and newlines. + if (!isWhiteSpaceCollapsible || IsInPlaintextMode()) { + while (pos != -1 && + pos < AssertedCast<int32_t>(aInsertionString.Length())) { + int32_t oldPos = pos; + int32_t subStrLen; + pos = aInsertionString.FindChar(nsCRT::LF, oldPos); + + if (pos != -1) { + subStrLen = pos - oldPos; + // if first char is newline, then use just it + if (!subStrLen) { + subStrLen = 1; + } + } else { + subStrLen = aInsertionString.Length() - oldPos; + pos = aInsertionString.Length(); + } + + nsDependentSubstring subStr(aInsertionString, oldPos, subStrLen); + + // is it a return? + if (subStr.Equals(newlineStr)) { + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, currentPoint); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // We don't want to update selection here because we've blocked + // InsertNodeTransaction updating selection with + // dontChangeMySelection. + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(!AllowsTransactionsToChangeSelection()); + + pos++; + RefPtr<Element> brElement = + unwrappedInsertBRElementResult.UnwrapNewNode(); + if (brElement->GetNextSibling()) { + pointToInsert.Set(brElement->GetNextSibling()); + } else { + pointToInsert.SetToEndOf(currentPoint.GetContainer()); + } + // XXX In most cases, pointToInsert and currentPoint are same here. + // But if the <br> element has been moved to different point by + // mutation observer, those points become different. + currentPoint.SetAfter(brElement); + NS_WARNING_ASSERTION(currentPoint.IsSet(), + "Failed to set after the <br> element"); + NS_WARNING_ASSERTION(currentPoint == pointToInsert, + "Perhaps, <br> element position has been moved " + "to different point " + "by mutation observer"); + } else { + Result<InsertTextResult, nsresult> insertTextResult = + InsertTextWithTransaction(*document, subStr, currentPoint); + if (MOZ_UNLIKELY(insertTextResult.isErr())) { + NS_WARNING("HTMLEditor::InsertTextWithTransaction() failed"); + return insertTextResult.propagateErr(); + } + // Ignore the caret suggestion because of `dontChangeMySelection` + // above. + insertTextResult.inspect().IgnoreCaretPointSuggestion(); + if (insertTextResult.inspect().Handled()) { + pointToInsert = currentPoint = insertTextResult.unwrap() + .EndOfInsertedTextRef() + .To<EditorDOMPoint>(); + } else { + pointToInsert = currentPoint; + } + } + } + } else { + constexpr auto tabStr = u"\t"_ns; + constexpr auto spacesStr = u" "_ns; + nsAutoString insertionString(aInsertionString); // For FindCharInSet(). + while (pos != -1 && + pos < AssertedCast<int32_t>(insertionString.Length())) { + int32_t oldPos = pos; + int32_t subStrLen; + pos = insertionString.FindCharInSet(u"\t\n", oldPos); + + if (pos != -1) { + subStrLen = pos - oldPos; + // if first char is newline, then use just it + if (!subStrLen) { + subStrLen = 1; + } + } else { + subStrLen = insertionString.Length() - oldPos; + pos = insertionString.Length(); + } + + nsDependentSubstring subStr(insertionString, oldPos, subStrLen); + + // is it a tab? + if (subStr.Equals(tabStr)) { + Result<InsertTextResult, nsresult> insertTextResult = + WhiteSpaceVisibilityKeeper::InsertText( + *this, spacesStr, currentPoint, *editingHost); + if (MOZ_UNLIKELY(insertTextResult.isErr())) { + NS_WARNING("WhiteSpaceVisibilityKeeper::InsertText() failed"); + return insertTextResult.propagateErr(); + } + // Ignore the caret suggestion because of `dontChangeMySelection` + // above. + insertTextResult.inspect().IgnoreCaretPointSuggestion(); + pos++; + if (insertTextResult.inspect().Handled()) { + pointToInsert = currentPoint = insertTextResult.unwrap() + .EndOfInsertedTextRef() + .To<EditorDOMPoint>(); + MOZ_ASSERT(pointToInsert.IsSet()); + } else { + pointToInsert = currentPoint; + MOZ_ASSERT(pointToInsert.IsSet()); + } + } + // is it a return? + else if (subStr.Equals(newlineStr)) { + Result<CreateElementResult, nsresult> insertBRElementResult = + WhiteSpaceVisibilityKeeper::InsertBRElement(*this, currentPoint, + *editingHost); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("WhiteSpaceVisibilityKeeper::InsertBRElement() failed"); + return insertBRElementResult.propagateErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // TODO: Some methods called for handling non-preformatted text use + // ComputeEditingHost(). Therefore, they depend on the latest + // selection. So we cannot skip updating selection here. + nsresult rv = unwrappedInsertBRElementResult.SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CreateElementResult::SuggestCaretPointTo() failed, but ignored"); + pos++; + RefPtr<Element> newBRElement = + unwrappedInsertBRElementResult.UnwrapNewNode(); + MOZ_DIAGNOSTIC_ASSERT(newBRElement); + if (newBRElement->GetNextSibling()) { + pointToInsert.Set(newBRElement->GetNextSibling()); + } else { + pointToInsert.SetToEndOf(currentPoint.GetContainer()); + } + currentPoint.SetAfter(newBRElement); + NS_WARNING_ASSERTION(currentPoint.IsSet(), + "Failed to set after the new <br> element"); + // XXX If the newBRElement has been moved or removed by mutation + // observer, we hit this assert. We need to check if + // newBRElement is in expected point, though, we must have + // a lot of same bugs... + NS_WARNING_ASSERTION( + currentPoint == pointToInsert, + "Perhaps, newBRElement has been moved or removed unexpectedly"); + } else { + Result<InsertTextResult, nsresult> insertTextResult = + WhiteSpaceVisibilityKeeper::InsertText( + *this, subStr, currentPoint, *editingHost); + if (MOZ_UNLIKELY(insertTextResult.isErr())) { + NS_WARNING("WhiteSpaceVisibilityKeeper::InsertText() failed"); + return insertTextResult.propagateErr(); + } + // Ignore the caret suggestion because of `dontChangeMySelection` + // above. + insertTextResult.inspect().IgnoreCaretPointSuggestion(); + if (insertTextResult.inspect().Handled()) { + pointToInsert = currentPoint = insertTextResult.unwrap() + .EndOfInsertedTextRef() + .To<EditorDOMPoint>(); + MOZ_ASSERT(pointToInsert.IsSet()); + } else { + pointToInsert = currentPoint; + MOZ_ASSERT(pointToInsert.IsSet()); + } + } + } + } + + // After this block, pointToInsert is updated by AutoTrackDOMPoint. + } + + if (currentPoint.IsSet()) { + currentPoint.SetInterlinePosition(InterlinePosition::EndOfLine); + nsresult rv = CollapseSelectionTo(currentPoint); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "Selection::Collapse() failed, but ignored"); + + // manually update the doc changed range so that AfterEdit will clean up + // the correct portion of the document. + rv = TopLevelEditSubActionDataRef().mChangedRange->SetStartAndEnd( + pointToInsert.ToRawRangeBoundary(), currentPoint.ToRawRangeBoundary()); + if (NS_FAILED(rv)) { + NS_WARNING("nsRange::SetStartAndEnd() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + + DebugOnly<nsresult> rvIgnored = + SelectionRef().SetInterlinePosition(InterlinePosition::EndOfLine); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "EndOfLine) failed, but ignored"); + rv = TopLevelEditSubActionDataRef().mChangedRange->CollapseTo(pointToInsert); + if (NS_FAILED(rv)) { + NS_WARNING("nsRange::CollapseTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::InsertLineBreakAsSubAction() { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); + + if (NS_WARN_IF(!mInitSucceeded)) { + return NS_ERROR_NOT_INITIALIZED; + } + + { + 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; + } + } + + // XXX This may be called by execCommand() with "insertLineBreak". + // In such case, naming the transaction "TypingTxnName" is odd. + AutoPlaceholderBatch treatAsOneTransaction(*this, *nsGkAtoms::TypingTxnName, + ScrollSelectionIntoView::Yes, + __FUNCTION__); + + // calling it text insertion to trigger moz br treatment by rules + // XXX Why do we use EditSubAction::eInsertText here? Looks like + // EditSubAction::eInsertLineBreak or EditSubAction::eInsertNode + // is better. + 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(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + UndefineCaretBidiLevel(); + + // If the selection isn't collapsed, delete it. + if (!SelectionRef().IsCollapsed()) { + nsresult rv = + DeleteSelectionAsSubAction(nsIEditor::eNone, nsIEditor::eStrip); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::DeleteSelectionAsSubAction(eNone, eStrip) failed"); + return rv; + } + } + + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return NS_ERROR_FAILURE; + } + + EditorDOMPoint atStartOfSelection(firstRange->StartRef()); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atStartOfSelection.IsSetAndValid()); + + RefPtr<Element> editingHost = ComputeEditingHost(); + if (NS_WARN_IF(!editingHost)) { + return NS_ERROR_FAILURE; + } + + // For backward compatibility, we should not insert a linefeed if + // paragraph separator is set to "br" which is Gecko-specific mode. + if (GetDefaultParagraphSeparator() == ParagraphSeparator::br || + !HTMLEditUtils::ShouldInsertLinefeedCharacter(atStartOfSelection, + *editingHost)) { + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, atStartOfSelection, + nsIEditor::eNext); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.unwrapErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + MOZ_ASSERT(unwrappedInsertBRElementResult.GetNewNode()); + // Next inserting text should be inserted into styled inline elements if + // they have first visible thing in the new line. + auto pointToPutCaret = [&]() -> EditorDOMPoint { + WSScanResult forwardScanResult = + WSRunScanner::ScanNextVisibleNodeOrBlockBoundary( + editingHost, EditorRawDOMPoint::After( + *unwrappedInsertBRElementResult.GetNewNode())); + if (forwardScanResult.InVisibleOrCollapsibleCharacters()) { + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + return forwardScanResult.Point<EditorDOMPoint>(); + } + if (forwardScanResult.ReachedSpecialContent()) { + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + return forwardScanResult.PointAtContent<EditorDOMPoint>(); + } + return unwrappedInsertBRElementResult.UnwrapCaretPoint(); + }(); + + nsresult rv = CollapseSelectionTo(pointToPutCaret); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "CreateElementResult::SuggestCaretPointTo() failed"); + return rv; + } + + 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"); + } + } + + firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return NS_ERROR_FAILURE; + } + + atStartOfSelection = EditorDOMPoint(firstRange->StartRef()); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atStartOfSelection.IsSetAndValid()); + + // Do nothing if the node is read-only + if (!HTMLEditUtils::IsSimplyEditableNode( + *atStartOfSelection.GetContainer())) { + return NS_SUCCESS_DOM_NO_OPERATION; + } + + Result<EditorDOMPoint, nsresult> insertLineFeedResult = + HandleInsertLinefeed(atStartOfSelection, *editingHost); + if (MOZ_UNLIKELY(insertLineFeedResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertLinefeed() failed"); + return insertLineFeedResult.unwrapErr(); + } + rv = CollapseSelectionTo(insertLineFeedResult.inspect()); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; +} + +Result<EditActionResult, nsresult> +HTMLEditor::InsertParagraphSeparatorAsSubAction(const Element& aEditingHost) { + if (NS_WARN_IF(!mInitSucceeded)) { + return Err(NS_ERROR_NOT_INITIALIZED); + } + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction( + CheckSelectionInReplacedElement::OnlyWhenNotInSameNode); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + // XXX This may be called by execCommand() with "insertParagraph". + // In such case, naming the transaction "TypingTxnName" is odd. + AutoPlaceholderBatch treatAsOneTransaction(*this, *nsGkAtoms::TypingTxnName, + ScrollSelectionIntoView::Yes, + __FUNCTION__); + + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eInsertParagraphSeparator, nsIEditor::eNext, + ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + UndefineCaretBidiLevel(); + + // If the selection isn't collapsed, delete it. + if (!SelectionRef().IsCollapsed()) { + nsresult rv = + DeleteSelectionAsSubAction(nsIEditor::eNone, nsIEditor::eStrip); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::DeleteSelectionAsSubAction(eNone, eStrip) failed"); + return Err(rv); + } + } + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + AutoRangeArray selectionRanges(SelectionRef()); + { + // If the editing host is the body element, the selection may be outside + // aEditingHost. In the case, we should use the editing host outside the + // <body> only here for keeping our traditional behavior for now. + // This should be fixed in bug 1634351. + const Element* editingHostMaybeOutsideBody = &aEditingHost; + if (aEditingHost.IsHTMLElement(nsGkAtoms::body)) { + editingHostMaybeOutsideBody = ComputeEditingHost(LimitInBodyElement::No); + if (NS_WARN_IF(!editingHostMaybeOutsideBody)) { + return Err(NS_ERROR_FAILURE); + } + } + selectionRanges.EnsureOnlyEditableRanges(*editingHostMaybeOutsideBody); + if (NS_WARN_IF(selectionRanges.Ranges().IsEmpty())) { + return Err(NS_ERROR_FAILURE); + } + } + + auto pointToInsert = + selectionRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_FAILURE); + } + while (true) { + Element* element = pointToInsert.GetContainerOrContainerParentElement(); + if (MOZ_UNLIKELY(!element)) { + return Err(NS_ERROR_FAILURE); + } + // If the element can have a <br> element (it means that the element or its + // container must be able to have <div> or <p> too), we can handle + // insertParagraph at the point. + if (HTMLEditUtils::CanNodeContain(*element, *nsGkAtoms::br)) { + break; + } + // Otherwise, try to insert paragraph at the parent. + pointToInsert = pointToInsert.ParentPoint(); + } + + if (IsMailEditor()) { + if (RefPtr<Element> mailCiteElement = GetMostDistantAncestorMailCiteElement( + *pointToInsert.ContainerAs<nsIContent>())) { + // Split any mailcites in the way. Should we abort this if we encounter + // table cell boundaries? + Result<EditorDOMPoint, nsresult> atNewBRElementOrError = + HandleInsertParagraphInMailCiteElement(*mailCiteElement, + pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(atNewBRElementOrError.isErr())) { + NS_WARNING( + "HTMLEditor::HandleInsertParagraphInMailCiteElement() failed"); + return atNewBRElementOrError.propagateErr(); + } + EditorDOMPoint pointToPutCaret = atNewBRElementOrError.unwrap(); + MOZ_ASSERT(pointToPutCaret.IsSet()); + pointToPutCaret.SetInterlinePosition(InterlinePosition::StartOfNextLine); + MOZ_ASSERT(pointToPutCaret.GetChild()); + MOZ_ASSERT(pointToPutCaret.GetChild()->IsHTMLElement(nsGkAtoms::br)); + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + } + + // If the active editing host is an inline element, or if the active editing + // host is the block parent itself and we're configured to use <br> as a + // paragraph separator, just append a <br>. + // If the editing host parent element is editable, it means that the editing + // host must be a <body> element and the selection may be outside the body + // element. If the selection is outside the editing host, we should not + // insert new paragraph nor <br> element. + // XXX Currently, we don't support editing outside <body> element, but Blink + // does it. + if (aEditingHost.GetParentElement() && + HTMLEditUtils::IsSimplyEditableNode(*aEditingHost.GetParentElement()) && + !nsContentUtils::ContentIsFlattenedTreeDescendantOf( + pointToInsert.ContainerAs<nsIContent>(), &aEditingHost)) { + return Err(NS_ERROR_EDITOR_NO_EDITABLE_RANGE); + } + + auto InsertLineBreakInstead = + [](const Element* aEditableBlockElement, + const EditorDOMPoint& aCandidatePointToSplit, + ParagraphSeparator aDefaultParagraphSeparator, + const Element& aEditingHost) { + // If there is no block parent in the editing host, i.e., the editing + // host itself is also a non-block element, we should insert a line + // break. + if (!aEditableBlockElement) { + // XXX Chromium checks if the CSS box of the editing host is a block. + return true; + } + + // If the editable block element is not splittable, e.g., it's an + // editing host, and the default paragraph separator is <br> or the + // element cannot contain a <p> element, we should insert a <br> + // element. + if (!HTMLEditUtils::IsSplittableNode(*aEditableBlockElement)) { + return aDefaultParagraphSeparator == ParagraphSeparator::br || + !HTMLEditUtils::CanElementContainParagraph(aEditingHost) || + HTMLEditUtils::ShouldInsertLinefeedCharacter( + aCandidatePointToSplit, aEditingHost); + } + + // If the nearest block parent is a single-line container declared in + // the execCommand spec and not the editing host, we should separate the + // block even if the default paragraph separator is <br> element. + if (HTMLEditUtils::IsSingleLineContainer(*aEditableBlockElement)) { + return false; + } + + // Otherwise, unless there is no block ancestor which can contain <p> + // element, we shouldn't insert a line break here. + for (const Element* editableBlockAncestor = aEditableBlockElement; + editableBlockAncestor; + editableBlockAncestor = HTMLEditUtils::GetAncestorElement( + *editableBlockAncestor, + HTMLEditUtils::ClosestEditableBlockElementOrButtonElement)) { + if (HTMLEditUtils::CanElementContainParagraph( + *editableBlockAncestor)) { + return false; + } + } + return true; + }; + + // Look for the nearest parent block. However, don't return error even if + // there is no block parent here because in such case, i.e., editing host + // is an inline element, we should insert <br> simply. + RefPtr<Element> editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *pointToInsert.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestEditableBlockElementOrButtonElement); + + // If we cannot insert a <p>/<div> element at the selection, we should insert + // a <br> element or a linefeed instead. + const ParagraphSeparator separator = GetDefaultParagraphSeparator(); + if (InsertLineBreakInstead(editableBlockElement, pointToInsert, separator, + aEditingHost)) { + // For backward compatibility, we should not insert a linefeed if + // paragraph separator is set to "br" which is Gecko-specific mode. + if (separator != ParagraphSeparator::br && + HTMLEditUtils::ShouldInsertLinefeedCharacter(pointToInsert, + aEditingHost)) { + Result<EditorDOMPoint, nsresult> insertLineFeedResult = + HandleInsertLinefeed(pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(insertLineFeedResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertLinefeed() failed"); + return insertLineFeedResult.propagateErr(); + } + nsresult rv = CollapseSelectionTo(insertLineFeedResult.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + + Result<CreateElementResult, nsresult> insertBRElementResult = + HandleInsertBRElement(pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertBRElement() failed"); + return insertBRElementResult.propagateErr(); + } + nsresult rv = + insertBRElementResult.inspect().SuggestCaretPointTo(*this, {}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + + // If somebody wants to restrict caret position in a block element below, + // we should guarantee it. Otherwise, we can put caret to the candidate + // point. + auto CollapseSelection = + [this](const EditorDOMPoint& aCandidatePointToPutCaret, + const Element* aBlockElementShouldHaveCaret, + const SuggestCaretOptions& aOptions) + MOZ_CAN_RUN_SCRIPT -> nsresult { + if (!aCandidatePointToPutCaret.IsSet()) { + if (aOptions.contains(SuggestCaret::OnlyIfHasSuggestion)) { + return NS_OK; + } + return aOptions.contains(SuggestCaret::AndIgnoreTrivialError) + ? NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR + : NS_ERROR_FAILURE; + } + EditorDOMPoint pointToPutCaret(aCandidatePointToPutCaret); + if (aBlockElementShouldHaveCaret) { + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorDOMPoint>(*aBlockElementShouldHaveCaret, + aCandidatePointToPutCaret); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditUtils::ComputePointToPutCaretInElementIfOutside() " + "failed, but ignored"); + } else if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv) && MOZ_LIKELY(rv != NS_ERROR_EDITOR_DESTROYED) && + aOptions.contains(SuggestCaret::AndIgnoreTrivialError)) { + rv = NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR; + } + return rv; + }; + + RefPtr<Element> blockElementToPutCaret; + // If the default paragraph separator is not <br> and selection is not in + // a splittable block element, we should wrap selected contents in a new + // paragraph, then, split it. + if (!HTMLEditUtils::IsSplittableNode(*editableBlockElement) && + separator != ParagraphSeparator::br) { + MOZ_ASSERT(separator == ParagraphSeparator::div || + separator == ParagraphSeparator::p); + Result<RefPtr<Element>, nsresult> suggestBlockElementToPutCaretOrError = + FormatBlockContainerWithTransaction( + selectionRanges, + MOZ_KnownLive(HTMLEditor::ToParagraphSeparatorTagName(separator)), + aEditingHost); + if (MOZ_UNLIKELY(suggestBlockElementToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::FormatBlockContainerWithTransaction() failed"); + return suggestBlockElementToPutCaretOrError.propagateErr(); + } + if (selectionRanges.HasSavedRanges()) { + selectionRanges.RestoreFromSavedRanges(); + } + pointToInsert = selectionRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + MOZ_ASSERT(pointToInsert.IsSetAndValid()); + blockElementToPutCaret = suggestBlockElementToPutCaretOrError.unwrap(); + + editableBlockElement = HTMLEditUtils::GetInclusiveAncestorElement( + *pointToInsert.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestEditableBlockElementOrButtonElement); + if (NS_WARN_IF(!editableBlockElement)) { + return Err(NS_ERROR_UNEXPECTED); + } + if (NS_WARN_IF(!HTMLEditUtils::IsSplittableNode(*editableBlockElement))) { + // Didn't create a new block for some reason, fall back to <br> + Result<CreateElementResult, nsresult> insertBRElementResult = + HandleInsertBRElement(pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertBRElement() failed"); + return insertBRElementResult.propagateErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + EditorDOMPoint pointToPutCaret = + unwrappedInsertBRElementResult.UnwrapCaretPoint(); + if (MOZ_UNLIKELY(!pointToPutCaret.IsSet())) { + NS_WARNING( + "HTMLEditor::HandleInsertBRElement() didn't suggest a point to put " + "caret"); + return Err(NS_ERROR_FAILURE); + } + nsresult rv = + CollapseSelection(pointToPutCaret, blockElementToPutCaret, {}); + if (NS_FAILED(rv)) { + NS_WARNING("CollapseSelection() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + // We want to collapse selection in the editable block element. + blockElementToPutCaret = editableBlockElement; + } + + // If block is empty, populate with br. (For example, imagine a div that + // contains the word "text". The user selects "text" and types return. + // "Text" is deleted leaving an empty block. We want to put in one br to + // make block have a line. Then code further below will put in a second br.) + RefPtr<Element> insertedPaddingBRElement; + if (HTMLEditUtils::IsEmptyBlockElement( + *editableBlockElement, + {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, + EditorDOMPoint::AtEndOf(*editableBlockElement)); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedInsertBRElementResult.GetNewNode()); + insertedPaddingBRElement = unwrappedInsertBRElementResult.UnwrapNewNode(); + + pointToInsert = selectionRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + } + + RefPtr<Element> maybeNonEditableListItem = + HTMLEditUtils::GetClosestAncestorListItemElement(*editableBlockElement, + &aEditingHost); + if (maybeNonEditableListItem && + HTMLEditUtils::IsSplittableNode(*maybeNonEditableListItem)) { + Result<InsertParagraphResult, nsresult> insertParagraphInListItemResult = + HandleInsertParagraphInListItemElement(*maybeNonEditableListItem, + pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(insertParagraphInListItemResult.isErr())) { + if (NS_WARN_IF(insertParagraphInListItemResult.unwrapErr() == + NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::HandleInsertParagraphInListItemElement() failed, but " + "ignored"); + return EditActionResult::HandledResult(); + } + InsertParagraphResult unwrappedInsertParagraphInListItemResult = + insertParagraphInListItemResult.unwrap(); + MOZ_ASSERT(unwrappedInsertParagraphInListItemResult.Handled()); + MOZ_ASSERT(unwrappedInsertParagraphInListItemResult.GetNewNode()); + const RefPtr<Element> listItemOrParagraphElement = + unwrappedInsertParagraphInListItemResult.UnwrapNewNode(); + const EditorDOMPoint pointToPutCaret = + unwrappedInsertParagraphInListItemResult.UnwrapCaretPoint(); + nsresult rv = CollapseSelection(pointToPutCaret, listItemOrParagraphElement, + {SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CollapseSelection() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION(rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CollapseSelection() failed, but ignored"); + return EditActionResult::HandledResult(); + } + + if (HTMLEditUtils::IsHeader(*editableBlockElement)) { + Result<InsertParagraphResult, nsresult> + insertParagraphInHeadingElementResult = + HandleInsertParagraphInHeadingElement(*editableBlockElement, + pointToInsert); + if (MOZ_UNLIKELY(insertParagraphInHeadingElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::HandleInsertParagraphInHeadingElement() failed, but " + "ignored"); + return EditActionResult::HandledResult(); + } + InsertParagraphResult unwrappedInsertParagraphInHeadingElementResult = + insertParagraphInHeadingElementResult.unwrap(); + if (unwrappedInsertParagraphInHeadingElementResult.Handled()) { + MOZ_ASSERT(unwrappedInsertParagraphInHeadingElementResult.GetNewNode()); + blockElementToPutCaret = + unwrappedInsertParagraphInHeadingElementResult.UnwrapNewNode(); + } + const EditorDOMPoint pointToPutCaret = + unwrappedInsertParagraphInHeadingElementResult.UnwrapCaretPoint(); + nsresult rv = CollapseSelection(pointToPutCaret, blockElementToPutCaret, + {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CollapseSelection() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION(rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CollapseSelection() failed, but ignored"); + return EditActionResult::HandledResult(); + } + + // XXX Ideally, we should take same behavior with both <p> container and + // <div> container. However, we are still using <br> as default + // paragraph separator (non-standard) and we've split only <p> container + // long time. Therefore, some web apps may depend on this behavior like + // Gmail. So, let's use traditional odd behavior only when the default + // paragraph separator is <br>. Otherwise, take consistent behavior + // between <p> container and <div> container. + if ((separator == ParagraphSeparator::br && + editableBlockElement->IsHTMLElement(nsGkAtoms::p)) || + (separator != ParagraphSeparator::br && + editableBlockElement->IsAnyOfHTMLElements(nsGkAtoms::p, + nsGkAtoms::div))) { + // Paragraphs: special rules to look for <br>s + Result<SplitNodeResult, nsresult> splitNodeResult = + HandleInsertParagraphInParagraph( + *editableBlockElement, + insertedPaddingBRElement ? EditorDOMPoint(insertedPaddingBRElement) + : pointToInsert, + aEditingHost); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertParagraphInParagraph() failed"); + return splitNodeResult.propagateErr(); + } + if (splitNodeResult.inspect().Handled()) { + SplitNodeResult unwrappedSplitNodeResult = splitNodeResult.unwrap(); + const RefPtr<Element> rightParagraphElement = + unwrappedSplitNodeResult.DidSplit() + ? unwrappedSplitNodeResult.GetNextContentAs<Element>() + : blockElementToPutCaret.get(); + const EditorDOMPoint pointToPutCaret = + unwrappedSplitNodeResult.UnwrapCaretPoint(); + nsresult rv = CollapseSelection(pointToPutCaret, rightParagraphElement, + {SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CollapseSelection() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION(rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CollapseSelection() failed, but ignored"); + return EditActionResult::HandledResult(); + } + MOZ_ASSERT(!splitNodeResult.inspect().HasCaretPointSuggestion()); + + // Fall through, if HandleInsertParagraphInParagraph() didn't handle it. + MOZ_ASSERT(pointToInsert.IsSetAndValid(), + "HTMLEditor::HandleInsertParagraphInParagraph() shouldn't touch " + "the DOM tree if it returns not-handled state"); + } + + // If nobody handles this edit action, let's insert new <br> at the selection. + Result<CreateElementResult, nsresult> insertBRElementResult = + HandleInsertBRElement(pointToInsert, aEditingHost); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::HandleInsertBRElement() failed"); + return insertBRElementResult.propagateErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + EditorDOMPoint pointToPutCaret = + unwrappedInsertBRElementResult.UnwrapCaretPoint(); + rv = CollapseSelection(pointToPutCaret, blockElementToPutCaret, {}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); +} + +Result<CreateElementResult, nsresult> HTMLEditor::HandleInsertBRElement( + const EditorDOMPoint& aPointToBreak, const Element& aEditingHost) { + MOZ_ASSERT(aPointToBreak.IsSet()); + MOZ_ASSERT(IsEditActionDataAvailable()); + + bool brElementIsAfterBlock = false, brElementIsBeforeBlock = false; + + // First, insert a <br> element. + RefPtr<Element> brElement; + if (IsInPlaintextMode()) { + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, aPointToBreak); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult; + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // We'll return with suggesting new caret position and nobody refers + // selection after here. So we don't need to update selection here. + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedInsertBRElementResult.GetNewNode()); + brElement = unwrappedInsertBRElementResult.UnwrapNewNode(); + } else { + EditorDOMPoint pointToBreak(aPointToBreak); + WSRunScanner wsRunScanner(&aEditingHost, pointToBreak); + WSScanResult backwardScanResult = + wsRunScanner.ScanPreviousVisibleNodeOrBlockBoundaryFrom(pointToBreak); + if (MOZ_UNLIKELY(backwardScanResult.Failed())) { + NS_WARNING( + "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundaryFrom() failed"); + return Err(NS_ERROR_FAILURE); + } + brElementIsAfterBlock = backwardScanResult.ReachedBlockBoundary(); + WSScanResult forwardScanResult = + wsRunScanner.ScanNextVisibleNodeOrBlockBoundaryFrom(pointToBreak); + if (MOZ_UNLIKELY(forwardScanResult.Failed())) { + NS_WARNING( + "WSRunScanner::ScanNextVisibleNodeOrBlockBoundaryFrom() failed"); + return Err(NS_ERROR_FAILURE); + } + brElementIsBeforeBlock = forwardScanResult.ReachedBlockBoundary(); + // If the container of the break is a link, we need to split it and + // insert new <br> between the split links. + RefPtr<Element> linkNode = + HTMLEditor::GetLinkElement(pointToBreak.GetContainer()); + if (linkNode) { + Result<SplitNodeResult, nsresult> splitLinkNodeResult = + SplitNodeDeepWithTransaction( + *linkNode, pointToBreak, + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitLinkNodeResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) failed"); + return splitLinkNodeResult.propagateErr(); + } + // TODO: Some methods called by + // WhiteSpaceVisibilityKeeper::InsertBRElement() use + // ComputeEditingHost() which depends on selection. Therefore, + // we cannot skip updating selection here. + nsresult rv = splitLinkNodeResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + if (NS_FAILED(rv)) { + NS_WARNING("SplitNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + pointToBreak = + splitLinkNodeResult.inspect().AtSplitPoint<EditorDOMPoint>(); + } + Result<CreateElementResult, nsresult> insertBRElementResult = + WhiteSpaceVisibilityKeeper::InsertBRElement(*this, pointToBreak, + aEditingHost); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("WhiteSpaceVisibilityKeeper::InsertBRElement() failed"); + return insertBRElementResult; + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // We'll return with suggesting new caret position and nobody refers + // selection after here. So we don't need to update selection here. + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + brElement = unwrappedInsertBRElementResult.UnwrapNewNode(); + MOZ_ASSERT(brElement); + } + + if (MOZ_UNLIKELY(!brElement->GetParentNode())) { + NS_WARNING("Inserted <br> element was removed by the web app"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (brElementIsAfterBlock && brElementIsBeforeBlock) { + // We just placed a <br> between block boundaries. This is the one case + // where we want the selection to be before the br we just placed, as the + // br will be on a new line, rather than at end of prior line. + // XXX brElementIsAfterBlock and brElementIsBeforeBlock were set before + // modifying the DOM tree. So, now, the <br> element may not be + // between blocks. + EditorDOMPoint pointToPutCaret(brElement, + InterlinePosition::StartOfNextLine); + return CreateElementResult(std::move(brElement), + std::move(pointToPutCaret)); + } + + auto afterBRElement = EditorDOMPoint::After(brElement); + WSScanResult forwardScanFromAfterBRElementResult = + WSRunScanner::ScanNextVisibleNodeOrBlockBoundary(&aEditingHost, + afterBRElement); + if (MOZ_UNLIKELY(forwardScanFromAfterBRElementResult.Failed())) { + NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); + return Err(NS_ERROR_FAILURE); + } + if (forwardScanFromAfterBRElementResult.ReachedBRElement()) { + // The next thing after the break we inserted is another break. Move the + // second break to be the first break's sibling. This will prevent them + // from being in different inline nodes, which would break + // SetInterlinePosition(). It will also assure that if the user clicks + // away and then clicks back on their new blank line, they will still get + // the style from the line above. + if (brElement->GetNextSibling() != + forwardScanFromAfterBRElementResult.BRElementPtr()) { + MOZ_ASSERT(forwardScanFromAfterBRElementResult.BRElementPtr()); + Result<MoveNodeResult, nsresult> moveBRElementResult = + MoveNodeWithTransaction( + MOZ_KnownLive( + *forwardScanFromAfterBRElementResult.BRElementPtr()), + afterBRElement); + if (MOZ_UNLIKELY(moveBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveBRElementResult.propagateErr(); + } + nsresult rv = moveBRElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + } + } + + // We want the caret to stick to whatever is past the break. This is because + // the break is on the same line we were on, but the next content will be on + // the following line. + + // An exception to this is if the break has a next sibling that is a block + // node. Then we stick to the left to avoid an uber caret. + nsIContent* nextSiblingOfBRElement = brElement->GetNextSibling(); + afterBRElement.SetInterlinePosition( + nextSiblingOfBRElement && + HTMLEditUtils::IsBlockElement(*nextSiblingOfBRElement) + ? InterlinePosition::EndOfLine + : InterlinePosition::StartOfNextLine); + return CreateElementResult(std::move(brElement), afterBRElement); +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::HandleInsertLinefeed( + const EditorDOMPoint& aPointToBreak, const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (NS_WARN_IF(!aPointToBreak.IsSet())) { + return Err(NS_ERROR_INVALID_ARG); + } + + const RefPtr<Document> document = GetDocument(); + MOZ_DIAGNOSTIC_ASSERT(document); + if (NS_WARN_IF(!document)) { + return Err(NS_ERROR_FAILURE); + } + + // TODO: The following code is duplicated from `HandleInsertText`. They + // should be merged when we fix bug 92921. + + Result<EditorDOMPoint, nsresult> setStyleResult = + CreateStyleForInsertText(aPointToBreak, aEditingHost); + if (MOZ_UNLIKELY(setStyleResult.isErr())) { + NS_WARNING("HTMLEditor::CreateStyleForInsertText() failed"); + return setStyleResult.propagateErr(); + } + + EditorDOMPoint pointToInsert = setStyleResult.inspect().IsSet() + ? setStyleResult.inspect() + : aPointToBreak; + if (NS_WARN_IF(!pointToInsert.IsSetAndValid()) || + NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + MOZ_ASSERT(pointToInsert.IsSetAndValid()); + + // The node may not be able to have a text node so that we need to check it + // here. + if (!pointToInsert.IsInTextNode() && + !HTMLEditUtils::CanNodeContain(*pointToInsert.ContainerAs<nsIContent>(), + *nsGkAtoms::textTagName)) { + NS_WARNING( + "HTMLEditor::HandleInsertLinefeed() couldn't insert a linefeed because " + "the insertion position couldn't have text nodes"); + return Err(NS_ERROR_EDITOR_NO_EDITABLE_RANGE); + } + + AutoRestore<bool> disableListener( + EditSubActionDataRef().mAdjustChangedRangeFromListener); + EditSubActionDataRef().mAdjustChangedRangeFromListener = false; + + // TODO: We don't need AutoTransactionsConserveSelection here in the normal + // cases, but removing this may cause the behavior with the legacy + // mutation event listeners. We should try to delete this in a bug. + AutoTransactionsConserveSelection dontChangeMySelection(*this); + + EditorDOMPoint pointToPutCaret; + { + AutoTrackDOMPoint trackingInsertingPosition(RangeUpdaterRef(), + &pointToInsert); + Result<InsertTextResult, nsresult> insertTextResult = + InsertTextWithTransaction(*document, u"\n"_ns, pointToInsert); + if (MOZ_UNLIKELY(insertTextResult.isErr())) { + NS_WARNING("HTMLEditor::InsertTextWithTransaction() failed"); + return insertTextResult.propagateErr(); + } + // Ignore the caret suggestion because of `dontChangeMySelection` above. + insertTextResult.inspect().IgnoreCaretPointSuggestion(); + pointToPutCaret = insertTextResult.inspect().Handled() + ? insertTextResult.unwrap() + .EndOfInsertedTextRef() + .To<EditorDOMPoint>() + : pointToInsert; + } + + // Insert a padding <br> element at the end of the block element if there is + // no content between the inserted linefeed and the following block boundary + // to make sure that the last line is visible. + // XXX Blink/WebKit inserts another linefeed character in this case. However, + // for doing it, we need more work, e.g., updating serializer, deleting + // unnecessary padding <br> element at modifying the last line. + if (pointToPutCaret.IsInContentNode() && pointToPutCaret.IsEndOfContainer()) { + WSRunScanner wsScannerAtCaret(&aEditingHost, pointToPutCaret); + if (wsScannerAtCaret.StartsFromPreformattedLineBreak() && + wsScannerAtCaret.EndsByBlockBoundary() && + HTMLEditUtils::CanNodeContain(*wsScannerAtCaret.GetEndReasonContent(), + *nsGkAtoms::br)) { + AutoTrackDOMPoint trackingInsertedPosition(RangeUpdaterRef(), + &pointToInsert); + AutoTrackDOMPoint trackingNewCaretPosition(RangeUpdaterRef(), + &pointToPutCaret); + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToPutCaret); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + // We're tracking next caret position with newCaretPosition. Therefore, + // we don't need to update selection here. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(insertBRElementResult.inspect().GetNewNode()); + } + } + + // manually update the doc changed range so that + // OnEndHandlingTopLevelEditSubActionInternal will clean up the correct + // portion of the document. + MOZ_ASSERT(pointToPutCaret.IsSet()); + if (NS_WARN_IF(!pointToPutCaret.IsSet())) { + // XXX Here is odd. We did mChangedRange->SetStartAndEnd(pointToInsert, + // pointToPutCaret), but it always fails because of the latter is unset. + // Therefore, always returning NS_ERROR_FAILURE from here is the + // traditional behavior... + // TODO: Stop updating the interline position of Selection with fixing here + // and returning expected point. + DebugOnly<nsresult> rvIgnored = + SelectionRef().SetInterlinePosition(InterlinePosition::EndOfLine); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "EndOfLine) failed, but ignored"); + if (NS_FAILED(TopLevelEditSubActionDataRef().mChangedRange->CollapseTo( + pointToInsert))) { + NS_WARNING("nsRange::CollapseTo() failed"); + return Err(NS_ERROR_FAILURE); + } + NS_WARNING( + "We always return NS_ERROR_FAILURE here because of a failure of " + "updating mChangedRange"); + return Err(NS_ERROR_FAILURE); + } + + if (NS_FAILED(TopLevelEditSubActionDataRef().mChangedRange->SetStartAndEnd( + pointToInsert.ToRawRangeBoundary(), + pointToPutCaret.ToRawRangeBoundary()))) { + NS_WARNING("nsRange::SetStartAndEnd() failed"); + return Err(NS_ERROR_FAILURE); + } + + pointToPutCaret.SetInterlinePosition(InterlinePosition::EndOfLine); + return pointToPutCaret; +} + +Result<EditorDOMPoint, nsresult> +HTMLEditor::HandleInsertParagraphInMailCiteElement( + Element& aMailCiteElement, const EditorDOMPoint& aPointToSplit, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aPointToSplit.IsSet()); + NS_ASSERTION(!HTMLEditUtils::IsEmptyNode(aMailCiteElement), + "The mail-cite element will be deleted, does it expected result " + "for you?"); + + auto splitCiteElementResult = + [&]() MOZ_CAN_RUN_SCRIPT -> Result<SplitNodeResult, nsresult> { + EditorDOMPoint pointToSplit(aPointToSplit); + + // If our selection is just before a break, nudge it to be just after + // it. This does two things for us. It saves us the trouble of having + // to add a break here ourselves to preserve the "blockness" of the + // inline span mailquote (in the inline case), and : it means the break + // won't end up making an empty line that happens to be inside a + // mailquote (in either inline or block case). The latter can confuse a + // user if they click there and start typing, because being in the + // mailquote may affect wrapping behavior, or font color, etc. + WSScanResult forwardScanFromPointToSplitResult = + WSRunScanner::ScanNextVisibleNodeOrBlockBoundary(&aEditingHost, + pointToSplit); + if (forwardScanFromPointToSplitResult.Failed()) { + return Err(NS_ERROR_FAILURE); + } + // If selection start point is before a break and it's inside the + // mailquote, let's split it after the visible node. + if (forwardScanFromPointToSplitResult.ReachedBRElement() && + forwardScanFromPointToSplitResult.BRElementPtr() != &aMailCiteElement && + aMailCiteElement.Contains( + forwardScanFromPointToSplitResult.BRElementPtr())) { + pointToSplit = + forwardScanFromPointToSplitResult.PointAfterContent<EditorDOMPoint>(); + } + + if (NS_WARN_IF(!pointToSplit.IsInContentNode())) { + return Err(NS_ERROR_FAILURE); + } + + Result<SplitNodeResult, nsresult> splitResult = + SplitNodeDeepWithTransaction(aMailCiteElement, pointToSplit, + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(aMailCiteElement, " + "SplitAtEdges::eDoNotCreateEmptyContainer) failed"); + return splitResult; + } + nsresult rv = splitResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + if (NS_FAILED(rv)) { + NS_WARNING("SplitNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + return splitResult; + }(); + if (MOZ_UNLIKELY(splitCiteElementResult.isErr())) { + NS_WARNING("Failed to split a mail-cite element"); + return splitCiteElementResult.propagateErr(); + } + SplitNodeResult unwrappedSplitCiteElementResult = + splitCiteElementResult.unwrap(); + // When adding caret suggestion to SplitNodeResult, here didn't change + // selection so that just ignore it. + unwrappedSplitCiteElementResult.IgnoreCaretPointSuggestion(); + + // Add an invisible <br> to the end of left cite node if it was a <span> of + // style="display: block". This is important, since when serializing the cite + // to plain text, the span which caused the visual break is discarded. So the + // added <br> will guarantee that the serializer will insert a break where the + // user saw one. + // FYI: unwrappedSplitCiteElementResult grabs the previous node and the next + // node with nsCOMPtr or EditorDOMPoint. So, it's safe to access + // leftCiteElement and rightCiteElement even after changing the DOM tree + // and/or selection even though it's raw pointer. + auto* const leftCiteElement = + unwrappedSplitCiteElementResult.GetPreviousContentAs<Element>(); + auto* const rightCiteElement = + unwrappedSplitCiteElementResult.GetNextContentAs<Element>(); + if (leftCiteElement && leftCiteElement->IsHTMLElement(nsGkAtoms::span) && + // XXX Oh, this depends on layout information of new element, and it's + // created by the hacky flush in DoSplitNode(). So we need to + // redesign around this for bug 1710784. + leftCiteElement->GetPrimaryFrame() && + leftCiteElement->GetPrimaryFrame()->IsBlockFrameOrSubclass()) { + nsIContent* lastChild = leftCiteElement->GetLastChild(); + if (lastChild && !lastChild->IsHTMLElement(nsGkAtoms::br)) { + Result<CreateElementResult, nsresult> insertInvisibleBRElementResult = + InsertBRElement(WithTransaction::Yes, + EditorDOMPoint::AtEndOf(*leftCiteElement)); + if (MOZ_UNLIKELY(insertInvisibleBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertInvisibleBRElementResult.propagateErr(); + } + // We don't need to update selection here because we'll do another + // InsertBRElement call soon. + insertInvisibleBRElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(insertInvisibleBRElementResult.inspect().GetNewNode()); + } + } + + // In most cases, <br> should be inserted after current cite. However, if + // left cite hasn't been created because the split point was start of the + // cite node, <br> should be inserted before the current cite. + Result<CreateElementResult, nsresult> insertBRElementResult = InsertBRElement( + WithTransaction::Yes, + unwrappedSplitCiteElementResult.AtSplitPoint<EditorDOMPoint>()); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return Err(insertBRElementResult.unwrapErr()); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // We'll return with suggesting caret position. Therefore, we don't need + // to update selection here. + unwrappedInsertBRElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedInsertBRElementResult.GetNewNode()); + + // if aMailCiteElement wasn't a block, we might also want another break before + // it. We need to examine the content both before the br we just added and + // also just after it. If we don't have another br or block boundary + // adjacent, then we will need a 2nd br added to achieve blank line that user + // expects. + if (HTMLEditUtils::IsInlineElement(aMailCiteElement)) { + nsresult rvOfInsertingBRElement = [&]() MOZ_CAN_RUN_SCRIPT { + EditorDOMPoint pointToCreateNewBRElement( + unwrappedInsertBRElementResult.GetNewNode()); + + // XXX Cannot we replace this complicated check with just a call of + // HTMLEditUtils::IsVisibleBRElement with + // resultOfInsertingBRElement.inspect()? + WSScanResult backwardScanFromPointToCreateNewBRElementResult = + WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundary( + &aEditingHost, pointToCreateNewBRElement); + if (MOZ_UNLIKELY( + backwardScanFromPointToCreateNewBRElementResult.Failed())) { + NS_WARNING( + "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundary() " + "failed"); + return NS_ERROR_FAILURE; + } + if (!backwardScanFromPointToCreateNewBRElementResult + .InVisibleOrCollapsibleCharacters() && + !backwardScanFromPointToCreateNewBRElementResult + .ReachedSpecialContent()) { + return NS_SUCCESS_DOM_NO_OPERATION; + } + WSScanResult forwardScanFromPointAfterNewBRElementResult = + WSRunScanner::ScanNextVisibleNodeOrBlockBoundary( + &aEditingHost, + EditorRawDOMPoint::After(pointToCreateNewBRElement)); + if (MOZ_UNLIKELY(forwardScanFromPointAfterNewBRElementResult.Failed())) { + NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); + return NS_ERROR_FAILURE; + } + if (!forwardScanFromPointAfterNewBRElementResult + .InVisibleOrCollapsibleCharacters() && + !forwardScanFromPointAfterNewBRElementResult + .ReachedSpecialContent() && + // In case we're at the very end. + !forwardScanFromPointAfterNewBRElementResult + .ReachedCurrentBlockBoundary()) { + return NS_SUCCESS_DOM_NO_OPERATION; + } + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToCreateNewBRElement); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.unwrapErr(); + } + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(insertBRElementResult.inspect().GetNewNode()); + return NS_OK; + }(); + + if (NS_FAILED(rvOfInsertingBRElement)) { + NS_WARNING( + "Failed to insert additional <br> element before the inline right " + "mail-cite element"); + return Err(rvOfInsertingBRElement); + } + } + + if (leftCiteElement && HTMLEditUtils::IsEmptyNode(*leftCiteElement)) { + // MOZ_KnownLive(leftCiteElement) because it's grabbed by + // unwrappedSplitCiteElementResult. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*leftCiteElement)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + + if (rightCiteElement && HTMLEditUtils::IsEmptyNode(*rightCiteElement)) { + // MOZ_KnownLive(rightCiteElement) because it's grabbed by + // unwrappedSplitCiteElementResult. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*rightCiteElement)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + + if (MOZ_UNLIKELY(!unwrappedInsertBRElementResult.GetNewNode()->GetParent())) { + NS_WARNING("Inserted <br> shouldn't become an orphan node"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + return EditorDOMPoint(unwrappedInsertBRElementResult.GetNewNode()); +} + +HTMLEditor::CharPointData +HTMLEditor::GetPreviousCharPointDataForNormalizingWhiteSpaces( + const EditorDOMPointInText& aPoint) const { + MOZ_ASSERT(aPoint.IsSetAndValid()); + + if (!aPoint.IsStartOfContainer()) { + return CharPointData::InSameTextNode( + HTMLEditor::GetPreviousCharPointType(aPoint)); + } + const auto previousCharPoint = + WSRunScanner::GetPreviousEditableCharPoint<EditorRawDOMPointInText>( + ComputeEditingHost(), aPoint); + if (!previousCharPoint.IsSet()) { + return CharPointData::InDifferentTextNode(CharPointType::TextEnd); + } + return CharPointData::InDifferentTextNode( + HTMLEditor::GetCharPointType(previousCharPoint)); +} + +HTMLEditor::CharPointData +HTMLEditor::GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( + const EditorDOMPointInText& aPoint) const { + MOZ_ASSERT(aPoint.IsSetAndValid()); + + if (!aPoint.IsEndOfContainer()) { + return CharPointData::InSameTextNode(HTMLEditor::GetCharPointType(aPoint)); + } + const auto nextCharPoint = + WSRunScanner::GetInclusiveNextEditableCharPoint<EditorRawDOMPointInText>( + ComputeEditingHost(), aPoint); + if (!nextCharPoint.IsSet()) { + return CharPointData::InDifferentTextNode(CharPointType::TextEnd); + } + return CharPointData::InDifferentTextNode( + HTMLEditor::GetCharPointType(nextCharPoint)); +} + +// static +void HTMLEditor::GenerateWhiteSpaceSequence( + nsAString& aResult, uint32_t aLength, + const CharPointData& aPreviousCharPointData, + const CharPointData& aNextCharPointData) { + MOZ_ASSERT(aResult.IsEmpty()); + MOZ_ASSERT(aLength); + // For now, this method does not assume that result will be append to + // white-space sequence in the text node. + MOZ_ASSERT(aPreviousCharPointData.AcrossTextNodeBoundary() || + !aPreviousCharPointData.IsCollapsibleWhiteSpace()); + // For now, this method does not assume that the result will be inserted + // into white-space sequence nor start of white-space sequence. + MOZ_ASSERT(aNextCharPointData.AcrossTextNodeBoundary() || + !aNextCharPointData.IsCollapsibleWhiteSpace()); + + if (aLength == 1) { + // Even if previous/next char is in different text node, we should put + // an ASCII white-space between visible characters. + // XXX This means that this does not allow to put an NBSP in HTML editor + // without preformatted style. However, Chrome has same issue too. + if (aPreviousCharPointData.Type() == CharPointType::VisibleChar && + aNextCharPointData.Type() == CharPointType::VisibleChar) { + aResult.Assign(HTMLEditUtils::kSpace); + return; + } + // If it's start or end of text, put an NBSP. + if (aPreviousCharPointData.Type() == CharPointType::TextEnd || + aNextCharPointData.Type() == CharPointType::TextEnd) { + aResult.Assign(HTMLEditUtils::kNBSP); + return; + } + // If the character is next to a preformatted linefeed, we need to put + // an NBSP for avoiding collapsed into the linefeed. + if (aPreviousCharPointData.Type() == CharPointType::PreformattedLineBreak || + aNextCharPointData.Type() == CharPointType::PreformattedLineBreak) { + aResult.Assign(HTMLEditUtils::kNBSP); + return; + } + // Now, the white-space will be inserted to a white-space sequence, but not + // end of text. We can put an ASCII white-space only when both sides are + // not ASCII white-spaces. + aResult.Assign( + aPreviousCharPointData.Type() == CharPointType::ASCIIWhiteSpace || + aNextCharPointData.Type() == CharPointType::ASCIIWhiteSpace + ? HTMLEditUtils::kNBSP + : HTMLEditUtils::kSpace); + return; + } + + // Generate pairs of NBSP and ASCII white-space. + aResult.SetLength(aLength); + bool appendNBSP = true; // Basically, starts with an NBSP. + char16_t* lastChar = aResult.EndWriting() - 1; + for (char16_t* iter = aResult.BeginWriting(); iter != lastChar; iter++) { + *iter = appendNBSP ? HTMLEditUtils::kNBSP : HTMLEditUtils::kSpace; + appendNBSP = !appendNBSP; + } + + // If the final one is expected to an NBSP, we can put an NBSP simply. + if (appendNBSP) { + *lastChar = HTMLEditUtils::kNBSP; + return; + } + + // If next char point is end of text node, an ASCII white-space or + // preformatted linefeed, we need to put an NBSP. + *lastChar = + aNextCharPointData.AcrossTextNodeBoundary() || + aNextCharPointData.Type() == CharPointType::ASCIIWhiteSpace || + aNextCharPointData.Type() == CharPointType::PreformattedLineBreak + ? HTMLEditUtils::kNBSP + : HTMLEditUtils::kSpace; +} + +void HTMLEditor::ExtendRangeToDeleteWithNormalizingWhiteSpaces( + EditorDOMPointInText& aStartToDelete, EditorDOMPointInText& aEndToDelete, + nsAString& aNormalizedWhiteSpacesInStartNode, + nsAString& aNormalizedWhiteSpacesInEndNode) const { + MOZ_ASSERT(aStartToDelete.IsSetAndValid()); + MOZ_ASSERT(aEndToDelete.IsSetAndValid()); + MOZ_ASSERT(aStartToDelete.EqualsOrIsBefore(aEndToDelete)); + MOZ_ASSERT(aNormalizedWhiteSpacesInStartNode.IsEmpty()); + MOZ_ASSERT(aNormalizedWhiteSpacesInEndNode.IsEmpty()); + + // First, check whether there is surrounding white-spaces or not, and if there + // are, check whether they are collapsible or not. Note that we shouldn't + // touch white-spaces in different text nodes for performance, but we need + // adjacent text node's first or last character information in some cases. + Element* editingHost = ComputeEditingHost(); + const EditorDOMPointInText precedingCharPoint = + WSRunScanner::GetPreviousEditableCharPoint(editingHost, aStartToDelete); + const EditorDOMPointInText followingCharPoint = + WSRunScanner::GetInclusiveNextEditableCharPoint(editingHost, + aEndToDelete); + // Blink-compat: Normalize white-spaces in first node only when not removing + // its last character or no text nodes follow the first node. + // If removing last character of first node and there are + // following text nodes, white-spaces in following text node are + // normalized instead. + const bool removingLastCharOfStartNode = + aStartToDelete.ContainerAs<Text>() != aEndToDelete.ContainerAs<Text>() || + (aEndToDelete.IsEndOfContainer() && followingCharPoint.IsSet()); + const bool maybeNormalizePrecedingWhiteSpaces = + !removingLastCharOfStartNode && precedingCharPoint.IsSet() && + !precedingCharPoint.IsEndOfContainer() && + precedingCharPoint.ContainerAs<Text>() == + aStartToDelete.ContainerAs<Text>() && + precedingCharPoint.IsCharCollapsibleASCIISpaceOrNBSP(); + const bool maybeNormalizeFollowingWhiteSpaces = + followingCharPoint.IsSet() && !followingCharPoint.IsEndOfContainer() && + (followingCharPoint.ContainerAs<Text>() == + aEndToDelete.ContainerAs<Text>() || + removingLastCharOfStartNode) && + followingCharPoint.IsCharCollapsibleASCIISpaceOrNBSP(); + + if (!maybeNormalizePrecedingWhiteSpaces && + !maybeNormalizeFollowingWhiteSpaces) { + return; // There are no white-spaces. + } + + // Next, consider the range to normalize. + EditorDOMPointInText startToNormalize, endToNormalize; + if (maybeNormalizePrecedingWhiteSpaces) { + Maybe<uint32_t> previousCharOffsetOfWhiteSpaces = + HTMLEditUtils::GetPreviousNonCollapsibleCharOffset( + precedingCharPoint, {WalkTextOption::TreatNBSPsCollapsible}); + startToNormalize.Set(precedingCharPoint.ContainerAs<Text>(), + previousCharOffsetOfWhiteSpaces.isSome() + ? previousCharOffsetOfWhiteSpaces.value() + 1 + : 0); + MOZ_ASSERT(!startToNormalize.IsEndOfContainer()); + } + if (maybeNormalizeFollowingWhiteSpaces) { + Maybe<uint32_t> nextCharOffsetOfWhiteSpaces = + HTMLEditUtils::GetInclusiveNextNonCollapsibleCharOffset( + followingCharPoint, {WalkTextOption::TreatNBSPsCollapsible}); + if (nextCharOffsetOfWhiteSpaces.isSome()) { + endToNormalize.Set(followingCharPoint.ContainerAs<Text>(), + nextCharOffsetOfWhiteSpaces.value()); + } else { + endToNormalize.SetToEndOf(followingCharPoint.ContainerAs<Text>()); + } + MOZ_ASSERT(!endToNormalize.IsStartOfContainer()); + } + + // Next, retrieve surrounding information of white-space sequence. + // If we're removing first text node's last character, we need to + // normalize white-spaces starts from another text node. In this case, + // we need to lie for avoiding assertion in GenerateWhiteSpaceSequence(). + CharPointData previousCharPointData = + removingLastCharOfStartNode + ? CharPointData::InDifferentTextNode(CharPointType::TextEnd) + : GetPreviousCharPointDataForNormalizingWhiteSpaces( + startToNormalize.IsSet() ? startToNormalize : aStartToDelete); + CharPointData nextCharPointData = + GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( + endToNormalize.IsSet() ? endToNormalize : aEndToDelete); + + // Next, compute number of white-spaces in start/end node. + uint32_t lengthInStartNode = 0, lengthInEndNode = 0; + if (startToNormalize.IsSet()) { + MOZ_ASSERT(startToNormalize.ContainerAs<Text>() == + aStartToDelete.ContainerAs<Text>()); + lengthInStartNode = aStartToDelete.Offset() - startToNormalize.Offset(); + MOZ_ASSERT(lengthInStartNode); + } + if (endToNormalize.IsSet()) { + lengthInEndNode = + endToNormalize.ContainerAs<Text>() == aEndToDelete.ContainerAs<Text>() + ? endToNormalize.Offset() - aEndToDelete.Offset() + : endToNormalize.Offset(); + MOZ_ASSERT(lengthInEndNode); + // If we normalize white-spaces in a text node, we can replace all of them + // with one ReplaceTextTransaction. + if (endToNormalize.ContainerAs<Text>() == + aStartToDelete.ContainerAs<Text>()) { + lengthInStartNode += lengthInEndNode; + lengthInEndNode = 0; + } + } + + MOZ_ASSERT(lengthInStartNode + lengthInEndNode); + + // Next, generate normalized white-spaces. + if (!lengthInEndNode) { + HTMLEditor::GenerateWhiteSpaceSequence( + aNormalizedWhiteSpacesInStartNode, lengthInStartNode, + previousCharPointData, nextCharPointData); + } else if (!lengthInStartNode) { + HTMLEditor::GenerateWhiteSpaceSequence( + aNormalizedWhiteSpacesInEndNode, lengthInEndNode, previousCharPointData, + nextCharPointData); + } else { + // For making `GenerateWhiteSpaceSequence()` simpler, we should create + // whole white-space sequence first, then, copy to the out params. + nsAutoString whiteSpaces; + HTMLEditor::GenerateWhiteSpaceSequence( + whiteSpaces, lengthInStartNode + lengthInEndNode, previousCharPointData, + nextCharPointData); + aNormalizedWhiteSpacesInStartNode = + Substring(whiteSpaces, 0, lengthInStartNode); + aNormalizedWhiteSpacesInEndNode = Substring(whiteSpaces, lengthInStartNode); + MOZ_ASSERT(aNormalizedWhiteSpacesInEndNode.Length() == lengthInEndNode); + } + + // TODO: Shrink the replacing range and string as far as possible because + // this may run a lot, i.e., HTMLEditor creates ReplaceTextTransaction + // a lot for normalizing white-spaces. Then, each transaction shouldn't + // have all white-spaces every time because once it's normalized, we + // don't need to normalize all of the sequence again, but currently + // we do. + + // Finally, extend the range. + if (startToNormalize.IsSet()) { + aStartToDelete = startToNormalize; + } + if (endToNormalize.IsSet()) { + aEndToDelete = endToNormalize; + } +} + +Result<CaretPoint, nsresult> +HTMLEditor::DeleteTextAndNormalizeSurroundingWhiteSpaces( + const EditorDOMPointInText& aStartToDelete, + const EditorDOMPointInText& aEndToDelete, + TreatEmptyTextNodes aTreatEmptyTextNodes, + DeleteDirection aDeleteDirection) { + MOZ_ASSERT(aStartToDelete.IsSetAndValid()); + MOZ_ASSERT(aEndToDelete.IsSetAndValid()); + MOZ_ASSERT(aStartToDelete.EqualsOrIsBefore(aEndToDelete)); + + // Use nsString for these replacing string because we should avoid to copy + // the buffer from auto storange to ReplaceTextTransaction. + nsString normalizedWhiteSpacesInFirstNode, normalizedWhiteSpacesInLastNode; + + // First, check whether we need to normalize white-spaces after deleting + // the given range. + EditorDOMPointInText startToDelete(aStartToDelete); + EditorDOMPointInText endToDelete(aEndToDelete); + ExtendRangeToDeleteWithNormalizingWhiteSpaces( + startToDelete, endToDelete, normalizedWhiteSpacesInFirstNode, + normalizedWhiteSpacesInLastNode); + + // If extended range is still collapsed, i.e., the caller just wants to + // normalize white-space sequence, but there is no white-spaces which need to + // be replaced, we need to do nothing here. + if (startToDelete == endToDelete) { + return CaretPoint(aStartToDelete.To<EditorDOMPoint>()); + } + + // Note that the container text node of startToDelete may be removed from + // the tree if it becomes empty. Therefore, we need to track the point. + EditorDOMPoint newCaretPosition; + if (aStartToDelete.ContainerAs<Text>() == aEndToDelete.ContainerAs<Text>()) { + newCaretPosition = aEndToDelete.To<EditorDOMPoint>(); + } else if (aDeleteDirection == DeleteDirection::Forward) { + newCaretPosition.SetToEndOf(aStartToDelete.ContainerAs<Text>()); + } else { + newCaretPosition.Set(aEndToDelete.ContainerAs<Text>(), 0u); + } + + // Then, modify the text nodes in the range. + while (true) { + AutoTrackDOMPoint trackingNewCaretPosition(RangeUpdaterRef(), + &newCaretPosition); + // Use ReplaceTextTransaction if we need to normalize white-spaces in + // the first text node. + if (!normalizedWhiteSpacesInFirstNode.IsEmpty()) { + EditorDOMPoint trackingEndToDelete(endToDelete.ContainerAs<Text>(), + endToDelete.Offset()); + { + AutoTrackDOMPoint trackEndToDelete(RangeUpdaterRef(), + &trackingEndToDelete); + uint32_t lengthToReplaceInFirstTextNode = + startToDelete.ContainerAs<Text>() == + trackingEndToDelete.ContainerAs<Text>() + ? trackingEndToDelete.Offset() - startToDelete.Offset() + : startToDelete.ContainerAs<Text>()->TextLength() - + startToDelete.Offset(); + Result<InsertTextResult, nsresult> replaceTextResult = + ReplaceTextWithTransaction( + MOZ_KnownLive(*startToDelete.ContainerAs<Text>()), + startToDelete.Offset(), lengthToReplaceInFirstTextNode, + normalizedWhiteSpacesInFirstNode); + if (MOZ_UNLIKELY(replaceTextResult.isErr())) { + NS_WARNING("HTMLEditor::ReplaceTextWithTransaction() failed"); + return replaceTextResult.propagateErr(); + } + // We'll return computed caret point, newCaretPosition, below. + replaceTextResult.unwrap().IgnoreCaretPointSuggestion(); + if (startToDelete.ContainerAs<Text>() == + trackingEndToDelete.ContainerAs<Text>()) { + MOZ_ASSERT(normalizedWhiteSpacesInLastNode.IsEmpty()); + break; // There is no more text which we need to delete. + } + } + if (MayHaveMutationEventListeners( + NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED) && + (NS_WARN_IF(!trackingEndToDelete.IsSetAndValid()) || + NS_WARN_IF(!trackingEndToDelete.IsInTextNode()))) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + MOZ_ASSERT(trackingEndToDelete.IsInTextNode()); + endToDelete.Set(trackingEndToDelete.ContainerAs<Text>(), + trackingEndToDelete.Offset()); + // If the remaining range was modified by mutation event listener, + // we should stop handling the deletion. + startToDelete = + EditorDOMPointInText::AtEndOf(*startToDelete.ContainerAs<Text>()); + if (MayHaveMutationEventListeners( + NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED) && + NS_WARN_IF(!startToDelete.IsBefore(endToDelete))) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + } + // Delete ASCII whiteSpaces in the range simpley if there are some text + // nodes which we don't need to replace their text. + if (normalizedWhiteSpacesInLastNode.IsEmpty() || + startToDelete.ContainerAs<Text>() != endToDelete.ContainerAs<Text>()) { + // If we need to replace text in the last text node, we should + // delete text before its previous text node. + EditorDOMPointInText endToDeleteExceptReplaceRange = + normalizedWhiteSpacesInLastNode.IsEmpty() + ? endToDelete + : EditorDOMPointInText(endToDelete.ContainerAs<Text>(), 0); + if (startToDelete != endToDeleteExceptReplaceRange) { + Result<CaretPoint, nsresult> caretPointOrError = + DeleteTextAndTextNodesWithTransaction(startToDelete, + endToDeleteExceptReplaceRange, + aTreatEmptyTextNodes); + if (MOZ_UNLIKELY(caretPointOrError.isErr())) { + NS_WARNING( + "HTMLEditor::DeleteTextAndTextNodesWithTransaction() failed"); + return caretPointOrError.propagateErr(); + } + nsresult rv = caretPointOrError.unwrap().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CaretPoint::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CaretPoint::SuggestCaretPointTo() failed, but ignored"); + if (normalizedWhiteSpacesInLastNode.IsEmpty()) { + break; // There is no more text which we need to delete. + } + if (MayHaveMutationEventListeners( + NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED | + NS_EVENT_BITS_MUTATION_NODEREMOVED | + NS_EVENT_BITS_MUTATION_NODEREMOVEDFROMDOCUMENT | + NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED) && + (NS_WARN_IF(!endToDeleteExceptReplaceRange.IsSetAndValid()) || + NS_WARN_IF(!endToDelete.IsSetAndValid()) || + NS_WARN_IF(endToDelete.IsStartOfContainer()))) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + // Then, replace the text in the last text node. + startToDelete = endToDeleteExceptReplaceRange; + } + } + + // Replace ASCII whiteSpaces in the range and following character in the + // last text node. + MOZ_ASSERT(!normalizedWhiteSpacesInLastNode.IsEmpty()); + MOZ_ASSERT(startToDelete.ContainerAs<Text>() == + endToDelete.ContainerAs<Text>()); + Result<InsertTextResult, nsresult> replaceTextResult = + ReplaceTextWithTransaction( + MOZ_KnownLive(*startToDelete.ContainerAs<Text>()), + startToDelete.Offset(), + endToDelete.Offset() - startToDelete.Offset(), + normalizedWhiteSpacesInLastNode); + if (MOZ_UNLIKELY(replaceTextResult.isErr())) { + NS_WARNING("HTMLEditor::ReplaceTextWithTransaction() failed"); + return replaceTextResult.propagateErr(); + } + // We'll return computed caret point, newCaretPosition, below. + replaceTextResult.unwrap().IgnoreCaretPointSuggestion(); + break; + } + + if (NS_WARN_IF(!newCaretPosition.IsSetAndValid()) || + NS_WARN_IF(!newCaretPosition.GetContainer()->IsInComposedDoc())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // Look for leaf node to put caret if we remove some empty inline ancestors + // at new caret position. + if (!newCaretPosition.IsInTextNode()) { + if (const Element* editableBlockElementOrInlineEditingHost = + HTMLEditUtils::GetInclusiveAncestorElement( + *newCaretPosition.ContainerAs<nsIContent>(), + HTMLEditUtils:: + ClosestEditableBlockElementOrInlineEditingHost)) { + Element* editingHost = ComputeEditingHost(); + // Try to put caret next to immediately after previous editable leaf. + nsIContent* previousContent = + HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement( + newCaretPosition, *editableBlockElementOrInlineEditingHost, + {LeafNodeType::LeafNodeOrNonEditableNode}, editingHost); + if (previousContent && !HTMLEditUtils::IsBlockElement(*previousContent)) { + newCaretPosition = + previousContent->IsText() || + HTMLEditUtils::IsContainerNode(*previousContent) + ? EditorDOMPoint::AtEndOf(*previousContent) + : EditorDOMPoint::After(*previousContent); + } + // But if the point is very first of a block element or immediately after + // a child block, look for next editable leaf instead. + else if (nsIContent* nextContent = + HTMLEditUtils::GetNextLeafContentOrNextBlockElement( + newCaretPosition, + *editableBlockElementOrInlineEditingHost, + {LeafNodeType::LeafNodeOrNonEditableNode}, + editingHost)) { + newCaretPosition = nextContent->IsText() || + HTMLEditUtils::IsContainerNode(*nextContent) + ? EditorDOMPoint(nextContent, 0) + : EditorDOMPoint(nextContent); + } + } + } + + // For compatibility with Blink, we should move caret to end of previous + // text node if it's direct previous sibling of the first text node in the + // range. + if (newCaretPosition.IsStartOfContainer() && + newCaretPosition.IsInTextNode() && + newCaretPosition.GetContainer()->GetPreviousSibling() && + newCaretPosition.GetContainer()->GetPreviousSibling()->IsText()) { + newCaretPosition.SetToEndOf( + newCaretPosition.GetContainer()->GetPreviousSibling()->AsText()); + } + + { + AutoTrackDOMPoint trackingNewCaretPosition(RangeUpdaterRef(), + &newCaretPosition); + Result<CaretPoint, nsresult> caretPointOrError = + InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( + newCaretPosition); + if (MOZ_UNLIKELY(caretPointOrError.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary() failed"); + return caretPointOrError; + } + } + if (!newCaretPosition.IsSetAndValid()) { + NS_WARNING("Inserting <br> element caused unexpected DOM tree"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + return CaretPoint(std::move(newCaretPosition)); +} + +Result<CaretPoint, nsresult> +HTMLEditor::InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( + const EditorDOMPoint& aPointToInsert) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aPointToInsert.IsSet()); + + if (!aPointToInsert.IsInContentNode()) { + return CaretPoint(EditorDOMPoint()); + } + + // If container of the point is not in a block, we don't need to put a + // `<br>` element here. + if (!HTMLEditUtils::IsBlockElement( + *aPointToInsert.ContainerAs<nsIContent>())) { + return CaretPoint(EditorDOMPoint()); + } + + WSRunScanner wsRunScanner(ComputeEditingHost(), aPointToInsert); + // If the point is not start of a hard line, we don't need to put a `<br>` + // element here. + if (!wsRunScanner.StartsFromHardLineBreak()) { + return CaretPoint(EditorDOMPoint()); + } + // If the point is not end of a hard line or the hard line does not end with + // block boundary, we don't need to put a `<br>` element here. + if (!wsRunScanner.EndsByBlockBoundary()) { + return CaretPoint(EditorDOMPoint()); + } + + // If we cannot insert a `<br>` element here, do nothing. + if (!HTMLEditUtils::CanNodeContain(*aPointToInsert.GetContainer(), + *nsGkAtoms::br)) { + return CaretPoint(EditorDOMPoint()); + } + + Result<CreateElementResult, nsresult> insertBRElementResult = InsertBRElement( + WithTransaction::Yes, aPointToInsert, nsIEditor::ePrevious); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes, ePrevious) failed"); + return insertBRElementResult.propagateErr(); + } + return CaretPoint(insertBRElementResult.unwrap().UnwrapCaretPoint()); +} + +Result<EditActionResult, nsresult> +HTMLEditor::MakeOrChangeListAndListItemAsSubAction( + const nsStaticAtom& aListElementOrListItemElementTagName, + const nsAString& aBulletType, + SelectAllOfCurrentList aSelectAllOfCurrentList) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(&aListElementOrListItemElementTagName == nsGkAtoms::ul || + &aListElementOrListItemElementTagName == nsGkAtoms::ol || + &aListElementOrListItemElementTagName == nsGkAtoms::dl || + &aListElementOrListItemElementTagName == nsGkAtoms::dd || + &aListElementOrListItemElementTagName == nsGkAtoms::dt); + + if (NS_WARN_IF(!mInitSucceeded)) { + return Err(NS_ERROR_NOT_INITIALIZED); + } + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Some selection containers are not content node, but ignored"); + return EditActionResult::IgnoredResult(); + } + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + + // XXX EditSubAction::eCreateOrChangeDefinitionListItem and + // EditSubAction::eCreateOrChangeList are treated differently in + // HTMLEditor::MaybeSplitElementsAtEveryBRElement(). Only when + // EditSubAction::eCreateOrChangeList, it splits inline nodes. + // Currently, it shouldn't be done when we called for formatting + // `<dd>` or `<dt>` by + // HTMLEditor::MakeDefinitionListItemWithTransaction(). But this + // difference may be a bug. We should investigate this later. + IgnoredErrorResult error; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, + &aListElementOrListItemElementTagName == nsGkAtoms::dd || + &aListElementOrListItemElementTagName == nsGkAtoms::dt + ? EditSubAction::eCreateOrChangeDefinitionListItem + : EditSubAction::eCreateOrChangeList, + nsIEditor::eNext, error); + if (NS_WARN_IF(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(error.StealNSResult()); + } + NS_WARNING_ASSERTION( + !error.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + const nsStaticAtom* listTagName = nullptr; + const nsStaticAtom* listItemTagName = nullptr; + if (&aListElementOrListItemElementTagName == nsGkAtoms::ul || + &aListElementOrListItemElementTagName == nsGkAtoms::ol) { + listTagName = &aListElementOrListItemElementTagName; + listItemTagName = nsGkAtoms::li; + } else if (&aListElementOrListItemElementTagName == nsGkAtoms::dl) { + listTagName = &aListElementOrListItemElementTagName; + listItemTagName = nsGkAtoms::dd; + } else if (&aListElementOrListItemElementTagName == nsGkAtoms::dd || + &aListElementOrListItemElementTagName == nsGkAtoms::dt) { + listTagName = nsGkAtoms::dl; + listItemTagName = &aListElementOrListItemElementTagName; + } else { + NS_WARNING( + "aListElementOrListItemElementTagName was neither list element name " + "nor " + "definition listitem element name"); + return Err(NS_ERROR_INVALID_ARG); + } + + const RefPtr<Element> editingHost = ComputeEditingHost(); + if (MOZ_UNLIKELY(!editingHost)) { + return EditActionResult::CanceledResult(); + } + + // Expands selection range to include the immediate block parent, and then + // further expands to include any ancestors whose children are all in the + // range. + // XXX Why do we do this only when there is only one selection range? + if (!SelectionRef().IsCollapsed() && SelectionRef().RangeCount() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + SelectionRef().GetRangeAt(0u), *editingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.propagateErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use Selection::SetStartAndEndInLimit() here. + error.SuppressException(); + SelectionRef().SetBaseAndExtentInLimiter( + extendedRange.inspect().StartRef().ToRawRangeBoundary(), + extendedRange.inspect().EndRef().ToRawRangeBoundary(), error); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (MOZ_UNLIKELY(error.Failed())) { + NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); + return Err(error.StealNSResult()); + } + } + + AutoListElementCreator listCreator(*listTagName, *listItemTagName, + aBulletType); + AutoRangeArray selectionRanges(SelectionRef()); + Result<EditActionResult, nsresult> result = listCreator.Run( + *this, selectionRanges, aSelectAllOfCurrentList, *editingHost); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::ConvertContentAroundRangesToList() failed"); + // XXX Should we try to restore selection ranges in this case? + return result; + } + + rv = selectionRanges.ApplyTo(SelectionRef()); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::ApplyTo() failed"); + return Err(rv); + } + return result.inspect().Ignored() ? EditActionResult::CanceledResult() + : EditActionResult::HandledResult(); +} + +Result<EditActionResult, nsresult> HTMLEditor::AutoListElementCreator::Run( + HTMLEditor& aHTMLEditor, AutoRangeArray& aRanges, + SelectAllOfCurrentList aSelectAllOfCurrentList, + const Element& aEditingHost) const { + MOZ_ASSERT(aHTMLEditor.IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(!aHTMLEditor.IsSelectionRangeContainerNotContent()); + + if (NS_WARN_IF(!aRanges.SaveAndTrackRanges(aHTMLEditor))) { + return Err(NS_ERROR_FAILURE); + } + + AutoContentNodeArray arrayOfContents; + nsresult rv = SplitAtRangeEdgesAndCollectContentNodesToMoveIntoList( + aHTMLEditor, aRanges, aSelectAllOfCurrentList, aEditingHost, + arrayOfContents); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoListElementCreator::" + "SplitAtRangeEdgesAndCollectContentNodesToMoveIntoList() failed"); + return Err(rv); + } + + // check if all our nodes are <br>s, or empty inlines + // if no nodes, we make empty list. Ditto if the user tried to make a list + // of some # of breaks. + if (AutoListElementCreator:: + IsEmptyOrContainsOnlyBRElementsOrEmptyInlineElements( + arrayOfContents)) { + Result<RefPtr<Element>, nsresult> newListItemElementOrError = + ReplaceContentNodesWithEmptyNewList(aHTMLEditor, aRanges, + arrayOfContents, aEditingHost); + if (MOZ_UNLIKELY(newListItemElementOrError.isErr())) { + NS_WARNING( + "AutoListElementCreator::ReplaceContentNodesWithEmptyNewList() " + "failed"); + return newListItemElementOrError.propagateErr(); + } + if (MOZ_UNLIKELY(!newListItemElementOrError.inspect())) { + aRanges.RestoreFromSavedRanges(); + return EditActionResult::CanceledResult(); + } + aRanges.ClearSavedRanges(); + nsresult rv = aRanges.Collapse( + EditorRawDOMPoint(newListItemElementOrError.inspect(), 0u)); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::Collapse() failed"); + return Err(rv); + } + return EditActionResult::IgnoredResult(); + } + + Result<RefPtr<Element>, nsresult> listItemOrListToPutCaretOrError = + WrapContentNodesIntoNewListElements(aHTMLEditor, aRanges, arrayOfContents, + aEditingHost); + if (MOZ_UNLIKELY(listItemOrListToPutCaretOrError.isErr())) { + NS_WARNING( + "AutoListElementCreator::WrapContentNodesIntoNewListElements() failed"); + return listItemOrListToPutCaretOrError.propagateErr(); + } + + MOZ_ASSERT(aRanges.HasSavedRanges()); + aRanges.RestoreFromSavedRanges(); + + // If selection will be collapsed but not in listItemOrListToPutCaret, we need + // to adjust the caret position into it. + if (listItemOrListToPutCaretOrError.inspect()) { + DebugOnly<nsresult> rvIgnored = + EnsureCollapsedRangeIsInListItemOrListElement( + *listItemOrListToPutCaretOrError.inspect(), aRanges); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "AutoListElementCreator::" + "EnsureCollapsedRangeIsInListItemOrListElement() failed, but ignored"); + } + + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::AutoListElementCreator:: + SplitAtRangeEdgesAndCollectContentNodesToMoveIntoList( + HTMLEditor& aHTMLEditor, AutoRangeArray& aRanges, + SelectAllOfCurrentList aSelectAllOfCurrentList, + const Element& aEditingHost, + ContentNodeArray& aOutArrayOfContents) const { + MOZ_ASSERT(aOutArrayOfContents.IsEmpty()); + + if (aSelectAllOfCurrentList == SelectAllOfCurrentList::Yes) { + if (Element* parentListElementOfRanges = + aRanges.GetClosestAncestorAnyListElementOfRange()) { + aOutArrayOfContents.AppendElement( + OwningNonNull<nsIContent>(*parentListElementOfRanges)); + return NS_OK; + } + } + + AutoRangeArray extendedRanges(aRanges); + + // TODO: We don't need AutoTransactionsConserveSelection here in the + // normal cases, but removing this may cause the behavior with the + // legacy mutation event listeners. We should try to delete this in + // a bug. + AutoTransactionsConserveSelection dontChangeMySelection(aHTMLEditor); + + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eCreateOrChangeList, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedRanges.SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + aHTMLEditor, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() failed"); + return splitResult.unwrapErr(); + } + nsresult rv = extendedRanges.CollectEditTargetNodes( + aHTMLEditor, aOutArrayOfContents, EditSubAction::eCreateOrChangeList, + AutoRangeArray::CollectNonEditableNodes::No); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eCreateOrChangeList, CollectNonEditableNodes::No) failed"); + return rv; + } + + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + aHTMLEditor.MaybeSplitElementsAtEveryBRElement( + aOutArrayOfContents, EditSubAction::eCreateOrChangeList); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eCreateOrChangeList) failed"); + return splitAtBRElementsResult.unwrapErr(); + } + return NS_OK; +} + +// static +bool HTMLEditor::AutoListElementCreator:: + IsEmptyOrContainsOnlyBRElementsOrEmptyInlineElements( + const ContentNodeArray& aArrayOfContents) { + for (const OwningNonNull<nsIContent>& content : aArrayOfContents) { + // if content is not a <br> or empty inline, we're done + // XXX Should we handle line breaks in preformatted text node? + if (!content->IsHTMLElement(nsGkAtoms::br) && + !HTMLEditUtils::IsEmptyInlineContainer( + content, {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + return false; + } + } + return true; +} + +Result<RefPtr<Element>, nsresult> +HTMLEditor::AutoListElementCreator::ReplaceContentNodesWithEmptyNewList( + HTMLEditor& aHTMLEditor, const AutoRangeArray& aRanges, + const AutoContentNodeArray& aArrayOfContents, + const Element& aEditingHost) const { + // if only breaks, delete them + for (const OwningNonNull<nsIContent>& content : aArrayOfContents) { + // MOZ_KnownLive because of bug 1620312 + nsresult rv = + aHTMLEditor.DeleteNodeWithTransaction(MOZ_KnownLive(*content)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + + const auto firstRangeStartPoint = + aRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!firstRangeStartPoint.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + + // Make sure we can put a list here. + if (!HTMLEditUtils::CanNodeContain(*firstRangeStartPoint.GetContainer(), + mListTagName)) { + return RefPtr<Element>(); + } + + RefPtr<Element> newListItemElement; + Result<CreateElementResult, nsresult> createNewListElementResult = + aHTMLEditor.InsertElementWithSplittingAncestorsWithTransaction( + mListTagName, firstRangeStartPoint, BRElementNextToSplitPoint::Keep, + aEditingHost, + // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868 + [&](HTMLEditor& aHTMLEditor, Element& aListElement, + const EditorDOMPoint&) MOZ_CAN_RUN_SCRIPT_BOUNDARY { + AutoHandlingState dummyState; + Result<CreateElementResult, nsresult> createListItemElementResult = + AppendListItemElement(aHTMLEditor, aListElement, dummyState); + if (MOZ_UNLIKELY(createListItemElementResult.isErr())) { + NS_WARNING( + "AutoListElementCreator::AppendListItemElement() failed"); + return createListItemElementResult.unwrapErr(); + } + CreateElementResult unwrappedResult = + createListItemElementResult.unwrap(); + // There is AutoSelectionRestorer in this method so that it'll + // be restored or updated with making it abort. Therefore, + // we don't need to update selection here. + // XXX I'd like to check aRanges.HasSavedRanges() here, but it + // requires ifdefs to avoid bustage of opt builds caused + // by unused warning... + unwrappedResult.IgnoreCaretPointSuggestion(); + newListItemElement = unwrappedResult.UnwrapNewNode(); + MOZ_ASSERT(newListItemElement); + return NS_OK; + }); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "%s) failed", + nsAtomCString(&mListTagName).get()) + .get()); + return createNewListElementResult.propagateErr(); + } + MOZ_ASSERT(createNewListElementResult.inspect().GetNewNode()); + + // Put selection in new list item and don't restore the Selection. + createNewListElementResult.inspect().IgnoreCaretPointSuggestion(); + return newListItemElement; +} + +Result<RefPtr<Element>, nsresult> +HTMLEditor::AutoListElementCreator::WrapContentNodesIntoNewListElements( + HTMLEditor& aHTMLEditor, AutoRangeArray& aRanges, + AutoContentNodeArray& aArrayOfContents, const Element& aEditingHost) const { + // if there is only one node in the array, and it is a list, div, or + // blockquote, then look inside of it until we find inner list or content. + if (aArrayOfContents.Length() == 1) { + if (Element* deepestDivBlockquoteOrListElement = + HTMLEditUtils::GetInclusiveDeepestFirstChildWhichHasOneChild( + aArrayOfContents[0], {WalkTreeOption::IgnoreNonEditableNode}, + nsGkAtoms::div, nsGkAtoms::blockquote, nsGkAtoms::ul, + nsGkAtoms::ol, nsGkAtoms::dl)) { + if (deepestDivBlockquoteOrListElement->IsAnyOfHTMLElements( + nsGkAtoms::div, nsGkAtoms::blockquote)) { + aArrayOfContents.Clear(); + HTMLEditUtils::CollectChildren(*deepestDivBlockquoteOrListElement, + aArrayOfContents, 0, {}); + } else { + aArrayOfContents.ReplaceElementAt( + 0, OwningNonNull<nsIContent>(*deepestDivBlockquoteOrListElement)); + } + } + } + + // Ok, now go through all the nodes and put then in the list, + // or whatever is appropriate. Wohoo! + AutoHandlingState handlingState; + for (const OwningNonNull<nsIContent>& content : aArrayOfContents) { + // MOZ_KnownLive because of bug 1620312 + nsresult rv = HandleChildContent(aHTMLEditor, MOZ_KnownLive(content), + handlingState, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("AutoListElementCreator::HandleChildContent() failed"); + return Err(rv); + } + } + + return std::move(handlingState.mListOrListItemElementToPutCaret); +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildContent( + HTMLEditor& aHTMLEditor, nsIContent& aHandlingContent, + AutoHandlingState& aState, const Element& aEditingHost) const { + // make sure we don't assemble content that is in different table cells + // into the same list. respect table cell boundaries when listifying. + if (aState.mCurrentListElement && + HTMLEditUtils::GetInclusiveAncestorAnyTableElement( + *aState.mCurrentListElement) != + HTMLEditUtils::GetInclusiveAncestorAnyTableElement( + aHandlingContent)) { + aState.mCurrentListElement = nullptr; + } + + // If current node is a `<br>` element, delete it and forget previous + // list item element. + // If current node is an empty inline node, just delete it. + if (EditorUtils::IsEditableContent(aHandlingContent, EditorType::HTML) && + (aHandlingContent.IsHTMLElement(nsGkAtoms::br) || + HTMLEditUtils::IsEmptyInlineContainer( + aHandlingContent, + {EmptyCheckOption::TreatSingleBRElementAsVisible}))) { + nsresult rv = aHTMLEditor.DeleteNodeWithTransaction(aHandlingContent); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + if (aHandlingContent.IsHTMLElement(nsGkAtoms::br)) { + aState.mPreviousListItemElement = nullptr; + } + return NS_OK; + } + + // If we meet a list, we can reuse it or convert it to the expected type list. + if (HTMLEditUtils::IsAnyListElement(&aHandlingContent)) { + nsresult rv = HandleChildListElement( + aHTMLEditor, MOZ_KnownLive(*aHandlingContent.AsElement()), aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::HandleChildListElement() failed"); + return rv; + } + + // We cannot handle nodes if not in element node. + if (NS_WARN_IF(!aHandlingContent.GetParentElement())) { + return NS_ERROR_FAILURE; + } + + // If we meet a list item, we can just move it to current list element or new + // list element. + if (HTMLEditUtils::IsListItem(&aHandlingContent)) { + nsresult rv = HandleChildListItemElement( + aHTMLEditor, MOZ_KnownLive(*aHandlingContent.AsElement()), aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::HandleChildListItemElement() failed"); + return rv; + } + + // If we meet a <div> or a <p>, we want only its children to wrapping into + // list element. Therefore, this call will call this recursively. + if (aHandlingContent.IsAnyOfHTMLElements(nsGkAtoms::div, nsGkAtoms::p)) { + nsresult rv = HandleChildDivOrParagraphElement( + aHTMLEditor, MOZ_KnownLive(*aHandlingContent.AsElement()), aState, + aEditingHost); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::HandleChildDivOrParagraphElement() failed"); + return rv; + } + + // If we've not met a list element, create a list element and make it + // current list element. + if (!aState.mCurrentListElement) { + nsresult rv = CreateAndUpdateCurrentListElement( + aHTMLEditor, EditorDOMPoint(&aHandlingContent), + EmptyListItem::NotCreate, aState, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("AutoListElementCreator::HandleChildInlineElement() failed"); + return rv; + } + } + + // If we meet an inline content, we want to move it to previously used list + // item element or new list item element. + // XXX Despite the name, HTMLEditUtils::IsInlineElement() returns true for + // non-element content nodes too. + if (HTMLEditUtils::IsInlineElement(aHandlingContent)) { + nsresult rv = + HandleChildInlineContent(aHTMLEditor, aHandlingContent, aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::HandleChildInlineElement() failed"); + return rv; + } + + // Otherwise, we should wrap it into new list item element. + nsresult rv = + WrapContentIntoNewListItemElement(aHTMLEditor, aHandlingContent, aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::WrapContentIntoNewListItemElement() failed"); + return rv; +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildListElement( + HTMLEditor& aHTMLEditor, Element& aHandlingListElement, + AutoHandlingState& aState) const { + MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aHandlingListElement)); + + // If we met a list element and current list element is not a descendant + // of the list, append current node to end of the current list element. + // Then, wrap it with list item element and delete the old container. + if (aState.mCurrentListElement && + !EditorUtils::IsDescendantOf(aHandlingListElement, + *aState.mCurrentListElement)) { + Result<MoveNodeResult, nsresult> moveNodeResult = + aHTMLEditor.MoveNodeToEndWithTransaction( + aHandlingListElement, MOZ_KnownLive(*aState.mCurrentListElement)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + moveNodeResult.inspect().IgnoreCaretPointSuggestion(); + + Result<CreateElementResult, nsresult> convertListTypeResult = + aHTMLEditor.ChangeListElementType(aHandlingListElement, mListTagName, + mListItemTagName); + if (MOZ_UNLIKELY(convertListTypeResult.isErr())) { + NS_WARNING("HTMLEditor::ChangeListElementType() failed"); + return convertListTypeResult.propagateErr(); + } + convertListTypeResult.inspect().IgnoreCaretPointSuggestion(); + + Result<EditorDOMPoint, nsresult> unwrapNewListElementResult = + aHTMLEditor.RemoveBlockContainerWithTransaction( + MOZ_KnownLive(*convertListTypeResult.inspect().GetNewNode())); + if (MOZ_UNLIKELY(unwrapNewListElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapNewListElementResult.propagateErr(); + } + aState.mPreviousListItemElement = nullptr; + return NS_OK; + } + + // If current list element is in found list element or we've not met a + // list element, convert current list element to proper type. + Result<CreateElementResult, nsresult> convertListTypeResult = + aHTMLEditor.ChangeListElementType(aHandlingListElement, mListTagName, + mListItemTagName); + if (MOZ_UNLIKELY(convertListTypeResult.isErr())) { + NS_WARNING("HTMLEditor::ChangeListElementType() failed"); + return convertListTypeResult.propagateErr(); + } + CreateElementResult unwrappedConvertListTypeResult = + convertListTypeResult.unwrap(); + unwrappedConvertListTypeResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedConvertListTypeResult.GetNewNode()); + aState.mCurrentListElement = unwrappedConvertListTypeResult.UnwrapNewNode(); + aState.mPreviousListItemElement = nullptr; + return NS_OK; +} + +nsresult +HTMLEditor::AutoListElementCreator::HandleChildListItemInDifferentTypeList( + HTMLEditor& aHTMLEditor, Element& aHandlingListItemElement, + AutoHandlingState& aState) const { + MOZ_ASSERT(HTMLEditUtils::IsListItem(&aHandlingListItemElement)); + MOZ_ASSERT( + !aHandlingListItemElement.GetParent()->IsHTMLElement(&mListTagName)); + + // If we've not met a list element or current node is not in current list + // element, insert a list element at current node and set current list element + // to the new one. + if (!aState.mCurrentListElement || + aHandlingListItemElement.IsInclusiveDescendantOf( + aState.mCurrentListElement)) { + EditorDOMPoint atListItem(&aHandlingListItemElement); + MOZ_ASSERT(atListItem.IsInContentNode()); + + Result<SplitNodeResult, nsresult> splitListItemParentResult = + aHTMLEditor.SplitNodeWithTransaction(atListItem); + if (MOZ_UNLIKELY(splitListItemParentResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); + return splitListItemParentResult.propagateErr(); + } + SplitNodeResult unwrappedSplitListItemParentResult = + splitListItemParentResult.unwrap(); + MOZ_ASSERT(unwrappedSplitListItemParentResult.DidSplit()); + unwrappedSplitListItemParentResult.IgnoreCaretPointSuggestion(); + + Result<CreateElementResult, nsresult> createNewListElementResult = + aHTMLEditor.CreateAndInsertElement( + WithTransaction::Yes, mListTagName, + unwrappedSplitListItemParentResult.AtNextContent<EditorDOMPoint>()); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) " + "failed"); + return createNewListElementResult.propagateErr(); + } + CreateElementResult unwrapCreateNewListElementResult = + createNewListElementResult.unwrap(); + unwrapCreateNewListElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrapCreateNewListElementResult.GetNewNode()); + aState.mCurrentListElement = + unwrapCreateNewListElementResult.UnwrapNewNode(); + } + + // Then, move current node into current list element. + Result<MoveNodeResult, nsresult> moveNodeResult = + aHTMLEditor.MoveNodeToEndWithTransaction( + aHandlingListItemElement, MOZ_KnownLive(*aState.mCurrentListElement)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + moveNodeResult.inspect().IgnoreCaretPointSuggestion(); + + // Convert list item type if current node is different list item type. + if (aHandlingListItemElement.IsHTMLElement(&mListItemTagName)) { + return NS_OK; + } + Result<CreateElementResult, nsresult> newListItemElementOrError = + aHTMLEditor.ReplaceContainerAndCloneAttributesWithTransaction( + aHandlingListItemElement, mListItemTagName); + if (MOZ_UNLIKELY(newListItemElementOrError.isErr())) { + NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); + return newListItemElementOrError.propagateErr(); + } + newListItemElementOrError.inspect().IgnoreCaretPointSuggestion(); + return NS_OK; +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildListItemElement( + HTMLEditor& aHTMLEditor, Element& aHandlingListItemElement, + AutoHandlingState& aState) const { + MOZ_ASSERT(aHandlingListItemElement.GetParentNode()); + MOZ_ASSERT(HTMLEditUtils::IsListItem(&aHandlingListItemElement)); + + // If current list item element is not in proper list element, we need + // to convert the list element. + // XXX This check is not enough, + if (!aHandlingListItemElement.GetParentNode()->IsHTMLElement(&mListTagName)) { + nsresult rv = HandleChildListItemInDifferentTypeList( + aHTMLEditor, aHandlingListItemElement, aState); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoListElementCreator::HandleChildListItemInDifferentTypeList() " + "failed"); + return rv; + } + } else { + nsresult rv = HandleChildListItemInSameTypeList( + aHTMLEditor, aHandlingListItemElement, aState); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoListElementCreator::HandleChildListItemInSameTypeList() failed"); + return rv; + } + } + + // If bullet type is specified, set list type attribute. + // XXX Cannot we set type attribute before inserting the list item + // element into the DOM tree? + if (!mBulletType.IsEmpty()) { + nsresult rv = aHTMLEditor.SetAttributeWithTransaction( + aHandlingListItemElement, *nsGkAtoms::type, mBulletType); + if (NS_WARN_IF(aHTMLEditor.Destroyed())) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::SetAttributeWithTransaction(nsGkAtoms::type) failed"); + return rv; + } + + // Otherwise, remove list type attribute if there is. + if (!aHandlingListItemElement.HasAttr(nsGkAtoms::type)) { + return NS_OK; + } + nsresult rv = aHTMLEditor.RemoveAttributeWithTransaction( + aHandlingListItemElement, *nsGkAtoms::type); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::type) failed"); + return rv; +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildListItemInSameTypeList( + HTMLEditor& aHTMLEditor, Element& aHandlingListItemElement, + AutoHandlingState& aState) const { + MOZ_ASSERT(HTMLEditUtils::IsListItem(&aHandlingListItemElement)); + MOZ_ASSERT( + aHandlingListItemElement.GetParent()->IsHTMLElement(&mListTagName)); + + EditorDOMPoint atListItem(&aHandlingListItemElement); + MOZ_ASSERT(atListItem.IsInContentNode()); + + // If we've not met a list element, set current list element to the + // parent of current list item element. + if (!aState.mCurrentListElement) { + aState.mCurrentListElement = atListItem.GetContainerAs<Element>(); + NS_WARNING_ASSERTION( + HTMLEditUtils::IsAnyListElement(aState.mCurrentListElement), + "Current list item parent is not a list element"); + } + // If current list item element is not a child of current list element, + // move it into current list item. + else if (atListItem.GetContainer() != aState.mCurrentListElement) { + Result<MoveNodeResult, nsresult> moveNodeResult = + aHTMLEditor.MoveNodeToEndWithTransaction( + aHandlingListItemElement, + MOZ_KnownLive(*aState.mCurrentListElement)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + moveNodeResult.inspect().IgnoreCaretPointSuggestion(); + } + + // Then, if current list item element is not proper type for current + // list element, convert list item element to proper element. + if (aHandlingListItemElement.IsHTMLElement(&mListItemTagName)) { + return NS_OK; + } + // FIXME: Manage attribute cloning + Result<CreateElementResult, nsresult> newListItemElementOrError = + aHTMLEditor.ReplaceContainerAndCloneAttributesWithTransaction( + aHandlingListItemElement, mListItemTagName); + if (MOZ_UNLIKELY(newListItemElementOrError.isErr())) { + NS_WARNING( + "HTMLEditor::ReplaceContainerAndCloneAttributesWithTransaction() " + "failed"); + return newListItemElementOrError.propagateErr(); + } + newListItemElementOrError.inspect().IgnoreCaretPointSuggestion(); + return NS_OK; +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildDivOrParagraphElement( + HTMLEditor& aHTMLEditor, Element& aHandlingDivOrParagraphElement, + AutoHandlingState& aState, const Element& aEditingHost) const { + MOZ_ASSERT(aHandlingDivOrParagraphElement.IsAnyOfHTMLElements(nsGkAtoms::div, + nsGkAtoms::p)); + + AutoRestore<RefPtr<Element>> previouslyReplacingBlockElement( + aState.mReplacingBlockElement); + aState.mReplacingBlockElement = &aHandlingDivOrParagraphElement; + AutoRestore<bool> previouslyReplacingBlockElementIdCopied( + aState.mMaybeCopiedReplacingBlockElementId); + aState.mMaybeCopiedReplacingBlockElementId = false; + + // If the <div> or <p> is empty, we should replace it with a list element + // and/or a list item element. + if (HTMLEditUtils::IsEmptyNode(aHandlingDivOrParagraphElement, + {EmptyCheckOption::IgnoreEditableState, + EmptyCheckOption::TreatListItemAsVisible, + EmptyCheckOption::TreatTableCellAsVisible})) { + if (!aState.mCurrentListElement) { + nsresult rv = CreateAndUpdateCurrentListElement( + aHTMLEditor, EditorDOMPoint(&aHandlingDivOrParagraphElement), + EmptyListItem::Create, aState, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoListElementCreator::CreateAndUpdateCurrentListElement(" + "EmptyListItem::Create) failed"); + return rv; + } + } else { + Result<CreateElementResult, nsresult> createListItemElementResult = + AppendListItemElement( + aHTMLEditor, MOZ_KnownLive(*aState.mCurrentListElement), aState); + if (MOZ_UNLIKELY(createListItemElementResult.isErr())) { + NS_WARNING("AutoListElementCreator::AppendListItemElement() failed"); + return createListItemElementResult.unwrapErr(); + } + CreateElementResult unwrappedResult = + createListItemElementResult.unwrap(); + unwrappedResult.IgnoreCaretPointSuggestion(); + aState.mListOrListItemElementToPutCaret = unwrappedResult.UnwrapNewNode(); + } + nsresult rv = + aHTMLEditor.DeleteNodeWithTransaction(aHandlingDivOrParagraphElement); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::DeleteNodeWithTransaction() failed"); + return rv; + } + + // We don't want new inline contents inserted into the new list item element + // because we want to keep the line break at end of + // aHandlingDivOrParagraphElement. + aState.mPreviousListItemElement = nullptr; + + return NS_OK; + } + + // If current node is a <div> element, replace it with its children and handle + // them as same as topmost children in the range. + AutoContentNodeArray arrayOfContentsInDiv; + HTMLEditUtils::CollectChildren(aHandlingDivOrParagraphElement, + arrayOfContentsInDiv, 0, + {CollectChildrenOption::CollectListChildren, + CollectChildrenOption::CollectTableChildren}); + + Result<EditorDOMPoint, nsresult> unwrapDivElementResult = + aHTMLEditor.RemoveContainerWithTransaction( + aHandlingDivOrParagraphElement); + if (MOZ_UNLIKELY(unwrapDivElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveContainerWithTransaction() failed"); + return unwrapDivElementResult.unwrapErr(); + } + + for (const OwningNonNull<nsIContent>& content : arrayOfContentsInDiv) { + // MOZ_KnownLive because of bug 1620312 + nsresult rv = HandleChildContent(aHTMLEditor, MOZ_KnownLive(content), + aState, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("AutoListElementCreator::HandleChildContent() failed"); + return rv; + } + } + + // We don't want new inline contents inserted into the new list item element + // because we want to keep the line break at end of + // aHandlingDivOrParagraphElement. + aState.mPreviousListItemElement = nullptr; + + return NS_OK; +} + +nsresult HTMLEditor::AutoListElementCreator::CreateAndUpdateCurrentListElement( + HTMLEditor& aHTMLEditor, const EditorDOMPoint& aPointToInsert, + EmptyListItem aEmptyListItem, AutoHandlingState& aState, + const Element& aEditingHost) const { + MOZ_ASSERT(aPointToInsert.IsSetAndValid()); + + aState.mPreviousListItemElement = nullptr; + RefPtr<Element> newListItemElement; + auto initializer = + // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868 + [&](HTMLEditor&, Element& aListElement, const EditorDOMPoint&) + MOZ_CAN_RUN_SCRIPT_BOUNDARY { + // If the replacing element has `dir` attribute, the new list + // element should take it to correct its list marker position. + if (aState.mReplacingBlockElement) { + nsString dirValue; + if (aState.mReplacingBlockElement->GetAttr(nsGkAtoms::dir, + dirValue) && + !dirValue.IsEmpty()) { + // We don't need to use transaction to set `dir` attribute here + // because the element will be stored with the `dir` attribute + // in InsertNodeTransaction. Therefore, undo should work. + IgnoredErrorResult ignoredError; + aListElement.SetAttr(nsGkAtoms::dir, dirValue, ignoredError); + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "Element::SetAttr(nsGkAtoms::dir) failed, but ignored"); + } + } + if (aEmptyListItem == EmptyListItem::Create) { + Result<CreateElementResult, nsresult> createNewListItemResult = + AppendListItemElement(aHTMLEditor, aListElement, aState); + if (MOZ_UNLIKELY(createNewListItemResult.isErr())) { + NS_WARNING( + "HTMLEditor::AppendNewElementToInsertingElement()" + " failed"); + return createNewListItemResult.unwrapErr(); + } + CreateElementResult unwrappedResult = + createNewListItemResult.unwrap(); + unwrappedResult.IgnoreCaretPointSuggestion(); + newListItemElement = unwrappedResult.UnwrapNewNode(); + } + return NS_OK; + }; + Result<CreateElementResult, nsresult> createNewListElementResult = + aHTMLEditor.InsertElementWithSplittingAncestorsWithTransaction( + mListTagName, aPointToInsert, BRElementNextToSplitPoint::Keep, + aEditingHost, initializer); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTransaction(%s) failed", + nsAtomCString(&mListTagName).get()) + .get()); + return createNewListElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewListElementResult = + createNewListElementResult.unwrap(); + unwrappedCreateNewListElementResult.IgnoreCaretPointSuggestion(); + + MOZ_ASSERT(unwrappedCreateNewListElementResult.GetNewNode()); + aState.mListOrListItemElementToPutCaret = + newListItemElement ? newListItemElement.get() + : unwrappedCreateNewListElementResult.GetNewNode(); + aState.mCurrentListElement = + unwrappedCreateNewListElementResult.UnwrapNewNode(); + aState.mPreviousListItemElement = std::move(newListItemElement); + return NS_OK; +} + +// static +nsresult HTMLEditor::AutoListElementCreator::MaybeCloneAttributesToNewListItem( + HTMLEditor& aHTMLEditor, Element& aListItemElement, + AutoHandlingState& aState) { + if (!aState.mReplacingBlockElement) { + return NS_OK; + } + // If we're replacing a block element, the list items should have attributes + // of the replacing element. However, we don't want to copy `dir` attribute + // because it does not affect content in list item element and setting + // opposite direction from the parent list causes the marker invisible. + // Therefore, we don't want to take it. Finally, we don't need to use + // transaction to copy the attributes here because the element will be stored + // with the attributes in InsertNodeTransaction. Therefore, undo should work. + nsresult rv = aHTMLEditor.CopyAttributes( + WithTransaction::No, aListItemElement, + MOZ_KnownLive(*aState.mReplacingBlockElement), + aState.mMaybeCopiedReplacingBlockElementId + ? HTMLEditor::CopyAllAttributesExceptIdAndDir + : HTMLEditor::CopyAllAttributesExceptDir); + aState.mMaybeCopiedReplacingBlockElementId = true; + if (NS_WARN_IF(aHTMLEditor.Destroyed())) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::CopyAttributes(WithTransaction::No) failed"); + return rv; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::AutoListElementCreator::AppendListItemElement( + HTMLEditor& aHTMLEditor, const Element& aListElement, + AutoHandlingState& aState) const { + const WithTransaction withTransaction = aListElement.IsInComposedDoc() + ? WithTransaction::Yes + : WithTransaction::No; + Result<CreateElementResult, nsresult> createNewListItemResult = + aHTMLEditor.CreateAndInsertElement( + withTransaction, mListItemTagName, + EditorDOMPoint::AtEndOf(aListElement), + !aState.mReplacingBlockElement + ? HTMLEditor::DoNothingForNewElement + // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868 + : [&aState](HTMLEditor& aHTMLEditor, Element& aListItemElement, + const EditorDOMPoint&) MOZ_CAN_RUN_SCRIPT_BOUNDARY { + nsresult rv = + AutoListElementCreator::MaybeCloneAttributesToNewListItem( + aHTMLEditor, aListItemElement, aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::" + "MaybeCloneAttributesToNewListItem() failed"); + return rv; + }); + NS_WARNING_ASSERTION(createNewListItemResult.isOk(), + "HTMLEditor::CreateAndInsertElement() failed"); + return createNewListItemResult; +} + +nsresult HTMLEditor::AutoListElementCreator::HandleChildInlineContent( + HTMLEditor& aHTMLEditor, nsIContent& aHandlingInlineContent, + AutoHandlingState& aState) const { + MOZ_ASSERT(HTMLEditUtils::IsInlineElement(aHandlingInlineContent)); + + // If we're currently handling contents of a list item and current node + // is not a block element, move current node into the list item. + if (!aState.mPreviousListItemElement) { + nsresult rv = WrapContentIntoNewListItemElement( + aHTMLEditor, aHandlingInlineContent, aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::WrapContentIntoNewListItemElement() failed"); + return rv; + } + + Result<MoveNodeResult, nsresult> moveInlineElementResult = + aHTMLEditor.MoveNodeToEndWithTransaction( + aHandlingInlineContent, + MOZ_KnownLive(*aState.mPreviousListItemElement)); + if (MOZ_UNLIKELY(moveInlineElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveInlineElementResult.propagateErr(); + } + moveInlineElementResult.inspect().IgnoreCaretPointSuggestion(); + return NS_OK; +} + +nsresult HTMLEditor::AutoListElementCreator::WrapContentIntoNewListItemElement( + HTMLEditor& aHTMLEditor, nsIContent& aHandlingContent, + AutoHandlingState& aState) const { + // If current node is not a paragraph, wrap current node with new list + // item element and move it into current list element. + Result<CreateElementResult, nsresult> wrapContentInListItemElementResult = + aHTMLEditor.InsertContainerWithTransaction( + aHandlingContent, mListItemTagName, + !aState.mReplacingBlockElement + ? HTMLEditor::DoNothingForNewElement + // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868 + : [&aState](HTMLEditor& aHTMLEditor, Element& aListItemElement, + const EditorDOMPoint&) MOZ_CAN_RUN_SCRIPT_BOUNDARY { + nsresult rv = + AutoListElementCreator::MaybeCloneAttributesToNewListItem( + aHTMLEditor, aListItemElement, aState); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "AutoListElementCreator::" + "MaybeCloneAttributesToNewListItem() failed"); + return rv; + }); + if (MOZ_UNLIKELY(wrapContentInListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertContainerWithTransaction() failed"); + return wrapContentInListItemElementResult.unwrapErr(); + } + CreateElementResult unwrappedWrapContentInListItemElementResult = + wrapContentInListItemElementResult.unwrap(); + unwrappedWrapContentInListItemElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedWrapContentInListItemElementResult.GetNewNode()); + + // MOZ_KnownLive(unwrappedWrapContentInListItemElementResult.GetNewNode()): + // The result is grabbed by unwrappedWrapContentInListItemElementResult. + Result<MoveNodeResult, nsresult> moveListItemElementResult = + aHTMLEditor.MoveNodeToEndWithTransaction( + MOZ_KnownLive( + *unwrappedWrapContentInListItemElementResult.GetNewNode()), + MOZ_KnownLive(*aState.mCurrentListElement)); + if (MOZ_UNLIKELY(moveListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveListItemElementResult.unwrapErr(); + } + moveListItemElementResult.inspect().IgnoreCaretPointSuggestion(); + + // If current node is not a block element, new list item should have + // following inline nodes too. + if (HTMLEditUtils::IsInlineElement(aHandlingContent)) { + aState.mPreviousListItemElement = + unwrappedWrapContentInListItemElementResult.UnwrapNewNode(); + } else { + aState.mPreviousListItemElement = nullptr; + } + + // XXX Why don't we set `type` attribute here?? + return NS_OK; +} + +nsresult HTMLEditor::AutoListElementCreator:: + EnsureCollapsedRangeIsInListItemOrListElement( + Element& aListItemOrListToPutCaret, AutoRangeArray& aRanges) const { + if (!aRanges.IsCollapsed() || aRanges.Ranges().IsEmpty()) { + return NS_OK; + } + + const auto firstRangeStartPoint = + aRanges.GetFirstRangeStartPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!firstRangeStartPoint.IsSet())) { + return NS_OK; + } + Result<EditorRawDOMPoint, nsresult> pointToPutCaretOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorRawDOMPoint>(aListItemOrListToPutCaret, firstRangeStartPoint); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditUtils::ComputePointToPutCaretInElementIfOutside()"); + return pointToPutCaretOrError.unwrapErr(); + } + if (pointToPutCaretOrError.inspect().IsSet()) { + nsresult rv = aRanges.Collapse(pointToPutCaretOrError.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::Collapse() failed"); + return rv; + } + } + return NS_OK; +} + +nsresult HTMLEditor::RemoveListAtSelectionAsSubAction( + const Element& aEditingHost) { + 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; + } + } + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult error; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eRemoveList, nsIEditor::eNext, error); + if (NS_WARN_IF(error.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return error.StealNSResult(); + } + NS_WARNING_ASSERTION( + !error.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + // XXX Why do we do this only when there is only one selection range? + if (!SelectionRef().IsCollapsed() && SelectionRef().RangeCount() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + SelectionRef().GetRangeAt(0u), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.unwrapErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use Selection::SetStartAndEndInLimit() here. + error.SuppressException(); + SelectionRef().SetBaseAndExtentInLimiter( + extendedRange.inspect().StartRef().ToRawRangeBoundary(), + extendedRange.inspect().EndRef().ToRawRangeBoundary(), error); + if (NS_WARN_IF(Destroyed())) { + return NS_ERROR_EDITOR_DESTROYED; + } + if (error.Failed()) { + NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); + return error.StealNSResult(); + } + } + + AutoSelectionRestorer restoreSelectionLater(*this); + + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + { + // TODO: We don't need AutoTransactionsConserveSelection here in the normal + // cases, but removing this may cause the behavior with the legacy + // mutation event listeners. We should try to delete this in a bug. + AutoTransactionsConserveSelection dontChangeMySelection(*this); + + { + AutoRangeArray extendedSelectionRanges(SelectionRef()); + extendedSelectionRanges + .ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eCreateOrChangeList, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedSelectionRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() " + "failed"); + return splitResult.unwrapErr(); + } + nsresult rv = extendedSelectionRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eCreateOrChangeList, + AutoRangeArray::CollectNonEditableNodes::No); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eCreateOrChangeList, CollectNonEditableNodes::No) failed"); + return rv; + } + } + + const Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eCreateOrChangeList); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eCreateOrChangeList) failed"); + return splitAtBRElementsResult.inspectErr(); + } + } + + // Remove all non-editable nodes. Leave them be. + // XXX CollectEditTargetNodes() should return only editable contents when it's + // called with CollectNonEditableNodes::No, but checking it here, looks + // like just wasting the runtime cost. + for (int32_t i = arrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull<nsIContent>& content = arrayOfContents[i]; + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + arrayOfContents.RemoveElementAt(i); + } + } + + // Only act on lists or list items in the array + for (auto& content : arrayOfContents) { + // here's where we actually figure out what to do + if (HTMLEditUtils::IsListItem(content)) { + // unlist this listitem + nsresult rv = LiftUpListItemElement(MOZ_KnownLive(*content->AsElement()), + LiftUpFromAllParentListElements::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" + ":Yes) failed"); + return rv; + } + continue; + } + if (HTMLEditUtils::IsAnyListElement(content)) { + // node is a list, move list items out + nsresult rv = + DestroyListStructureRecursively(MOZ_KnownLive(*content->AsElement())); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::DestroyListStructureRecursively() failed"); + return rv; + } + continue; + } + } + return NS_OK; +} + +Result<RefPtr<Element>, nsresult> +HTMLEditor::FormatBlockContainerWithTransaction( + AutoRangeArray& aSelectionRanges, nsAtom& blockType, + const Element& aEditingHost) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + // XXX Why do we do this only when there is only one selection range? + if (!aSelectionRanges.IsCollapsed() && + aSelectionRanges.Ranges().Length() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + aSelectionRanges.FirstRangeRef(), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.propagateErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use AutoRangeArray::SetStartAndEnd() here. + if (NS_FAILED(aSelectionRanges.SetBaseAndExtent( + extendedRange.inspect().StartRef(), + extendedRange.inspect().EndRef()))) { + NS_WARNING("AutoRangeArray::SetBaseAndExtent() failed"); + return Err(NS_ERROR_FAILURE); + } + } + + MOZ_ALWAYS_TRUE(aSelectionRanges.SaveAndTrackRanges(*this)); + + // TODO: We don't need AutoTransactionsConserveSelection here in the normal + // cases, but removing this may cause the behavior with the legacy + // mutation event listeners. We should try to delete this in a bug. + AutoTransactionsConserveSelection dontChangeMySelection(*this); + + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + aSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eCreateOrRemoveBlock, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + aSelectionRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() failed"); + return splitResult.propagateErr(); + } + nsresult rv = aSelectionRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eCreateOrRemoveBlock, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eCreateOrRemoveBlock, CollectNonEditableNodes::No) failed"); + return Err(rv); + } + + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eCreateOrRemoveBlock); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eCreateOrRemoveBlock) failed"); + return splitAtBRElementsResult.propagateErr(); + } + + // If there is no visible and editable nodes in the edit targets, make an + // empty block. + // XXX Isn't this odd if there are only non-editable visible nodes? + if (HTMLEditUtils::IsEmptyOneHardLine(arrayOfContents)) { + if (NS_WARN_IF(aSelectionRanges.Ranges().IsEmpty())) { + return Err(NS_ERROR_FAILURE); + } + + auto pointToInsertBlock = + aSelectionRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (&blockType == nsGkAtoms::normal || &blockType == nsGkAtoms::_empty) { + if (!pointToInsertBlock.IsInContentNode()) { + NS_WARNING( + "HTMLEditor::FormatBlockContainerWithTransaction() couldn't find " + "block parent because container of the point is not content"); + return Err(NS_ERROR_FAILURE); + } + // We are removing blocks (going to "body text") + const RefPtr<Element> editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *pointToInsertBlock.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestEditableBlockElement); + if (!editableBlockElement) { + NS_WARNING( + "HTMLEditor::FormatBlockContainerWithTransaction() couldn't find " + "block parent"); + return Err(NS_ERROR_FAILURE); + } + if (!HTMLEditUtils::IsFormatNode(editableBlockElement)) { + return RefPtr<Element>(); + } + + // If the first editable node after selection is a br, consume it. + // Otherwise it gets pushed into a following block after the split, + // which is visually bad. + if (nsCOMPtr<nsIContent> brContent = HTMLEditUtils::GetNextContent( + pointToInsertBlock, {WalkTreeOption::IgnoreNonEditableNode}, + &aEditingHost)) { + if (brContent && brContent->IsHTMLElement(nsGkAtoms::br)) { + AutoEditorDOMPointChildInvalidator lockOffset(pointToInsertBlock); + nsresult rv = DeleteNodeWithTransaction(*brContent); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + } + // Do the splits! + Result<SplitNodeResult, nsresult> splitNodeResult = + SplitNodeDeepWithTransaction( + *editableBlockElement, pointToInsertBlock, + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); + return splitNodeResult.propagateErr(); + } + SplitNodeResult unwrappedSplitNodeResult = splitNodeResult.unwrap(); + unwrappedSplitNodeResult.IgnoreCaretPointSuggestion(); + // Put a <br> element at the split point + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement( + WithTransaction::Yes, + unwrappedSplitNodeResult.AtSplitPoint<EditorDOMPoint>()); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + MOZ_ASSERT(insertBRElementResult.inspect().GetNewNode()); + aSelectionRanges.ClearSavedRanges(); + nsresult rv = aSelectionRanges.Collapse( + EditorRawDOMPoint(insertBRElementResult.inspect().GetNewNode())); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::Collapse() failed"); + return Err(rv); + } + return RefPtr<Element>(); + } + + // We are making a block. Consume a br, if needed. + if (nsCOMPtr<nsIContent> maybeBRContent = HTMLEditUtils::GetNextContent( + pointToInsertBlock, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + &aEditingHost)) { + if (maybeBRContent->IsHTMLElement(nsGkAtoms::br)) { + AutoEditorDOMPointChildInvalidator lockOffset(pointToInsertBlock); + nsresult rv = DeleteNodeWithTransaction(*maybeBRContent); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + // We don't need to act on this node any more + arrayOfContents.RemoveElement(maybeBRContent); + } + } + // Make sure we can put a block here. + Result<CreateElementResult, nsresult> createNewBlockElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + blockType, pointToInsertBlock, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewBlockElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "%s) failed", + nsAtomCString(&blockType).get()) + .get()); + return createNewBlockElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewBlockElementResult = + createNewBlockElementResult.unwrap(); + unwrappedCreateNewBlockElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedCreateNewBlockElementResult.GetNewNode()); + + // Delete anything that was in the list of nodes + while (!arrayOfContents.IsEmpty()) { + OwningNonNull<nsIContent>& content = arrayOfContents[0]; + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + arrayOfContents.RemoveElementAt(0); + } + // Put selection in new block + aSelectionRanges.ClearSavedRanges(); + nsresult rv = aSelectionRanges.Collapse(EditorRawDOMPoint( + unwrappedCreateNewBlockElementResult.GetNewNode(), 0u)); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::Collapse() failed"); + return Err(rv); + } + return unwrappedCreateNewBlockElementResult.UnwrapNewNode(); + } + // Okay, now go through all the nodes and make the right kind of blocks, or + // whatever is appropriate. + // Note: blockquote is handled a little differently. + if (&blockType == nsGkAtoms::blockquote) { + Result<CreateElementResult, nsresult> + wrapContentsInBlockquoteElementsResult = + WrapContentsInBlockquoteElementsWithTransaction(arrayOfContents, + aEditingHost); + if (MOZ_UNLIKELY(wrapContentsInBlockquoteElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::WrapContentsInBlockquoteElementsWithTransaction() " + "failed"); + return wrapContentsInBlockquoteElementsResult.propagateErr(); + } + wrapContentsInBlockquoteElementsResult.inspect() + .IgnoreCaretPointSuggestion(); + return wrapContentsInBlockquoteElementsResult.unwrap().UnwrapNewNode(); + } + if (&blockType == nsGkAtoms::normal || &blockType == nsGkAtoms::_empty) { + Result<EditorDOMPoint, nsresult> removeBlockContainerElementsResult = + RemoveBlockContainerElementsWithTransaction(arrayOfContents); + if (MOZ_UNLIKELY(removeBlockContainerElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementsWithTransaction() failed"); + return removeBlockContainerElementsResult.propagateErr(); + } + return RefPtr<Element>(); + } + Result<CreateElementResult, nsresult> wrapContentsInBlockElementResult = + CreateOrChangeBlockContainerElement(arrayOfContents, blockType, + aEditingHost); + if (MOZ_UNLIKELY(wrapContentsInBlockElementResult.isErr())) { + NS_WARNING("HTMLEditor::CreateOrChangeBlockContainerElement() failed"); + return wrapContentsInBlockElementResult.propagateErr(); + } + wrapContentsInBlockElementResult.inspect().IgnoreCaretPointSuggestion(); + return wrapContentsInBlockElementResult.unwrap().UnwrapNewNode(); +} + +nsresult HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); + + if (!SelectionRef().IsCollapsed()) { + return NS_OK; + } + + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return NS_ERROR_FAILURE; + } + const RangeBoundary& atStartOfSelection = firstRange->StartRef(); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + return NS_ERROR_FAILURE; + } + if (!atStartOfSelection.Container()->IsElement()) { + return NS_OK; + } + OwningNonNull<Element> startContainerElement = + *atStartOfSelection.Container()->AsElement(); + nsresult rv = + InsertPaddingBRElementForEmptyLastLineIfNeeded(startContainerElement); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineIfNeeded() failed"); + return rv; +} + +Result<EditActionResult, nsresult> HTMLEditor::IndentAsSubAction( + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eIndent, nsIEditor::eNext, ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Some selection containers are not content node, but ignored"); + return EditActionResult::IgnoredResult(); + } + + Result<EditActionResult, nsresult> result = + HandleIndentAtSelection(aEditingHost); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::HandleIndentAtSelection() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Mutation event listener might have changed selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // TODO: Investigate when we need to put a `<br>` element after indenting + // ranges. Then, we could stop calling this here, or maybe we need to + // do it while moving content nodes. + nsresult rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); + if (NS_FAILED(rv)) { + NS_WARNING( + "MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() failed"); + return Err(rv); + } + return result; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::IndentListChildWithTransaction( + RefPtr<Element>* aSubListElement, const EditorDOMPoint& aPointInListElement, + nsIContent& aContentMovingToSubList, const Element& aEditingHost) { + MOZ_ASSERT( + HTMLEditUtils::IsAnyListElement(aPointInListElement.GetContainer()), + "unexpected container"); + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + // some logic for putting list items into nested lists... + + // If aContentMovingToSubList is followed by a sub-list element whose tag is + // same as the parent list element's tag, we can move it to start of the + // sub-list. + if (nsIContent* nextEditableSibling = HTMLEditUtils::GetNextSibling( + aContentMovingToSubList, {WalkTreeOption::IgnoreWhiteSpaceOnlyText, + WalkTreeOption::IgnoreNonEditableNode})) { + if (HTMLEditUtils::IsAnyListElement(nextEditableSibling) && + aPointInListElement.GetContainer()->NodeInfo()->NameAtom() == + nextEditableSibling->NodeInfo()->NameAtom() && + aPointInListElement.GetContainer()->NodeInfo()->NamespaceID() == + nextEditableSibling->NodeInfo()->NamespaceID()) { + Result<MoveNodeResult, nsresult> moveListElementResult = + MoveNodeWithTransaction(aContentMovingToSubList, + EditorDOMPoint(nextEditableSibling, 0u)); + if (MOZ_UNLIKELY(moveListElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveListElementResult.propagateErr(); + } + return moveListElementResult.unwrap().UnwrapCaretPoint(); + } + } + + // If aContentMovingToSubList follows a sub-list element whose tag is same + // as the parent list element's tag, we can move it to end of the sub-list. + if (nsCOMPtr<nsIContent> previousEditableSibling = + HTMLEditUtils::GetPreviousSibling( + aContentMovingToSubList, + {WalkTreeOption::IgnoreWhiteSpaceOnlyText, + WalkTreeOption::IgnoreNonEditableNode})) { + if (HTMLEditUtils::IsAnyListElement(previousEditableSibling) && + aPointInListElement.GetContainer()->NodeInfo()->NameAtom() == + previousEditableSibling->NodeInfo()->NameAtom() && + aPointInListElement.GetContainer()->NodeInfo()->NamespaceID() == + previousEditableSibling->NodeInfo()->NamespaceID()) { + Result<MoveNodeResult, nsresult> moveListElementResult = + MoveNodeToEndWithTransaction(aContentMovingToSubList, + *previousEditableSibling); + if (MOZ_UNLIKELY(moveListElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveListElementResult.propagateErr(); + } + return moveListElementResult.unwrap().UnwrapCaretPoint(); + } + } + + // If aContentMovingToSubList does not follow aSubListElement, we need + // to create new sub-list element. + EditorDOMPoint pointToPutCaret; + nsIContent* previousEditableSibling = + *aSubListElement ? HTMLEditUtils::GetPreviousSibling( + aContentMovingToSubList, + {WalkTreeOption::IgnoreWhiteSpaceOnlyText, + WalkTreeOption::IgnoreNonEditableNode}) + : nullptr; + if (!*aSubListElement || (previousEditableSibling && + previousEditableSibling != *aSubListElement)) { + nsAtom* containerName = + aPointInListElement.GetContainer()->NodeInfo()->NameAtom(); + // Create a new nested list of correct type. + Result<CreateElementResult, nsresult> createNewListElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + MOZ_KnownLive(*containerName), aPointInListElement, + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "%s) failed", + nsAtomCString(containerName).get()) + .get()); + return createNewListElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewListElementResult = + createNewListElementResult.unwrap(); + MOZ_ASSERT(unwrappedCreateNewListElementResult.GetNewNode()); + pointToPutCaret = unwrappedCreateNewListElementResult.UnwrapCaretPoint(); + *aSubListElement = unwrappedCreateNewListElementResult.UnwrapNewNode(); + } + + // Finally, we should move aContentMovingToSubList into aSubListElement. + const RefPtr<Element> subListElement = *aSubListElement; + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(aContentMovingToSubList, *subListElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + if (unwrappedMoveNodeResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveNodeResult.UnwrapCaretPoint(); + } + return pointToPutCaret; +} + +Result<EditActionResult, nsresult> HTMLEditor::HandleIndentAtSelection( + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + AutoRangeArray selectionRanges(SelectionRef()); + + if (MOZ_UNLIKELY(!selectionRanges.IsInContent())) { + NS_WARNING("Mutation event listener might have changed the selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (IsCSSEnabled()) { + nsresult rv = HandleCSSIndentAroundRanges(selectionRanges, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::HandleCSSIndentAroundRanges() failed"); + return Err(rv); + } + } else { + nsresult rv = HandleHTMLIndentAroundRanges(selectionRanges, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::HandleHTMLIndentAroundRanges() failed"); + return Err(rv); + } + } + rv = selectionRanges.ApplyTo(SelectionRef()); + if (MOZ_UNLIKELY(Destroyed())) { + NS_WARNING("AutoRangeArray::ApplyTo() caused destroying the editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::ApplyTo() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::HandleCSSIndentAroundRanges(AutoRangeArray& aRanges, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(!aRanges.Ranges().IsEmpty()); + MOZ_ASSERT(aRanges.IsInContent()); + + if (aRanges.Ranges().IsEmpty()) { + NS_WARNING("There is no selection range"); + return NS_ERROR_FAILURE; + } + + // XXX Why do we do this only when there is only one selection range? + if (!aRanges.IsCollapsed() && aRanges.Ranges().Length() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + aRanges.FirstRangeRef(), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.unwrapErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use SetStartAndEnd() here. + nsresult rv = aRanges.SetBaseAndExtent(extendedRange.inspect().StartRef(), + extendedRange.inspect().EndRef()); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::SetBaseAndExtent() failed"); + return rv; + } + } + + if (NS_WARN_IF(!aRanges.SaveAndTrackRanges(*this))) { + return NS_ERROR_FAILURE; + } + + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + + // short circuit: detect case of collapsed selection inside an <li>. + // just sublist that <li>. This prevents bug 97797. + + if (aRanges.IsCollapsed()) { + const auto atCaret = aRanges.GetFirstRangeStartPoint<EditorRawDOMPoint>(); + if (NS_WARN_IF(!atCaret.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atCaret.IsInContentNode()); + Element* const editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *atCaret.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestEditableBlockElement); + if (editableBlockElement && + HTMLEditUtils::IsListItem(editableBlockElement)) { + arrayOfContents.AppendElement(*editableBlockElement); + } + } + + EditorDOMPoint pointToPutCaret; + if (arrayOfContents.IsEmpty()) { + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eIndent, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() " + "failed"); + return splitResult.unwrapErr(); + } + if (splitResult.inspect().IsSet()) { + pointToPutCaret = splitResult.unwrap(); + } + nsresult rv = extendedRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eIndent, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::eIndent, " + "CollectNonEditableNodes::Yes) failed"); + return rv; + } + } + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eIndent); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eIndent) failed"); + return splitAtBRElementsResult.inspectErr(); + } + if (splitAtBRElementsResult.inspect().IsSet()) { + pointToPutCaret = splitAtBRElementsResult.unwrap(); + } + } + + // If there is no visible and editable nodes in the edit targets, make an + // empty block. + // XXX Isn't this odd if there are only non-editable visible nodes? + if (HTMLEditUtils::IsEmptyOneHardLine(arrayOfContents)) { + const EditorDOMPoint pointToInsertDivElement = + pointToPutCaret.IsSet() + ? std::move(pointToPutCaret) + : aRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToInsertDivElement.IsSet())) { + return NS_ERROR_FAILURE; + } + + // make sure we can put a block here + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, pointToInsertDivElement, + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + // We'll collapse ranges below, so we don't need to touch the ranges here. + unwrappedCreateNewDivElementResult.IgnoreCaretPointSuggestion(); + const RefPtr<Element> newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + MOZ_ASSERT(newDivElement); + const Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ChangeMarginStart(*newDivElement, ChangeMargin::Increase, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (NS_WARN_IF(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Increase) failed, but " + "ignored"); + } + // delete anything that was in the list of nodes + // XXX We don't need to remove the nodes from the array for performance. + for (const OwningNonNull<nsIContent>& content : arrayOfContents) { + // MOZ_KnownLive(content) due to bug 1622253 + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(content)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + aRanges.ClearSavedRanges(); + nsresult rv = aRanges.Collapse(EditorDOMPoint(newDivElement, 0u)); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "AutoRangeArray::Collapse() failed"); + return rv; + } + + RefPtr<Element> latestNewBlockElement; + auto RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside = + [&]() -> nsresult { + MOZ_ASSERT(aRanges.HasSavedRanges()); + aRanges.RestoreFromSavedRanges(); + + if (!latestNewBlockElement || !aRanges.IsCollapsed() || + aRanges.Ranges().IsEmpty()) { + return NS_OK; + } + + const auto firstRangeStartRawPoint = + aRanges.GetFirstRangeStartPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!firstRangeStartRawPoint.IsSet())) { + return NS_OK; + } + Result<EditorRawDOMPoint, nsresult> pointInNewBlockElementOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorRawDOMPoint>(*latestNewBlockElement, firstRangeStartRawPoint); + if (MOZ_UNLIKELY(pointInNewBlockElementOrError.isErr())) { + NS_WARNING( + "HTMLEditUtils::ComputePointToPutCaretInElementIfOutside() failed, " + "but ignored"); + return NS_OK; + } + if (!pointInNewBlockElementOrError.inspect().IsSet()) { + return NS_OK; + } + return aRanges.Collapse(pointInNewBlockElementOrError.unwrap()); + }; + + // Ok, now go through all the nodes and put them into sub-list element + // elements and new <div> elements which have start margin. + RefPtr<Element> subListElement, divElement; + for (OwningNonNull<nsIContent>& content : arrayOfContents) { + // Here's where we actually figure out what to do. + EditorDOMPoint atContent(content); + if (NS_WARN_IF(!atContent.IsSet())) { + continue; + } + + // Ignore all non-editable nodes. Leave them be. + // XXX We ignore non-editable nodes here, but not so in the above block. + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + continue; + } + + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + const RefPtr<Element> oldSubListElement = subListElement; + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + IndentListChildWithTransaction(&subListElement, atContent, + MOZ_KnownLive(content), aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::IndentListChildWithTransaction() failed"); + return pointToPutCaretOrError.unwrapErr(); + } + if (subListElement != oldSubListElement) { + // New list element is created, so we should put caret into the new list + // element. + latestNewBlockElement = subListElement; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + continue; + } + + // Not a list item. + + if (HTMLEditUtils::IsBlockElement(content)) { + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ChangeMarginStart(MOZ_KnownLive(*content->AsElement()), + ChangeMargin::Increase, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (MOZ_UNLIKELY(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Increase) failed"); + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Increase) failed, but " + "ignored"); + } else if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + divElement = nullptr; + continue; + } + + if (!divElement) { + // First, check that our element can contain a div. + if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), + *nsGkAtoms::div)) { + // XXX This is odd, why do we stop indenting remaining content nodes? + // Perhaps, `continue` is better. + nsresult rv = + RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "RestoreSavedRangesAndCollapseInLatestBlockElement" + "IfOutside() failed"); + return rv; + } + + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + pointToPutCaret = unwrappedCreateNewDivElementResult.UnwrapCaretPoint(); + + MOZ_ASSERT(unwrappedCreateNewDivElementResult.GetNewNode()); + divElement = unwrappedCreateNewDivElementResult.UnwrapNewNode(); + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ChangeMarginStart(*divElement, ChangeMargin::Increase, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (MOZ_UNLIKELY(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Increase) failed"); + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Increase) failed, but " + "ignored"); + } else if (AllowsTransactionsToChangeSelection() && + pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + + latestNewBlockElement = divElement; + } + + // Move the content into the <div> which has start margin. + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *divElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.unwrapErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + if (unwrappedMoveNodeResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveNodeResult.UnwrapCaretPoint(); + } + } + + nsresult rv = RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside(); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside() failed"); + return rv; +} + +nsresult HTMLEditor::HandleHTMLIndentAroundRanges(AutoRangeArray& aRanges, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(!aRanges.Ranges().IsEmpty()); + MOZ_ASSERT(aRanges.IsInContent()); + + // XXX Why do we do this only when there is only one range? + if (!aRanges.IsCollapsed() && aRanges.Ranges().Length() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + aRanges.FirstRangeRef(), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.unwrapErr(); + } + // Note that end point may be prior to start point. So, we cannot use + // SetStartAndEnd() here. + nsresult rv = aRanges.SetBaseAndExtent(extendedRange.inspect().StartRef(), + extendedRange.inspect().EndRef()); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::SetBaseAndExtent() failed"); + return rv; + } + } + + if (NS_WARN_IF(!aRanges.SaveAndTrackRanges(*this))) { + return NS_ERROR_FAILURE; + } + + EditorDOMPoint pointToPutCaret; + + // convert the selection ranges into "promoted" selection ranges: + // this basically just expands the range to include the immediate + // block parent, and then further expands to include any ancestors + // whose children are all in the range + + // use these ranges to construct a list of nodes to act on. + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eIndent, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() " + "failed"); + return splitResult.unwrapErr(); + } + if (splitResult.inspect().IsSet()) { + pointToPutCaret = splitResult.unwrap(); + } + nsresult rv = extendedRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eIndent, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::eIndent, " + "CollectNonEditableNodes::Yes) failed"); + return rv; + } + } + + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eIndent); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::eIndent)" + " failed"); + return splitAtBRElementsResult.inspectErr(); + } + if (splitAtBRElementsResult.inspect().IsSet()) { + pointToPutCaret = splitAtBRElementsResult.unwrap(); + } + + // If there is no visible and editable nodes in the edit targets, make an + // empty block. + // XXX Isn't this odd if there are only non-editable visible nodes? + if (HTMLEditUtils::IsEmptyOneHardLine(arrayOfContents)) { + const EditorDOMPoint pointToInsertBlockquoteElement = + pointToPutCaret.IsSet() + ? std::move(pointToPutCaret) + : EditorBase::GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!pointToInsertBlockquoteElement.IsSet())) { + return NS_ERROR_FAILURE; + } + + // Make sure we can put a block here. + Result<CreateElementResult, nsresult> createNewBlockquoteElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::blockquote, pointToInsertBlockquoteElement, + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewBlockquoteElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::blockquote) failed"); + return createNewBlockquoteElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewBlockquoteElementResult = + createNewBlockquoteElementResult.unwrap(); + unwrappedCreateNewBlockquoteElementResult.IgnoreCaretPointSuggestion(); + RefPtr<Element> newBlockquoteElement = + unwrappedCreateNewBlockquoteElementResult.UnwrapNewNode(); + MOZ_ASSERT(newBlockquoteElement); + // delete anything that was in the list of nodes + // XXX We don't need to remove the nodes from the array for performance. + for (const OwningNonNull<nsIContent>& content : arrayOfContents) { + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + aRanges.ClearSavedRanges(); + nsresult rv = aRanges.Collapse(EditorRawDOMPoint(newBlockquoteElement, 0u)); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionToStartOf() failed"); + return rv; + } + + RefPtr<Element> latestNewBlockElement; + auto RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside = + [&]() -> nsresult { + MOZ_ASSERT(aRanges.HasSavedRanges()); + aRanges.RestoreFromSavedRanges(); + + if (!latestNewBlockElement || !aRanges.IsCollapsed() || + aRanges.Ranges().IsEmpty()) { + return NS_OK; + } + + const auto firstRangeStartRawPoint = + aRanges.GetFirstRangeStartPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!firstRangeStartRawPoint.IsSet())) { + return NS_OK; + } + Result<EditorRawDOMPoint, nsresult> pointInNewBlockElementOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorRawDOMPoint>(*latestNewBlockElement, firstRangeStartRawPoint); + if (MOZ_UNLIKELY(pointInNewBlockElementOrError.isErr())) { + NS_WARNING( + "HTMLEditUtils::ComputePointToPutCaretInElementIfOutside() failed, " + "but ignored"); + return NS_OK; + } + if (!pointInNewBlockElementOrError.inspect().IsSet()) { + return NS_OK; + } + return aRanges.Collapse(pointInNewBlockElementOrError.unwrap()); + }; + + // Ok, now go through all the nodes and put them in a blockquote, + // or whatever is appropriate. Wohoo! + RefPtr<Element> subListElement, blockquoteElement, indentedListItemElement; + for (OwningNonNull<nsIContent>& content : arrayOfContents) { + // Here's where we actually figure out what to do. + EditorDOMPoint atContent(content); + if (NS_WARN_IF(!atContent.IsSet())) { + continue; + } + + // Ignore all non-editable nodes. Leave them be. + // XXX We ignore non-editable nodes here, but not so in the above block. + if (!EditorUtils::IsEditableContent(content, EditorType::HTML) || + !HTMLEditUtils::IsRemovableNode(content)) { + continue; + } + + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + const RefPtr<Element> oldSubListElement = subListElement; + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + IndentListChildWithTransaction(&subListElement, atContent, + MOZ_KnownLive(content), aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::IndentListChildWithTransaction() failed"); + return pointToPutCaretOrError.unwrapErr(); + } + if (oldSubListElement != subListElement) { + // New list element is created, so we should put caret into the new list + // element. + latestNewBlockElement = subListElement; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + blockquoteElement = nullptr; + continue; + } + + // Not a list item, use blockquote? + + // if we are inside a list item, we don't want to blockquote, we want + // to sublist the list item. We may have several nodes listed in the + // array of nodes to act on, that are in the same list item. Since + // we only want to indent that li once, we must keep track of the most + // recent indented list item, and not indent it if we find another node + // to act on that is still inside the same li. + if (RefPtr<Element> listItem = + HTMLEditUtils::GetClosestAncestorListItemElement(content, + &aEditingHost)) { + if (indentedListItemElement == listItem) { + // already indented this list item + continue; + } + // check to see if subListElement is still appropriate. Which it is if + // content is still right after it in the same list. + nsIContent* previousEditableSibling = + subListElement + ? HTMLEditUtils::GetPreviousSibling( + *listItem, {WalkTreeOption::IgnoreNonEditableNode}) + : nullptr; + if (!subListElement || (previousEditableSibling && + previousEditableSibling != subListElement)) { + EditorDOMPoint atListItem(listItem); + if (NS_WARN_IF(!listItem)) { + return NS_ERROR_FAILURE; + } + nsAtom* containerName = + atListItem.GetContainer()->NodeInfo()->NameAtom(); + // Create a new nested list of correct type. + Result<CreateElementResult, nsresult> createNewListElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + MOZ_KnownLive(*containerName), atListItem, + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING(nsPrintfCString("HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTr" + "ansaction(%s) failed", + nsAtomCString(containerName).get()) + .get()); + return createNewListElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewListElementResult = + createNewListElementResult.unwrap(); + if (unwrappedCreateNewListElementResult.HasCaretPointSuggestion()) { + pointToPutCaret = + unwrappedCreateNewListElementResult.UnwrapCaretPoint(); + } + MOZ_ASSERT(unwrappedCreateNewListElementResult.GetNewNode()); + subListElement = unwrappedCreateNewListElementResult.UnwrapNewNode(); + } + + Result<MoveNodeResult, nsresult> moveListItemElementResult = + MoveNodeToEndWithTransaction(*listItem, *subListElement); + if (MOZ_UNLIKELY(moveListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveListItemElementResult.unwrapErr(); + } + MoveNodeResult unwrappedMoveListItemElementResult = + moveListItemElementResult.unwrap(); + if (unwrappedMoveListItemElementResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveListItemElementResult.UnwrapCaretPoint(); + } + + // Remember the list item element which we indented now for ignoring its + // children to avoid using <blockquote> in it. + indentedListItemElement = std::move(listItem); + + continue; + } + + // need to make a blockquote to put things in if we haven't already, + // or if this node doesn't go in blockquote we used earlier. + // One reason it might not go in prio blockquote is if we are now + // in a different table cell. + if (blockquoteElement && + HTMLEditUtils::GetInclusiveAncestorAnyTableElement( + *blockquoteElement) != + HTMLEditUtils::GetInclusiveAncestorAnyTableElement(content)) { + blockquoteElement = nullptr; + } + + if (!blockquoteElement) { + // First, check that our element can contain a blockquote. + if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), + *nsGkAtoms::blockquote)) { + // XXX This is odd, why do we stop indenting remaining content nodes? + // Perhaps, `continue` is better. + nsresult rv = + RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "RestoreSavedRangesAndCollapseInLatestBlockElement" + "IfOutside() failed"); + return rv; + } + + Result<CreateElementResult, nsresult> createNewBlockquoteElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::blockquote, atContent, + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewBlockquoteElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::blockquote) failed"); + return createNewBlockquoteElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewBlockquoteElementResult = + createNewBlockquoteElementResult.unwrap(); + if (unwrappedCreateNewBlockquoteElementResult.HasCaretPointSuggestion()) { + pointToPutCaret = + unwrappedCreateNewBlockquoteElementResult.UnwrapCaretPoint(); + } + + MOZ_ASSERT(unwrappedCreateNewBlockquoteElementResult.GetNewNode()); + blockquoteElement = + unwrappedCreateNewBlockquoteElementResult.UnwrapNewNode(); + latestNewBlockElement = blockquoteElement; + } + + // tuck the node into the end of the active blockquote + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), + *blockquoteElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.unwrapErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + if (unwrappedMoveNodeResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveNodeResult.UnwrapCaretPoint(); + } + subListElement = nullptr; + } + + nsresult rv = RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside(); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "RestoreSavedRangesAndCollapseInLatestBlockElementIfOutside() failed"); + return rv; +} + +Result<EditActionResult, nsresult> HTMLEditor::OutdentAsSubAction( + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eOutdent, nsIEditor::eNext, ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Some selection containers are not content node, but ignored"); + return EditActionResult::IgnoredResult(); + } + + Result<EditActionResult, nsresult> result = + HandleOutdentAtSelection(aEditingHost); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::HandleOutdentAtSelection() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Mutation event listener might have changed the selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + nsresult rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() " + "failed"); + return Err(rv); + } + return result; +} + +Result<EditActionResult, nsresult> HTMLEditor::HandleOutdentAtSelection( + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); + + // XXX Why do we do this only when there is only one selection range? + if (!SelectionRef().IsCollapsed() && SelectionRef().RangeCount() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + SelectionRef().GetRangeAt(0u), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.propagateErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use Selection::SetStartAndEndInLimit() here. + IgnoredErrorResult error; + SelectionRef().SetBaseAndExtentInLimiter( + extendedRange.inspect().StartRef().ToRawRangeBoundary(), + extendedRange.inspect().EndRef().ToRawRangeBoundary(), error); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (MOZ_UNLIKELY(error.Failed())) { + NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); + return Err(error.StealNSResult()); + } + } + + // HandleOutdentAtSelectionInternal() creates AutoSelectionRestorer. + // Therefore, even if it returns NS_OK, the editor might have been destroyed + // at restoring Selection. + Result<SplitRangeOffFromNodeResult, nsresult> outdentResult = + HandleOutdentAtSelectionInternal(aEditingHost); + MOZ_ASSERT_IF(outdentResult.isOk(), + !outdentResult.inspect().HasCaretPointSuggestion()); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (MOZ_UNLIKELY(outdentResult.isErr())) { + NS_WARNING("HTMLEditor::HandleOutdentAtSelectionInternal() failed"); + return outdentResult.propagateErr(); + } + SplitRangeOffFromNodeResult unwrappedOutdentResult = outdentResult.unwrap(); + + // Make sure selection didn't stick to last piece of content in old bq (only + // a problem for collapsed selections) + if (!unwrappedOutdentResult.GetLeftContent() && + !unwrappedOutdentResult.GetRightContent()) { + return EditActionResult::HandledResult(); + } + + if (!SelectionRef().IsCollapsed()) { + return EditActionResult::HandledResult(); + } + + // Push selection past end of left element of last split indented element. + if (unwrappedOutdentResult.GetLeftContent()) { + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return EditActionResult::HandledResult(); + } + const RangeBoundary& atStartOfSelection = firstRange->StartRef(); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + if (atStartOfSelection.Container() == + unwrappedOutdentResult.GetLeftContent() || + EditorUtils::IsDescendantOf(*atStartOfSelection.Container(), + *unwrappedOutdentResult.GetLeftContent())) { + // Selection is inside the left node - push it past it. + EditorRawDOMPoint afterRememberedLeftBQ( + EditorRawDOMPoint::After(*unwrappedOutdentResult.GetLeftContent())); + NS_WARNING_ASSERTION( + afterRememberedLeftBQ.IsSet(), + "Failed to set after remembered left blockquote element"); + nsresult rv = CollapseSelectionTo(afterRememberedLeftBQ); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed, but ignored"); + } + } + // And pull selection before beginning of right element of last split + // indented element. + if (unwrappedOutdentResult.GetRightContent()) { + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return EditActionResult::HandledResult(); + } + const RangeBoundary& atStartOfSelection = firstRange->StartRef(); + if (NS_WARN_IF(!atStartOfSelection.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + if (atStartOfSelection.Container() == + unwrappedOutdentResult.GetRightContent() || + EditorUtils::IsDescendantOf( + *atStartOfSelection.Container(), + *unwrappedOutdentResult.GetRightContent())) { + // Selection is inside the right element - push it before it. + EditorRawDOMPoint atRememberedRightBQ( + unwrappedOutdentResult.GetRightContent()); + nsresult rv = CollapseSelectionTo(atRememberedRightBQ); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed, but ignored"); + } + } + return EditActionResult::HandledResult(); +} + +Result<SplitRangeOffFromNodeResult, nsresult> +HTMLEditor::HandleOutdentAtSelectionInternal(const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoSelectionRestorer restoreSelectionLater(*this); + + bool useCSS = IsCSSEnabled(); + + // Convert the selection ranges into "promoted" selection ranges: this + // basically just expands the range to include the immediate block parent, + // and then further expands to include any ancestors whose children are all + // in the range + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + { + AutoRangeArray extendedSelectionRanges(SelectionRef()); + extendedSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eOutdent, aEditingHost); + nsresult rv = extendedSelectionRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eOutdent, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::eOutdent, " + "CollectNonEditableNodes::Yes) failed"); + return Err(rv); + } + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eOutdent); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eOutdent) failed"); + return splitAtBRElementsResult.propagateErr(); + } + if (AllowsTransactionsToChangeSelection() && + splitAtBRElementsResult.inspect().IsSet()) { + nsresult rv = CollapseSelectionTo(splitAtBRElementsResult.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + } + + nsCOMPtr<nsIContent> leftContentOfLastOutdented; + nsCOMPtr<nsIContent> middleContentOfLastOutdented; + nsCOMPtr<nsIContent> rightContentOfLastOutdented; + RefPtr<Element> indentedParentElement; + nsCOMPtr<nsIContent> firstContentToBeOutdented, lastContentToBeOutdented; + BlockIndentedWith indentedParentIndentedWith = BlockIndentedWith::HTML; + for (OwningNonNull<nsIContent>& content : arrayOfContents) { + // Here's where we actually figure out what to do + EditorDOMPoint atContent(content); + if (!atContent.IsSet()) { + continue; + } + + // If it's a `<blockquote>`, remove it to outdent its children. + if (content->IsHTMLElement(nsGkAtoms::blockquote)) { + // If we've already found an ancestor block element indented, we need to + // split it and remove the block element first. + if (indentedParentElement) { + NS_WARNING_ASSERTION(indentedParentElement == content, + "Indented parent element is not the <blockquote>"); + Result<SplitRangeOffFromNodeResult, nsresult> outdentResult = + OutdentPartOfBlock(*indentedParentElement, + *firstContentToBeOutdented, + *lastContentToBeOutdented, + indentedParentIndentedWith, aEditingHost); + if (MOZ_UNLIKELY(outdentResult.isErr())) { + NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); + return outdentResult; + } + SplitRangeOffFromNodeResult unwrappedOutdentResult = + outdentResult.unwrap(); + unwrappedOutdentResult.IgnoreCaretPointSuggestion(); + leftContentOfLastOutdented = unwrappedOutdentResult.UnwrapLeftContent(); + middleContentOfLastOutdented = + unwrappedOutdentResult.UnwrapMiddleContent(); + rightContentOfLastOutdented = + unwrappedOutdentResult.UnwrapRightContent(); + indentedParentElement = nullptr; + firstContentToBeOutdented = nullptr; + lastContentToBeOutdented = nullptr; + indentedParentIndentedWith = BlockIndentedWith::HTML; + } + Result<EditorDOMPoint, nsresult> unwrapBlockquoteElementResult = + RemoveBlockContainerWithTransaction( + MOZ_KnownLive(*content->AsElement())); + if (MOZ_UNLIKELY(unwrapBlockquoteElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapBlockquoteElementResult.propagateErr(); + } + const EditorDOMPoint& pointToPutCaret = + unwrapBlockquoteElementResult.inspect(); + if (AllowsTransactionsToChangeSelection() && pointToPutCaret.IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + continue; + } + + // If we're using CSS and the node is a block element, check its start + // margin whether it's indented with CSS. + if (useCSS && HTMLEditUtils::IsBlockElement(content)) { + nsStaticAtom& marginProperty = + MarginPropertyAtomForIndent(MOZ_KnownLive(content)); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + nsAutoString value; + DebugOnly<nsresult> rvIgnored = + CSSEditUtils::GetSpecifiedProperty(content, marginProperty, value); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetSpecifiedProperty() failed, but ignored"); + float startMargin = 0; + RefPtr<nsAtom> unit; + CSSEditUtils::ParseLength(value, &startMargin, getter_AddRefs(unit)); + // If indented with CSS, we should decrease the start margin. + if (startMargin > 0) { + const Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ChangeMarginStart(MOZ_KnownLive(*content->AsElement()), + ChangeMargin::Decrease, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (NS_WARN_IF(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Decrease) failed, " + "but ignored"); + } else if (AllowsTransactionsToChangeSelection() && + pointToPutCaretOrError.inspect().IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaretOrError.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + continue; + } + } + + // If it's a list item, we should treat as that it "indents" its children. + if (HTMLEditUtils::IsListItem(content)) { + // If it is a list item, that means we are not outdenting whole list. + // XXX I don't understand this sentence... We may meet parent list + // element, no? + if (indentedParentElement) { + Result<SplitRangeOffFromNodeResult, nsresult> outdentResult = + OutdentPartOfBlock(*indentedParentElement, + *firstContentToBeOutdented, + *lastContentToBeOutdented, + indentedParentIndentedWith, aEditingHost); + if (MOZ_UNLIKELY(outdentResult.isErr())) { + NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); + return outdentResult; + } + SplitRangeOffFromNodeResult unwrappedOutdentResult = + outdentResult.unwrap(); + unwrappedOutdentResult.IgnoreCaretPointSuggestion(); + leftContentOfLastOutdented = unwrappedOutdentResult.UnwrapLeftContent(); + middleContentOfLastOutdented = + unwrappedOutdentResult.UnwrapMiddleContent(); + rightContentOfLastOutdented = + unwrappedOutdentResult.UnwrapRightContent(); + indentedParentElement = nullptr; + firstContentToBeOutdented = nullptr; + lastContentToBeOutdented = nullptr; + indentedParentIndentedWith = BlockIndentedWith::HTML; + } + // XXX `content` could become different element since + // `OutdentPartOfBlock()` may run mutation event listeners. + nsresult rv = LiftUpListItemElement(MOZ_KnownLive(*content->AsElement()), + LiftUpFromAllParentListElements::No); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" + ":No) failed"); + return Err(rv); + } + continue; + } + + // If we've found an ancestor block element which indents its children + // and the current node is NOT a descendant of it, we should remove it to + // outdent its children. Otherwise, i.e., current node is a descendant of + // it, we meet new node which should be outdented when the indented parent + // is removed. + if (indentedParentElement) { + if (EditorUtils::IsDescendantOf(*content, *indentedParentElement)) { + // Extend the range to be outdented at removing the + // indentedParentElement. + lastContentToBeOutdented = content; + continue; + } + Result<SplitRangeOffFromNodeResult, nsresult> outdentResult = + OutdentPartOfBlock(*indentedParentElement, *firstContentToBeOutdented, + *lastContentToBeOutdented, + indentedParentIndentedWith, aEditingHost); + if (MOZ_UNLIKELY(outdentResult.isErr())) { + NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); + return outdentResult; + } + SplitRangeOffFromNodeResult unwrappedOutdentResult = + outdentResult.unwrap(); + unwrappedOutdentResult.IgnoreCaretPointSuggestion(); + leftContentOfLastOutdented = unwrappedOutdentResult.UnwrapLeftContent(); + middleContentOfLastOutdented = + unwrappedOutdentResult.UnwrapMiddleContent(); + rightContentOfLastOutdented = unwrappedOutdentResult.UnwrapRightContent(); + indentedParentElement = nullptr; + firstContentToBeOutdented = nullptr; + lastContentToBeOutdented = nullptr; + // curBlockIndentedWith = HTMLEditor::BlockIndentedWith::HTML; + + // Then, we need to look for next indentedParentElement. + } + + indentedParentIndentedWith = BlockIndentedWith::HTML; + for (nsCOMPtr<nsIContent> parentContent = content->GetParent(); + parentContent && !parentContent->IsHTMLElement(nsGkAtoms::body) && + parentContent != &aEditingHost && + (parentContent->IsHTMLElement(nsGkAtoms::table) || + !HTMLEditUtils::IsAnyTableElement(parentContent)); + parentContent = parentContent->GetParent()) { + if (MOZ_UNLIKELY(!HTMLEditUtils::IsRemovableNode(*parentContent))) { + continue; + } + // If we reach a `<blockquote>` ancestor, it should be split at next + // time at least for outdenting current node. + if (parentContent->IsHTMLElement(nsGkAtoms::blockquote)) { + indentedParentElement = parentContent->AsElement(); + firstContentToBeOutdented = content; + lastContentToBeOutdented = content; + break; + } + + if (!useCSS) { + continue; + } + + nsCOMPtr<nsINode> grandParentNode = parentContent->GetParentNode(); + nsStaticAtom& marginProperty = + MarginPropertyAtomForIndent(MOZ_KnownLive(content)); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_WARN_IF(grandParentNode != parentContent->GetParentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + nsAutoString value; + DebugOnly<nsresult> rvIgnored = CSSEditUtils::GetSpecifiedProperty( + *parentContent, marginProperty, value); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetSpecifiedProperty() failed, but ignored"); + // XXX Now, editing host may become different element. If so, shouldn't + // we stop this handling? + float startMargin; + RefPtr<nsAtom> unit; + CSSEditUtils::ParseLength(value, &startMargin, getter_AddRefs(unit)); + // If we reach a block element which indents its children with start + // margin, we should remove it at next time. + if (startMargin > 0 && + !(HTMLEditUtils::IsAnyListElement(atContent.GetContainer()) && + HTMLEditUtils::IsAnyListElement(content))) { + indentedParentElement = parentContent->AsElement(); + firstContentToBeOutdented = content; + lastContentToBeOutdented = content; + indentedParentIndentedWith = BlockIndentedWith::CSS; + break; + } + } + + if (indentedParentElement) { + continue; + } + + // If we don't have any block elements which indents current node and + // both current node and its parent are list element, remove current + // node to move all its children to the parent list. + // XXX This is buggy. When both lists' item types are different, + // we create invalid tree. E.g., `<ul>` may have `<dd>` as its + // list item element. + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + if (!HTMLEditUtils::IsAnyListElement(content)) { + continue; + } + // Just unwrap this sublist + Result<EditorDOMPoint, nsresult> unwrapSubListElementResult = + RemoveBlockContainerWithTransaction( + MOZ_KnownLive(*content->AsElement())); + if (MOZ_UNLIKELY(unwrapSubListElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapSubListElementResult.propagateErr(); + } + const EditorDOMPoint& pointToPutCaret = + unwrapSubListElementResult.inspect(); + if (!AllowsTransactionsToChangeSelection() || !pointToPutCaret.IsSet()) { + continue; + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + continue; + } + + // If current content is a list element but its parent is not a list + // element, move children to where it is and remove it from the tree. + if (HTMLEditUtils::IsAnyListElement(content)) { + // XXX If mutation event listener appends new children forever, this + // becomes an infinite loop so that we should set limitation from + // first child count. + for (nsCOMPtr<nsIContent> lastChildContent = content->GetLastChild(); + lastChildContent; lastChildContent = content->GetLastChild()) { + if (HTMLEditUtils::IsListItem(lastChildContent)) { + nsresult rv = LiftUpListItemElement( + MOZ_KnownLive(*lastChildContent->AsElement()), + LiftUpFromAllParentListElements::No); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::LiftUpListItemElement(" + "LiftUpFromAllParentListElements::No) failed"); + return Err(rv); + } + continue; + } + + if (HTMLEditUtils::IsAnyListElement(lastChildContent)) { + // We have an embedded list, so move it out from under the parent + // list. Be sure to put it after the parent list because this + // loop iterates backwards through the parent's list of children. + EditorDOMPoint afterCurrentList(EditorDOMPoint::After(atContent)); + NS_WARNING_ASSERTION( + afterCurrentList.IsSet(), + "Failed to set it to after current list element"); + Result<MoveNodeResult, nsresult> moveListElementResult = + MoveNodeWithTransaction(*lastChildContent, afterCurrentList); + if (MOZ_UNLIKELY(moveListElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveListElementResult.propagateErr(); + } + nsresult rv = moveListElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + continue; + } + + // Delete any non-list items for now + // XXX Chrome moves it from the list element. We should follow it. + nsresult rv = DeleteNodeWithTransaction(*lastChildContent); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + // Delete the now-empty list + Result<EditorDOMPoint, nsresult> unwrapListElementResult = + RemoveBlockContainerWithTransaction( + MOZ_KnownLive(*content->AsElement())); + if (MOZ_UNLIKELY(unwrapListElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapListElementResult.propagateErr(); + } + const EditorDOMPoint& pointToPutCaret = unwrapListElementResult.inspect(); + if (!AllowsTransactionsToChangeSelection() || !pointToPutCaret.IsSet()) { + continue; + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + continue; + } + + if (useCSS) { + if (RefPtr<Element> element = content->GetAsElementOrParentElement()) { + const Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ChangeMarginStart(*element, ChangeMargin::Decrease, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (NS_WARN_IF(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::ChangeMarginStart(ChangeMargin::Decrease) failed, " + "but ignored"); + } else if (AllowsTransactionsToChangeSelection() && + pointToPutCaretOrError.inspect().IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaretOrError.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + } + continue; + } + } + + if (!indentedParentElement) { + return SplitRangeOffFromNodeResult(leftContentOfLastOutdented, + middleContentOfLastOutdented, + rightContentOfLastOutdented); + } + + // We have a <blockquote> we haven't finished handling. + Result<SplitRangeOffFromNodeResult, nsresult> outdentResult = + OutdentPartOfBlock(*indentedParentElement, *firstContentToBeOutdented, + *lastContentToBeOutdented, indentedParentIndentedWith, + aEditingHost); + if (MOZ_UNLIKELY(outdentResult.isErr())) { + NS_WARNING("HTMLEditor::OutdentPartOfBlock() failed"); + return outdentResult; + } + // We will restore selection soon. Therefore, callers do not need to restore + // the selection. + SplitRangeOffFromNodeResult unwrappedOutdentResult = outdentResult.unwrap(); + unwrappedOutdentResult.ForgetCaretPointSuggestion(); + return unwrappedOutdentResult; +} + +Result<SplitRangeOffFromNodeResult, nsresult> +HTMLEditor::RemoveBlockContainerElementWithTransactionBetween( + Element& aBlockContainerElement, nsIContent& aStartOfRange, + nsIContent& aEndOfRange) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + EditorDOMPoint pointToPutCaret; + Result<SplitRangeOffFromNodeResult, nsresult> splitResult = + SplitRangeOffFromBlock(aBlockContainerElement, aStartOfRange, + aEndOfRange); + if (MOZ_UNLIKELY(splitResult.isErr())) { + if (splitResult.inspectErr() == NS_ERROR_EDITOR_DESTROYED) { + NS_WARNING("HTMLEditor::SplitRangeOffFromBlock() failed"); + return splitResult; + } + NS_WARNING( + "HTMLEditor::SplitRangeOffFromBlock() failed, but might be ignored"); + return SplitRangeOffFromNodeResult(nullptr, nullptr, nullptr); + } + SplitRangeOffFromNodeResult unwrappedSplitResult = splitResult.unwrap(); + unwrappedSplitResult.MoveCaretPointTo(pointToPutCaret, + {SuggestCaret::OnlyIfHasSuggestion}); + + // Even if either split aBlockContainerElement or did not split it, we should + // unwrap the right most element which is split from aBlockContainerElement + // (or aBlockContainerElement itself if it was not split without errors). + Element* rightmostElement = + unwrappedSplitResult.GetRightmostContentAs<Element>(); + MOZ_ASSERT(rightmostElement); + if (NS_WARN_IF(!rightmostElement)) { + return Err(NS_ERROR_FAILURE); + } + MOZ_ASSERT_IF(GetSplitNodeDirection() == SplitNodeDirection::LeftNodeIsNewOne, + rightmostElement == &aBlockContainerElement); + { + // MOZ_KnownLive(rightmostElement) because it's grabbed by + // unwrappedSplitResult. + Result<EditorDOMPoint, nsresult> unwrapBlockElementResult = + RemoveBlockContainerWithTransaction(MOZ_KnownLive(*rightmostElement)); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapBlockElementResult.propagateErr(); + } + if (unwrapBlockElementResult.inspect().IsSet()) { + pointToPutCaret = unwrapBlockElementResult.unwrap(); + } + } + + return SplitRangeOffFromNodeResult( + unwrappedSplitResult.GetLeftContent(), nullptr, + unwrappedSplitResult.GetRightContent(), std::move(pointToPutCaret)); +} + +Result<SplitRangeOffFromNodeResult, nsresult> +HTMLEditor::SplitRangeOffFromBlock(Element& aBlockElement, + nsIContent& aStartOfMiddleElement, + nsIContent& aEndOfMiddleElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // aStartOfMiddleElement and aEndOfMiddleElement must be exclusive + // descendants of aBlockElement. + MOZ_ASSERT(EditorUtils::IsDescendantOf(aStartOfMiddleElement, aBlockElement)); + MOZ_ASSERT(EditorUtils::IsDescendantOf(aEndOfMiddleElement, aBlockElement)); + + EditorDOMPoint pointToPutCaret; + // Split at the start. + Result<SplitNodeResult, nsresult> splitAtStartResult = + SplitNodeDeepWithTransaction(aBlockElement, + EditorDOMPoint(&aStartOfMiddleElement), + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitAtStartResult.isErr())) { + if (splitAtStartResult.inspectErr() == NS_ERROR_EDITOR_DESTROYED) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed (at left)"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) at start of middle element failed"); + } else { + splitAtStartResult.inspect().CopyCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + } + + // Split at after the end + auto atAfterEnd = EditorDOMPoint::After(aEndOfMiddleElement); + Element* rightElement = + splitAtStartResult.isOk() && splitAtStartResult.inspect().DidSplit() + ? splitAtStartResult.inspect().GetNextContentAs<Element>() + : &aBlockElement; + // MOZ_KnownLive(rightElement) because it's grabbed by splitAtStartResult or + // aBlockElement whose lifetime is guaranteed by the caller. + Result<SplitNodeResult, nsresult> splitAtEndResult = + SplitNodeDeepWithTransaction(MOZ_KnownLive(*rightElement), atAfterEnd, + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitAtEndResult.isErr())) { + if (splitAtEndResult.inspectErr() == NS_ERROR_EDITOR_DESTROYED) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction() failed (at right)"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) after end of middle element failed"); + } else { + splitAtEndResult.inspect().CopyCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + } + + if (splitAtStartResult.isOk() && splitAtStartResult.inspect().DidSplit() && + splitAtEndResult.isOk() && splitAtEndResult.inspect().DidSplit()) { + // Note that the middle node can be computed only with the latter split + // result. + return SplitRangeOffFromNodeResult( + splitAtStartResult.inspect().GetPreviousContent(), + splitAtEndResult.inspect().GetPreviousContent(), + splitAtEndResult.inspect().GetNextContent(), + std::move(pointToPutCaret)); + } + if (splitAtStartResult.isOk() && splitAtStartResult.inspect().DidSplit()) { + return SplitRangeOffFromNodeResult( + splitAtStartResult.inspect().GetPreviousContent(), + splitAtStartResult.inspect().GetNextContent(), nullptr, + std::move(pointToPutCaret)); + } + if (splitAtEndResult.isOk() && splitAtEndResult.inspect().DidSplit()) { + return SplitRangeOffFromNodeResult( + nullptr, splitAtEndResult.inspect().GetPreviousContent(), + splitAtEndResult.inspect().GetNextContent(), + std::move(pointToPutCaret)); + } + return SplitRangeOffFromNodeResult(nullptr, &aBlockElement, nullptr, + std::move(pointToPutCaret)); +} + +Result<SplitRangeOffFromNodeResult, nsresult> HTMLEditor::OutdentPartOfBlock( + Element& aBlockElement, nsIContent& aStartOfOutdent, + nsIContent& aEndOfOutdent, BlockIndentedWith aBlockIndentedWith, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + Result<SplitRangeOffFromNodeResult, nsresult> splitResult = + SplitRangeOffFromBlock(aBlockElement, aStartOfOutdent, aEndOfOutdent); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING("HTMLEditor::SplitRangeOffFromBlock() failed"); + return splitResult; + } + + SplitRangeOffFromNodeResult unwrappedSplitResult = splitResult.unwrap(); + Element* middleElement = unwrappedSplitResult.GetMiddleContentAs<Element>(); + if (MOZ_UNLIKELY(!middleElement)) { + NS_WARNING( + "HTMLEditor::SplitRangeOffFromBlock() didn't return middle content"); + unwrappedSplitResult.IgnoreCaretPointSuggestion(); + return Err(NS_ERROR_FAILURE); + } + if (NS_WARN_IF(!HTMLEditUtils::IsRemovableNode(*middleElement))) { + unwrappedSplitResult.IgnoreCaretPointSuggestion(); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + nsresult rv = unwrappedSplitResult.SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("SplitRangeOffFromNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "SplitRangeOffFromNodeResult::SuggestCaretPointTo() " + "failed, but ignored"); + + if (aBlockIndentedWith == BlockIndentedWith::HTML) { + // MOZ_KnownLive(middleElement) because of grabbed by unwrappedSplitResult. + Result<EditorDOMPoint, nsresult> unwrapBlockElementResult = + RemoveBlockContainerWithTransaction(MOZ_KnownLive(*middleElement)); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapBlockElementResult.propagateErr(); + } + const EditorDOMPoint& pointToPutCaret = unwrapBlockElementResult.inspect(); + if (AllowsTransactionsToChangeSelection() && pointToPutCaret.IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + return SplitRangeOffFromNodeResult(unwrappedSplitResult.GetLeftContent(), + nullptr, + unwrappedSplitResult.GetRightContent()); + } + + // MOZ_KnownLive(middleElement) because of grabbed by unwrappedSplitResult. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = ChangeMarginStart( + MOZ_KnownLive(*middleElement), ChangeMargin::Decrease, aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::ChangeMarginStart(ChangeMargin::Decrease) failed"); + return pointToPutCaretOrError.propagateErr(); + } + if (AllowsTransactionsToChangeSelection() && + pointToPutCaretOrError.inspect().IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaretOrError.inspect()); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return Err(rv); + } + } + return unwrappedSplitResult; +} + +Result<CreateElementResult, nsresult> HTMLEditor::ChangeListElementType( + Element& aListElement, nsAtom& aNewListTag, nsAtom& aNewListItemTag) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + EditorDOMPoint pointToPutCaret; + + AutoTArray<OwningNonNull<nsIContent>, 32> listElementChildren; + HTMLEditUtils::CollectAllChildren(aListElement, listElementChildren); + + for (const OwningNonNull<nsIContent>& childContent : listElementChildren) { + if (!childContent->IsElement()) { + continue; + } + Element* childElement = childContent->AsElement(); + if (HTMLEditUtils::IsListItem(childElement) && + !childContent->IsHTMLElement(&aNewListItemTag)) { + // MOZ_KnownLive(childElement) because its lifetime is guaranteed by + // listElementChildren. + Result<CreateElementResult, nsresult> + replaceWithNewListItemElementResult = + ReplaceContainerAndCloneAttributesWithTransaction( + MOZ_KnownLive(*childElement), aNewListItemTag); + if (MOZ_UNLIKELY(replaceWithNewListItemElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::ReplaceContainerAndCloneAttributesWithTransaction() " + "failed"); + return replaceWithNewListItemElementResult; + } + CreateElementResult unwrappedReplaceWithNewListItemElementResult = + replaceWithNewListItemElementResult.unwrap(); + unwrappedReplaceWithNewListItemElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + continue; + } + if (HTMLEditUtils::IsAnyListElement(childElement) && + !childElement->IsHTMLElement(&aNewListTag)) { + // XXX List elements shouldn't have other list elements as their + // child. Why do we handle such invalid tree? + // -> Maybe, for bug 525888. + // MOZ_KnownLive(childElement) because its lifetime is guaranteed by + // listElementChildren. + Result<CreateElementResult, nsresult> convertListTypeResult = + ChangeListElementType(MOZ_KnownLive(*childElement), aNewListTag, + aNewListItemTag); + if (MOZ_UNLIKELY(convertListTypeResult.isErr())) { + NS_WARNING("HTMLEditor::ChangeListElementType() failed"); + return convertListTypeResult; + } + CreateElementResult unwrappedConvertListTypeResult = + convertListTypeResult.unwrap(); + unwrappedConvertListTypeResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + continue; + } + } + + if (aListElement.IsHTMLElement(&aNewListTag)) { + return CreateElementResult(&aListElement, std::move(pointToPutCaret)); + } + + // XXX If we replace the list element, shouldn't we create it first and then, + // move children into it before inserting the new list element into the + // DOM tree? Then, we could reduce the cost of dispatching DOM mutation + // events. + Result<CreateElementResult, nsresult> replaceWithNewListElementResult = + ReplaceContainerWithTransaction(aListElement, aNewListTag); + if (MOZ_UNLIKELY(replaceWithNewListElementResult.isErr())) { + NS_WARNING("HTMLEditor::ReplaceContainerWithTransaction() failed"); + return replaceWithNewListElementResult; + } + CreateElementResult unwrappedReplaceWithNewListElementResult = + replaceWithNewListElementResult.unwrap(); + unwrappedReplaceWithNewListElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + return CreateElementResult( + unwrappedReplaceWithNewListElementResult.UnwrapNewNode(), + std::move(pointToPutCaret)); +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::CreateStyleForInsertText( + const EditorDOMPoint& aPointToInsertText, const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aPointToInsertText.IsSetAndValid()); + MOZ_ASSERT(mPendingStylesToApplyToNewContent); + + const RefPtr<Element> documentRootElement = GetDocument()->GetRootElement(); + if (NS_WARN_IF(!documentRootElement)) { + return Err(NS_ERROR_FAILURE); + } + + // process clearing any styles first + UniquePtr<PendingStyle> pendingStyle = + mPendingStylesToApplyToNewContent->TakeClearingStyle(); + + EditorDOMPoint pointToPutCaret(aPointToInsertText); + { + // Transactions may set selection, but we will set selection if necessary. + AutoTransactionsConserveSelection dontChangeMySelection(*this); + + while (pendingStyle && + pointToPutCaret.GetContainer() != documentRootElement) { + // MOZ_KnownLive because we own pendingStyle which guarantees the lifetime + // of its members. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + ClearStyleAt(pointToPutCaret, pendingStyle->ToInlineStyle(), + pendingStyle->GetSpecifiedStyle()); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::ClearStyleAt() failed"); + return pointToPutCaretOrError; + } + pointToPutCaret = pointToPutCaretOrError.unwrap(); + if (NS_WARN_IF(!pointToPutCaret.IsSetAndValid())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + pendingStyle = mPendingStylesToApplyToNewContent->TakeClearingStyle(); + } + } + + // then process setting any styles + const int32_t relFontSize = + mPendingStylesToApplyToNewContent->TakeRelativeFontSize(); + AutoTArray<EditorInlineStyleAndValue, 32> stylesToSet; + mPendingStylesToApplyToNewContent->TakeAllPreservedStyles(stylesToSet); + if (stylesToSet.IsEmpty() && !relFontSize) { + return pointToPutCaret; + } + + // We're in chrome, e.g., the email composer of Thunderbird, and there is + // relative font size changes, we need to keep using legacy path until we port + // IncrementOrDecrementFontSizeAsSubAction() to work with + // AutoInlineStyleSetter. + if (relFontSize) { + // we have at least one style to add; make a new text node to insert style + // nodes above. + EditorDOMPoint pointToInsertTextNode(pointToPutCaret); + if (pointToInsertTextNode.IsInTextNode()) { + // if we are in a text node, split it + Result<SplitNodeResult, nsresult> splitTextNodeResult = + SplitNodeDeepWithTransaction( + MOZ_KnownLive(*pointToInsertTextNode.ContainerAs<Text>()), + pointToInsertTextNode, + SplitAtEdges::eAllowToCreateEmptyContainer); + if (MOZ_UNLIKELY(splitTextNodeResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eAllowToCreateEmptyContainer) failed"); + return splitTextNodeResult.propagateErr(); + } + SplitNodeResult unwrappedSplitTextNodeResult = + splitTextNodeResult.unwrap(); + unwrappedSplitTextNodeResult.MoveCaretPointTo( + pointToPutCaret, *this, + {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + pointToInsertTextNode = + unwrappedSplitTextNodeResult.AtSplitPoint<EditorDOMPoint>(); + } + if (!pointToInsertTextNode.IsInContentNode() || + !HTMLEditUtils::IsContainerNode( + *pointToInsertTextNode.ContainerAs<nsIContent>())) { + return pointToPutCaret; + } + RefPtr<Text> newEmptyTextNode = CreateTextNode(u""_ns); + if (!newEmptyTextNode) { + NS_WARNING("EditorBase::CreateTextNode() failed"); + return Err(NS_ERROR_FAILURE); + } + Result<CreateTextResult, nsresult> insertNewTextNodeResult = + InsertNodeWithTransaction<Text>(*newEmptyTextNode, + pointToInsertTextNode); + if (MOZ_UNLIKELY(insertNewTextNodeResult.isErr())) { + NS_WARNING("EditorBase::InsertNodeWithTransaction() failed"); + return insertNewTextNodeResult.propagateErr(); + } + insertNewTextNodeResult.inspect().IgnoreCaretPointSuggestion(); + pointToPutCaret.Set(newEmptyTextNode, 0u); + + // FIXME: If the stylesToSet have background-color style, it may + // be applied shorter because outer <span> element height is not + // computed with inner element's height. + HTMLEditor::FontSize incrementOrDecrement = + relFontSize > 0 ? HTMLEditor::FontSize::incr + : HTMLEditor::FontSize::decr; + for ([[maybe_unused]] uint32_t j : IntegerRange(Abs(relFontSize))) { + Result<CreateElementResult, nsresult> wrapTextInBigOrSmallElementResult = + SetFontSizeOnTextNode(*newEmptyTextNode, 0, UINT32_MAX, + incrementOrDecrement); + if (MOZ_UNLIKELY(wrapTextInBigOrSmallElementResult.isErr())) { + NS_WARNING("HTMLEditor::SetFontSizeOnTextNode() failed"); + return wrapTextInBigOrSmallElementResult.propagateErr(); + } + // We don't need to update here because we'll suggest caret position + // which is computed above. + MOZ_ASSERT(pointToPutCaret.IsSet()); + wrapTextInBigOrSmallElementResult.inspect().IgnoreCaretPointSuggestion(); + } + + for (const EditorInlineStyleAndValue& styleToSet : stylesToSet) { + AutoInlineStyleSetter inlineStyleSetter(styleToSet); + // MOZ_KnownLive(...ContainerAs<nsIContent>()) because pointToPutCaret + // grabs the result. + Result<CaretPoint, nsresult> setStyleResult = + inlineStyleSetter.ApplyStyleToNodeOrChildrenAndRemoveNestedSameStyle( + *this, MOZ_KnownLive(*pointToPutCaret.ContainerAs<nsIContent>())); + if (MOZ_UNLIKELY(setStyleResult.isErr())) { + NS_WARNING("HTMLEditor::SetInlinePropertyOnNode() failed"); + return setStyleResult.propagateErr(); + } + // We don't need to update here because we'll suggest caret position which + // is computed above. + MOZ_ASSERT(pointToPutCaret.IsSet()); + setStyleResult.unwrap().IgnoreCaretPointSuggestion(); + } + return pointToPutCaret; + } + + // If we have preserved commands except relative font style changes, we can + // use inline style setting code which reuse ancestors better. + AutoRangeArray ranges(pointToPutCaret); + if (MOZ_UNLIKELY(ranges.Ranges().IsEmpty())) { + NS_WARNING("AutoRangeArray::AutoRangeArray() failed"); + return Err(NS_ERROR_FAILURE); + } + nsresult rv = + SetInlinePropertiesAroundRanges(ranges, stylesToSet, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::SetInlinePropertiesAroundRanges() failed"); + return Err(rv); + } + if (NS_WARN_IF(ranges.Ranges().IsEmpty())) { + return Err(NS_ERROR_FAILURE); + } + // Now `ranges` selects new styled contents and the range may not be + // collapsed. We should use the deepest editable start point of the range + // to insert text. + nsINode* container = ranges.FirstRangeRef()->GetStartContainer(); + if (MOZ_UNLIKELY(!container->IsContent())) { + container = ranges.FirstRangeRef()->GetChildAtStartOffset(); + if (MOZ_UNLIKELY(!container)) { + NS_WARNING("How did we get lost insertion point?"); + return Err(NS_ERROR_FAILURE); + } + } + pointToPutCaret = + HTMLEditUtils::GetDeepestEditableStartPointOf<EditorDOMPoint>( + *container->AsContent()); + if (NS_WARN_IF(!pointToPutCaret.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + return pointToPutCaret; +} + +Result<EditActionResult, nsresult> HTMLEditor::AlignAsSubAction( + const nsAString& aAlignType, const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eSetOrClearAlignment, nsIEditor::eNext, + ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Some selection containers are not content node, but ignored"); + return EditActionResult::IgnoredResult(); + } + + nsresult rv = 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 (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Mutation event listener might have changed the selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (NS_SUCCEEDED(rv) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + AutoRangeArray selectionRanges(SelectionRef()); + + // XXX Why do we do this only when there is only one selection range? + if (!selectionRanges.IsCollapsed() && + selectionRanges.Ranges().Length() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + selectionRanges.FirstRangeRef(), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.propagateErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use etStartAndEnd() here. + nsresult rv = selectionRanges.SetBaseAndExtent( + extendedRange.inspect().StartRef(), extendedRange.inspect().EndRef()); + if (NS_FAILED(rv)) { + NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); + return Err(rv); + } + } + + rv = AlignContentsAtRanges(selectionRanges, aAlignType, aEditingHost); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::AlignContentsAtSelection() failed"); + return Err(rv); + } + rv = selectionRanges.ApplyTo(SelectionRef()); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::ApplyTo() failed"); + return Err(rv); + } + + if (MOZ_UNLIKELY(IsSelectionRangeContainerNotContent())) { + NS_WARNING("Mutation event listener might have changed the selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() " + "failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::AlignContentsAtRanges(AutoRangeArray& aRanges, + const nsAString& aAlignType, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(aRanges.IsInContent()); + + if (NS_WARN_IF(!aRanges.SaveAndTrackRanges(*this))) { + return NS_ERROR_FAILURE; + } + + EditorDOMPoint pointToPutCaret; + + // Convert the selection ranges into "promoted" selection ranges: This + // basically just expands the range to include the immediate block parent, + // and then further expands to include any ancestors whose children are all + // in the range + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eSetOrClearAlignment, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() " + "failed"); + return splitResult.unwrapErr(); + } + if (splitResult.inspect().IsSet()) { + pointToPutCaret = splitResult.unwrap(); + } + nsresult rv = extendedRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eSetOrClearAlignment, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eSetOrClearAlignment, CollectNonEditableNodes::Yes) failed"); + return rv; + } + } + + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eSetOrClearAlignment); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eSetOrClearAlignment) failed"); + return splitAtBRElementsResult.inspectErr(); + } + if (splitAtBRElementsResult.inspect().IsSet()) { + pointToPutCaret = splitAtBRElementsResult.unwrap(); + } + + // If we don't have any nodes, or we have only a single br, then we are + // creating an empty alignment div. We have to do some different things for + // these. + bool createEmptyDivElement = arrayOfContents.IsEmpty(); + if (arrayOfContents.Length() == 1) { + OwningNonNull<nsIContent>& content = arrayOfContents[0]; + + if (HTMLEditUtils::SupportsAlignAttr(content)) { + // The node is a table element, an hr, a paragraph, a div or a section + // header; in HTML 4, it can directly carry the ALIGN attribute and we + // don't need to make a div! If we are in CSS mode, all the work is done + // in SetBlockElementAlign(). + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + SetBlockElementAlign(MOZ_KnownLive(*content->AsElement()), aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::SetBlockElementAlign() failed"); + return pointToPutCaretOrError.unwrapErr(); + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + + if (content->IsHTMLElement(nsGkAtoms::br)) { + // The special case createEmptyDivElement code (below) that consumes + // `<br>` elements can cause tables to split if the start node of the + // selection is not in a table cell or caption, for example parent is a + // `<tr>`. Avoid this unnecessary splitting if possible by leaving + // createEmptyDivElement false so that we fall through to the normal case + // alignment code. + // + // XXX: It seems a little error prone for the createEmptyDivElement + // special case code to assume that the start node of the selection + // is the parent of the single node in the arrayOfContents, as the + // paragraph above points out. Do we rely on the selection start + // node because of the fact that arrayOfContents can be empty? We + // should probably revisit this issue. - kin + + const EditorDOMPoint firstRangeStartPoint = + pointToPutCaret.IsSet() + ? pointToPutCaret + : aRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!firstRangeStartPoint.IsSet())) { + return NS_ERROR_FAILURE; + } + nsINode* parent = firstRangeStartPoint.GetContainer(); + createEmptyDivElement = !HTMLEditUtils::IsAnyTableElement(parent) || + HTMLEditUtils::IsTableCellOrCaption(*parent); + } + } + + if (createEmptyDivElement) { + if (MOZ_UNLIKELY(!pointToPutCaret.IsSet() && !aRanges.IsInContent())) { + NS_WARNING("Mutation event listener might have changed the selection"); + return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE; + } + const EditorDOMPoint pointToInsertDivElement = + pointToPutCaret.IsSet() + ? pointToPutCaret + : aRanges.GetFirstRangeStartPoint<EditorDOMPoint>(); + Result<CreateElementResult, nsresult> insertNewDivElementResult = + InsertDivElementToAlignContents(pointToInsertDivElement, aAlignType, + aEditingHost); + if (insertNewDivElementResult.isErr()) { + NS_WARNING("HTMLEditor::InsertDivElementToAlignContents() failed"); + return insertNewDivElementResult.unwrapErr(); + } + CreateElementResult unwrappedInsertNewDivElementResult = + insertNewDivElementResult.unwrap(); + aRanges.ClearSavedRanges(); + EditorDOMPoint pointToPutCaret = + unwrappedInsertNewDivElementResult.UnwrapCaretPoint(); + nsresult rv = aRanges.Collapse(pointToPutCaret); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "AutoRangeArray::Collapse() failed"); + return rv; + } + + Result<CreateElementResult, nsresult> maybeCreateDivElementResult = + AlignNodesAndDescendants(arrayOfContents, aAlignType, aEditingHost); + if (MOZ_UNLIKELY(maybeCreateDivElementResult.isErr())) { + NS_WARNING("HTMLEditor::AlignNodesAndDescendants() failed"); + return maybeCreateDivElementResult.unwrapErr(); + } + maybeCreateDivElementResult.inspect().IgnoreCaretPointSuggestion(); + + MOZ_ASSERT(aRanges.HasSavedRanges()); + aRanges.RestoreFromSavedRanges(); + // If restored range is collapsed outside the latest cased <div> element, + // we should move caret into the <div>. + if (maybeCreateDivElementResult.inspect().GetNewNode() && + aRanges.IsCollapsed() && !aRanges.Ranges().IsEmpty()) { + const auto firstRangeStartRawPoint = + aRanges.GetFirstRangeStartPoint<EditorRawDOMPoint>(); + if (MOZ_LIKELY(firstRangeStartRawPoint.IsSet())) { + Result<EditorRawDOMPoint, nsresult> pointInNewDivOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorRawDOMPoint>( + *maybeCreateDivElementResult.inspect().GetNewNode(), + firstRangeStartRawPoint); + if (MOZ_UNLIKELY(pointInNewDivOrError.isErr())) { + NS_WARNING( + "HTMLEditUtils::ComputePointToPutCaretInElementIfOutside() failed, " + "but ignored"); + } else if (pointInNewDivOrError.inspect().IsSet()) { + nsresult rv = aRanges.Collapse(pointInNewDivOrError.unwrap()); + if (NS_FAILED(rv)) { + NS_WARNING("AutoRangeArray::Collapse() failed"); + return rv; + } + } + } + } + return NS_OK; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::InsertDivElementToAlignContents( + const EditorDOMPoint& aPointToInsert, const nsAString& aAlignType, + const Element& aEditingHost) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + MOZ_ASSERT(!IsSelectionRangeContainerNotContent()); + MOZ_ASSERT(aPointToInsert.IsSetAndValid()); + + if (NS_WARN_IF(!aPointToInsert.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, aPointToInsert, BRElementNextToSplitPoint::Delete, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div, BRElementNextToSplitPoint::Delete) failed"); + return createNewDivElementResult; + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + // We'll suggest start of the new <div>, so we don't need the suggested + // position. + unwrappedCreateNewDivElementResult.IgnoreCaretPointSuggestion(); + + MOZ_ASSERT(unwrappedCreateNewDivElementResult.GetNewNode()); + RefPtr<Element> newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + // Set up the alignment on the div, using HTML or CSS + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + SetBlockElementAlign(*newDivElement, aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::SetBlockElementAlign(EditTarget::" + "OnlyDescendantsExceptTable) failed"); + return pointToPutCaretOrError.propagateErr(); + } + // We don't need the new suggested position too. + + // Put in a padding <br> element for empty last line so that it won't get + // deleted. + { + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction( + EditorDOMPoint(newDivElement, 0u)); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " + "failed"); + return insertPaddingBRElementResult; + } + insertPaddingBRElementResult.inspect().IgnoreCaretPointSuggestion(); + } + + return CreateElementResult(std::move(newDivElement), + EditorDOMPoint(newDivElement, 0u)); +} + +Result<CreateElementResult, nsresult> HTMLEditor::AlignNodesAndDescendants( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + const nsAString& aAlignType, const Element& aEditingHost) { + // Detect all the transitions in the array, where a transition means that + // adjacent nodes in the array don't have the same parent. + AutoTArray<bool, 64> transitionList; + HTMLEditor::MakeTransitionList(aArrayOfContents, transitionList); + + RefPtr<Element> latestCreatedDivElement; + EditorDOMPoint pointToPutCaret; + + // Okay, now go through all the nodes and give them an align attrib or put + // them in a div, or whatever is appropriate. Woohoo! + + RefPtr<Element> createdDivElement; + const bool useCSS = IsCSSEnabled(); + int32_t indexOfTransitionList = -1; + for (OwningNonNull<nsIContent>& content : aArrayOfContents) { + ++indexOfTransitionList; + + // Ignore all non-editable nodes. Leave them be. + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + continue; + } + + // The node is a table element, an hr, a paragraph, a div or a section + // header; in HTML 4, it can directly carry the ALIGN attribute and we + // don't need to nest it, just set the alignment. In CSS, assign the + // corresponding CSS styles in SetBlockElementAlign(). + if (HTMLEditUtils::SupportsAlignAttr(content)) { + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + SetBlockElementAlign(MOZ_KnownLive(*content->AsElement()), aAlignType, + EditTarget::NodeAndDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::SetBlockElementAlign(EditTarget::" + "NodeAndDescendantsExceptTable) failed"); + return pointToPutCaretOrError.propagateErr(); + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + // Clear out createdDivElement so that we don't put nodes after this one + // into it + createdDivElement = nullptr; + continue; + } + + EditorDOMPoint atContent(content); + if (NS_WARN_IF(!atContent.IsSet())) { + continue; + } + + // Skip insignificant formatting text nodes to prevent unnecessary + // structure splitting! + if (content->IsText() && + ((HTMLEditUtils::IsAnyTableElement(atContent.GetContainer()) && + !HTMLEditUtils::IsTableCellOrCaption(*atContent.GetContainer())) || + HTMLEditUtils::IsAnyListElement(atContent.GetContainer()) || + HTMLEditUtils::IsEmptyNode( + *content, {EmptyCheckOption::TreatSingleBRElementAsVisible}))) { + continue; + } + + // If it's a list item, or a list inside a list, forget any "current" div, + // and instead put divs inside the appropriate block (td, li, etc.) + if (HTMLEditUtils::IsListItem(content) || + HTMLEditUtils::IsAnyListElement(content)) { + Element* listOrListItemElement = content->AsElement(); + { + AutoEditorDOMPointOffsetInvalidator lockChild(atContent); + // MOZ_KnownLive(*listOrListItemElement): An element of aArrayOfContents + // which is array of OwningNonNull. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + RemoveAlignFromDescendants(MOZ_KnownLive(*listOrListItemElement), + aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveAlignFromDescendants(EditTarget::" + "OnlyDescendantsExceptTable) failed"); + return pointToPutCaretOrError.propagateErr(); + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + if (NS_WARN_IF(!atContent.IsSetAndValid())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (useCSS) { + nsStyledElement* styledListOrListItemElement = + nsStyledElement::FromNode(listOrListItemElement); + if (styledListOrListItemElement && + EditorElementStyle::Align().IsCSSSettable( + *styledListOrListItemElement)) { + // MOZ_KnownLive(*styledListOrListItemElement): An element of + // aArrayOfContents which is array of OwningNonNull. + Result<size_t, nsresult> result = + CSSEditUtils::SetCSSEquivalentToStyle( + WithTransaction::Yes, *this, + MOZ_KnownLive(*styledListOrListItemElement), + EditorElementStyle::Align(), &aAlignType); + if (MOZ_UNLIKELY(result.isErr())) { + if (NS_WARN_IF(result.inspectErr() == NS_ERROR_EDITOR_DESTROYED)) { + return result.propagateErr(); + } + NS_WARNING( + "CSSEditUtils::SetCSSEquivalentToStyle(EditorElementStyle::" + "Align()) failed, but ignored"); + } + } + createdDivElement = nullptr; + continue; + } + + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + // If we don't use CSS, add a content to list element: they have to + // be inside another list, i.e., >= second level of nesting. + // XXX AlignContentsInAllTableCellsAndListItems() handles only list + // item elements and table cells. Is it intentional? Why don't + // we need to align contents in other type blocks? + // MOZ_KnownLive(*listOrListItemElement): An element of aArrayOfContents + // which is array of OwningNonNull. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + AlignContentsInAllTableCellsAndListItems( + MOZ_KnownLive(*listOrListItemElement), aAlignType); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::AlignContentsInAllTableCellsAndListItems() failed"); + return pointToPutCaretOrError.propagateErr(); + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + createdDivElement = nullptr; + continue; + } + + // Clear out createdDivElement so that we don't put nodes after this one + // into it + } + + // Need to make a div to put things in if we haven't already, or if this + // node doesn't go in div we used earlier. + if (!createdDivElement || transitionList[indexOfTransitionList]) { + // First, check that our element can contain a div. + if (!HTMLEditUtils::CanNodeContain(*atContent.GetContainer(), + *nsGkAtoms::div)) { + // XXX Why do we return "OK" here rather than returning error or + // doing continue? + return latestCreatedDivElement + ? CreateElementResult(std::move(latestCreatedDivElement), + std::move(pointToPutCaret)) + : CreateElementResult::NotHandled( + std::move(pointToPutCaret)); + } + + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult; + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + if (unwrappedCreateNewDivElementResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedCreateNewDivElementResult.UnwrapCaretPoint(); + } + + MOZ_ASSERT(unwrappedCreateNewDivElementResult.GetNewNode()); + createdDivElement = unwrappedCreateNewDivElementResult.UnwrapNewNode(); + // Set up the alignment on the div + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + SetBlockElementAlign(*createdDivElement, aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + if (NS_WARN_IF(pointToPutCaretOrError.inspectErr() == + NS_ERROR_EDITOR_DESTROYED)) { + return pointToPutCaretOrError.propagateErr(); + } + NS_WARNING( + "HTMLEditor::SetBlockElementAlign(EditTarget::" + "OnlyDescendantsExceptTable) failed, but ignored"); + } else if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + latestCreatedDivElement = createdDivElement; + } + + // Tuck the node into the end of the active div + // + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), + *createdDivElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + if (unwrappedMoveNodeResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveNodeResult.UnwrapCaretPoint(); + } + } + + return latestCreatedDivElement + ? CreateElementResult(std::move(latestCreatedDivElement), + std::move(pointToPutCaret)) + : CreateElementResult::NotHandled(std::move(pointToPutCaret)); +} + +Result<EditorDOMPoint, nsresult> +HTMLEditor::AlignContentsInAllTableCellsAndListItems( + Element& aElement, const nsAString& aAlignType) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // Gather list of table cells or list items + AutoTArray<OwningNonNull<Element>, 64> arrayOfTableCellsAndListItems; + DOMIterator iter(aElement); + iter.AppendNodesToArray( + +[](nsINode& aNode, void*) -> bool { + MOZ_ASSERT(Element::FromNode(&aNode)); + return HTMLEditUtils::IsTableCell(&aNode) || + HTMLEditUtils::IsListItem(&aNode); + }, + arrayOfTableCellsAndListItems); + + // Now that we have the list, align their contents as requested + EditorDOMPoint pointToPutCaret; + for (auto& tableCellOrListItemElement : arrayOfTableCellsAndListItems) { + // MOZ_KnownLive because 'arrayOfTableCellsAndListItems' is guaranteed to + // keep it alive. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + AlignBlockContentsWithDivElement( + MOZ_KnownLive(tableCellOrListItemElement), aAlignType); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::AlignBlockContentsWithDivElement() failed"); + return pointToPutCaretOrError; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + + return pointToPutCaret; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::AlignBlockContentsWithDivElement( + Element& aBlockElement, const nsAString& aAlignType) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // XXX I don't understand why we should NOT align non-editable children + // with modifying EDITABLE `<div>` element. + nsCOMPtr<nsIContent> firstEditableContent = HTMLEditUtils::GetFirstChild( + aBlockElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (!firstEditableContent) { + // This block has no editable content, nothing to align. + return EditorDOMPoint(); + } + + // If there is only one editable content and it's a `<div>` element, + // just set `align` attribute of it. + nsCOMPtr<nsIContent> lastEditableContent = HTMLEditUtils::GetLastChild( + aBlockElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (firstEditableContent == lastEditableContent && + firstEditableContent->IsHTMLElement(nsGkAtoms::div)) { + nsresult rv = SetAttributeOrEquivalent( + MOZ_KnownLive(firstEditableContent->AsElement()), nsGkAtoms::align, + aAlignType, false); + if (NS_WARN_IF(Destroyed())) { + NS_WARNING( + "EditorBase::SetAttributeOrEquivalent(nsGkAtoms::align) caused " + "destroying the editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::SetAttributeOrEquivalent(nsGkAtoms::align) failed"); + return Err(rv); + } + return EditorDOMPoint(); + } + + // Otherwise, we need to insert a `<div>` element to set `align` attribute. + // XXX Don't insert the new `<div>` element until we set `align` attribute + // for avoiding running mutation event listeners. + Result<CreateElementResult, nsresult> createNewDivElementResult = + CreateAndInsertElement( + WithTransaction::Yes, *nsGkAtoms::div, + EditorDOMPoint(&aBlockElement, 0u), + // MOZ_CAN_RUN_SCRIPT_BOUNDARY due to bug 1758868 + [&aAlignType](HTMLEditor& aHTMLEditor, Element& aDivElement, + const EditorDOMPoint&) MOZ_CAN_RUN_SCRIPT_BOUNDARY { + MOZ_ASSERT(!aDivElement.IsInComposedDoc()); + // If aDivElement has not been connected yet, we do not need + // transaction of setting align attribute here. + nsresult rv = aHTMLEditor.SetAttributeOrEquivalent( + &aDivElement, nsGkAtoms::align, aAlignType, false); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::SetAttributeOrEquivalent(" + "nsGkAtoms::align, \"...\", false) failed"); + return rv; + }); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes, " + "nsGkAtoms::div) failed"); + return createNewDivElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + EditorDOMPoint pointToPutCaret = + unwrappedCreateNewDivElementResult.UnwrapCaretPoint(); + RefPtr<Element> newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + MOZ_ASSERT(newDivElement); + // XXX This is tricky and does not work with mutation event listeners. + // But I'm not sure what we should do if new content is inserted. + // Anyway, I don't think that we should move editable contents + // over non-editable contents. Chrome does no do that. + while (lastEditableContent && (lastEditableContent != newDivElement)) { + Result<MoveNodeResult, nsresult> moveNodeResult = MoveNodeWithTransaction( + *lastEditableContent, EditorDOMPoint(newDivElement, 0u)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + if (unwrappedMoveNodeResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedMoveNodeResult.UnwrapCaretPoint(); + } + lastEditableContent = HTMLEditUtils::GetLastChild( + aBlockElement, {WalkTreeOption::IgnoreNonEditableNode}); + } + return pointToPutCaret; +} + +Result<EditorRawDOMRange, nsresult> +HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction( + const nsRange* aRange, const Element& aEditingHost) const { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // This tweaks selections to be more "natural". + // Idea here is to adjust edges of selection ranges so that they do not cross + // breaks or block boundaries unless something editable beyond that boundary + // is also selected. This adjustment makes it much easier for the various + // block operations to determine what nodes to act on. + if (NS_WARN_IF(!aRange) || NS_WARN_IF(!aRange->IsPositioned())) { + return Err(NS_ERROR_FAILURE); + } + + const EditorRawDOMPoint startPoint(aRange->StartRef()); + if (NS_WARN_IF(!startPoint.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + const EditorRawDOMPoint endPoint(aRange->EndRef()); + if (NS_WARN_IF(!endPoint.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + + // adjusted values default to original values + EditorRawDOMRange newRange(startPoint, endPoint); + + // Is there any intervening visible white-space? If so we can't push + // selection past that, it would visibly change meaning of users selection. + WSRunScanner wsScannerAtEnd(&aEditingHost, endPoint); + WSScanResult scanResultAtEnd = + wsScannerAtEnd.ScanPreviousVisibleNodeOrBlockBoundaryFrom(endPoint); + if (scanResultAtEnd.Failed()) { + NS_WARNING( + "WSRunScanner::ScanPreviousVisibleNodeOrBlockBoundaryFrom() failed"); + return Err(NS_ERROR_FAILURE); + } + if (scanResultAtEnd.ReachedSomethingNonTextContent()) { + // eThisBlock and eOtherBlock conveniently distinguish cases + // of going "down" into a block and "up" out of a block. + if (wsScannerAtEnd.StartsFromOtherBlockElement()) { + // endpoint is just after the close of a block. + if (nsIContent* child = HTMLEditUtils::GetLastLeafContent( + *wsScannerAtEnd.StartReasonOtherBlockElementPtr(), + {LeafNodeType::LeafNodeOrChildBlock})) { + newRange.SetEnd(EditorRawDOMPoint::After(*child)); + } + // else block is empty - we can leave selection alone here, i think. + } else if (wsScannerAtEnd.StartsFromCurrentBlockBoundary()) { + // endpoint is just after start of this block + if (nsIContent* child = HTMLEditUtils::GetPreviousContent( + endPoint, {WalkTreeOption::IgnoreNonEditableNode}, + &aEditingHost)) { + newRange.SetEnd(EditorRawDOMPoint::After(*child)); + } + // else block is empty - we can leave selection alone here, i think. + } else if (wsScannerAtEnd.StartsFromBRElement()) { + // endpoint is just after break. lets adjust it to before it. + newRange.SetEnd( + EditorRawDOMPoint(wsScannerAtEnd.StartReasonBRElementPtr())); + } + } + + // Is there any intervening visible white-space? If so we can't push + // selection past that, it would visibly change meaning of users selection. + WSRunScanner wsScannerAtStart(&aEditingHost, startPoint); + WSScanResult scanResultAtStart = + wsScannerAtStart.ScanNextVisibleNodeOrBlockBoundaryFrom(startPoint); + if (scanResultAtStart.Failed()) { + NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundaryFrom() failed"); + return Err(NS_ERROR_FAILURE); + } + if (scanResultAtStart.ReachedSomethingNonTextContent()) { + // eThisBlock and eOtherBlock conveniently distinguish cases + // of going "down" into a block and "up" out of a block. + if (wsScannerAtStart.EndsByOtherBlockElement()) { + // startpoint is just before the start of a block. + if (nsIContent* child = HTMLEditUtils::GetFirstLeafContent( + *wsScannerAtStart.EndReasonOtherBlockElementPtr(), + {LeafNodeType::LeafNodeOrChildBlock})) { + newRange.SetStart(EditorRawDOMPoint(child)); + } + // else block is empty - we can leave selection alone here, i think. + } else if (wsScannerAtStart.EndsByCurrentBlockBoundary()) { + // startpoint is just before end of this block + if (nsIContent* child = HTMLEditUtils::GetNextContent( + startPoint, {WalkTreeOption::IgnoreNonEditableNode}, + &aEditingHost)) { + newRange.SetStart(EditorRawDOMPoint(child)); + } + // else block is empty - we can leave selection alone here, i think. + } else if (wsScannerAtStart.EndsByBRElement()) { + // startpoint is just before a break. lets adjust it to after it. + newRange.SetStart( + EditorRawDOMPoint::After(*wsScannerAtStart.EndReasonBRElementPtr())); + } + } + + // There is a demented possibility we have to check for. We might have a very + // strange selection that is not collapsed and yet does not contain any + // editable content, and satisfies some of the above conditions that cause + // tweaking. In this case we don't want to tweak the selection into a block + // it was never in, etc. There are a variety of strategies one might use to + // try to detect these cases, but I think the most straightforward is to see + // if the adjusted locations "cross" the old values: i.e., new end before old + // start, or new start after old end. If so then just leave things alone. + + Maybe<int32_t> comp = nsContentUtils::ComparePoints( + startPoint.ToRawRangeBoundary(), newRange.EndRef().ToRawRangeBoundary()); + + if (NS_WARN_IF(!comp)) { + return Err(NS_ERROR_FAILURE); + } + + if (*comp == 1) { + return EditorRawDOMRange(); // New end before old start. + } + + comp = nsContentUtils::ComparePoints(newRange.StartRef().ToRawRangeBoundary(), + endPoint.ToRawRangeBoundary()); + + if (NS_WARN_IF(!comp)) { + return Err(NS_ERROR_FAILURE); + } + + if (*comp == 1) { + return EditorRawDOMRange(); // New start after old end. + } + + return newRange; +} + +template <typename EditorDOMRangeType> +already_AddRefed<nsRange> HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMRangeType& aRange) { + MOZ_DIAGNOSTIC_ASSERT(aRange.IsPositioned()); + return CreateRangeIncludingAdjuscentWhiteSpaces(aRange.StartRef(), + aRange.EndRef()); +} + +template <typename EditorDOMPointType1, typename EditorDOMPointType2> +already_AddRefed<nsRange> HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMPointType1& aStartPoint, + const EditorDOMPointType2& aEndPoint) { + MOZ_DIAGNOSTIC_ASSERT(!aStartPoint.IsInNativeAnonymousSubtree()); + MOZ_DIAGNOSTIC_ASSERT(!aEndPoint.IsInNativeAnonymousSubtree()); + + if (!aStartPoint.IsInContentNode() || !aEndPoint.IsInContentNode()) { + NS_WARNING_ASSERTION(aStartPoint.IsSet(), "aStartPoint was not set"); + NS_WARNING_ASSERTION(aEndPoint.IsSet(), "aEndPoint was not set"); + return nullptr; + } + + const Element* const editingHost = ComputeEditingHost(); + if (NS_WARN_IF(!editingHost)) { + return nullptr; + } + + EditorDOMPoint startPoint = aStartPoint.template To<EditorDOMPoint>(); + EditorDOMPoint endPoint = aEndPoint.template To<EditorDOMPoint>(); + AutoRangeArray::UpdatePointsToSelectAllChildrenIfCollapsedInEmptyBlockElement( + startPoint, endPoint, *editingHost); + + if (NS_WARN_IF(!startPoint.IsInContentNode()) || + NS_WARN_IF(!endPoint.IsInContentNode())) { + NS_WARNING( + "AutoRangeArray::" + "UpdatePointsToSelectAllChildrenIfCollapsedInEmptyBlockElement() " + "failed"); + return nullptr; + } + + // For text actions, we want to look backwards (or forwards, as + // appropriate) for additional white-space or nbsp's. We may have to act + // on these later even though they are outside of the initial selection. + // Even if they are in another node! + // XXX Those scanners do not treat siblings of the text nodes. Perhaps, + // we should use `WSRunScanner::GetFirstASCIIWhiteSpacePointCollapsedTo()` + // and `WSRunScanner::GetEndOfCollapsibleASCIIWhiteSpaces()` instead. + if (startPoint.IsInTextNode()) { + while (!startPoint.IsStartOfContainer()) { + if (!startPoint.IsPreviousCharASCIISpaceOrNBSP()) { + break; + } + MOZ_ALWAYS_TRUE(startPoint.RewindOffset()); + } + } + if (!startPoint.GetChildOrContainerIfDataNode() || + !startPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf( + editingHost)) { + return nullptr; + } + if (endPoint.IsInTextNode()) { + while (!endPoint.IsEndOfContainer()) { + if (!endPoint.IsCharASCIISpaceOrNBSP()) { + break; + } + MOZ_ALWAYS_TRUE(endPoint.AdvanceOffset()); + } + } + EditorDOMPoint lastRawPoint(endPoint); + if (!lastRawPoint.IsStartOfContainer()) { + lastRawPoint.RewindOffset(); + } + if (!lastRawPoint.GetChildOrContainerIfDataNode() || + !lastRawPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf( + editingHost)) { + return nullptr; + } + + RefPtr<nsRange> range = + nsRange::Create(startPoint.ToRawRangeBoundary(), + endPoint.ToRawRangeBoundary(), IgnoreErrors()); + NS_WARNING_ASSERTION(range, "nsRange::Create() failed"); + return range.forget(); +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::MaybeSplitElementsAtEveryBRElement( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + EditSubAction aEditSubAction) { + // Post-process the list to break up inline containers that contain br's, but + // only for operations that might care, like making lists or paragraphs + switch (aEditSubAction) { + case EditSubAction::eCreateOrRemoveBlock: + case EditSubAction::eMergeBlockContents: + case EditSubAction::eCreateOrChangeList: + case EditSubAction::eSetOrClearAlignment: + case EditSubAction::eSetPositionToAbsolute: + case EditSubAction::eIndent: + case EditSubAction::eOutdent: { + EditorDOMPoint pointToPutCaret; + for (int32_t i = aArrayOfContents.Length() - 1; i >= 0; i--) { + OwningNonNull<nsIContent>& content = aArrayOfContents[i]; + if (HTMLEditUtils::IsInlineElement(content) && + HTMLEditUtils::IsContainerNode(content) && !content->IsText()) { + AutoTArray<OwningNonNull<nsIContent>, 24> arrayOfInlineContents; + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it + // alive. + Result<EditorDOMPoint, nsresult> splitResult = + SplitElementsAtEveryBRElement(MOZ_KnownLive(content), + arrayOfInlineContents); + if (splitResult.isErr()) { + NS_WARNING("HTMLEditor::SplitElementsAtEveryBRElement() failed"); + return splitResult; + } + if (splitResult.inspect().IsSet()) { + pointToPutCaret = splitResult.unwrap(); + } + // Put these nodes in aArrayOfContents, replacing the current node + aArrayOfContents.RemoveElementAt(i); + aArrayOfContents.InsertElementsAt(i, arrayOfInlineContents); + } + } + return pointToPutCaret; + } + default: + return EditorDOMPoint(); + } +} + +Result<EditorDOMPoint, nsresult> +HTMLEditor::SplitParentInlineElementsAtRangeBoundaries( + RangeItem& aRangeItem, const Element& aEditingHost, + const nsIContent* aAncestorLimiter /* = nullptr */) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + EditorDOMPoint pointToPutCaret; + if (!aRangeItem.Collapsed() && aRangeItem.mEndContainer && + aRangeItem.mEndContainer->IsContent()) { + nsCOMPtr<nsIContent> mostAncestorInlineContentAtEnd = + HTMLEditUtils::GetMostDistantAncestorInlineElement( + *aRangeItem.mEndContainer->AsContent(), &aEditingHost, + aAncestorLimiter); + + if (mostAncestorInlineContentAtEnd) { + Result<SplitNodeResult, nsresult> splitEndInlineResult = + SplitNodeDeepWithTransaction( + *mostAncestorInlineContentAtEnd, aRangeItem.EndPoint(), + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitEndInlineResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) failed"); + return splitEndInlineResult.propagateErr(); + } + SplitNodeResult unwrappedSplitEndInlineResult = + splitEndInlineResult.unwrap(); + unwrappedSplitEndInlineResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + if (pointToPutCaret.IsInContentNode() && + MOZ_UNLIKELY( + &aEditingHost != + ComputeEditingHost(*pointToPutCaret.ContainerAs<nsIContent>()))) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) caused changing editing host"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + const auto splitPointAtEnd = + unwrappedSplitEndInlineResult.AtSplitPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!splitPointAtEnd.IsSet())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) didn't return split point"); + return Err(NS_ERROR_FAILURE); + } + aRangeItem.mEndContainer = splitPointAtEnd.GetContainer(); + aRangeItem.mEndOffset = splitPointAtEnd.Offset(); + } + } + + if (!aRangeItem.mStartContainer || !aRangeItem.mStartContainer->IsContent()) { + return pointToPutCaret; + } + + nsCOMPtr<nsIContent> mostAncestorInlineContentAtStart = + HTMLEditUtils::GetMostDistantAncestorInlineElement( + *aRangeItem.mStartContainer->AsContent(), &aEditingHost, + aAncestorLimiter); + + if (mostAncestorInlineContentAtStart) { + Result<SplitNodeResult, nsresult> splitStartInlineResult = + SplitNodeDeepWithTransaction(*mostAncestorInlineContentAtStart, + aRangeItem.StartPoint(), + SplitAtEdges::eDoNotCreateEmptyContainer); + if (MOZ_UNLIKELY(splitStartInlineResult.isErr())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) failed"); + return splitStartInlineResult.propagateErr(); + } + SplitNodeResult unwrappedSplitStartInlineResult = + splitStartInlineResult.unwrap(); + // XXX Why don't we check editing host like above?? + unwrappedSplitStartInlineResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + // XXX If we split only here because of collapsed range, we're modifying + // only start point of aRangeItem. Shouldn't we modify end point here + // if it's collapsed? + const auto splitPointAtStart = + unwrappedSplitStartInlineResult.AtSplitPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!splitPointAtStart.IsSet())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) didn't return split point"); + return Err(NS_ERROR_FAILURE); + } + aRangeItem.mStartContainer = splitPointAtStart.GetContainer(); + aRangeItem.mStartOffset = splitPointAtStart.Offset(); + } + + return pointToPutCaret; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::SplitElementsAtEveryBRElement( + nsIContent& aMostAncestorToBeSplit, + nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // First build up a list of all the break nodes inside the inline container. + AutoTArray<OwningNonNull<HTMLBRElement>, 24> arrayOfBRElements; + DOMIterator iter(aMostAncestorToBeSplit); + iter.AppendAllNodesToArray(arrayOfBRElements); + + // If there aren't any breaks, just put inNode itself in the array + if (arrayOfBRElements.IsEmpty()) { + aOutArrayOfContents.AppendElement(aMostAncestorToBeSplit); + return EditorDOMPoint(); + } + + // Else we need to bust up aMostAncestorToBeSplit along all the breaks + nsCOMPtr<nsIContent> nextContent = &aMostAncestorToBeSplit; + EditorDOMPoint pointToPutCaret; + for (OwningNonNull<HTMLBRElement>& brElement : arrayOfBRElements) { + EditorDOMPoint atBRNode(brElement); + if (NS_WARN_IF(!atBRNode.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + Result<SplitNodeResult, nsresult> splitNodeResult = + SplitNodeDeepWithTransaction( + *nextContent, atBRNode, SplitAtEdges::eAllowToCreateEmptyContainer); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); + return splitNodeResult.propagateErr(); + } + SplitNodeResult unwrappedSplitNodeResult = splitNodeResult.unwrap(); + unwrappedSplitNodeResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + // Put previous node at the split point. + if (nsIContent* previousContent = + unwrappedSplitNodeResult.GetPreviousContent()) { + // Might not be a left node. A break might have been at the very + // beginning of inline container, in which case + // SplitNodeDeepWithTransaction() would not actually split anything. + aOutArrayOfContents.AppendElement(*previousContent); + } + + // Move break outside of container and also put in node list + // MOZ_KnownLive because 'arrayOfBRElements' is guaranteed to keep it alive. + Result<MoveNodeResult, nsresult> moveBRElementResult = + MoveNodeWithTransaction( + MOZ_KnownLive(brElement), + unwrappedSplitNodeResult.AtNextContent<EditorDOMPoint>()); + if (MOZ_UNLIKELY(moveBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveBRElementResult.propagateErr(); + } + MoveNodeResult unwrappedMoveBRElementResult = moveBRElementResult.unwrap(); + unwrappedMoveBRElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + aOutArrayOfContents.AppendElement(brElement); + + nextContent = unwrappedSplitNodeResult.GetNextContent(); + } + + // Now tack on remaining next node. + aOutArrayOfContents.AppendElement(*nextContent); + + return pointToPutCaret; +} + +// static +void HTMLEditor::MakeTransitionList( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + nsTArray<bool>& aTransitionArray) { + nsINode* prevParent = nullptr; + aTransitionArray.EnsureLengthAtLeast(aArrayOfContents.Length()); + for (uint32_t i = 0; i < aArrayOfContents.Length(); i++) { + aTransitionArray[i] = aArrayOfContents[i]->GetParentNode() != prevParent; + prevParent = aArrayOfContents[i]->GetParentNode(); + } +} + +Result<InsertParagraphResult, nsresult> +HTMLEditor::HandleInsertParagraphInHeadingElement( + Element& aHeadingElement, const EditorDOMPoint& aPointToSplit) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + auto splitHeadingResult = + [this, &aPointToSplit, &aHeadingElement]() + MOZ_CAN_RUN_SCRIPT -> Result<SplitNodeResult, nsresult> { + // Normalize collapsible white-spaces around the split point to keep + // them visible after the split. Note that this does not touch + // selection because of using AutoTransactionsConserveSelection in + // WhiteSpaceVisibilityKeeper::ReplaceTextAndRemoveEmptyTextNodes(). + Result<EditorDOMPoint, nsresult> preparationResult = + WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement( + *this, aPointToSplit, aHeadingElement); + if (MOZ_UNLIKELY(preparationResult.isErr())) { + NS_WARNING( + "WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement() " + "failed"); + return preparationResult.propagateErr(); + } + EditorDOMPoint pointToSplit = preparationResult.unwrap(); + MOZ_ASSERT(pointToSplit.IsInContentNode()); + + // Split the header + Result<SplitNodeResult, nsresult> splitResult = + SplitNodeDeepWithTransaction( + aHeadingElement, pointToSplit, + SplitAtEdges::eAllowToCreateEmptyContainer); + NS_WARNING_ASSERTION( + splitResult.isOk(), + "HTMLEditor::SplitNodeDeepWithTransaction(aHeadingElement, " + "SplitAtEdges::eAllowToCreateEmptyContainer) failed"); + return splitResult; + }(); + if (MOZ_UNLIKELY(splitHeadingResult.isErr())) { + NS_WARNING("Failed to splitting aHeadingElement"); + return splitHeadingResult.propagateErr(); + } + SplitNodeResult unwrappedSplitHeadingResult = splitHeadingResult.unwrap(); + unwrappedSplitHeadingResult.IgnoreCaretPointSuggestion(); + if (MOZ_UNLIKELY(!unwrappedSplitHeadingResult.DidSplit())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eAllowToCreateEmptyContainer) didn't split aHeadingElement"); + return Err(NS_ERROR_FAILURE); + } + + // If the left heading element is empty, put a padding <br> element for empty + // last line into it. + // FYI: leftHeadingElement is grabbed by unwrappedSplitHeadingResult so that + // it's safe to access anytime. + auto* const leftHeadingElement = + unwrappedSplitHeadingResult.GetPreviousContentAs<Element>(); + MOZ_ASSERT(leftHeadingElement, + "SplitNodeResult::GetPreviousContent() should return something if " + "DidSplit() returns true"); + MOZ_DIAGNOSTIC_ASSERT(HTMLEditUtils::IsHeader(*leftHeadingElement)); + if (HTMLEditUtils::IsEmptyNode( + *leftHeadingElement, + {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction( + EditorDOMPoint(leftHeadingElement, 0u)); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction(" + ") failed"); + return insertPaddingBRElementResult.propagateErr(); + } + insertPaddingBRElementResult.inspect().IgnoreCaretPointSuggestion(); + } + + // Put caret at start of the right head element if it's not empty. + auto* const rightHeadingElement = + unwrappedSplitHeadingResult.GetNextContentAs<Element>(); + MOZ_ASSERT(rightHeadingElement, + "SplitNodeResult::GetNextContent() should return something if " + "DidSplit() returns true"); + if (!HTMLEditUtils::IsEmptyBlockElement(*rightHeadingElement, {})) { + return InsertParagraphResult(rightHeadingElement, + EditorDOMPoint(rightHeadingElement, 0u)); + } + + // If the right heading element is empty, delete it. + // TODO: If we know the new heading element becomes empty, we stop spliting + // the heading element. + // MOZ_KnownLive(rightHeadingElement) because it's grabbed by + // unwrappedSplitHeadingResult. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*rightHeadingElement)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + + // Layout tells the caret to blink in a weird place if we don't place a + // break after the header. + // XXX This block is dead code unless the removed right heading element is + // reconnected by a mutation event listener. This is a regression of + // bug 1405751: + // https://searchfox.org/mozilla-central/diff/879f3317d1331818718e18776caa47be7f426a22/editor/libeditor/HTMLEditRules.cpp#6389 + // However, the traditional behavior is different from the other browsers. + // Chrome creates new paragraph in this case. Therefore, we should just + // drop this block in a follow up bug. + if (rightHeadingElement->GetNextSibling()) { + // XXX Ignoring non-editable <br> element here is odd because non-editable + // <br> elements also work as <br> from point of view of layout. + nsIContent* nextEditableSibling = + HTMLEditUtils::GetNextSibling(*rightHeadingElement->GetNextSibling(), + {WalkTreeOption::IgnoreNonEditableNode}); + if (nextEditableSibling && + nextEditableSibling->IsHTMLElement(nsGkAtoms::br)) { + auto afterEditableBRElement = EditorDOMPoint::After(*nextEditableSibling); + if (NS_WARN_IF(!afterEditableBRElement.IsSet())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + // Put caret at the <br> element. + return InsertParagraphResult::NotHandled( + std::move(afterEditableBRElement)); + } + } + + if (MOZ_UNLIKELY(!leftHeadingElement->IsInComposedDoc())) { + NS_WARNING("The left heading element was unexpectedly removed"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + TopLevelEditSubActionDataRef().mCachedPendingStyles->Clear(); + mPendingStylesToApplyToNewContent->ClearAllStyles(); + + // Create a paragraph if the right heading element is not followed by an + // editable <br> element. + nsStaticAtom& newParagraphTagName = + &DefaultParagraphSeparatorTagName() == nsGkAtoms::br + ? *nsGkAtoms::p + : DefaultParagraphSeparatorTagName(); + // We want a wrapper element even if we separate with a <br>. + // MOZ_KnownLive(newParagraphTagName) because it's available until shutdown. + Result<CreateElementResult, nsresult> createNewParagraphElementResult = + CreateAndInsertElement(WithTransaction::Yes, + MOZ_KnownLive(newParagraphTagName), + EditorDOMPoint::After(*leftHeadingElement), + HTMLEditor::InsertNewBRElement); + if (MOZ_UNLIKELY(createNewParagraphElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) failed"); + return createNewParagraphElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewParagraphElementResult = + createNewParagraphElementResult.unwrap(); + // Put caret at the <br> element in the following paragraph. + unwrappedCreateNewParagraphElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedCreateNewParagraphElementResult.GetNewNode()); + EditorDOMPoint pointToPutCaret( + unwrappedCreateNewParagraphElementResult.GetNewNode(), 0u); + return InsertParagraphResult( + unwrappedCreateNewParagraphElementResult.UnwrapNewNode(), + std::move(pointToPutCaret)); +} + +Result<SplitNodeResult, nsresult> HTMLEditor::HandleInsertParagraphInParagraph( + Element& aParentDivOrP, const EditorDOMPoint& aCandidatePointToSplit, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aCandidatePointToSplit.IsSetAndValid()); + + // First, get a better split point to avoid to create a new empty link in the + // right paragraph. + EditorDOMPoint pointToSplit = [&]() { + // We shouldn't create new anchor element which has non-empty href unless + // splitting middle of it because we assume that users don't want to create + // *same* anchor element across two or more paragraphs in most cases. + // So, adjust selection start if it's edge of anchor element(s). + // XXX We don't support white-space collapsing in these cases since it needs + // some additional work with WhiteSpaceVisibilityKeeper but it's not + // usual case. E.g., |<a href="foo"><b>foo []</b> </a>| + if (aCandidatePointToSplit.IsStartOfContainer()) { + EditorDOMPoint candidatePoint(aCandidatePointToSplit); + for (nsIContent* container = + aCandidatePointToSplit.GetContainerAs<nsIContent>(); + container && container != &aParentDivOrP; + container = container->GetParent()) { + if (HTMLEditUtils::IsLink(container)) { + // Found link should be only in right node. So, we shouldn't split + // it. + candidatePoint.Set(container); + // Even if we found an anchor element, don't break because DOM API + // allows to nest anchor elements. + } + // If the container is middle of its parent, stop adjusting split point. + if (container->GetPreviousSibling()) { + // XXX Should we check if previous sibling is visible content? + // E.g., should we ignore comment node, invisible <br> element? + break; + } + } + return candidatePoint; + } + + // We also need to check if selection is at invisible <br> element at end + // of an <a href="foo"> element because editor inserts a <br> element when + // user types Enter key after a white-space which is at middle of + // <a href="foo"> element and when setting selection at end of the element, + // selection becomes referring the <br> element. We may need to change this + // behavior later if it'd be standardized. + if (aCandidatePointToSplit.IsEndOfContainer() || + aCandidatePointToSplit.IsBRElementAtEndOfContainer()) { + // If there are 2 <br> elements, the first <br> element is visible. E.g., + // |<a href="foo"><b>boo[]<br></b><br></a>|, we should split the <a> + // element. Otherwise, E.g., |<a href="foo"><b>boo[]<br></b></a>|, + // we should not split the <a> element and ignore inline elements in it. + bool foundBRElement = + aCandidatePointToSplit.IsBRElementAtEndOfContainer(); + EditorDOMPoint candidatePoint(aCandidatePointToSplit); + for (nsIContent* container = + aCandidatePointToSplit.GetContainerAs<nsIContent>(); + container && container != &aParentDivOrP; + container = container->GetParent()) { + if (HTMLEditUtils::IsLink(container)) { + // Found link should be only in left node. So, we shouldn't split it. + candidatePoint.SetAfter(container); + // Even if we found an anchor element, don't break because DOM API + // allows to nest anchor elements. + } + // If the container is middle of its parent, stop adjusting split point. + if (nsIContent* nextSibling = container->GetNextSibling()) { + if (foundBRElement) { + // If we've already found a <br> element, we assume found node is + // visible <br> or something other node. + // XXX Should we check if non-text data node like comment? + break; + } + + // XXX Should we check if non-text data node like comment? + if (!nextSibling->IsHTMLElement(nsGkAtoms::br)) { + break; + } + foundBRElement = true; + } + } + return candidatePoint; + } + return aCandidatePointToSplit; + }(); + + const bool createNewParagraph = GetReturnInParagraphCreatesNewParagraph(); + RefPtr<HTMLBRElement> brElement; + if (createNewParagraph && pointToSplit.GetContainer() == &aParentDivOrP) { + // We are try to split only the current paragraph. Therefore, we don't need + // to create new <br> elements around it (if left and/or right paragraph + // becomes empty, it'll be treated by SplitParagraphWithTransaction(). + brElement = nullptr; + } else if (pointToSplit.IsInTextNode()) { + if (pointToSplit.IsStartOfContainer()) { + // If we're splitting the paragraph at start of a text node and there is + // no preceding visible <br> element, we need to create a <br> element to + // keep the inline elements containing this text node. + // TODO: If the parent of the text node is the splitting paragraph, + // obviously we don't need to do this because empty paragraphs will + // be treated by SplitParagraphWithTransaction(). In this case, we + // just need to update pointToSplit for using the same path as the + // previous `if` block. + brElement = + HTMLBRElement::FromNodeOrNull(HTMLEditUtils::GetPreviousSibling( + *pointToSplit.ContainerAs<Text>(), + {WalkTreeOption::IgnoreNonEditableNode})); + if (!brElement || HTMLEditUtils::IsInvisibleBRElement(*brElement) || + EditorUtils::IsPaddingBRElementForEmptyLastLine(*brElement)) { + // If insertParagraph does not create a new paragraph, default to + // insertLineBreak. + if (!createNewParagraph) { + return SplitNodeResult::NotHandled(pointToSplit, + GetSplitNodeDirection()); + } + const EditorDOMPoint pointToInsertBR = pointToSplit.ParentPoint(); + MOZ_ASSERT(pointToInsertBR.IsSet()); + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToInsertBR); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + // We'll collapse `Selection` to the place suggested by + // SplitParagraphWithTransaction. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + brElement = HTMLBRElement::FromNodeOrNull( + insertBRElementResult.inspect().GetNewNode()); + } + } else if (pointToSplit.IsEndOfContainer()) { + // If we're splitting the paragraph at end of a text node and there is not + // following visible <br> element, we need to create a <br> element after + // the text node to make current style specified by parent inline elements + // keep in the right paragraph. + // TODO: Same as above, we don't need to do this if the text node is a + // direct child of the paragraph. For using the simplest path, we + // just need to update `pointToSplit` in the case. + brElement = HTMLBRElement::FromNodeOrNull(HTMLEditUtils::GetNextSibling( + *pointToSplit.ContainerAs<Text>(), + {WalkTreeOption::IgnoreNonEditableNode})); + if (!brElement || HTMLEditUtils::IsInvisibleBRElement(*brElement) || + EditorUtils::IsPaddingBRElementForEmptyLastLine(*brElement)) { + // If insertParagraph does not create a new paragraph, default to + // insertLineBreak. + if (!createNewParagraph) { + return SplitNodeResult::NotHandled(pointToSplit, + GetSplitNodeDirection()); + } + const auto pointToInsertBR = + EditorDOMPoint::After(*pointToSplit.ContainerAs<Text>()); + MOZ_ASSERT(pointToInsertBR.IsSet()); + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToInsertBR); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + // We'll collapse `Selection` to the place suggested by + // SplitParagraphWithTransaction. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + brElement = HTMLBRElement::FromNodeOrNull( + insertBRElementResult.inspect().GetNewNode()); + } + } else { + // If insertParagraph does not create a new paragraph, default to + // insertLineBreak. + if (!createNewParagraph) { + return SplitNodeResult::NotHandled(pointToSplit, + GetSplitNodeDirection()); + } + + // If we're splitting the paragraph at middle of a text node, we should + // split the text node here and put a <br> element next to the left text + // node. + // XXX Why? I think that this should be handled in + // SplitParagraphWithTransaction() directly because I don't find + // the necessary case of the <br> element. + + // XXX We split a text node here if caret is middle of it to insert + // <br> element **before** splitting aParentDivOrP. Then, if + // the <br> element becomes unnecessary, it'll be removed again. + // So this does much more complicated things than what we want to + // do here. We should handle this case separately to make the code + // much simpler. + + // Normalize collapsible white-spaces around the split point to keep + // them visible after the split. Note that this does not touch + // selection because of using AutoTransactionsConserveSelection in + // WhiteSpaceVisibilityKeeper::ReplaceTextAndRemoveEmptyTextNodes(). + Result<EditorDOMPoint, nsresult> pointToSplitOrError = + WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement( + *this, pointToSplit, aParentDivOrP); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (MOZ_UNLIKELY(pointToSplitOrError.isErr())) { + NS_WARNING( + "WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement() " + "failed"); + return pointToSplitOrError.propagateErr(); + } + MOZ_ASSERT(pointToSplitOrError.inspect().IsSetAndValid()); + if (pointToSplitOrError.inspect().IsSet()) { + pointToSplit = pointToSplitOrError.unwrap(); + } + Result<SplitNodeResult, nsresult> splitParentDivOrPResult = + SplitNodeWithTransaction(pointToSplit); + if (MOZ_UNLIKELY(splitParentDivOrPResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); + return splitParentDivOrPResult; + } + // We'll collapse `Selection` to the place suggested by + // SplitParagraphWithTransaction. + splitParentDivOrPResult.inspect().IgnoreCaretPointSuggestion(); + + pointToSplit.SetToEndOf( + splitParentDivOrPResult.inspect().GetPreviousContent()); + if (NS_WARN_IF(!pointToSplit.IsInContentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // We need to put new <br> after the left node if given node was split + // above. + const auto pointToInsertBR = + EditorDOMPoint::After(*pointToSplit.ContainerAs<nsIContent>()); + MOZ_ASSERT(pointToInsertBR.IsSet()); + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToInsertBR); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + // We'll collapse `Selection` to the place suggested by + // SplitParagraphWithTransaction. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + brElement = HTMLBRElement::FromNodeOrNull( + insertBRElementResult.inspect().GetNewNode()); + } + } else { + // If we're splitting in a child element of the paragraph, and there is no + // <br> element around it, we should insert a <br> element at the split + // point and keep splitting the paragraph after the new <br> element. + // XXX Why? We probably need to do this if we're splitting in an inline + // element which and whose parents provide some styles, we should put + // the <br> element for making a placeholder in the left paragraph for + // moving to the caret, but I think that this could be handled in fewer + // cases than this. + brElement = HTMLBRElement::FromNodeOrNull(HTMLEditUtils::GetPreviousContent( + pointToSplit, {WalkTreeOption::IgnoreNonEditableNode}, &aEditingHost)); + if (!brElement || HTMLEditUtils::IsInvisibleBRElement(*brElement) || + EditorUtils::IsPaddingBRElementForEmptyLastLine(*brElement)) { + // is there a BR after it? + brElement = HTMLBRElement::FromNodeOrNull(HTMLEditUtils::GetNextContent( + pointToSplit, {WalkTreeOption::IgnoreNonEditableNode}, + &aEditingHost)); + if (!brElement || HTMLEditUtils::IsInvisibleBRElement(*brElement) || + EditorUtils::IsPaddingBRElementForEmptyLastLine(*brElement)) { + // If insertParagraph does not create a new paragraph, default to + // insertLineBreak. + if (!createNewParagraph) { + return SplitNodeResult::NotHandled(pointToSplit, + GetSplitNodeDirection()); + } + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, pointToSplit); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.propagateErr(); + } + // We'll collapse `Selection` to the place suggested by + // SplitParagraphWithTransaction. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + brElement = HTMLBRElement::FromNodeOrNull( + insertBRElementResult.inspect().GetNewNode()); + // We split the parent after the <br>. + pointToSplit.SetAfter(brElement); + if (NS_WARN_IF(!pointToSplit.IsSet())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + } + } + } + + Result<SplitNodeResult, nsresult> splitParagraphResult = + SplitParagraphWithTransaction(aParentDivOrP, pointToSplit, brElement); + if (MOZ_UNLIKELY(splitParagraphResult.isErr())) { + NS_WARNING("HTMLEditor::SplitParagraphWithTransaction() failed"); + return splitParagraphResult; + } + if (MOZ_UNLIKELY(!splitParagraphResult.inspect().DidSplit())) { + NS_WARNING( + "HTMLEditor::SplitParagraphWithTransaction() didn't split the " + "paragraph"); + splitParagraphResult.inspect().IgnoreCaretPointSuggestion(); + return Err(NS_ERROR_FAILURE); + } + MOZ_ASSERT(splitParagraphResult.inspect().Handled()); + return splitParagraphResult; +} + +Result<SplitNodeResult, nsresult> HTMLEditor::SplitParagraphWithTransaction( + Element& aParentDivOrP, const EditorDOMPoint& aStartOfRightNode, + HTMLBRElement* aMayBecomeVisibleBRElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + Result<EditorDOMPoint, nsresult> preparationResult = + WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement( + *this, aStartOfRightNode, aParentDivOrP); + if (MOZ_UNLIKELY(preparationResult.isErr())) { + NS_WARNING( + "WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement() failed"); + return preparationResult.propagateErr(); + } + EditorDOMPoint pointToSplit = preparationResult.unwrap(); + MOZ_ASSERT(pointToSplit.IsInContentNode()); + + // Split the paragraph. + Result<SplitNodeResult, nsresult> splitDivOrPResult = + SplitNodeDeepWithTransaction(aParentDivOrP, pointToSplit, + SplitAtEdges::eAllowToCreateEmptyContainer); + if (MOZ_UNLIKELY(splitDivOrPResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); + return splitDivOrPResult; + } + SplitNodeResult unwrappedSplitDivOrPResult = splitDivOrPResult.unwrap(); + if (MOZ_UNLIKELY(!unwrappedSplitDivOrPResult.DidSplit())) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction() didn't split any nodes"); + return unwrappedSplitDivOrPResult; + } + + // We'll compute caret suggestion later. So the simple result is not needed. + unwrappedSplitDivOrPResult.IgnoreCaretPointSuggestion(); + + auto* const leftDivOrParagraphElement = + unwrappedSplitDivOrPResult.GetPreviousContentAs<Element>(); + MOZ_ASSERT(leftDivOrParagraphElement, + "SplitNodeResult::GetPreviousContent() should return something if " + "DidSplit() returns true"); + auto* const rightDivOrParagraphElement = + unwrappedSplitDivOrPResult.GetNextContentAs<Element>(); + MOZ_ASSERT(rightDivOrParagraphElement, + "SplitNodeResult::GetNextContent() should return something if " + "DidSplit() returns true"); + + // Get rid of the break, if it is visible (otherwise it may be needed to + // prevent an empty p). + if (aMayBecomeVisibleBRElement && + HTMLEditUtils::IsVisibleBRElement(*aMayBecomeVisibleBRElement)) { + nsresult rv = DeleteNodeWithTransaction(*aMayBecomeVisibleBRElement); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + + // Remove ID attribute on the paragraph from the right node. + // MOZ_KnownLive(rightDivOrParagraphElement) because it's grabbed by + // unwrappedSplitDivOrPResult. + nsresult rv = RemoveAttributeWithTransaction( + MOZ_KnownLive(*rightDivOrParagraphElement), *nsGkAtoms::id); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::id) failed"); + return Err(rv); + } + + // We need to ensure to both paragraphs visible even if they are empty. + // However, padding <br> element for empty last line isn't useful in this + // case because it'll be ignored by PlaintextSerializer. Additionally, + // it'll be exposed as <br> with Element.innerHTML. Therefore, we can use + // normal <br> elements for placeholder in this case. Note that Chromium + // also behaves so. + auto InsertBRElementIfEmptyBlockElement = + [&](Element& aElement) MOZ_CAN_RUN_SCRIPT { + if (!HTMLEditUtils::IsBlockElement(aElement)) { + return NS_OK; + } + + if (!HTMLEditUtils::IsEmptyNode( + aElement, {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + return NS_OK; + } + + // XXX: Probably, we should use + // InsertPaddingBRElementForEmptyLastLineWithTransaction here, and + // if there are some empty inline container, we should put the <br> + // into the last one. + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, + EditorDOMPoint(&aElement, 0u)); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.unwrapErr(); + } + // After this is called twice, we'll compute new caret position. + // Therefore, we don't need to update selection here. + insertBRElementResult.inspect().IgnoreCaretPointSuggestion(); + return NS_OK; + }; + + // MOZ_KnownLive(leftDivOrParagraphElement) because it's grabbed by + // splitDivOrResult. + rv = InsertBRElementIfEmptyBlockElement( + MOZ_KnownLive(*leftDivOrParagraphElement)); + if (NS_FAILED(rv)) { + NS_WARNING( + "InsertBRElementIfEmptyBlockElement(leftDivOrParagraphElement) failed"); + return Err(rv); + } + + if (HTMLEditUtils::IsEmptyNode(*rightDivOrParagraphElement)) { + // If the right paragraph is empty, it might have an empty inline element + // (which may contain other empty inline containers) and optionally a <br> + // element which may not be in the deepest inline element. + const RefPtr<Element> deepestInlineContainerElement = + [](const Element& aBlockElement) { + Element* result = nullptr; + for (Element* maybeDeepestInlineContainer = + Element::FromNodeOrNull(aBlockElement.GetFirstChild()); + maybeDeepestInlineContainer && + HTMLEditUtils::IsInlineElement(*maybeDeepestInlineContainer) && + HTMLEditUtils::IsContainerNode(*maybeDeepestInlineContainer); + maybeDeepestInlineContainer = + maybeDeepestInlineContainer->GetFirstElementChild()) { + result = maybeDeepestInlineContainer; + } + return result; + }(*rightDivOrParagraphElement); + if (deepestInlineContainerElement) { + RefPtr<HTMLBRElement> brElement = + HTMLEditUtils::GetFirstBRElement(*rightDivOrParagraphElement); + // If there is a <br> element and it is in the deepest inline container, + // we need to do nothing anymore. Let's suggest caret position as at the + // <br>. + if (brElement && + brElement->GetParentNode() == deepestInlineContainerElement) { + brElement->SetFlags(NS_PADDING_FOR_EMPTY_LAST_LINE); + return SplitNodeResult(std::move(unwrappedSplitDivOrPResult), + EditorDOMPoint(brElement)); + } + // Otherwise, we should put a padding <br> element into the deepest inline + // container and then, existing <br> element (if there is) becomes + // unnecessary. + if (brElement) { + nsresult rv = DeleteNodeWithTransaction(*brElement); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction( + EditorDOMPoint::AtEndOf(deepestInlineContainerElement)); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertPaddingBRElementForEmptyLastLineWithTransaction() failed"); + return insertPaddingBRElementResult.propagateErr(); + } + insertPaddingBRElementResult.inspect().IgnoreCaretPointSuggestion(); + return SplitNodeResult( + std::move(unwrappedSplitDivOrPResult), + EditorDOMPoint(insertPaddingBRElementResult.inspect().GetNewNode())); + } + + // If there is no inline container elements, we just need to make the + // right paragraph visible. + nsresult rv = InsertBRElementIfEmptyBlockElement( + MOZ_KnownLive(*rightDivOrParagraphElement)); + if (NS_FAILED(rv)) { + NS_WARNING( + "InsertBRElementIfEmptyBlockElement(rightDivOrParagraphElement) " + "failed"); + return Err(rv); + } + } + + // Let's put caret at start of the first leaf container. + nsIContent* child = HTMLEditUtils::GetFirstLeafContent( + *rightDivOrParagraphElement, {LeafNodeType::LeafNodeOrChildBlock}); + if (MOZ_UNLIKELY(!child)) { + return SplitNodeResult(std::move(unwrappedSplitDivOrPResult), + EditorDOMPoint(rightDivOrParagraphElement, 0u)); + } + return child->IsText() || HTMLEditUtils::IsContainerNode(*child) + ? SplitNodeResult(std::move(unwrappedSplitDivOrPResult), + EditorDOMPoint(child, 0u)) + : SplitNodeResult(std::move(unwrappedSplitDivOrPResult), + EditorDOMPoint(child)); +} + +Result<InsertParagraphResult, nsresult> +HTMLEditor::HandleInsertParagraphInListItemElement( + Element& aListItemElement, const EditorDOMPoint& aPointToSplit, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(HTMLEditUtils::IsListItem(&aListItemElement)); + + // If aListItemElement is empty, then we want to outdent its content. + if (&aEditingHost != aListItemElement.GetParentElement() && + HTMLEditUtils::IsEmptyBlockElement(aListItemElement, {})) { + RefPtr<Element> leftListElement = aListItemElement.GetParentElement(); + // If the given list item element is not the last list item element of + // its parent nor not followed by sub list elements, split the parent + // before it. + if (!HTMLEditUtils::IsLastChild(aListItemElement, + {WalkTreeOption::IgnoreNonEditableNode})) { + Result<SplitNodeResult, nsresult> splitListItemParentResult = + SplitNodeWithTransaction(EditorDOMPoint(&aListItemElement)); + if (MOZ_UNLIKELY(splitListItemParentResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); + return splitListItemParentResult.propagateErr(); + } + SplitNodeResult unwrappedSplitListItemParentResult = + splitListItemParentResult.unwrap(); + if (MOZ_UNLIKELY(!unwrappedSplitListItemParentResult.DidSplit())) { + NS_WARNING( + "HTMLEditor::SplitNodeWithTransaction() didn't split the parent of " + "aListItemElement"); + MOZ_ASSERT( + !unwrappedSplitListItemParentResult.HasCaretPointSuggestion()); + return Err(NS_ERROR_FAILURE); + } + unwrappedSplitListItemParentResult.IgnoreCaretPointSuggestion(); + leftListElement = + unwrappedSplitListItemParentResult.GetPreviousContentAs<Element>(); + MOZ_DIAGNOSTIC_ASSERT(leftListElement); + } + + auto afterLeftListElement = EditorDOMPoint::After(leftListElement); + if (MOZ_UNLIKELY(!afterLeftListElement.IsSet())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // If aListItemElement is in an invalid sub-list element, move it into + // the grand parent list element in order to outdent. + if (HTMLEditUtils::IsAnyListElement(afterLeftListElement.GetContainer())) { + Result<MoveNodeResult, nsresult> moveListItemElementResult = + MoveNodeWithTransaction(aListItemElement, afterLeftListElement); + if (MOZ_UNLIKELY(moveListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveListItemElementResult.propagateErr(); + } + moveListItemElementResult.inspect().IgnoreCaretPointSuggestion(); + return InsertParagraphResult(&aListItemElement, + EditorDOMPoint(&aListItemElement, 0u)); + } + + // Otherwise, replace the empty aListItemElement with a new paragraph. + nsresult rv = DeleteNodeWithTransaction(aListItemElement); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + nsStaticAtom& newParagraphTagName = + &DefaultParagraphSeparatorTagName() == nsGkAtoms::br + ? *nsGkAtoms::p + : DefaultParagraphSeparatorTagName(); + // MOZ_KnownLive(newParagraphTagName) because it's available until shutdown. + Result<CreateElementResult, nsresult> createNewParagraphElementResult = + CreateAndInsertElement( + WithTransaction::Yes, MOZ_KnownLive(newParagraphTagName), + afterLeftListElement, HTMLEditor::InsertNewBRElement); + if (MOZ_UNLIKELY(createNewParagraphElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) failed"); + return createNewParagraphElementResult.propagateErr(); + } + createNewParagraphElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(createNewParagraphElementResult.inspect().GetNewNode()); + EditorDOMPoint pointToPutCaret( + createNewParagraphElementResult.inspect().GetNewNode(), 0u); + return InsertParagraphResult( + createNewParagraphElementResult.inspect().GetNewNode(), + std::move(pointToPutCaret)); + } + + // If aListItemElement has some content or aListItemElement is empty but it's + // a child of editing host, we want a new list item at the same list level. + // First, sort out white-spaces. + Result<EditorDOMPoint, nsresult> preparationResult = + WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement( + *this, aPointToSplit, aListItemElement); + if (preparationResult.isErr()) { + NS_WARNING( + "WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement() failed"); + return Err(preparationResult.unwrapErr()); + } + EditorDOMPoint pointToSplit = preparationResult.unwrap(); + MOZ_ASSERT(pointToSplit.IsInContentNode()); + + // Now split the list item. + Result<SplitNodeResult, nsresult> splitListItemResult = + SplitNodeDeepWithTransaction(aListItemElement, pointToSplit, + SplitAtEdges::eAllowToCreateEmptyContainer); + if (MOZ_UNLIKELY(splitListItemResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() failed"); + return splitListItemResult.propagateErr(); + } + SplitNodeResult unwrappedSplitListItemElement = splitListItemResult.unwrap(); + unwrappedSplitListItemElement.IgnoreCaretPointSuggestion(); + if (MOZ_UNLIKELY(!aListItemElement.GetParent())) { + NS_WARNING("Somebody disconnected the target listitem from the parent"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // If aListItemElement is not replaced, we should not do anything anymore. + if (MOZ_UNLIKELY(!unwrappedSplitListItemElement.DidSplit()) || + NS_WARN_IF(!unwrappedSplitListItemElement.GetNewContentAs<Element>()) || + NS_WARN_IF( + !unwrappedSplitListItemElement.GetOriginalContentAs<Element>())) { + NS_WARNING("HTMLEditor::SplitNodeDeepWithTransaction() didn't split"); + return Err(NS_ERROR_FAILURE); + } + + // FYI: They are grabbed by unwrappedSplitListItemElement so that they are + // known live + // things. + auto& leftListItemElement = + *unwrappedSplitListItemElement.GetPreviousContentAs<Element>(); + auto& rightListItemElement = + *unwrappedSplitListItemElement.GetNextContentAs<Element>(); + + // Hack: until I can change the damaged doc range code back to being + // extra-inclusive, I have to manually detect certain list items that may be + // left empty. + if (HTMLEditUtils::IsEmptyNode( + leftListItemElement, + {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction( + EditorDOMPoint(&leftListItemElement, 0u)); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction(" + ") failed"); + return insertPaddingBRElementResult.propagateErr(); + } + // We're returning a candidate point to put caret so that we don't need to + // update now. + insertPaddingBRElementResult.inspect().IgnoreCaretPointSuggestion(); + return InsertParagraphResult(&rightListItemElement, + EditorDOMPoint(&rightListItemElement, 0u)); + } + + if (HTMLEditUtils::IsEmptyNode(rightListItemElement)) { + // If aListItemElement is a <dd> or a <dt> and the right list item is empty + // or a direct child of the editing host, replace it a new list item element + // whose type is the other one. + if (aListItemElement.IsAnyOfHTMLElements(nsGkAtoms::dd, nsGkAtoms::dt)) { + nsStaticAtom& nextDefinitionListItemTagName = + aListItemElement.IsHTMLElement(nsGkAtoms::dt) ? *nsGkAtoms::dd + : *nsGkAtoms::dt; + // MOZ_KnownLive(nextDefinitionListItemTagName) because it's available + // until shutdown. + Result<CreateElementResult, nsresult> createNewListItemElementResult = + CreateAndInsertElement(WithTransaction::Yes, + MOZ_KnownLive(nextDefinitionListItemTagName), + EditorDOMPoint::After(rightListItemElement)); + if (MOZ_UNLIKELY(createNewListItemElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) failed"); + return createNewListItemElementResult.propagateErr(); + } + CreateElementResult unwrappedCreateNewListItemElementResult = + createNewListItemElementResult.unwrap(); + unwrappedCreateNewListItemElementResult.IgnoreCaretPointSuggestion(); + RefPtr<Element> newListItemElement = + unwrappedCreateNewListItemElementResult.UnwrapNewNode(); + MOZ_ASSERT(newListItemElement); + // MOZ_KnownLive(rightListItemElement) because it's grabbed by + // unwrappedSplitListItemElement. + nsresult rv = + DeleteNodeWithTransaction(MOZ_KnownLive(rightListItemElement)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + EditorDOMPoint pointToPutCaret(newListItemElement, 0u); + return InsertParagraphResult(std::move(newListItemElement), + std::move(pointToPutCaret)); + } + + // If aListItemElement is a <li> and the right list item becomes empty or a + // direct child of the editing host, copy all inline elements affecting to + // the style at end of the left list item element to the right list item + // element. + // MOZ_KnownLive(leftListItemElement) and + // MOZ_KnownLive(rightListItemElement) because they are grabbed by + // unwrappedSplitListItemElement. + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + CopyLastEditableChildStylesWithTransaction( + MOZ_KnownLive(leftListItemElement), + MOZ_KnownLive(rightListItemElement), aEditingHost); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::CopyLastEditableChildStylesWithTransaction() failed"); + return pointToPutCaretOrError.propagateErr(); + } + return InsertParagraphResult(&rightListItemElement, + pointToPutCaretOrError.unwrap()); + } + + // If the right list item element is not empty, we need to consider where to + // put caret in it. If it has non-container inline elements, <br> or <hr>, at + // the element is proper position. + WSScanResult forwardScanFromStartOfListItemResult = + WSRunScanner::ScanNextVisibleNodeOrBlockBoundary( + &aEditingHost, EditorRawDOMPoint(&rightListItemElement, 0u)); + if (MOZ_UNLIKELY(forwardScanFromStartOfListItemResult.Failed())) { + NS_WARNING("WSRunScanner::ScanNextVisibleNodeOrBlockBoundary() failed"); + return Err(NS_ERROR_FAILURE); + } + if (forwardScanFromStartOfListItemResult.ReachedSpecialContent() || + forwardScanFromStartOfListItemResult.ReachedBRElement() || + forwardScanFromStartOfListItemResult.ReachedHRElement()) { + auto atFoundElement = + forwardScanFromStartOfListItemResult.PointAtContent<EditorDOMPoint>(); + if (NS_WARN_IF(!atFoundElement.IsSetAndValid())) { + return Err(NS_ERROR_FAILURE); + } + return InsertParagraphResult(&rightListItemElement, + std::move(atFoundElement)); + } + + // If we reached a block boundary (end of the list item or a child block), + // let's put deepest start of the list item or the child block. + if (forwardScanFromStartOfListItemResult.ReachedBlockBoundary()) { + return InsertParagraphResult( + &rightListItemElement, + HTMLEditUtils::GetDeepestEditableStartPointOf<EditorDOMPoint>( + forwardScanFromStartOfListItemResult.GetContent() + ? *forwardScanFromStartOfListItemResult.GetContent() + : rightListItemElement)); + } + + // Otherwise, return the point at first visible thing. + // XXX This may be not meaningful position if it reached block element + // in aListItemElement. + return InsertParagraphResult( + &rightListItemElement, + forwardScanFromStartOfListItemResult.Point<EditorDOMPoint>()); +} + +Result<CreateElementResult, nsresult> +HTMLEditor::WrapContentsInBlockquoteElementsWithTransaction( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + const Element& aEditingHost) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + // The idea here is to put the nodes into a minimal number of blockquotes. + // When the user blockquotes something, they expect one blockquote. That + // may not be possible (for instance, if they have two table cells selected, + // you need two blockquotes inside the cells). + RefPtr<Element> curBlock, blockElementToPutCaret; + nsCOMPtr<nsINode> prevParent; + + EditorDOMPoint pointToPutCaret; + for (auto& content : aArrayOfContents) { + // If the node is a table element or list item, dive inside + if (HTMLEditUtils::IsAnyTableElementButNotTable(content) || + HTMLEditUtils::IsListItem(content)) { + // Forget any previous block + curBlock = nullptr; + // Recursion time + AutoTArray<OwningNonNull<nsIContent>, 24> childContents; + HTMLEditUtils::CollectAllChildren(*content, childContents); + Result<CreateElementResult, nsresult> + wrapChildrenInAnotherBlockquoteResult = + WrapContentsInBlockquoteElementsWithTransaction(childContents, + aEditingHost); + if (MOZ_UNLIKELY(wrapChildrenInAnotherBlockquoteResult.isErr())) { + NS_WARNING( + "HTMLEditor::WrapContentsInBlockquoteElementsWithTransaction() " + "failed"); + return wrapChildrenInAnotherBlockquoteResult; + } + CreateElementResult unwrappedWrapChildrenInAnotherBlockquoteResult = + wrapChildrenInAnotherBlockquoteResult.unwrap(); + unwrappedWrapChildrenInAnotherBlockquoteResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + if (unwrappedWrapChildrenInAnotherBlockquoteResult.GetNewNode()) { + blockElementToPutCaret = + unwrappedWrapChildrenInAnotherBlockquoteResult.UnwrapNewNode(); + } + } + + // If the node has different parent than previous node, further nodes in a + // new parent + if (prevParent) { + if (prevParent != content->GetParentNode()) { + // Forget any previous blockquote node we were using + curBlock = nullptr; + prevParent = content->GetParentNode(); + } + } else { + prevParent = content->GetParentNode(); + } + + // If no curBlock, make one + if (!curBlock) { + Result<CreateElementResult, nsresult> createNewBlockquoteElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::blockquote, EditorDOMPoint(content), + BRElementNextToSplitPoint::Keep, aEditingHost); + if (MOZ_UNLIKELY(createNewBlockquoteElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::blockquote) failed"); + return createNewBlockquoteElementResult; + } + CreateElementResult unwrappedCreateNewBlockquoteElementResult = + createNewBlockquoteElementResult.unwrap(); + unwrappedCreateNewBlockquoteElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + MOZ_ASSERT(unwrappedCreateNewBlockquoteElementResult.GetNewNode()); + blockElementToPutCaret = + unwrappedCreateNewBlockquoteElementResult.GetNewNode(); + curBlock = unwrappedCreateNewBlockquoteElementResult.UnwrapNewNode(); + } + + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to/ keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curBlock); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + unwrappedMoveNodeResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + } + return blockElementToPutCaret + ? CreateElementResult(std::move(blockElementToPutCaret), + std::move(pointToPutCaret)) + : CreateElementResult::NotHandled(std::move(pointToPutCaret)); +} + +Result<EditorDOMPoint, nsresult> +HTMLEditor::RemoveBlockContainerElementsWithTransaction( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // Intent of this routine is to be used for converting to/from headers, + // paragraphs, pre, and address. Those blocks that pretty much just contain + // inline things... + RefPtr<Element> blockElement; + nsCOMPtr<nsIContent> firstContent, lastContent; + EditorDOMPoint pointToPutCaret; + for (auto& content : aArrayOfContents) { + // If curNode is an <address>, <p>, <hn>, or <pre>, remove it. + if (HTMLEditUtils::IsFormatNode(content)) { + // Process any partial progress saved + if (blockElement) { + Result<SplitRangeOffFromNodeResult, nsresult> unwrapBlockElementResult = + RemoveBlockContainerElementWithTransactionBetween( + *blockElement, *firstContent, *lastContent); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementWithTransactionBetween() " + "failed"); + return unwrapBlockElementResult.propagateErr(); + } + unwrapBlockElementResult.unwrap().MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + firstContent = lastContent = blockElement = nullptr; + } + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + continue; + } + // Remove current block + Result<EditorDOMPoint, nsresult> unwrapFormatBlockResult = + RemoveBlockContainerWithTransaction( + MOZ_KnownLive(*content->AsElement())); + if (MOZ_UNLIKELY(unwrapFormatBlockResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapFormatBlockResult; + } + if (unwrapFormatBlockResult.inspect().IsSet()) { + pointToPutCaret = unwrapFormatBlockResult.unwrap(); + } + continue; + } + + // XXX How about, <th>, <thead>, <tfoot>, <dt>, <dl>? + if (content->IsAnyOfHTMLElements( + nsGkAtoms::table, nsGkAtoms::tr, nsGkAtoms::tbody, nsGkAtoms::td, + nsGkAtoms::li, nsGkAtoms::blockquote, nsGkAtoms::div) || + HTMLEditUtils::IsAnyListElement(content)) { + // Process any partial progress saved + if (blockElement) { + Result<SplitRangeOffFromNodeResult, nsresult> unwrapBlockElementResult = + RemoveBlockContainerElementWithTransactionBetween( + *blockElement, *firstContent, *lastContent); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementWithTransactionBetween() " + "failed"); + return unwrapBlockElementResult.propagateErr(); + } + unwrapBlockElementResult.unwrap().MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + firstContent = lastContent = blockElement = nullptr; + } + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + continue; + } + // Recursion time + AutoTArray<OwningNonNull<nsIContent>, 24> childContents; + HTMLEditUtils::CollectAllChildren(*content, childContents); + Result<EditorDOMPoint, nsresult> removeBlockContainerElementsResult = + RemoveBlockContainerElementsWithTransaction(childContents); + if (MOZ_UNLIKELY(removeBlockContainerElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementsWithTransaction() failed"); + return removeBlockContainerElementsResult; + } + if (removeBlockContainerElementsResult.inspect().IsSet()) { + pointToPutCaret = removeBlockContainerElementsResult.unwrap(); + } + continue; + } + + if (HTMLEditUtils::IsInlineElement(content)) { + if (blockElement) { + // If so, is this node a descendant? + if (EditorUtils::IsDescendantOf(*content, *blockElement)) { + // Then we don't need to do anything different for this node + lastContent = content; + continue; + } + // Otherwise, we have progressed beyond end of blockElement, so let's + // handle it now. We need to remove the portion of blockElement that + // contains [firstContent - lastContent]. + Result<SplitRangeOffFromNodeResult, nsresult> unwrapBlockElementResult = + RemoveBlockContainerElementWithTransactionBetween( + *blockElement, *firstContent, *lastContent); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementWithTransactionBetween() " + "failed"); + return unwrapBlockElementResult.propagateErr(); + } + unwrapBlockElementResult.unwrap().MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + firstContent = lastContent = blockElement = nullptr; + // Fall out and handle content + } + blockElement = HTMLEditUtils::GetAncestorElement( + content, HTMLEditUtils::ClosestEditableBlockElement); + if (!blockElement || !HTMLEditUtils::IsFormatNode(blockElement) || + !HTMLEditUtils::IsRemovableNode(*blockElement)) { + // Not a block kind that we care about. + blockElement = nullptr; + } else { + firstContent = lastContent = content; + } + continue; + } + + if (blockElement) { + // Some node that is already sans block style. Skip over it and process + // any partial progress saved. + Result<SplitRangeOffFromNodeResult, nsresult> unwrapBlockElementResult = + RemoveBlockContainerElementWithTransactionBetween( + *blockElement, *firstContent, *lastContent); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementWithTransactionBetween() " + "failed"); + return unwrapBlockElementResult.propagateErr(); + } + unwrapBlockElementResult.unwrap().MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + firstContent = lastContent = blockElement = nullptr; + continue; + } + } + // Process any partial progress saved + if (blockElement) { + Result<SplitRangeOffFromNodeResult, nsresult> unwrapBlockElementResult = + RemoveBlockContainerElementWithTransactionBetween( + *blockElement, *firstContent, *lastContent); + if (MOZ_UNLIKELY(unwrapBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementWithTransactionBetween() " + "failed"); + return unwrapBlockElementResult.propagateErr(); + } + unwrapBlockElementResult.unwrap().MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + firstContent = lastContent = blockElement = nullptr; + } + return pointToPutCaret; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::CreateOrChangeBlockContainerElement( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, nsAtom& aBlockTag, + const Element& aEditingHost) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + // Intent of this routine is to be used for converting to/from headers, + // paragraphs, pre, and address. Those blocks that pretty much just contain + // inline things... + RefPtr<Element> newBlock, curBlock, blockElementToPutCaret; + EditorDOMPoint pointToPutCaret; + for (auto& content : aArrayOfContents) { + EditorDOMPoint atContent(content); + if (NS_WARN_IF(!atContent.IsInContentNode())) { + // If given node has been removed from the document, let's ignore it + // since the following code may need its parent replace it with new + // block. + curBlock = nullptr; + newBlock = nullptr; + continue; + } + + // Is it already the right kind of block, or an uneditable block? + if (content->IsHTMLElement(&aBlockTag) || + (!EditorUtils::IsEditableContent(content, EditorType::HTML) && + HTMLEditUtils::IsBlockElement(content))) { + // Forget any previous block used for previous inline nodes + curBlock = nullptr; + // Do nothing to this block + continue; + } + + // If content is a address, p, header, address, or pre, replace it with a + // new block of correct type. + // XXX: pre can't hold everything the others can + if (HTMLEditUtils::IsMozDiv(content) || + HTMLEditUtils::IsFormatNode(content)) { + // Forget any previous block used for previous inline nodes + curBlock = nullptr; + Result<CreateElementResult, nsresult> replaceWithNewBlockElementResult = + ReplaceContainerAndCloneAttributesWithTransaction( + MOZ_KnownLive(*content->AsElement()), aBlockTag); + if (MOZ_UNLIKELY(replaceWithNewBlockElementResult.isErr())) { + NS_WARNING( + "EditorBase::ReplaceContainerAndCloneAttributesWithTransaction() " + "failed"); + return replaceWithNewBlockElementResult; + } + CreateElementResult unwrappedReplaceWithNewBlockElementResult = + replaceWithNewBlockElementResult.unwrap(); + // If the new block element was moved to different element or removed by + // the web app via mutation event listener, we should stop handling this + // action since we cannot handle each of a lot of edge cases. + if (NS_WARN_IF(unwrappedReplaceWithNewBlockElementResult.GetNewNode() + ->GetParentNode() != atContent.GetContainer())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + unwrappedReplaceWithNewBlockElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + newBlock = unwrappedReplaceWithNewBlockElementResult.UnwrapNewNode(); + continue; + } + + if (HTMLEditUtils::IsTable(content) || + HTMLEditUtils::IsAnyListElement(content) || + content->IsAnyOfHTMLElements(nsGkAtoms::tbody, nsGkAtoms::tr, + nsGkAtoms::td, nsGkAtoms::li, + nsGkAtoms::blockquote, nsGkAtoms::div)) { + // Forget any previous block used for previous inline nodes + curBlock = nullptr; + // Recursion time + AutoTArray<OwningNonNull<nsIContent>, 24> childContents; + HTMLEditUtils::CollectAllChildren(*content, childContents); + if (!childContents.IsEmpty()) { + Result<CreateElementResult, nsresult> wrapChildrenInBlockElementResult = + CreateOrChangeBlockContainerElement(childContents, aBlockTag, + aEditingHost); + if (MOZ_UNLIKELY(wrapChildrenInBlockElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateOrChangeBlockContainerElement() failed"); + return wrapChildrenInBlockElementResult; + } + CreateElementResult unwrappedWrapChildrenInBlockElementResult = + wrapChildrenInBlockElementResult.unwrap(); + unwrappedWrapChildrenInBlockElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + if (unwrappedWrapChildrenInBlockElementResult.GetNewNode()) { + blockElementToPutCaret = + unwrappedWrapChildrenInBlockElementResult.UnwrapNewNode(); + } + continue; + } + + // Make sure we can put a block here + Result<CreateElementResult, nsresult> createNewBlockElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + aBlockTag, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewBlockElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTransaction(%s) failed", + nsAtomCString(&aBlockTag).get()) + .get()); + return createNewBlockElementResult; + } + CreateElementResult unwrappedCreateNewBlockElementResult = + createNewBlockElementResult.unwrap(); + unwrappedCreateNewBlockElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + MOZ_ASSERT(unwrappedCreateNewBlockElementResult.GetNewNode()); + blockElementToPutCaret = + unwrappedCreateNewBlockElementResult.UnwrapNewNode(); + continue; + } + + if (content->IsHTMLElement(nsGkAtoms::br)) { + // If the node is a break, we honor it by putting further nodes in a new + // parent + if (curBlock) { + // Forget any previous block used for previous inline nodes + curBlock = nullptr; + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it + // alive. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*content)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + continue; + } + + // The break is the first (or even only) node we encountered. Create a + // block for it. + Result<CreateElementResult, nsresult> createNewBlockElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + aBlockTag, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewBlockElementResult.isErr())) { + NS_WARNING( + nsPrintfCString( + "HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTransaction(%s) failed", + nsAtomCString(&aBlockTag).get()) + .get()); + return createNewBlockElementResult; + } + CreateElementResult unwrappedCreateNewBlockElementResult = + createNewBlockElementResult.unwrap(); + unwrappedCreateNewBlockElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + RefPtr<Element> newBlockElement = + unwrappedCreateNewBlockElementResult.UnwrapNewNode(); + MOZ_ASSERT(newBlockElement); + blockElementToPutCaret = newBlockElement; + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it + // alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), + *newBlockElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + unwrappedMoveNodeResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + curBlock = std::move(newBlockElement); + continue; + } + + if (HTMLEditUtils::IsInlineElement(content)) { + // If content is inline, pull it into curBlock. Note: it's assumed that + // consecutive inline nodes in aNodeArray are actually members of the + // same block parent. This happens to be true now as a side effect of + // how aNodeArray is contructed, but some additional logic should be + // added here if that should change + // + // If content is a non editable, drop it if we are going to <pre>. + if (&aBlockTag == nsGkAtoms::pre && + !EditorUtils::IsEditableContent(content, EditorType::HTML)) { + // Do nothing to this block + continue; + } + + // If no curBlock, make one + if (!curBlock) { + Result<CreateElementResult, nsresult> createNewBlockElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + aBlockTag, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewBlockElementResult.isErr())) { + NS_WARNING(nsPrintfCString("HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTr" + "ansaction(%s) failed", + nsAtomCString(&aBlockTag).get()) + .get()); + return createNewBlockElementResult; + } + CreateElementResult unwrappedCreateNewBlockElementResult = + createNewBlockElementResult.unwrap(); + unwrappedCreateNewBlockElementResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + MOZ_ASSERT(unwrappedCreateNewBlockElementResult.GetNewNode()); + blockElementToPutCaret = + unwrappedCreateNewBlockElementResult.GetNewNode(); + curBlock = unwrappedCreateNewBlockElementResult.UnwrapNewNode(); + + // Update container of content. + atContent.Set(content); + } + + if (NS_WARN_IF(!atContent.IsSet())) { + // This is possible due to mutation events, let's not assert + return Err(NS_ERROR_UNEXPECTED); + } + + // XXX If content is a br, replace it with a return if going to <pre> + + // This is a continuation of some inline nodes that belong together in + // the same block item. Use curBlock. + // + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it + // alive. We could try to make that a rvalue ref and create a const array + // on the stack here, but callers are passing in auto arrays, and we don't + // want to introduce copies.. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *curBlock); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + MoveNodeResult unwrappedMoveNodeResult = moveNodeResult.unwrap(); + unwrappedMoveNodeResult.MoveCaretPointTo( + pointToPutCaret, {SuggestCaret::OnlyIfHasSuggestion}); + } + } + return blockElementToPutCaret + ? CreateElementResult(std::move(blockElementToPutCaret), + std::move(pointToPutCaret)) + : CreateElementResult::NotHandled(std::move(pointToPutCaret)); +} + +Result<SplitNodeResult, nsresult> +HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction( + nsAtom& aTag, const EditorDOMPoint& aStartOfDeepestRightNode, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (NS_WARN_IF(!aEditingHost.IsInComposedDoc())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (NS_WARN_IF(!aStartOfDeepestRightNode.IsSet())) { + return Err(NS_ERROR_INVALID_ARG); + } + MOZ_ASSERT(aStartOfDeepestRightNode.IsSetAndValid()); + + // The point must be descendant of editing host. + // XXX Isn't it a valid case if it points a direct child of aEditingHost? + if (aStartOfDeepestRightNode.GetContainer() != &aEditingHost && + !EditorUtils::IsDescendantOf(*aStartOfDeepestRightNode.GetContainer(), + aEditingHost)) { + NS_WARNING("aStartOfDeepestRightNode was not in editing host"); + return Err(NS_ERROR_INVALID_ARG); + } + + // Look for a node that can legally contain the tag. + EditorDOMPoint pointToInsert(aStartOfDeepestRightNode); + for (; pointToInsert.IsSet(); + pointToInsert.Set(pointToInsert.GetContainer())) { + // We cannot split active editing host and its ancestor. So, there is + // no element to contain the specified element. + if (pointToInsert.GetChild() == &aEditingHost) { + NS_WARNING( + "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() reached " + "editing host"); + return Err(NS_ERROR_FAILURE); + } + + if (HTMLEditUtils::CanNodeContain(*pointToInsert.GetContainer(), aTag)) { + // Found an ancestor node which can contain the element. + break; + } + } + + // If we got lost the editing host, we can do nothing. + if (NS_WARN_IF(!pointToInsert.IsSet())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + // If the point itself can contain the tag, we don't need to split any + // ancestor nodes. In this case, we should return the given split point + // as is. + if (pointToInsert.GetContainer() == aStartOfDeepestRightNode.GetContainer()) { + return SplitNodeResult::NotHandled(aStartOfDeepestRightNode, + GetSplitNodeDirection()); + } + + Result<SplitNodeResult, nsresult> splitNodeResult = + SplitNodeDeepWithTransaction(MOZ_KnownLive(*pointToInsert.GetChild()), + aStartOfDeepestRightNode, + SplitAtEdges::eAllowToCreateEmptyContainer); + NS_WARNING_ASSERTION(splitNodeResult.isOk(), + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eAllowToCreateEmptyContainer) failed"); + return splitNodeResult; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction( + nsAtom& aTagName, const EditorDOMPoint& aPointToInsert, + BRElementNextToSplitPoint aBRElementNextToSplitPoint, + const Element& aEditingHost, + const InitializeInsertingElement& aInitializer) { + MOZ_ASSERT(aPointToInsert.IsSetAndValid()); + + const nsCOMPtr<nsIContent> childAtPointToInsert = aPointToInsert.GetChild(); + Result<SplitNodeResult, nsresult> splitNodeResult = + MaybeSplitAncestorsForInsertWithTransaction(aTagName, aPointToInsert, + aEditingHost); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() failed"); + return splitNodeResult.propagateErr(); + } + SplitNodeResult unwrappedSplitNodeResult = splitNodeResult.unwrap(); + DebugOnly<bool> wasCaretPositionSuggestedAtSplit = + unwrappedSplitNodeResult.HasCaretPointSuggestion(); + // We'll update selection below, and nobody touches selection until then. + // Therefore, we don't need to touch selection here. + unwrappedSplitNodeResult.IgnoreCaretPointSuggestion(); + + // If current handling node has been moved from the container by a + // mutation event listener when we need to do something more for it, + // we should stop handling this action since we cannot handle each + // edge case. + if (childAtPointToInsert && + NS_WARN_IF(!childAtPointToInsert->IsInclusiveDescendantOf( + unwrappedSplitNodeResult.DidSplit() + ? unwrappedSplitNodeResult.GetNextContent() + : aPointToInsert.GetContainer()))) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + auto splitPoint = unwrappedSplitNodeResult.AtSplitPoint<EditorDOMPoint>(); + if (aBRElementNextToSplitPoint == BRElementNextToSplitPoint::Delete) { + // Consume a trailing br, if any. This is to keep an alignment from + // creating extra lines, if possible. + if (nsCOMPtr<nsIContent> maybeBRContent = HTMLEditUtils::GetNextContent( + splitPoint, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + &aEditingHost)) { + if (maybeBRContent->IsHTMLElement(nsGkAtoms::br) && + splitPoint.GetChild()) { + // Making use of html structure... if next node after where we are + // putting our div is not a block, then the br we found is in same + // block we are, so it's safe to consume it. + if (nsIContent* nextEditableSibling = HTMLEditUtils::GetNextSibling( + *splitPoint.GetChild(), + {WalkTreeOption::IgnoreNonEditableNode})) { + if (!HTMLEditUtils::IsBlockElement(*nextEditableSibling)) { + AutoEditorDOMPointChildInvalidator lockOffset(splitPoint); + nsresult rv = DeleteNodeWithTransaction(*maybeBRContent); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return Err(rv); + } + } + } + } + } + } + + Result<CreateElementResult, nsresult> createNewElementResult = + CreateAndInsertElement(WithTransaction::Yes, aTagName, splitPoint, + aInitializer); + if (MOZ_UNLIKELY(createNewElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) failed"); + return createNewElementResult; + } + MOZ_ASSERT_IF(wasCaretPositionSuggestedAtSplit, + createNewElementResult.inspect().HasCaretPointSuggestion()); + MOZ_ASSERT(createNewElementResult.inspect().GetNewNode()); + + // If the new block element was moved to different element or removed by + // the web app via mutation event listener, we should stop handling this + // action since we cannot handle each of a lot of edge cases. + if (NS_WARN_IF( + createNewElementResult.inspect().GetNewNode()->GetParentNode() != + splitPoint.GetContainer())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + return createNewElementResult; +} + +nsresult HTMLEditor::JoinNearestEditableNodesWithTransaction( + nsIContent& aNodeLeft, nsIContent& aNodeRight, + EditorDOMPoint* aNewFirstChildOfRightNode) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aNewFirstChildOfRightNode); + + // Caller responsible for left and right node being the same type + if (NS_WARN_IF(!aNodeLeft.GetParentNode())) { + return NS_ERROR_FAILURE; + } + // If they don't have the same parent, first move the right node to after + // the left one + if (aNodeLeft.GetParentNode() != aNodeRight.GetParentNode()) { + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeWithTransaction(aNodeRight, EditorDOMPoint(&aNodeLeft)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveNodeResult.unwrapErr(); + } + nsresult rv = moveNodeResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + } + + // Separate join rules for differing blocks + if (HTMLEditUtils::IsAnyListElement(&aNodeLeft) || aNodeLeft.IsText()) { + // For lists, merge shallow (wouldn't want to combine list items) + Result<JoinNodesResult, nsresult> joinNodesResult = + JoinNodesWithTransaction(aNodeLeft, aNodeRight); + if (MOZ_UNLIKELY(joinNodesResult.isErr())) { + NS_WARNING("HTMLEditor::JoinNodesWithTransaction failed"); + return joinNodesResult.unwrapErr(); + } + *aNewFirstChildOfRightNode = + joinNodesResult.inspect().AtJoinedPoint<EditorDOMPoint>(); + return NS_OK; + } + + // Remember the last left child, and first right child + nsCOMPtr<nsIContent> lastEditableChildOfLeftContent = + HTMLEditUtils::GetLastChild(aNodeLeft, + {WalkTreeOption::IgnoreNonEditableNode}); + if (MOZ_UNLIKELY(NS_WARN_IF(!lastEditableChildOfLeftContent))) { + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIContent> firstEditableChildOfRightContent = + HTMLEditUtils::GetFirstChild(aNodeRight, + {WalkTreeOption::IgnoreNonEditableNode}); + if (NS_WARN_IF(!firstEditableChildOfRightContent)) { + return NS_ERROR_FAILURE; + } + + // For list items, divs, etc., merge smart + Result<JoinNodesResult, nsresult> joinNodesResult = + JoinNodesWithTransaction(aNodeLeft, aNodeRight); + if (MOZ_UNLIKELY(joinNodesResult.isErr())) { + NS_WARNING("HTMLEditor::JoinNodesWithTransaction() failed"); + return joinNodesResult.unwrapErr(); + } + + if ((lastEditableChildOfLeftContent->IsText() || + lastEditableChildOfLeftContent->IsElement()) && + HTMLEditUtils::CanContentsBeJoined(*lastEditableChildOfLeftContent, + *firstEditableChildOfRightContent)) { + nsresult rv = JoinNearestEditableNodesWithTransaction( + *lastEditableChildOfLeftContent, *firstEditableChildOfRightContent, + aNewFirstChildOfRightNode); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::JoinNearestEditableNodesWithTransaction() failed"); + return rv; + } + *aNewFirstChildOfRightNode = + joinNodesResult.inspect().AtJoinedPoint<EditorDOMPoint>(); + return NS_OK; +} + +Element* HTMLEditor::GetMostDistantAncestorMailCiteElement( + const nsINode& aNode) const { + Element* mailCiteElement = nullptr; + const bool isPlaintextEditor = IsInPlaintextMode(); + for (Element* element : aNode.InclusiveAncestorsOfType<Element>()) { + if ((isPlaintextEditor && element->IsHTMLElement(nsGkAtoms::pre)) || + HTMLEditUtils::IsMailCite(*element)) { + mailCiteElement = element; + continue; + } + if (element->IsHTMLElement(nsGkAtoms::body)) { + break; + } + } + return mailCiteElement; +} + +nsresult HTMLEditor::CacheInlineStyles(Element& Element) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + nsresult rv = GetInlineStyles( + Element, *TopLevelEditSubActionDataRef().mCachedPendingStyles); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "HTMLEditor::GetInlineStyles() failed"); + return rv; +} + +nsresult HTMLEditor::GetInlineStyles( + Element& aElement, AutoPendingStyleCacheArray& aPendingStyleCacheArray) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aPendingStyleCacheArray.IsEmpty()); + + if (!IsCSSEnabled()) { + // In the HTML styling mode, we should preserve the order of inline styles + // specified with HTML elements, then, we can keep same order as original + // one when we create new elements to apply the styles at new place. + // XXX Currently, we don't preserve all inline parents, therefore, we cannot + // restore all inline elements as-is. Perhaps, we should store all + // inline elements with more details (e.g., all attributes), and store + // same elements. For example, web apps may give style as: + // em { + // font-style: italic; + // } + // em em { + // font-style: normal; + // font-weight: bold; + // } + // but we cannot restore the style as-is. + nsString value; + const bool givenElementIsEditable = + HTMLEditUtils::IsSimplyEditableNode(aElement); + auto NeedToAppend = [&](nsStaticAtom& aTagName, nsStaticAtom* aAttribute) { + if (mPendingStylesToApplyToNewContent->GetStyleState( + aTagName, aAttribute) != PendingStyleState::NotUpdated) { + return false; // The style has already been changed. + } + if (aPendingStyleCacheArray.Contains(aTagName, aAttribute)) { + return false; // Already preserved + } + return true; + }; + for (Element* const inclusiveAncestor : + aElement.InclusiveAncestorsOfType<Element>()) { + if (HTMLEditUtils::IsBlockElement(*inclusiveAncestor) || + (givenElementIsEditable && + !HTMLEditUtils::IsSimplyEditableNode(*inclusiveAncestor))) { + break; + } + if (inclusiveAncestor->IsAnyOfHTMLElements( + nsGkAtoms::b, nsGkAtoms::i, nsGkAtoms::u, nsGkAtoms::s, + nsGkAtoms::strike, nsGkAtoms::tt, nsGkAtoms::em, + nsGkAtoms::strong, nsGkAtoms::dfn, nsGkAtoms::code, + nsGkAtoms::samp, nsGkAtoms::var, nsGkAtoms::cite, nsGkAtoms::abbr, + nsGkAtoms::acronym, nsGkAtoms::sub, nsGkAtoms::sup)) { + nsStaticAtom& tagName = const_cast<nsStaticAtom&>( + *inclusiveAncestor->NodeInfo()->NameAtom()->AsStatic()); + if (NeedToAppend(tagName, nullptr)) { + aPendingStyleCacheArray.AppendElement( + PendingStyleCache(tagName, nullptr, EmptyString())); + } + continue; + } + if (inclusiveAncestor->IsHTMLElement(nsGkAtoms::font)) { + if (NeedToAppend(*nsGkAtoms::font, nsGkAtoms::face)) { + inclusiveAncestor->GetAttr(kNameSpaceID_None, nsGkAtoms::face, value); + if (!value.IsEmpty()) { + aPendingStyleCacheArray.AppendElement( + PendingStyleCache(*nsGkAtoms::font, nsGkAtoms::face, value)); + value.Truncate(); + } + } + if (NeedToAppend(*nsGkAtoms::font, nsGkAtoms::size)) { + inclusiveAncestor->GetAttr(kNameSpaceID_None, nsGkAtoms::size, value); + if (!value.IsEmpty()) { + aPendingStyleCacheArray.AppendElement( + PendingStyleCache(*nsGkAtoms::font, nsGkAtoms::size, value)); + value.Truncate(); + } + } + if (NeedToAppend(*nsGkAtoms::font, nsGkAtoms::color)) { + inclusiveAncestor->GetAttr(kNameSpaceID_None, nsGkAtoms::color, + value); + if (!value.IsEmpty()) { + aPendingStyleCacheArray.AppendElement( + PendingStyleCache(*nsGkAtoms::font, nsGkAtoms::color, value)); + value.Truncate(); + } + } + continue; + } + } + return NS_OK; + } + + for (nsStaticAtom* property : {nsGkAtoms::b, + nsGkAtoms::i, + nsGkAtoms::u, + nsGkAtoms::s, + nsGkAtoms::strike, + nsGkAtoms::face, + nsGkAtoms::size, + nsGkAtoms::color, + nsGkAtoms::tt, + nsGkAtoms::em, + nsGkAtoms::strong, + nsGkAtoms::dfn, + nsGkAtoms::code, + nsGkAtoms::samp, + nsGkAtoms::var, + nsGkAtoms::cite, + nsGkAtoms::abbr, + nsGkAtoms::acronym, + nsGkAtoms::backgroundColor, + nsGkAtoms::sub, + nsGkAtoms::sup}) { + const EditorInlineStyle style = + property == nsGkAtoms::face || property == nsGkAtoms::size || + property == nsGkAtoms::color + ? EditorInlineStyle(*nsGkAtoms::font, property) + : EditorInlineStyle(*property); + // If type-in state is set, don't intervene + const PendingStyleState styleState = + mPendingStylesToApplyToNewContent->GetStyleState(*style.mHTMLProperty, + style.mAttribute); + if (styleState != PendingStyleState::NotUpdated) { + continue; + } + bool isSet = false; + nsString value; // Don't use nsAutoString here because it requires memcpy + // at creating new PendingStyleCache instance. + // Don't use CSS for <font size>, we don't support it usefully (bug 780035) + if (property == nsGkAtoms::size) { + isSet = HTMLEditUtils::IsInlineStyleSetByElement(aElement, style, nullptr, + &value); + } else if (style.IsCSSSettable(aElement)) { + Result<bool, nsresult> isComputedCSSEquivalentToStyleOrError = + CSSEditUtils::IsComputedCSSEquivalentTo(*this, aElement, style, + value); + if (MOZ_UNLIKELY(isComputedCSSEquivalentToStyleOrError.isErr())) { + NS_WARNING("CSSEditUtils::IsComputedCSSEquivalentTo() failed"); + return isComputedCSSEquivalentToStyleOrError.unwrapErr(); + } + isSet = isComputedCSSEquivalentToStyleOrError.unwrap(); + } + if (isSet) { + aPendingStyleCacheArray.AppendElement( + style.ToPendingStyleCache(std::move(value))); + } + } + return NS_OK; +} + +nsresult HTMLEditor::ReapplyCachedStyles() { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + // The idea here is to examine our cached list of styles and see if any have + // been removed. If so, add typeinstate for them, so that they will be + // reinserted when new content is added. + + if (TopLevelEditSubActionDataRef().mCachedPendingStyles->IsEmpty() || + !SelectionRef().RangeCount()) { + return NS_OK; + } + + // remember if we are in css mode + const bool useCSS = IsCSSEnabled(); + + const RangeBoundary& atStartOfSelection = + SelectionRef().GetRangeAt(0)->StartRef(); + const RefPtr<Element> startContainerElement = + atStartOfSelection.Container() && + atStartOfSelection.Container()->IsContent() + ? atStartOfSelection.Container()->GetAsElementOrParentElement() + : nullptr; + if (NS_WARN_IF(!startContainerElement)) { + return NS_OK; + } + + AutoPendingStyleCacheArray styleCacheArrayAtInsertionPoint; + nsresult rv = + GetInlineStyles(*startContainerElement, styleCacheArrayAtInsertionPoint); + if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) { + return NS_ERROR_EDITOR_DESTROYED; + } + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::GetInlineStyles() failed, but ignored"); + return NS_OK; + } + + for (PendingStyleCache& styleCacheBeforeEdit : + Reversed(*TopLevelEditSubActionDataRef().mCachedPendingStyles)) { + bool isFirst = false, isAny = false, isAll = false; + nsAutoString currentValue; + const EditorInlineStyle inlineStyle = styleCacheBeforeEdit.ToInlineStyle(); + if (useCSS && inlineStyle.IsCSSSettable(*startContainerElement)) { + // check computed style first in css case + // MOZ_KnownLive(styleCacheBeforeEdit.*) because they are nsStaticAtom + // and its instances are alive until shutting down. + Result<bool, nsresult> isComputedCSSEquivalentToStyleOrError = + CSSEditUtils::IsComputedCSSEquivalentTo(*this, *startContainerElement, + inlineStyle, currentValue); + if (MOZ_UNLIKELY(isComputedCSSEquivalentToStyleOrError.isErr())) { + NS_WARNING("CSSEditUtils::IsComputedCSSEquivalentTo() failed"); + return isComputedCSSEquivalentToStyleOrError.unwrapErr(); + } + isAny = isComputedCSSEquivalentToStyleOrError.unwrap(); + } + if (!isAny) { + // then check typeinstate and html style + nsresult rv = GetInlinePropertyBase( + inlineStyle, &styleCacheBeforeEdit.AttributeValueOrCSSValueRef(), + &isFirst, &isAny, &isAll, ¤tValue); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::GetInlinePropertyBase() failed"); + return rv; + } + } + // This style has disappeared through deletion. Let's add the styles to + // mPendingStylesToApplyToNewContent when same style isn't applied to the + // node already. + if (isAny && + !IsPendingStyleCachePreservingSubAction(GetTopLevelEditSubAction())) { + continue; + } + AutoPendingStyleCacheArray::index_type index = + styleCacheArrayAtInsertionPoint.IndexOf( + styleCacheBeforeEdit.TagRef(), styleCacheBeforeEdit.GetAttribute()); + if (index == AutoPendingStyleCacheArray::NoIndex || + styleCacheBeforeEdit.AttributeValueOrCSSValueRef() != + styleCacheArrayAtInsertionPoint.ElementAt(index) + .AttributeValueOrCSSValueRef()) { + mPendingStylesToApplyToNewContent->PreserveStyle(styleCacheBeforeEdit); + } + } + return NS_OK; +} + +nsresult HTMLEditor::InsertBRElementToEmptyListItemsAndTableCellsInRange( + const RawRangeBoundary& aStartRef, const RawRangeBoundary& aEndRef) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoTArray<OwningNonNull<Element>, 64> arrayOfEmptyElements; + DOMIterator iter; + if (NS_FAILED(iter.Init(aStartRef, aEndRef))) { + NS_WARNING("DOMIterator::Init() failed"); + return NS_ERROR_FAILURE; + } + iter.AppendNodesToArray( + +[](nsINode& aNode, void* aSelf) { + MOZ_ASSERT(Element::FromNode(&aNode)); + MOZ_ASSERT(aSelf); + Element* element = aNode.AsElement(); + if (!EditorUtils::IsEditableContent(*element, EditorType::HTML) || + (!HTMLEditUtils::IsListItem(element) && + !HTMLEditUtils::IsTableCellOrCaption(*element))) { + return false; + } + return HTMLEditUtils::IsEmptyNode( + *element, {EmptyCheckOption::TreatSingleBRElementAsVisible}); + }, + arrayOfEmptyElements, this); + + // Put padding <br> elements for empty <li> and <td>. + EditorDOMPoint pointToPutCaret; + for (auto& emptyElement : arrayOfEmptyElements) { + // Need to put br at END of node. It may have empty containers in it and + // still pass the "IsEmptyNode" test, and we want the br's to be after + // them. Also, we want the br to be after the selection if the selection + // is in this node. + EditorDOMPoint endOfNode(EditorDOMPoint::AtEndOf(emptyElement)); + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction(endOfNode); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " + "failed"); + return insertPaddingBRElementResult.unwrapErr(); + } + CreateElementResult unwrappedInsertPaddingBRElementResult = + insertPaddingBRElementResult.unwrap(); + unwrappedInsertPaddingBRElementResult.MoveCaretPointTo( + pointToPutCaret, *this, + {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + } + if (pointToPutCaret.IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + 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"); + } + return NS_OK; +} + +void HTMLEditor::SetSelectionInterlinePosition() { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(SelectionRef().IsCollapsed()); + + // Get the (collapsed) selection location + const nsRange* firstRange = SelectionRef().GetRangeAt(0); + if (NS_WARN_IF(!firstRange)) { + return; + } + + EditorDOMPoint atCaret(firstRange->StartRef()); + if (NS_WARN_IF(!atCaret.IsSet())) { + return; + } + MOZ_ASSERT(atCaret.IsSetAndValid()); + + // First, let's check to see if we are after a `<br>`. We take care of this + // special-case first so that we don't accidentally fall through into one of + // the other conditionals. + // XXX Although I don't understand "interline position", if caret is + // immediately after non-editable contents, but previous editable + // content is `<br>`, does this do right thing? + if (Element* editingHost = ComputeEditingHost()) { + if (nsIContent* previousEditableContentInBlock = + HTMLEditUtils::GetPreviousContent( + atCaret, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + editingHost)) { + if (previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::br)) { + DebugOnly<nsresult> rvIgnored = SelectionRef().SetInterlinePosition( + InterlinePosition::StartOfNextLine); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "StartOfNextLine) failed, but ignored"); + return; + } + } + } + + if (!atCaret.GetChild()) { + return; + } + + // If caret is immediately after a block, set interline position to "right". + // XXX Although I don't understand "interline position", if caret is + // immediately after non-editable contents, but previous editable + // content is a block, does this do right thing? + if (nsIContent* previousEditableContentInBlockAtCaret = + HTMLEditUtils::GetPreviousSibling( + *atCaret.GetChild(), {WalkTreeOption::IgnoreNonEditableNode})) { + if (HTMLEditUtils::IsBlockElement(*previousEditableContentInBlockAtCaret)) { + DebugOnly<nsresult> rvIgnored = SelectionRef().SetInterlinePosition( + InterlinePosition::StartOfNextLine); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "StartOfNextLine) failed, but ignored"); + return; + } + } + + // If caret is immediately before a block, set interline position to "left". + // XXX Although I don't understand "interline position", if caret is + // immediately before non-editable contents, but next editable + // content is a block, does this do right thing? + if (nsIContent* nextEditableContentInBlockAtCaret = + HTMLEditUtils::GetNextSibling( + *atCaret.GetChild(), {WalkTreeOption::IgnoreNonEditableNode})) { + if (HTMLEditUtils::IsBlockElement(*nextEditableContentInBlockAtCaret)) { + DebugOnly<nsresult> rvIgnored = + SelectionRef().SetInterlinePosition(InterlinePosition::EndOfLine); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "EndOfLine) failed, but ignored"); + } + } +} + +nsresult HTMLEditor::AdjustCaretPositionAndEnsurePaddingBRElement( + nsIEditor::EDirection aDirectionAndAmount) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(SelectionRef().IsCollapsed()); + + auto point = GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!point.IsInContentNode())) { + return NS_ERROR_FAILURE; + } + + // If selection start is not editable, climb up the tree until editable one. + while (!EditorUtils::IsEditableContent(*point.ContainerAs<nsIContent>(), + EditorType::HTML)) { + point.Set(point.GetContainer()); + if (NS_WARN_IF(!point.IsInContentNode())) { + return NS_ERROR_FAILURE; + } + } + + // If caret is in empty block element, we need to insert a `<br>` element + // because the block should have one-line height. + // XXX Even if only a part of the block is editable, shouldn't we put + // caret if the block element is now empty? + if (Element* const editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *point.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestEditableBlockElement)) { + if (editableBlockElement && + HTMLEditUtils::IsEmptyNode( + *editableBlockElement, + {EmptyCheckOption::TreatSingleBRElementAsVisible}) && + HTMLEditUtils::CanNodeContain(*point.GetContainer(), *nsGkAtoms::br)) { + Element* bodyOrDocumentElement = GetRoot(); + if (NS_WARN_IF(!bodyOrDocumentElement)) { + return NS_ERROR_FAILURE; + } + if (point.GetContainer() == bodyOrDocumentElement) { + // Our root node is completely empty. Don't add a <br> here. + // AfterEditInner() will add one for us when it calls + // EditorBase::MaybeCreatePaddingBRElementForEmptyEditor(). + // XXX This kind of dependency between methods makes us spaghetti. + // Let's handle it here later. + // XXX This looks odd check. If active editing host is not a + // `<body>`, what are we doing? + return NS_OK; + } + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction(point); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction(" + ") failed"); + return insertPaddingBRElementResult.unwrapErr(); + } + nsresult rv = insertPaddingBRElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CreateElementResult::SuggestCaretPointTo() failed, but ignored"); + return NS_OK; + } + } + + // XXX Perhaps, we should do something if we're in a data node but not + // a text node. + if (point.IsInTextNode()) { + return NS_OK; + } + + // Do we need to insert a padding <br> element for empty last line? We do + // if we are: + // 1) prior node is in same block where selection is AND + // 2) prior node is a br AND + // 3) that br is not visible + RefPtr<Element> editingHost = ComputeEditingHost(); + if (!editingHost) { + return NS_OK; + } + + if (nsCOMPtr<nsIContent> previousEditableContent = + HTMLEditUtils::GetPreviousContent( + point, {WalkTreeOption::IgnoreNonEditableNode}, editingHost)) { + // If caret and previous editable content are in same block element + // (even if it's a non-editable element), we should put a padding <br> + // element at end of the block. + const Element* const blockElementContainingCaret = + HTMLEditUtils::GetInclusiveAncestorElement( + *point.ContainerAs<nsIContent>(), + HTMLEditUtils::ClosestBlockElement); + const Element* const blockElementContainingPreviousEditableContent = + HTMLEditUtils::GetAncestorElement(*previousEditableContent, + HTMLEditUtils::ClosestBlockElement); + // If previous editable content of caret is in same block and a `<br>` + // element, we need to adjust interline position. + if (blockElementContainingCaret && + blockElementContainingCaret == + blockElementContainingPreviousEditableContent && + point.ContainerAs<nsIContent>()->GetEditingHost() == + previousEditableContent->GetEditingHost() && + previousEditableContent && + previousEditableContent->IsHTMLElement(nsGkAtoms::br)) { + // If it's an invisible `<br>` element, we need to insert a padding + // `<br>` element for making empty line have one-line height. + if (HTMLEditUtils::IsInvisibleBRElement(*previousEditableContent) && + !EditorUtils::IsPaddingBRElementForEmptyLastLine( + *previousEditableContent)) { + AutoEditorDOMPointChildInvalidator lockOffset(point); + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction(point); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertPaddingBRElementForEmptyLastLineWithTransaction() failed"); + return insertPaddingBRElementResult.unwrapErr(); + } + insertPaddingBRElementResult.inspect().IgnoreCaretPointSuggestion(); + nsresult rv = CollapseSelectionTo(EditorRawDOMPoint( + insertPaddingBRElementResult.inspect().GetNewNode(), + InterlinePosition::StartOfNextLine)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return rv; + } + } + // If it's a visible `<br>` element and next editable content is a + // padding `<br>` element, we need to set interline position. + else if (nsIContent* nextEditableContentInBlock = + HTMLEditUtils::GetNextContent( + *previousEditableContent, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + editingHost)) { + if (EditorUtils::IsPaddingBRElementForEmptyLastLine( + *nextEditableContentInBlock)) { + // Make it stick to the padding `<br>` element so that it will be + // on blank line. + DebugOnly<nsresult> rvIgnored = SelectionRef().SetInterlinePosition( + InterlinePosition::StartOfNextLine); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "Selection::SetInterlinePosition(InterlinePosition::" + "StartOfNextLine) failed, but ignored"); + } + } + } + } + + // If previous editable content in same block is `<br>`, text node, `<img>` + // or `<hr>`, current caret position is fine. + if (nsIContent* previousEditableContentInBlock = + HTMLEditUtils::GetPreviousContent( + point, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + editingHost)) { + if (previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::br) || + previousEditableContentInBlock->IsText() || + HTMLEditUtils::IsImage(previousEditableContentInBlock) || + previousEditableContentInBlock->IsHTMLElement(nsGkAtoms::hr)) { + return NS_OK; + } + } + + // If next editable content in same block is `<br>`, text node, `<img>` or + // `<hr>`, current caret position is fine. + if (nsIContent* nextEditableContentInBlock = + HTMLEditUtils::GetNextContent(point, + {WalkTreeOption::IgnoreNonEditableNode, + WalkTreeOption::StopAtBlockBoundary}, + editingHost)) { + if (nextEditableContentInBlock->IsText() || + nextEditableContentInBlock->IsAnyOfHTMLElements( + nsGkAtoms::br, nsGkAtoms::img, nsGkAtoms::hr)) { + return NS_OK; + } + } + + // Otherwise, look for a near editable content towards edit action direction. + + // If there is no editable content, keep current caret position. + // XXX Why do we treat `nsIEditor::ePreviousWord` etc as forward direction? + nsIContent* nearEditableContent = HTMLEditUtils::GetAdjacentContentToPutCaret( + point, + aDirectionAndAmount == nsIEditor::ePrevious ? WalkTreeDirection::Backward + : WalkTreeDirection::Forward, + *editingHost); + if (!nearEditableContent) { + return NS_OK; + } + + EditorRawDOMPoint pointToPutCaret = + HTMLEditUtils::GetGoodCaretPointFor<EditorRawDOMPoint>( + *nearEditableContent, aDirectionAndAmount); + if (!pointToPutCaret.IsSet()) { + NS_WARNING("HTMLEditUtils::GetGoodCaretPointFor() failed"); + return NS_ERROR_FAILURE; + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; +} + +nsresult HTMLEditor::RemoveEmptyNodesIn(const EditorDOMRange& aRange) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aRange.IsPositioned()); + + // Some general notes on the algorithm used here: the goal is to examine all + // the nodes in aRange, and remove the empty ones. We do this by + // using a content iterator to traverse all the nodes in the range, and + // placing the empty nodes into an array. After finishing the iteration, + // we delete the empty nodes in the array. (They cannot be deleted as we + // find them because that would invalidate the iterator.) + // + // Since checking to see if a node is empty can be costly for nodes with + // many descendants, there are some optimizations made. I rely on the fact + // that the iterator is post-order: it will visit children of a node before + // visiting the parent node. So if I find that a child node is not empty, I + // know that its parent is not empty without even checking. So I put the + // parent on a "skipList" which is just a voidArray of nodes I can skip the + // empty check on. If I encounter a node on the skiplist, i skip the + // processing for that node and replace its slot in the skiplist with that + // node's parent. + // + // An interesting idea is to go ahead and regard parent nodes that are NOT + // on the skiplist as being empty (without even doing the IsEmptyNode check) + // on the theory that if they weren't empty, we would have encountered a + // non-empty child earlier and thus put this parent node on the skiplist. + // + // Unfortunately I can't use that strategy here, because the range may + // include some children of a node while excluding others. Thus I could + // find all the _examined_ children empty, but still not have an empty + // parent. + + const RawRangeBoundary endOfRange = [&]() { + // If the range is not collapsed and end of the range is start of a + // container, it means that the inclusive ancestor empty element may be + // created by splitting the left nodes. + if (aRange.Collapsed() || !aRange.IsInContentNodes() || + !aRange.EndRef().IsStartOfContainer()) { + return aRange.EndRef().ToRawRangeBoundary(); + } + nsINode* const commonAncestor = + nsContentUtils::GetClosestCommonInclusiveAncestor( + aRange.StartRef().ContainerAs<nsIContent>(), + aRange.EndRef().ContainerAs<nsIContent>()); + if (!commonAncestor) { + return aRange.EndRef().ToRawRangeBoundary(); + } + nsIContent* maybeRightContent = nullptr; + for (nsIContent* content : aRange.EndRef() + .ContainerAs<nsIContent>() + ->InclusiveAncestorsOfType<nsIContent>()) { + if (!HTMLEditUtils::IsSimplyEditableNode(*content) || + content == commonAncestor) { + break; + } + if (aRange.StartRef().ContainerAs<nsIContent>() == content) { + break; + } + EmptyCheckOptions options = {EmptyCheckOption::TreatListItemAsVisible, + EmptyCheckOption::TreatTableCellAsVisible}; + if (!HTMLEditUtils::IsBlockElement(*content)) { + options += EmptyCheckOption::TreatSingleBRElementAsVisible; + } + if (!HTMLEditUtils::IsEmptyNode(*content, options)) { + break; + } + maybeRightContent = content; + } + if (!maybeRightContent) { + return aRange.EndRef().ToRawRangeBoundary(); + } + return EditorRawDOMPoint::After(*maybeRightContent).ToRawRangeBoundary(); + }(); + + PostContentIterator postOrderIter; + nsresult rv = + postOrderIter.Init(aRange.StartRef().ToRawRangeBoundary(), endOfRange); + if (NS_FAILED(rv)) { + NS_WARNING("PostContentIterator::Init() failed"); + return rv; + } + + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfEmptyContents, + arrayOfEmptyCites; + + // Collect empty nodes first. + { + const bool isMailEditor = IsMailEditor(); + AutoTArray<OwningNonNull<nsIContent>, 64> knownNonEmptyContents; + Maybe<AutoRangeArray> maybeSelectionRanges; + for (; !postOrderIter.IsDone(); postOrderIter.Next()) { + MOZ_ASSERT(postOrderIter.GetCurrentNode()->IsContent()); + + nsIContent* content = postOrderIter.GetCurrentNode()->AsContent(); + nsIContent* parentContent = content->GetParent(); + + size_t idx = knownNonEmptyContents.IndexOf(content); + if (idx != decltype(knownNonEmptyContents)::NoIndex) { + // This node is on our skip list. Skip processing for this node, and + // replace its value in the skip list with the value of its parent + if (parentContent) { + knownNonEmptyContents[idx] = parentContent; + } + continue; + } + + const bool isEmptyNode = [&]() { + if (!content->IsElement()) { + return false; + } + const bool isMailCite = + isMailEditor && HTMLEditUtils::IsMailCite(*content->AsElement()); + const bool isCandidate = [&]() { + if (content->IsHTMLElement(nsGkAtoms::body)) { + // Don't delete the body + return false; + } + if (isMailCite || content->IsHTMLElement(nsGkAtoms::a) || + HTMLEditUtils::IsInlineStyle(content) || + HTMLEditUtils::IsAnyListElement(content) || + content->IsHTMLElement(nsGkAtoms::div)) { + // Only consider certain nodes to be empty for purposes of removal + return true; + } + if (HTMLEditUtils::IsFormatNode(content) || + HTMLEditUtils::IsListItem(content) || + content->IsHTMLElement(nsGkAtoms::blockquote)) { + // These node types are candidates if selection is not in them. If + // it is one of these, don't delete if selection inside. This is so + // we can create empty headings, etc., for the user to type into. + if (maybeSelectionRanges.isNothing()) { + maybeSelectionRanges.emplace(SelectionRef()); + } + return !maybeSelectionRanges + ->IsAtLeastOneContainerOfRangeBoundariesInclusiveDescendantOf( + *content); + } + return false; + }(); + + if (!isCandidate) { + return false; + } + + // We delete mailcites even if they have a solo br in them. Other + // nodes we require to be empty. + HTMLEditUtils::EmptyCheckOptions options{ + EmptyCheckOption::TreatListItemAsVisible, + EmptyCheckOption::TreatTableCellAsVisible}; + if (!isMailCite) { + options += EmptyCheckOption::TreatSingleBRElementAsVisible; + } + if (!HTMLEditUtils::IsEmptyNode(*content, options)) { + return false; + } + + if (isMailCite) { + // mailcites go on a separate list from other empty nodes + arrayOfEmptyCites.AppendElement(*content); + } + // Don't delete non-editable nodes in this method because this is a + // clean up method to remove unnecessary nodes of the result of + // editing. So, we shouldn't delete non-editable nodes which were + // there before editing. Additionally, if the element is some special + // elements such as <body>, we shouldn't delete it. + else if (HTMLEditUtils::IsSimplyEditableNode(*content) && + HTMLEditUtils::IsRemovableNode(*content)) { + arrayOfEmptyContents.AppendElement(*content); + } + return true; + }(); + if (!isEmptyNode && parentContent) { + knownNonEmptyContents.AppendElement(*parentContent); + } + } // end of the for-loop iterating with postOrderIter + } + + // now delete the empty nodes + for (OwningNonNull<nsIContent>& emptyContent : arrayOfEmptyContents) { + // MOZ_KnownLive due to bug 1622253 + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(emptyContent)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + + // Now delete the empty mailcites. This is a separate step because we want + // to pull out any br's and preserve them. + EditorDOMPoint pointToPutCaret; + for (OwningNonNull<nsIContent>& emptyCite : arrayOfEmptyCites) { + if (!HTMLEditUtils::IsEmptyNode( + emptyCite, {EmptyCheckOption::TreatSingleBRElementAsVisible, + EmptyCheckOption::TreatListItemAsVisible, + EmptyCheckOption::TreatTableCellAsVisible})) { + // We are deleting a cite that has just a `<br>`. We want to delete cite, + // but preserve `<br>`. + Result<CreateElementResult, nsresult> insertBRElementResult = + InsertBRElement(WithTransaction::Yes, EditorDOMPoint(emptyCite)); + if (MOZ_UNLIKELY(insertBRElementResult.isErr())) { + NS_WARNING("HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult.unwrapErr(); + } + CreateElementResult unwrappedInsertBRElementResult = + insertBRElementResult.unwrap(); + // XXX Is this intentional selection change? + unwrappedInsertBRElementResult.MoveCaretPointTo( + pointToPutCaret, *this, + {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + MOZ_ASSERT(unwrappedInsertBRElementResult.GetNewNode()); + } + // MOZ_KnownLive because 'arrayOfEmptyCites' is guaranteed to keep it alive. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(emptyCite)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + // XXX Is this intentional selection change? + if (pointToPutCaret.IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + 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"); + } + + return NS_OK; +} + +nsresult HTMLEditor::LiftUpListItemElement( + Element& aListItemElement, + LiftUpFromAllParentListElements aLiftUpFromAllParentListElements) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (!HTMLEditUtils::IsListItem(&aListItemElement)) { + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(!aListItemElement.GetParentElement()) || + NS_WARN_IF(!aListItemElement.GetParentElement()->GetParentNode())) { + return NS_ERROR_FAILURE; + } + + // if it's first or last list item, don't need to split the list + // otherwise we do. + bool isFirstListItem = HTMLEditUtils::IsFirstChild( + aListItemElement, {WalkTreeOption::IgnoreNonEditableNode}); + bool isLastListItem = HTMLEditUtils::IsLastChild( + aListItemElement, {WalkTreeOption::IgnoreNonEditableNode}); + + Element* leftListElement = aListItemElement.GetParentElement(); + if (NS_WARN_IF(!leftListElement)) { + return NS_ERROR_FAILURE; + } + + // If it's at middle of parent list element, split the parent list element. + // Then, aListItem becomes the first list item of the right list element. + if (!isFirstListItem && !isLastListItem) { + EditorDOMPoint atListItemElement(&aListItemElement); + if (NS_WARN_IF(!atListItemElement.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atListItemElement.IsSetAndValid()); + Result<SplitNodeResult, nsresult> splitListItemParentResult = + SplitNodeWithTransaction(atListItemElement); + if (MOZ_UNLIKELY(splitListItemParentResult.isErr())) { + NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed"); + return splitListItemParentResult.unwrapErr(); + } + nsresult rv = splitListItemParentResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + if (NS_FAILED(rv)) { + NS_WARNING("SplitNodeResult::SuggestCaretPointTo() failed"); + return rv; + } + + leftListElement = + splitListItemParentResult.inspect().GetPreviousContentAs<Element>(); + if (MOZ_UNLIKELY(!leftListElement)) { + NS_WARNING( + "HTMLEditor::SplitNodeWithTransaction() didn't return left list " + "element"); + return NS_ERROR_FAILURE; + } + } + + // In most cases, insert the list item into the new left list node.. + EditorDOMPoint pointToInsertListItem(leftListElement); + if (NS_WARN_IF(!pointToInsertListItem.IsSet())) { + return NS_ERROR_FAILURE; + } + + // But when the list item was the first child of the right list, it should + // be inserted between the both list elements. This allows user to hit + // Enter twice at a list item breaks the parent list node. + if (!isFirstListItem) { + DebugOnly<bool> advanced = pointToInsertListItem.AdvanceOffset(); + NS_WARNING_ASSERTION(advanced, + "Failed to advance offset to right list node"); + } + + EditorDOMPoint pointToPutCaret; + { + Result<MoveNodeResult, nsresult> moveListItemElementResult = + MoveNodeWithTransaction(aListItemElement, pointToInsertListItem); + if (MOZ_UNLIKELY(moveListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeWithTransaction() failed"); + return moveListItemElementResult.unwrapErr(); + } + MoveNodeResult unwrappedMoveListItemElementResult = + moveListItemElementResult.unwrap(); + unwrappedMoveListItemElementResult.MoveCaretPointTo( + pointToPutCaret, *this, + {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + } + + // Unwrap list item contents if they are no longer in a list + // XXX If the parent list element is a child of another list element + // (although invalid tree), the list item element won't be unwrapped. + // That makes the parent ancestor element tree valid, but might be + // unexpected result. + // XXX If aListItemElement is <dl> or <dd> and current parent is <ul> or <ol>, + // the list items won't be unwrapped. If aListItemElement is <li> and its + // current parent is <dl>, there is same issue. + if (!HTMLEditUtils::IsAnyListElement(pointToInsertListItem.GetContainer()) && + HTMLEditUtils::IsListItem(&aListItemElement)) { + Result<EditorDOMPoint, nsresult> unwrapOrphanListItemElementResult = + RemoveBlockContainerWithTransaction(aListItemElement); + if (MOZ_UNLIKELY(unwrapOrphanListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapOrphanListItemElementResult.unwrapErr(); + } + if (AllowsTransactionsToChangeSelection() && + unwrapOrphanListItemElementResult.inspect().IsSet()) { + pointToPutCaret = unwrapOrphanListItemElementResult.unwrap(); + } + if (!pointToPutCaret.IsSet()) { + return NS_OK; + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; + } + + if (pointToPutCaret.IsSet()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed, but ignored"); + } + + if (aLiftUpFromAllParentListElements == LiftUpFromAllParentListElements::No) { + return NS_OK; + } + // XXX If aListItemElement is moved to unexpected element by mutation event + // listener, shouldn't we stop calling this? + nsresult rv = LiftUpListItemElement(aListItemElement, + LiftUpFromAllParentListElements::Yes); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "HTMLEditor::LiftUpListItemElement(" + "LiftUpFromAllParentListElements::Yes) failed"); + return rv; +} + +nsresult HTMLEditor::DestroyListStructureRecursively(Element& aListElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement)); + + // XXX If mutation event listener inserts new child into `aListElement`, + // this becomes infinite loop so that we should set limit of the + // loop count from original child count. + while (aListElement.GetFirstChild()) { + OwningNonNull<nsIContent> child = *aListElement.GetFirstChild(); + + if (HTMLEditUtils::IsListItem(child)) { + // XXX Using LiftUpListItemElement() is too expensive for this purpose. + // Looks like the reason why this method uses it is, only this loop + // wants to work with first child of aListElement. However, what it + // actually does is removing <li> as container. Perhaps, we should + // decide destination first, and then, move contents in `child`. + // XXX If aListElement is is a child of another list element (although + // it's invalid tree), this moves the list item to outside of + // aListElement's parent. Is that really intentional behavior? + nsresult rv = LiftUpListItemElement( + MOZ_KnownLive(*child->AsElement()), + HTMLEditor::LiftUpFromAllParentListElements::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::LiftUpListItemElement(LiftUpFromAllParentListElements:" + ":Yes) failed"); + return rv; + } + continue; + } + + if (HTMLEditUtils::IsAnyListElement(child)) { + nsresult rv = + DestroyListStructureRecursively(MOZ_KnownLive(*child->AsElement())); + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::DestroyListStructureRecursively() failed"); + return rv; + } + continue; + } + + // Delete any non-list items for now + // XXX This is not HTML5 aware. HTML5 allows all list elements to have + // <script> and <template> and <dl> element to have <div> to group + // some <dt> and <dd> elements. So, this may break valid children. + nsresult rv = DeleteNodeWithTransaction(*child); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + + // Delete the now-empty list + const Result<EditorDOMPoint, nsresult> unwrapListElementResult = + RemoveBlockContainerWithTransaction(aListElement); + if (MOZ_UNLIKELY(unwrapListElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveBlockContainerWithTransaction() failed"); + return unwrapListElementResult.inspectErr(); + } + const EditorDOMPoint& pointToPutCaret = unwrapListElementResult.inspect(); + if (!AllowsTransactionsToChangeSelection() || !pointToPutCaret.IsSet()) { + return NS_OK; + } + nsresult rv = CollapseSelectionTo(pointToPutCaret); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; +} + +nsresult HTMLEditor::EnsureSelectionInBodyOrDocumentElement() { + MOZ_ASSERT(IsEditActionDataAvailable()); + + RefPtr<Element> bodyOrDocumentElement = GetRoot(); + if (NS_WARN_IF(!bodyOrDocumentElement)) { + return NS_ERROR_FAILURE; + } + + const auto atCaret = GetFirstSelectionStartPoint<EditorRawDOMPoint>(); + if (NS_WARN_IF(!atCaret.IsSet())) { + return NS_ERROR_FAILURE; + } + + // XXX This does wrong things. Web apps can put any elements as sibling + // of `<body>` element. Therefore, this collapses `Selection` into + // the `<body>` element which `HTMLDocument.body` is set to. So, + // this makes users impossible to modify content outside of the + // `<body>` element even if caret is in an editing host. + + // Check that selection start container is inside the <body> element. + // XXXsmaug this code is insane. + nsINode* temp = atCaret.GetContainer(); + while (temp && !temp->IsHTMLElement(nsGkAtoms::body)) { + temp = temp->GetParentOrShadowHostNode(); + } + + // If we aren't in the <body> element, force the issue. + if (!temp) { + nsresult rv = CollapseSelectionToStartOf(*bodyOrDocumentElement); + 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"); + return NS_OK; + } + + const auto selectionEndPoint = GetFirstSelectionEndPoint<EditorRawDOMPoint>(); + if (NS_WARN_IF(!selectionEndPoint.IsSet())) { + return NS_ERROR_FAILURE; + } + + // check that selNode is inside body + // XXXsmaug this code is insane. + temp = selectionEndPoint.GetContainer(); + while (temp && !temp->IsHTMLElement(nsGkAtoms::body)) { + temp = temp->GetParentOrShadowHostNode(); + } + + // If we aren't in the <body> element, force the issue. + if (!temp) { + nsresult rv = CollapseSelectionToStartOf(*bodyOrDocumentElement); + 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"); + } + + return NS_OK; +} + +nsresult HTMLEditor::InsertPaddingBRElementForEmptyLastLineIfNeeded( + Element& aElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + if (!HTMLEditUtils::IsBlockElement(aElement)) { + return NS_OK; + } + + if (!HTMLEditUtils::IsEmptyNode( + aElement, {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + return NS_OK; + } + + Result<CreateElementResult, nsresult> insertPaddingBRElementResult = + InsertPaddingBRElementForEmptyLastLineWithTransaction( + EditorDOMPoint(&aElement, 0u)); + if (MOZ_UNLIKELY(insertPaddingBRElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineWithTransaction() " + "failed"); + return insertPaddingBRElementResult.unwrapErr(); + } + nsresult rv = insertPaddingBRElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CreateElementResult::SuggestCaretPointTo() failed, but ignored"); + return NS_OK; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::RemoveAlignFromDescendants( + Element& aElement, const nsAString& aAlignType, EditTarget aEditTarget) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(!aElement.IsHTMLElement(nsGkAtoms::table)); + + const bool useCSS = IsCSSEnabled(); + + EditorDOMPoint pointToPutCaret; + + // Let's remove all alignment hints in the children of aNode; it can + // be an ALIGN attribute (in case we just remove it) or a CENTER + // element (here we have to remove the container and keep its + // children). We break on tables and don't look at their children. + nsCOMPtr<nsIContent> nextSibling; + for (nsIContent* content = + aEditTarget == EditTarget::NodeAndDescendantsExceptTable + ? &aElement + : aElement.GetFirstChild(); + content; content = nextSibling) { + // Get the next sibling before removing content from the DOM tree. + // XXX If next sibling is removed from the parent and/or inserted to + // different parent, we will behave unexpectedly. I think that + // we should create child list and handle it with checking whether + // it's still a child of expected parent. + nextSibling = aEditTarget == EditTarget::NodeAndDescendantsExceptTable + ? nullptr + : content->GetNextSibling(); + + if (content->IsHTMLElement(nsGkAtoms::center)) { + OwningNonNull<Element> centerElement = *content->AsElement(); + { + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + RemoveAlignFromDescendants(centerElement, aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveAlignFromDescendants(EditTarget::" + "OnlyDescendantsExceptTable) failed"); + return pointToPutCaretOrError; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + + // We may have to insert a `<br>` element before first child of the + // `<center>` element because it should be first element of a hard line + // even after removing the `<center>` element. + { + Result<CreateElementResult, nsresult> + maybeInsertBRElementBeforeFirstChildResult = + EnsureHardLineBeginsWithFirstChildOf(centerElement); + if (MOZ_UNLIKELY(maybeInsertBRElementBeforeFirstChildResult.isErr())) { + NS_WARNING( + "HTMLEditor::EnsureHardLineBeginsWithFirstChildOf() failed"); + return maybeInsertBRElementBeforeFirstChildResult.propagateErr(); + } + CreateElementResult unwrappedResult = + maybeInsertBRElementBeforeFirstChildResult.unwrap(); + if (unwrappedResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedResult.UnwrapCaretPoint(); + } + } + + // We may have to insert a `<br>` element after last child of the + // `<center>` element because it should be last element of a hard line + // even after removing the `<center>` element. + { + Result<CreateElementResult, nsresult> + maybeInsertBRElementAfterLastChildResult = + EnsureHardLineEndsWithLastChildOf(centerElement); + if (MOZ_UNLIKELY(maybeInsertBRElementAfterLastChildResult.isErr())) { + NS_WARNING("HTMLEditor::EnsureHardLineEndsWithLastChildOf() failed"); + return maybeInsertBRElementAfterLastChildResult.propagateErr(); + } + CreateElementResult unwrappedResult = + maybeInsertBRElementAfterLastChildResult.unwrap(); + if (unwrappedResult.HasCaretPointSuggestion()) { + pointToPutCaret = unwrappedResult.UnwrapCaretPoint(); + } + } + + { + Result<EditorDOMPoint, nsresult> unwrapCenterElementResult = + RemoveContainerWithTransaction(centerElement); + if (MOZ_UNLIKELY(unwrapCenterElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveContainerWithTransaction() failed"); + return unwrapCenterElementResult; + } + if (unwrapCenterElementResult.inspect().IsSet()) { + pointToPutCaret = unwrapCenterElementResult.unwrap(); + } + } + continue; + } + + if (!HTMLEditUtils::IsBlockElement(*content) && + !content->IsHTMLElement(nsGkAtoms::hr)) { + continue; + } + + const OwningNonNull<Element> blockOrHRElement = *content->AsElement(); + if (HTMLEditUtils::SupportsAlignAttr(blockOrHRElement)) { + nsresult rv = + RemoveAttributeWithTransaction(blockOrHRElement, *nsGkAtoms::align); + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::align) " + "failed"); + return Err(rv); + } + } + if (useCSS) { + if (blockOrHRElement->IsAnyOfHTMLElements(nsGkAtoms::table, + nsGkAtoms::hr)) { + nsresult rv = SetAttributeOrEquivalent( + blockOrHRElement, nsGkAtoms::align, aAlignType, false); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING( + "EditorBase::SetAttributeOrEquivalent(nsGkAtoms::align) failed"); + return Err(rv); + } + } else { + nsStyledElement* styledBlockOrHRElement = + nsStyledElement::FromNode(blockOrHRElement); + if (NS_WARN_IF(!styledBlockOrHRElement)) { + return Err(NS_ERROR_FAILURE); + } + // MOZ_KnownLive(*styledBlockOrHRElement): It's `blockOrHRElement + // which is OwningNonNull. + nsAutoString dummyCssValue; + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + CSSEditUtils::RemoveCSSInlineStyleWithTransaction( + *this, MOZ_KnownLive(*styledBlockOrHRElement), + nsGkAtoms::textAlign, dummyCssValue); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "CSSEditUtils::RemoveCSSInlineStyleWithTransaction(nsGkAtoms::" + "textAlign) failed"); + return pointToPutCaretOrError; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + } + if (!blockOrHRElement->IsHTMLElement(nsGkAtoms::table)) { + // unless this is a table, look at children + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + RemoveAlignFromDescendants(blockOrHRElement, aAlignType, + EditTarget::OnlyDescendantsExceptTable); + if (pointToPutCaretOrError.isErr()) { + NS_WARNING( + "HTMLEditor::RemoveAlignFromDescendants(EditTarget::" + "OnlyDescendantsExceptTable) failed"); + return pointToPutCaretOrError; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + } + return pointToPutCaret; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::EnsureHardLineBeginsWithFirstChildOf( + Element& aRemovingContainerElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + nsIContent* firstEditableChild = HTMLEditUtils::GetFirstChild( + aRemovingContainerElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (!firstEditableChild) { + return CreateElementResult::NotHandled(); + } + + if (HTMLEditUtils::IsBlockElement(*firstEditableChild) || + firstEditableChild->IsHTMLElement(nsGkAtoms::br)) { + return CreateElementResult::NotHandled(); + } + + nsIContent* previousEditableContent = HTMLEditUtils::GetPreviousSibling( + aRemovingContainerElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (!previousEditableContent) { + return CreateElementResult::NotHandled(); + } + + if (HTMLEditUtils::IsBlockElement(*previousEditableContent) || + previousEditableContent->IsHTMLElement(nsGkAtoms::br)) { + return CreateElementResult::NotHandled(); + } + + Result<CreateElementResult, nsresult> insertBRElementResult = InsertBRElement( + WithTransaction::Yes, EditorDOMPoint(&aRemovingContainerElement, 0u)); + NS_WARNING_ASSERTION( + insertBRElementResult.isOk(), + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult; +} + +Result<CreateElementResult, nsresult> +HTMLEditor::EnsureHardLineEndsWithLastChildOf( + Element& aRemovingContainerElement) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + nsIContent* firstEditableContent = HTMLEditUtils::GetLastChild( + aRemovingContainerElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (!firstEditableContent) { + return CreateElementResult::NotHandled(); + } + + if (HTMLEditUtils::IsBlockElement(*firstEditableContent) || + firstEditableContent->IsHTMLElement(nsGkAtoms::br)) { + return CreateElementResult::NotHandled(); + } + + nsIContent* nextEditableContent = HTMLEditUtils::GetPreviousSibling( + aRemovingContainerElement, {WalkTreeOption::IgnoreNonEditableNode}); + if (!nextEditableContent) { + return CreateElementResult::NotHandled(); + } + + if (HTMLEditUtils::IsBlockElement(*nextEditableContent) || + nextEditableContent->IsHTMLElement(nsGkAtoms::br)) { + return CreateElementResult::NotHandled(); + } + + Result<CreateElementResult, nsresult> insertBRElementResult = InsertBRElement( + WithTransaction::Yes, EditorDOMPoint::AtEndOf(aRemovingContainerElement)); + NS_WARNING_ASSERTION( + insertBRElementResult.isOk(), + "HTMLEditor::InsertBRElement(WithTransaction::Yes) failed"); + return insertBRElementResult; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::SetBlockElementAlign( + Element& aBlockOrHRElement, const nsAString& aAlignType, + EditTarget aEditTarget) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(HTMLEditUtils::IsBlockElement(aBlockOrHRElement) || + aBlockOrHRElement.IsHTMLElement(nsGkAtoms::hr)); + MOZ_ASSERT(IsCSSEnabled() || + HTMLEditUtils::SupportsAlignAttr(aBlockOrHRElement)); + + EditorDOMPoint pointToPutCaret; + if (!aBlockOrHRElement.IsHTMLElement(nsGkAtoms::table)) { + Result<EditorDOMPoint, nsresult> pointToPutCaretOrError = + RemoveAlignFromDescendants(aBlockOrHRElement, aAlignType, aEditTarget); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING("HTMLEditor::RemoveAlignFromDescendants() failed"); + return pointToPutCaretOrError; + } + if (pointToPutCaretOrError.inspect().IsSet()) { + pointToPutCaret = pointToPutCaretOrError.unwrap(); + } + } + nsresult rv = SetAttributeOrEquivalent(&aBlockOrHRElement, nsGkAtoms::align, + aAlignType, false); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::SetAttributeOrEquivalent(nsGkAtoms::align) failed"); + return Err(rv); + } + return pointToPutCaret; +} + +Result<EditorDOMPoint, nsresult> HTMLEditor::ChangeMarginStart( + Element& aElement, ChangeMargin aChangeMargin, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + nsStaticAtom& marginProperty = MarginPropertyAtomForIndent(aElement); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + nsAutoString value; + DebugOnly<nsresult> rvIgnored = + CSSEditUtils::GetSpecifiedProperty(aElement, marginProperty, value); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "CSSEditUtils::GetSpecifiedProperty() failed, but ignored"); + float f; + RefPtr<nsAtom> unit; + CSSEditUtils::ParseLength(value, &f, getter_AddRefs(unit)); + if (!f) { + unit = nsGkAtoms::px; + } + int8_t multiplier = aChangeMargin == ChangeMargin::Increase ? 1 : -1; + if (nsGkAtoms::in == unit) { + f += NS_EDITOR_INDENT_INCREMENT_IN * multiplier; + } else if (nsGkAtoms::cm == unit) { + f += NS_EDITOR_INDENT_INCREMENT_CM * multiplier; + } else if (nsGkAtoms::mm == unit) { + f += NS_EDITOR_INDENT_INCREMENT_MM * multiplier; + } else if (nsGkAtoms::pt == unit) { + f += NS_EDITOR_INDENT_INCREMENT_PT * multiplier; + } else if (nsGkAtoms::pc == unit) { + f += NS_EDITOR_INDENT_INCREMENT_PC * multiplier; + } else if (nsGkAtoms::em == unit) { + f += NS_EDITOR_INDENT_INCREMENT_EM * multiplier; + } else if (nsGkAtoms::ex == unit) { + f += NS_EDITOR_INDENT_INCREMENT_EX * multiplier; + } else if (nsGkAtoms::px == unit) { + f += NS_EDITOR_INDENT_INCREMENT_PX * multiplier; + } else if (nsGkAtoms::percentage == unit) { + f += NS_EDITOR_INDENT_INCREMENT_PERCENT * multiplier; + } + + if (0 < f) { + if (nsStyledElement* styledElement = nsStyledElement::FromNode(&aElement)) { + nsAutoString newValue; + newValue.AppendFloat(f); + newValue.Append(nsDependentAtomString(unit)); + // MOZ_KnownLive(*styledElement): It's aElement and its lifetime must + // be guaranteed by caller because of MOZ_CAN_RUN_SCRIPT method. + // MOZ_KnownLive(merginProperty): It's nsStaticAtom. + nsresult rv = CSSEditUtils::SetCSSPropertyWithTransaction( + *this, MOZ_KnownLive(*styledElement), MOZ_KnownLive(marginProperty), + newValue); + if (rv == NS_ERROR_EDITOR_DESTROYED) { + NS_WARNING( + "CSSEditUtils::SetCSSPropertyWithTransaction() destroyed the " + "editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "CSSEditUtils::SetCSSPropertyWithTransaction() failed, but ignored"); + } + return EditorDOMPoint(); + } + + if (nsStyledElement* styledElement = nsStyledElement::FromNode(&aElement)) { + // MOZ_KnownLive(*styledElement): It's aElement and its lifetime must + // be guaranteed by caller because of MOZ_CAN_RUN_SCRIPT method. + // MOZ_KnownLive(merginProperty): It's nsStaticAtom. + nsresult rv = CSSEditUtils::RemoveCSSPropertyWithTransaction( + *this, MOZ_KnownLive(*styledElement), MOZ_KnownLive(marginProperty), + value); + if (rv == NS_ERROR_EDITOR_DESTROYED) { + NS_WARNING( + "CSSEditUtils::RemoveCSSPropertyWithTransaction() destroyed the " + "editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "CSSEditUtils::RemoveCSSPropertyWithTransaction() failed, but ignored"); + } + + // Remove unnecessary divs + if (!aElement.IsHTMLElement(nsGkAtoms::div) || + HTMLEditUtils::ElementHasAttribute(aElement)) { + return EditorDOMPoint(); + } + // Don't touch editing host nor node which is outside of it. + if (&aElement == &aEditingHost || + !aElement.IsInclusiveDescendantOf(&aEditingHost)) { + return EditorDOMPoint(); + } + + Result<EditorDOMPoint, nsresult> unwrapDivElementResult = + RemoveContainerWithTransaction(aElement); + NS_WARNING_ASSERTION(unwrapDivElementResult.isOk(), + "HTMLEditor::RemoveContainerWithTransaction() failed"); + return unwrapDivElementResult; +} + +Result<EditActionResult, nsresult> +HTMLEditor::SetSelectionToAbsoluteAsSubAction(const Element& aEditingHost) { + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eSetPositionToAbsolute, nsIEditor::eNext, + ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + auto EnsureCaretInElementIfCollapsedOutside = + [&](Element& aElement) MOZ_CAN_RUN_SCRIPT { + if (!SelectionRef().IsCollapsed() || !SelectionRef().RangeCount()) { + return NS_OK; + } + const auto firstRangeStartPoint = + GetFirstSelectionStartPoint<EditorRawDOMPoint>(); + if (MOZ_UNLIKELY(!firstRangeStartPoint.IsSet())) { + return NS_OK; + } + const Result<EditorRawDOMPoint, nsresult> pointToPutCaretOrError = + HTMLEditUtils::ComputePointToPutCaretInElementIfOutside< + EditorRawDOMPoint>(aElement, firstRangeStartPoint); + if (MOZ_UNLIKELY(pointToPutCaretOrError.isErr())) { + NS_WARNING( + "HTMLEditUtils::ComputePointToPutCaretInElementIfOutside() " + "failed, but ignored"); + return NS_OK; + } + if (!pointToPutCaretOrError.inspect().IsSet()) { + return NS_OK; + } + nsresult rv = CollapseSelectionTo(pointToPutCaretOrError.inspect()); + if (MOZ_UNLIKELY(rv == NS_ERROR_EDITOR_DESTROYED)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return NS_ERROR_EDITOR_DESTROYED; + } + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed, but ignored"); + return NS_OK; + }; + + RefPtr<Element> focusElement = GetSelectionContainerElement(); + if (focusElement && HTMLEditUtils::IsImage(focusElement)) { + nsresult rv = EnsureCaretInElementIfCollapsedOutside(*focusElement); + if (NS_FAILED(rv)) { + NS_WARNING("EnsureCaretInElementIfCollapsedOutside() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); + } + + // XXX Why do we do this only when there is only one selection range? + if (!SelectionRef().IsCollapsed() && SelectionRef().RangeCount() == 1u) { + Result<EditorRawDOMRange, nsresult> extendedRange = + GetRangeExtendedToHardLineEdgesForBlockEditAction( + SelectionRef().GetRangeAt(0u), aEditingHost); + if (MOZ_UNLIKELY(extendedRange.isErr())) { + NS_WARNING( + "HTMLEditor::GetRangeExtendedToHardLineEdgesForBlockEditAction() " + "failed"); + return extendedRange.propagateErr(); + } + // Note that end point may be prior to start point. So, we + // cannot use Selection::SetStartAndEndInLimit() here. + IgnoredErrorResult error; + SelectionRef().SetBaseAndExtentInLimiter( + extendedRange.inspect().StartRef().ToRawRangeBoundary(), + extendedRange.inspect().EndRef().ToRawRangeBoundary(), error); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (MOZ_UNLIKELY(error.Failed())) { + NS_WARNING("Selection::SetBaseAndExtentInLimiter() failed"); + return Err(error.StealNSResult()); + } + } + + RefPtr<Element> divElement; + rv = MoveSelectedContentsToDivElementToMakeItAbsolutePosition( + address_of(divElement), aEditingHost); + // MoveSelectedContentsToDivElementToMakeItAbsolutePosition() may restore + // selection with AutoSelectionRestorer. Therefore, the editor might have + // already been destroyed now. + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::MoveSelectedContentsToDivElementToMakeItAbsolutePosition()" + " failed"); + return Err(rv); + } + + if (IsSelectionRangeContainerNotContent()) { + NS_WARNING("Mutation event listener might have changed the selection"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + rv = MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); + if (NS_FAILED(rv)) { + NS_WARNING( + "HTMLEditor::MaybeInsertPaddingBRElementForEmptyLastLineAtSelection() " + "failed"); + return Err(rv); + } + + if (!divElement) { + return EditActionResult::HandledResult(); + } + + rv = SetPositionToAbsoluteOrStatic(*divElement, true); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::SetPositionToAbsoluteOrStatic() failed"); + return Err(rv); + } + + rv = EnsureCaretInElementIfCollapsedOutside(*divElement); + if (NS_FAILED(rv)) { + NS_WARNING("EnsureCaretInElementIfCollapsedOutside() failed"); + return Err(rv); + } + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::MoveSelectedContentsToDivElementToMakeItAbsolutePosition( + RefPtr<Element>* aTargetElement, const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aTargetElement); + + AutoSelectionRestorer restoreSelectionLater(*this); + + EditorDOMPoint pointToPutCaret; + + // Use these ranges to construct a list of nodes to act on. + AutoTArray<OwningNonNull<nsIContent>, 64> arrayOfContents; + { + AutoRangeArray extendedSelectionRanges(SelectionRef()); + extendedSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eSetPositionToAbsolute, aEditingHost); + Result<EditorDOMPoint, nsresult> splitResult = + extendedSelectionRanges + .SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries( + *this, aEditingHost); + if (MOZ_UNLIKELY(splitResult.isErr())) { + NS_WARNING( + "AutoRangeArray::" + "SplitTextAtEndBoundariesAndInlineAncestorsAtBothBoundaries() " + "failed"); + return splitResult.unwrapErr(); + } + if (splitResult.inspect().IsSet()) { + pointToPutCaret = splitResult.unwrap(); + } + nsresult rv = extendedSelectionRanges.CollectEditTargetNodes( + *this, arrayOfContents, EditSubAction::eSetPositionToAbsolute, + AutoRangeArray::CollectNonEditableNodes::Yes); + if (NS_FAILED(rv)) { + NS_WARNING( + "AutoRangeArray::CollectEditTargetNodes(EditSubAction::" + "eSetPositionToAbsolute, CollectNonEditableNodes::Yes) failed"); + return rv; + } + } + + Result<EditorDOMPoint, nsresult> splitAtBRElementsResult = + MaybeSplitElementsAtEveryBRElement(arrayOfContents, + EditSubAction::eSetPositionToAbsolute); + if (MOZ_UNLIKELY(splitAtBRElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitElementsAtEveryBRElement(EditSubAction::" + "eSetPositionToAbsolute) failed"); + return splitAtBRElementsResult.inspectErr(); + } + if (splitAtBRElementsResult.inspect().IsSet()) { + pointToPutCaret = splitAtBRElementsResult.unwrap(); + } + + if (AllowsTransactionsToChangeSelection() && + pointToPutCaret.IsSetAndValid()) { + nsresult rv = CollapseSelectionTo(pointToPutCaret); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::CollapseSelectionTo() failed"); + return rv; + } + } + + // If there is no visible and editable nodes in the edit targets, make an + // empty block. + // XXX Isn't this odd if there are only non-editable visible nodes? + if (HTMLEditUtils::IsEmptyOneHardLine(arrayOfContents)) { + const auto atCaret = + EditorBase::GetFirstSelectionStartPoint<EditorDOMPoint>(); + if (NS_WARN_IF(!atCaret.IsSet())) { + return NS_ERROR_FAILURE; + } + + // Make sure we can put a block here. + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atCaret, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult.unwrapErr(); + } + CreateElementResult unwrappedCreateNewDivElementResult = + createNewDivElementResult.unwrap(); + // We'll update selection after deleting the content nodes and nobody + // refers selection until then. Therefore, we don't need to update + // selection here. + unwrappedCreateNewDivElementResult.IgnoreCaretPointSuggestion(); + RefPtr<Element> newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + MOZ_ASSERT(newDivElement); + // Delete anything that was in the list of nodes + // XXX We don't need to remove items from the array. + for (OwningNonNull<nsIContent>& curNode : arrayOfContents) { + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to keep it alive. + nsresult rv = DeleteNodeWithTransaction(MOZ_KnownLive(*curNode)); + if (NS_FAILED(rv)) { + NS_WARNING("EditorBase::DeleteNodeWithTransaction() failed"); + return rv; + } + } + // Don't restore the selection + restoreSelectionLater.Abort(); + nsresult rv = CollapseSelectionToStartOf(*newDivElement); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionToStartOf() failed"); + *aTargetElement = std::move(newDivElement); + return rv; + } + + // `<div>` element to be positioned absolutely. This may have already + // existed or newly created by this method. + RefPtr<Element> targetDivElement; + // Newly created list element for moving selected list item elements into + // targetDivElement. I.e., this is created in the `<div>` element. + RefPtr<Element> createdListElement; + // If we handle a parent list item element, this is set to it. In such case, + // we should handle its children again. + RefPtr<Element> handledListItemElement; + for (OwningNonNull<nsIContent>& content : arrayOfContents) { + // Here's where we actually figure out what to do. + EditorDOMPoint atContent(content); + if (NS_WARN_IF(!atContent.IsSet())) { + return NS_ERROR_FAILURE; // XXX not continue?? + } + + // Ignore all non-editable nodes. Leave them be. + if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { + continue; + } + + // If current node is a child of a list element, we need another list + // element in absolute-positioned `<div>` element to avoid non-selected + // list items are moved into the `<div>` element. + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + // If we cannot move current node to created list element, we need a + // list element in the target `<div>` element for the destination. + // Therefore, duplicate same list element into the target `<div>` + // element. + nsIContent* previousEditableContent = + createdListElement + ? HTMLEditUtils::GetPreviousSibling( + content, {WalkTreeOption::IgnoreNonEditableNode}) + : nullptr; + if (!createdListElement || + (previousEditableContent && + previousEditableContent != createdListElement)) { + nsAtom* ULOrOLOrDLTagName = + atContent.GetContainer()->NodeInfo()->NameAtom(); + if (targetDivElement) { + // XXX Do we need to split the container? Since we'll append new + // element at end of the <div> element. + Result<SplitNodeResult, nsresult> splitNodeResult = + MaybeSplitAncestorsForInsertWithTransaction( + MOZ_KnownLive(*ULOrOLOrDLTagName), atContent, aEditingHost); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() " + "failed"); + return splitNodeResult.unwrapErr(); + } + // We'll update selection after creating a list element below. + // Therefore, we don't need to touch selection here. + splitNodeResult.inspect().IgnoreCaretPointSuggestion(); + } else { + // If we've not had a target <div> element yet, let's insert a <div> + // element with splitting the ancestors. + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTransaction(nsGkAtoms::" + "div) failed"); + return createNewDivElementResult.unwrapErr(); + } + // We'll update selection after creating a list element below. + // Therefor, we don't need to touch selection here. + createNewDivElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(createNewDivElementResult.inspect().GetNewNode()); + targetDivElement = createNewDivElementResult.unwrap().UnwrapNewNode(); + } + Result<CreateElementResult, nsresult> createNewListElementResult = + CreateAndInsertElement(WithTransaction::Yes, + MOZ_KnownLive(*ULOrOLOrDLTagName), + EditorDOMPoint::AtEndOf(targetDivElement)); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) " + "failed"); + return createNewListElementResult.unwrapErr(); + } + nsresult rv = createNewListElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CreateElementResult::SuggestCaretPointTo() failed, but ignored"); + createdListElement = + createNewListElementResult.unwrap().UnwrapNewNode(); + MOZ_ASSERT(createdListElement); + } + // Move current node (maybe, assumed as a list item element) into the + // new list element in the target `<div>` element to be positioned + // absolutely. + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), + *createdListElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + nsresult rv = moveNodeResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + continue; + } + + // If contents in a list item element is selected, we should move current + // node into the target `<div>` element with the list item element itself + // because we want to keep indent level of the contents. + if (RefPtr<Element> listItemElement = + HTMLEditUtils::GetClosestAncestorListItemElement(content, + &aEditingHost)) { + if (handledListItemElement == listItemElement) { + // Current node has already been moved into the `<div>` element. + continue; + } + // If we cannot move the list item element into created list element, + // we need another list element in the target `<div>` element. + nsIContent* previousEditableContent = + createdListElement + ? HTMLEditUtils::GetPreviousSibling( + *listItemElement, {WalkTreeOption::IgnoreNonEditableNode}) + : nullptr; + if (!createdListElement || + (previousEditableContent && + previousEditableContent != createdListElement)) { + EditorDOMPoint atListItem(listItemElement); + if (NS_WARN_IF(!atListItem.IsSet())) { + return NS_ERROR_FAILURE; + } + // XXX If content is the listItemElement and not in a list element, + // we duplicate wrong element into the target `<div>` element. + nsAtom* containerName = + atListItem.GetContainer()->NodeInfo()->NameAtom(); + if (targetDivElement) { + // XXX Do we need to split the container? Since we'll append new + // element at end of the <div> element. + Result<SplitNodeResult, nsresult> splitNodeResult = + MaybeSplitAncestorsForInsertWithTransaction( + MOZ_KnownLive(*containerName), atListItem, aEditingHost); + if (MOZ_UNLIKELY(splitNodeResult.isErr())) { + NS_WARNING( + "HTMLEditor::MaybeSplitAncestorsForInsertWithTransaction() " + "failed"); + return splitNodeResult.unwrapErr(); + } + // We'll update selection after creating a list element below. + // Therefore, we don't need to touch selection here. + splitNodeResult.inspect().IgnoreCaretPointSuggestion(); + } else { + // If we've not had a target <div> element yet, let's insert a <div> + // element with splitting the ancestors. + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult.unwrapErr(); + } + // We'll update selection after creating a list element below. + // Therefore, we don't need to touch selection here. + createNewDivElementResult.inspect().IgnoreCaretPointSuggestion(); + MOZ_ASSERT(createNewDivElementResult.inspect().GetNewNode()); + targetDivElement = createNewDivElementResult.unwrap().UnwrapNewNode(); + } + // XXX So, createdListElement may be set to a non-list element. + Result<CreateElementResult, nsresult> createNewListElementResult = + CreateAndInsertElement(WithTransaction::Yes, + MOZ_KnownLive(*containerName), + EditorDOMPoint::AtEndOf(targetDivElement)); + if (MOZ_UNLIKELY(createNewListElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::CreateAndInsertElement(WithTransaction::Yes) " + "failed"); + return createNewListElementResult.unwrapErr(); + } + nsresult rv = createNewListElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "CreateElementResult::SuggestCaretPointTo() failed, but ignored"); + createdListElement = + createNewListElementResult.unwrap().UnwrapNewNode(); + MOZ_ASSERT(createdListElement); + } + // Move current list item element into the createdListElement (could be + // non-list element due to the above bug) in a candidate `<div>` element + // to be positioned absolutely. + Result<MoveNodeResult, nsresult> moveListItemElementResult = + MoveNodeToEndWithTransaction(*listItemElement, *createdListElement); + if (MOZ_UNLIKELY(moveListItemElementResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveListItemElementResult.unwrapErr(); + } + nsresult rv = moveListItemElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return Err(rv); + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + handledListItemElement = std::move(listItemElement); + continue; + } + + if (!targetDivElement) { + // If we meet a `<div>` element, use it as the absolute-position + // container. + // XXX This looks odd. If there are 2 or more `<div>` elements are + // selected, first found `<div>` element will have all other + // selected nodes. + if (content->IsHTMLElement(nsGkAtoms::div)) { + targetDivElement = content->AsElement(); + MOZ_ASSERT(!createdListElement); + MOZ_ASSERT(!handledListItemElement); + continue; + } + // Otherwise, create new `<div>` element to be positioned absolutely + // and to contain all selected nodes. + Result<CreateElementResult, nsresult> createNewDivElementResult = + InsertElementWithSplittingAncestorsWithTransaction( + *nsGkAtoms::div, atContent, BRElementNextToSplitPoint::Keep, + aEditingHost); + if (MOZ_UNLIKELY(createNewDivElementResult.isErr())) { + NS_WARNING( + "HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction(" + "nsGkAtoms::div) failed"); + return createNewDivElementResult.unwrapErr(); + } + nsresult rv = createNewDivElementResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt}); + if (NS_FAILED(rv)) { + NS_WARNING("CreateElementResult::SuggestCaretPointTo() failed"); + return rv; + } + MOZ_ASSERT(createNewDivElementResult.inspect().GetNewNode()); + targetDivElement = createNewDivElementResult.unwrap().UnwrapNewNode(); + } + + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to keep it alive. + Result<MoveNodeResult, nsresult> moveNodeResult = + MoveNodeToEndWithTransaction(MOZ_KnownLive(content), *targetDivElement); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.unwrapErr(); + } + nsresult rv = moveNodeResult.inspect().SuggestCaretPointTo( + *this, {SuggestCaret::OnlyIfHasSuggestion, + SuggestCaret::OnlyIfTransactionsAllowedToDoIt, + SuggestCaret::AndIgnoreTrivialError}); + if (NS_FAILED(rv)) { + NS_WARNING("MoveNodeResult::SuggestCaretPointTo() failed"); + return rv; + } + NS_WARNING_ASSERTION( + rv != NS_SUCCESS_EDITOR_BUT_IGNORED_TRIVIAL_ERROR, + "MoveNodeResult::SuggestCaretPointTo() failed, but ignored"); + // Forget createdListElement, if any + createdListElement = nullptr; + } + *aTargetElement = std::move(targetDivElement); + return NS_OK; +} + +Result<EditActionResult, nsresult> +HTMLEditor::SetSelectionToStaticAsSubAction() { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, EditSubAction::eSetPositionToStatic, nsIEditor::eNext, + ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + RefPtr<Element> element = GetAbsolutelyPositionedSelectionContainer(); + if (!element) { + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::GetAbsolutelyPositionedSelectionContainer() returned " + "nullptr"); + return Err(NS_ERROR_FAILURE); + } + + { + AutoSelectionRestorer restoreSelectionLater(*this); + + nsresult rv = SetPositionToAbsoluteOrStatic(*element, false); + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + if (NS_FAILED(rv)) { + NS_WARNING("HTMLEditor::SetPositionToAbsoluteOrStatic() failed"); + return Err(rv); + } + } + + // Restoring Selection might cause destroying the HTML editor. + if (MOZ_UNLIKELY(Destroyed())) { + NS_WARNING("Destroying AutoSelectionRestorer caused destroying the editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + return EditActionResult::HandledResult(); +} + +Result<EditActionResult, nsresult> HTMLEditor::AddZIndexAsSubAction( + int32_t aChange) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + AutoPlaceholderBatch treatAsOneTransaction( + *this, ScrollSelectionIntoView::Yes, __FUNCTION__); + IgnoredErrorResult ignoredError; + AutoEditSubActionNotifier startToHandleEditSubAction( + *this, + aChange < 0 ? EditSubAction::eDecreaseZIndex + : EditSubAction::eIncreaseZIndex, + nsIEditor::eNext, ignoredError); + if (NS_WARN_IF(ignoredError.ErrorCodeIs(NS_ERROR_EDITOR_DESTROYED))) { + return Err(ignoredError.StealNSResult()); + } + NS_WARNING_ASSERTION( + !ignoredError.Failed(), + "HTMLEditor::OnStartToHandleTopLevelEditSubAction() failed, but ignored"); + + { + Result<EditActionResult, nsresult> result = CanHandleHTMLEditSubAction(); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::CanHandleHTMLEditSubAction() failed"); + return result; + } + if (result.inspect().Canceled()) { + return result; + } + } + + nsresult rv = 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) && SelectionRef().IsCollapsed()) { + nsresult rv = 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 = 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"); + } + } + + RefPtr<Element> absolutelyPositionedElement = + GetAbsolutelyPositionedSelectionContainer(); + if (!absolutelyPositionedElement) { + if (NS_WARN_IF(Destroyed())) { + return Err(NS_ERROR_EDITOR_DESTROYED); + } + NS_WARNING( + "HTMLEditor::GetAbsolutelyPositionedSelectionContainer() returned " + "nullptr"); + return Err(NS_ERROR_FAILURE); + } + + nsStyledElement* absolutelyPositionedStyledElement = + nsStyledElement::FromNode(absolutelyPositionedElement); + if (NS_WARN_IF(!absolutelyPositionedStyledElement)) { + return Err(NS_ERROR_FAILURE); + } + + { + AutoSelectionRestorer restoreSelectionLater(*this); + + // MOZ_KnownLive(*absolutelyPositionedStyledElement): It's + // absolutelyPositionedElement whose type is RefPtr. + Result<int32_t, nsresult> result = AddZIndexWithTransaction( + MOZ_KnownLive(*absolutelyPositionedStyledElement), aChange); + if (MOZ_UNLIKELY(result.isErr())) { + NS_WARNING("HTMLEditor::AddZIndexWithTransaction() failed"); + return result.propagateErr(); + } + } + + // Restoring Selection might cause destroying the HTML editor. + if (MOZ_UNLIKELY(Destroyed())) { + NS_WARNING("Destroying AutoSelectionRestorer caused destroying the editor"); + return Err(NS_ERROR_EDITOR_DESTROYED); + } + + return EditActionResult::HandledResult(); +} + +nsresult HTMLEditor::OnDocumentModified() { + if (mPendingDocumentModifiedRunner) { + return NS_OK; // We've already posted same runnable into the queue. + } + mPendingDocumentModifiedRunner = NewRunnableMethod( + "HTMLEditor::OnModifyDocument", this, &HTMLEditor::OnModifyDocument); + nsContentUtils::AddScriptRunner(do_AddRef(mPendingDocumentModifiedRunner)); + // Be aware, if OnModifyDocument() may be called synchronously, the + // editor might have been destroyed here. + return NS_WARN_IF(Destroyed()) ? NS_ERROR_EDITOR_DESTROYED : NS_OK; +} + +} // namespace mozilla |