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 mailCiteElement = GetMostDistantAncestorMailCiteElement( + *pointToInsert.ContainerAs())) { + // Split any mailcites in the way. Should we abort this if we encounter + // table cell boundaries? + Result 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
as a + // paragraph separator, just append a
. + // If the editing host parent element is editable, it means that the editing + // host must be a 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
element. + // XXX Currently, we don't support editing outside element, but Blink + // does it. + if (aEditingHost.GetParentElement() && + HTMLEditUtils::IsSimplyEditableNode(*aEditingHost.GetParentElement()) && + !nsContentUtils::ContentIsFlattenedTreeDescendantOf( + pointToInsert.ContainerAs(), &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
or the + // element cannot contain a

element, we should insert a
+ // 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
element. + if (HTMLEditUtils::IsSingleLineContainer(*aEditableBlockElement)) { + return false; + } + + // Otherwise, unless there is no block ancestor which can contain

+ // 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
simply. + RefPtr editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *pointToInsert.ContainerAs(), + HTMLEditUtils::ClosestEditableBlockElementOrButtonElement); + + // If we cannot insert a

element at the selection, we should insert + // a
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 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 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 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 blockElementToPutCaret; + // If the default paragraph separator is not
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, 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(); + 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(), + 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
+ Result 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 insertedPaddingBRElement; + if (HTMLEditUtils::IsEmptyBlockElement( + *editableBlockElement, + {EmptyCheckOption::TreatSingleBRElementAsVisible})) { + Result 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(); + if (NS_WARN_IF(!pointToInsert.IsInContentNode())) { + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + } + + RefPtr maybeNonEditableListItem = + HTMLEditUtils::GetClosestAncestorListItemElement(*editableBlockElement, + &aEditingHost); + if (maybeNonEditableListItem && + HTMLEditUtils::IsSplittableNode(*maybeNonEditableListItem)) { + Result 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 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 + 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

container and + //

container. However, we are still using
as default + // paragraph separator (non-standard) and we've split only

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
. Otherwise, take consistent behavior + // between

container and

container. + if ((separator == ParagraphSeparator::br && + editableBlockElement->IsHTMLElement(nsGkAtoms::p)) || + (separator != ParagraphSeparator::br && + editableBlockElement->IsAnyOfHTMLElements(nsGkAtoms::p, + nsGkAtoms::div))) { + // Paragraphs: special rules to look for
s + Result 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 rightParagraphElement = + unwrappedSplitNodeResult.DidSplit() + ? unwrappedSplitNodeResult.GetNextContentAs() + : 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
at the selection. + Result 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 HTMLEditor::HandleInsertBRElement( + const EditorDOMPoint& aPointToBreak, const Element& aEditingHost) { + MOZ_ASSERT(aPointToBreak.IsSet()); + MOZ_ASSERT(IsEditActionDataAvailable()); + + bool brElementIsAfterBlock = false, brElementIsBeforeBlock = false; + + // First, insert a
element. + RefPtr brElement; + if (IsInPlaintextMode()) { + Result 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
between the split links. + RefPtr linkNode = + HTMLEditor::GetLinkElement(pointToBreak.GetContainer()); + if (linkNode) { + Result 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(); + } + Result 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
element was removed by the web app"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + + if (brElementIsAfterBlock && brElementIsBeforeBlock) { + // We just placed a
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
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 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 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 = 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 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(), + *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 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 = + 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() + : pointToInsert; + } + + // Insert a padding
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
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 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 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 +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 { + 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(); + } + + if (NS_WARN_IF(!pointToSplit.IsInContentNode())) { + return Err(NS_ERROR_FAILURE); + } + + Result 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
to the end of left cite node if it was a 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
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(); + auto* const rightCiteElement = + unwrappedSplitCiteElementResult.GetNextContentAs(); + 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 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,
should be inserted after current cite. However, if + // left cite hasn't been created because the split point was start of the + // cite node,
should be inserted before the current cite. + Result insertBRElementResult = InsertBRElement( + WithTransaction::Yes, + unwrappedSplitCiteElementResult.AtSplitPoint()); + 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 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
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
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( + 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( + 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() != aEndToDelete.ContainerAs() || + (aEndToDelete.IsEndOfContainer() && followingCharPoint.IsSet()); + const bool maybeNormalizePrecedingWhiteSpaces = + !removingLastCharOfStartNode && precedingCharPoint.IsSet() && + !precedingCharPoint.IsEndOfContainer() && + precedingCharPoint.ContainerAs() == + aStartToDelete.ContainerAs() && + precedingCharPoint.IsCharCollapsibleASCIISpaceOrNBSP(); + const bool maybeNormalizeFollowingWhiteSpaces = + followingCharPoint.IsSet() && !followingCharPoint.IsEndOfContainer() && + (followingCharPoint.ContainerAs() == + aEndToDelete.ContainerAs() || + removingLastCharOfStartNode) && + followingCharPoint.IsCharCollapsibleASCIISpaceOrNBSP(); + + if (!maybeNormalizePrecedingWhiteSpaces && + !maybeNormalizeFollowingWhiteSpaces) { + return; // There are no white-spaces. + } + + // Next, consider the range to normalize. + EditorDOMPointInText startToNormalize, endToNormalize; + if (maybeNormalizePrecedingWhiteSpaces) { + Maybe previousCharOffsetOfWhiteSpaces = + HTMLEditUtils::GetPreviousNonCollapsibleCharOffset( + precedingCharPoint, {WalkTextOption::TreatNBSPsCollapsible}); + startToNormalize.Set(precedingCharPoint.ContainerAs(), + previousCharOffsetOfWhiteSpaces.isSome() + ? previousCharOffsetOfWhiteSpaces.value() + 1 + : 0); + MOZ_ASSERT(!startToNormalize.IsEndOfContainer()); + } + if (maybeNormalizeFollowingWhiteSpaces) { + Maybe nextCharOffsetOfWhiteSpaces = + HTMLEditUtils::GetInclusiveNextNonCollapsibleCharOffset( + followingCharPoint, {WalkTextOption::TreatNBSPsCollapsible}); + if (nextCharOffsetOfWhiteSpaces.isSome()) { + endToNormalize.Set(followingCharPoint.ContainerAs(), + nextCharOffsetOfWhiteSpaces.value()); + } else { + endToNormalize.SetToEndOf(followingCharPoint.ContainerAs()); + } + 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() == + aStartToDelete.ContainerAs()); + lengthInStartNode = aStartToDelete.Offset() - startToNormalize.Offset(); + MOZ_ASSERT(lengthInStartNode); + } + if (endToNormalize.IsSet()) { + lengthInEndNode = + endToNormalize.ContainerAs() == aEndToDelete.ContainerAs() + ? 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() == + aStartToDelete.ContainerAs()) { + 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 +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()); + } + + // 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() == aEndToDelete.ContainerAs()) { + newCaretPosition = aEndToDelete.To(); + } else if (aDeleteDirection == DeleteDirection::Forward) { + newCaretPosition.SetToEndOf(aStartToDelete.ContainerAs()); + } else { + newCaretPosition.Set(aEndToDelete.ContainerAs(), 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(), + endToDelete.Offset()); + { + AutoTrackDOMPoint trackEndToDelete(RangeUpdaterRef(), + &trackingEndToDelete); + uint32_t lengthToReplaceInFirstTextNode = + startToDelete.ContainerAs() == + trackingEndToDelete.ContainerAs() + ? trackingEndToDelete.Offset() - startToDelete.Offset() + : startToDelete.ContainerAs()->TextLength() - + startToDelete.Offset(); + Result replaceTextResult = + ReplaceTextWithTransaction( + MOZ_KnownLive(*startToDelete.ContainerAs()), + 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() == + trackingEndToDelete.ContainerAs()) { + 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(), + trackingEndToDelete.Offset()); + // If the remaining range was modified by mutation event listener, + // we should stop handling the deletion. + startToDelete = + EditorDOMPointInText::AtEndOf(*startToDelete.ContainerAs()); + 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() != endToDelete.ContainerAs()) { + // 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(), 0); + if (startToDelete != endToDeleteExceptReplaceRange) { + Result 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() == + endToDelete.ContainerAs()); + Result replaceTextResult = + ReplaceTextWithTransaction( + MOZ_KnownLive(*startToDelete.ContainerAs()), + 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(), + 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 caretPointOrError = + InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( + newCaretPosition); + if (MOZ_UNLIKELY(caretPointOrError.isErr())) { + NS_WARNING( + "HTMLEditor::" + "InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary() failed"); + return caretPointOrError; + } + } + if (!newCaretPosition.IsSetAndValid()) { + NS_WARNING("Inserting
element caused unexpected DOM tree"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + return CaretPoint(std::move(newCaretPosition)); +} + +Result +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 + // `
` element here. + if (!HTMLEditUtils::IsBlockElement( + *aPointToInsert.ContainerAs())) { + return CaretPoint(EditorDOMPoint()); + } + + WSRunScanner wsRunScanner(ComputeEditingHost(), aPointToInsert); + // If the point is not start of a hard line, we don't need to put a `
` + // 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 `
` element here. + if (!wsRunScanner.EndsByBlockBoundary()) { + return CaretPoint(EditorDOMPoint()); + } + + // If we cannot insert a `
` element here, do nothing. + if (!HTMLEditUtils::CanNodeContain(*aPointToInsert.GetContainer(), + *nsGkAtoms::br)) { + return CaretPoint(EditorDOMPoint()); + } + + Result 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 +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 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 + // `

` or `

` 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 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 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 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 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
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, 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, 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 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(*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 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 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& content : aArrayOfContents) { + // if content is not a
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, nsresult> +HTMLEditor::AutoListElementCreator::ReplaceContentNodesWithEmptyNewList( + HTMLEditor& aHTMLEditor, const AutoRangeArray& aRanges, + const AutoContentNodeArray& aArrayOfContents, + const Element& aEditingHost) const { + // if only breaks, delete them + for (const OwningNonNull& 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(); + 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(); + } + + RefPtr newListItemElement; + Result 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 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, 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(*deepestDivBlockquoteOrListElement)); + } + } + } + + // Ok, now go through all the nodes and put then in the list, + // or whatever is appropriate. Wohoo! + AutoHandlingState handlingState; + for (const OwningNonNull& 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 `
` 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

or a

, 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 = + aHTMLEditor.MoveNodeToEndWithTransaction( + aHandlingListElement, MOZ_KnownLive(*aState.mCurrentListElement)); + if (MOZ_UNLIKELY(moveNodeResult.isErr())) { + NS_WARNING("HTMLEditor::MoveNodeToEndWithTransaction() failed"); + return moveNodeResult.propagateErr(); + } + moveNodeResult.inspect().IgnoreCaretPointSuggestion(); + + Result convertListTypeResult = + aHTMLEditor.ChangeListElementType(aHandlingListElement, mListTagName, + mListItemTagName); + if (MOZ_UNLIKELY(convertListTypeResult.isErr())) { + NS_WARNING("HTMLEditor::ChangeListElementType() failed"); + return convertListTypeResult.propagateErr(); + } + convertListTypeResult.inspect().IgnoreCaretPointSuggestion(); + + Result 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 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 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 createNewListElementResult = + aHTMLEditor.CreateAndInsertElement( + WithTransaction::Yes, mListTagName, + unwrappedSplitListItemParentResult.AtNextContent()); + 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 = + 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 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(); + 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 = + 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 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> previouslyReplacingBlockElement( + aState.mReplacingBlockElement); + aState.mReplacingBlockElement = &aHandlingDivOrParagraphElement; + AutoRestore previouslyReplacingBlockElementIdCopied( + aState.mMaybeCopiedReplacingBlockElementId); + aState.mMaybeCopiedReplacingBlockElementId = false; + + // If the

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 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

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 unwrapDivElementResult = + aHTMLEditor.RemoveContainerWithTransaction( + aHandlingDivOrParagraphElement); + if (MOZ_UNLIKELY(unwrapDivElementResult.isErr())) { + NS_WARNING("HTMLEditor::RemoveContainerWithTransaction() failed"); + return unwrapDivElementResult.unwrapErr(); + } + + for (const OwningNonNull& 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 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 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 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 +HTMLEditor::AutoListElementCreator::AppendListItemElement( + HTMLEditor& aHTMLEditor, const Element& aListElement, + AutoHandlingState& aState) const { + const WithTransaction withTransaction = aListElement.IsInComposedDoc() + ? WithTransaction::Yes + : WithTransaction::No; + Result 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 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 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 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(); + if (MOZ_UNLIKELY(!firstRangeStartPoint.IsSet())) { + return NS_OK; + } + Result 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 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 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, 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 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 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& 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, 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 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, 64> arrayOfContents; + aSelectionRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eCreateOrRemoveBlock, aEditingHost); + Result 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 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(); + 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 editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *pointToInsertBlock.ContainerAs(), + HTMLEditUtils::ClosestEditableBlockElement); + if (!editableBlockElement) { + NS_WARNING( + "HTMLEditor::FormatBlockContainerWithTransaction() couldn't find " + "block parent"); + return Err(NS_ERROR_FAILURE); + } + if (!HTMLEditUtils::IsFormatNode(editableBlockElement)) { + return RefPtr(); + } + + // 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 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 = + 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
element at the split point + Result insertBRElementResult = + InsertBRElement( + WithTransaction::Yes, + unwrappedSplitNodeResult.AtSplitPoint()); + 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(); + } + + // We are making a block. Consume a br, if needed. + if (nsCOMPtr 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 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& 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 + 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 removeBlockContainerElementsResult = + RemoveBlockContainerElementsWithTransaction(arrayOfContents); + if (MOZ_UNLIKELY(removeBlockContainerElementsResult.isErr())) { + NS_WARNING( + "HTMLEditor::RemoveBlockContainerElementsWithTransaction() failed"); + return removeBlockContainerElementsResult.propagateErr(); + } + return RefPtr(); + } + Result 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 startContainerElement = + *atStartOfSelection.Container()->AsElement(); + nsresult rv = + InsertPaddingBRElementForEmptyLastLineIfNeeded(startContainerElement); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rv), + "HTMLEditor::InsertPaddingBRElementForEmptyLastLineIfNeeded() failed"); + return rv; +} + +Result 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 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 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 `
` 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 HTMLEditor::IndentListChildWithTransaction( + RefPtr* 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 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 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 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 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 subListElement = *aSubListElement; + Result 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 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 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, 64> arrayOfContents; + + // short circuit: detect case of collapsed selection inside an

. + // just sublist that

. This prevents bug 97797. + + if (aRanges.IsCollapsed()) { + const auto atCaret = aRanges.GetFirstRangeStartPoint(); + if (NS_WARN_IF(!atCaret.IsSet())) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(atCaret.IsInContentNode()); + Element* const editableBlockElement = + HTMLEditUtils::GetInclusiveAncestorElement( + *atCaret.ContainerAs(), + HTMLEditUtils::ClosestEditableBlockElement); + if (editableBlockElement && + HTMLEditUtils::IsListItem(editableBlockElement)) { + arrayOfContents.AppendElement(*editableBlockElement); + } + } + + EditorDOMPoint pointToPutCaret; + if (arrayOfContents.IsEmpty()) { + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eIndent, aEditingHost); + Result 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 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(); + if (NS_WARN_IF(!pointToInsertDivElement.IsSet())) { + return NS_ERROR_FAILURE; + } + + // make sure we can put a block here + Result 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 newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + MOZ_ASSERT(newDivElement); + const Result 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& 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 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(); + if (MOZ_UNLIKELY(!firstRangeStartRawPoint.IsSet())) { + return NS_OK; + } + Result 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

elements which have start margin. + RefPtr subListElement, divElement; + for (OwningNonNull& 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 oldSubListElement = subListElement; + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result 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 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 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 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

which has start margin. + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result 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 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, 64> arrayOfContents; + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eIndent, aEditingHost); + Result 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 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(); + if (NS_WARN_IF(!pointToInsertBlockquoteElement.IsSet())) { + return NS_ERROR_FAILURE; + } + + // Make sure we can put a block here. + Result 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 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& 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 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(); + if (MOZ_UNLIKELY(!firstRangeStartRawPoint.IsSet())) { + return NS_OK; + } + Result 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 subListElement, blockquoteElement, indentedListItemElement; + for (OwningNonNull& 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 oldSubListElement = subListElement; + // MOZ_KnownLive because 'arrayOfContents' is guaranteed to + // keep it alive. + Result 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 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 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 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

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 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 = + 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 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 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 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 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 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 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 +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, 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 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 leftContentOfLastOutdented; + nsCOMPtr middleContentOfLastOutdented; + nsCOMPtr rightContentOfLastOutdented; + RefPtr indentedParentElement; + nsCOMPtr firstContentToBeOutdented, lastContentToBeOutdented; + BlockIndentedWith indentedParentIndentedWith = BlockIndentedWith::HTML; + for (OwningNonNull& content : arrayOfContents) { + // Here's where we actually figure out what to do + EditorDOMPoint atContent(content); + if (!atContent.IsSet()) { + continue; + } + + // If it's a `

`, 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

"); + Result 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 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 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 unit; + CSSEditUtils::ParseLength(value, &startMargin, getter_AddRefs(unit)); + // If indented with CSS, we should decrease the start margin. + if (startMargin > 0) { + const Result 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 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 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 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 `

` 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 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 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 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., `

` as its + // list item element. + if (HTMLEditUtils::IsAnyListElement(atContent.GetContainer())) { + if (!HTMLEditUtils::IsAnyListElement(content)) { + continue; + } + // Just unwrap this sublist + Result 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 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 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 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 = content->GetAsElementOrParentElement()) { + const Result 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

we haven't finished handling. + Result 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 +HTMLEditor::RemoveBlockContainerElementWithTransactionBetween( + Element& aBlockContainerElement, nsIContent& aStartOfRange, + nsIContent& aEndOfRange) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + EditorDOMPoint pointToPutCaret; + Result 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(); + 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 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 +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 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() + : &aBlockElement; + // MOZ_KnownLive(rightElement) because it's grabbed by splitAtStartResult or + // aBlockElement whose lifetime is guaranteed by the caller. + Result 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 HTMLEditor::OutdentPartOfBlock( + Element& aBlockElement, nsIContent& aStartOfOutdent, + nsIContent& aEndOfOutdent, BlockIndentedWith aBlockIndentedWith, + const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + Result 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(); + 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 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 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 HTMLEditor::ChangeListElementType( + Element& aListElement, nsAtom& aNewListTag, nsAtom& aNewListItemTag) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + EditorDOMPoint pointToPutCaret; + + AutoTArray, 32> listElementChildren; + HTMLEditUtils::CollectAllChildren(aListElement, listElementChildren); + + for (const OwningNonNull& 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 + 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 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 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 HTMLEditor::CreateStyleForInsertText( + const EditorDOMPoint& aPointToInsertText, const Element& aEditingHost) { + MOZ_ASSERT(IsEditActionDataAvailable()); + MOZ_ASSERT(aPointToInsertText.IsSetAndValid()); + MOZ_ASSERT(mPendingStylesToApplyToNewContent); + + const RefPtr documentRootElement = GetDocument()->GetRootElement(); + if (NS_WARN_IF(!documentRootElement)) { + return Err(NS_ERROR_FAILURE); + } + + // process clearing any styles first + UniquePtr 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 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 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 splitTextNodeResult = + SplitNodeDeepWithTransaction( + MOZ_KnownLive(*pointToInsertTextNode.ContainerAs()), + 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(); + } + if (!pointToInsertTextNode.IsInContentNode() || + !HTMLEditUtils::IsContainerNode( + *pointToInsertTextNode.ContainerAs())) { + return pointToPutCaret; + } + RefPtr newEmptyTextNode = CreateTextNode(u""_ns); + if (!newEmptyTextNode) { + NS_WARNING("EditorBase::CreateTextNode() failed"); + return Err(NS_ERROR_FAILURE); + } + Result insertNewTextNodeResult = + InsertNodeWithTransaction(*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 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 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()) because pointToPutCaret + // grabs the result. + Result setStyleResult = + inlineStyleSetter.ApplyStyleToNodeOrChildrenAndRemoveNestedSameStyle( + *this, MOZ_KnownLive(*pointToPutCaret.ContainerAs())); + 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( + *container->AsContent()); + if (NS_WARN_IF(!pointToPutCaret.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + return pointToPutCaret; +} + +Result 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 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 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, 64> arrayOfContents; + { + AutoRangeArray extendedRanges(aRanges); + extendedRanges.ExtendRangesToWrapLinesToHandleBlockLevelEditAction( + EditSubAction::eSetOrClearAlignment, aEditingHost); + Result 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 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& 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 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 + // `
` 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 + // ``. 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(); + 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(); + Result 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 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

element, + // we should move caret into the

. + if (maybeCreateDivElementResult.inspect().GetNewNode() && + aRanges.IsCollapsed() && !aRanges.Ranges().IsEmpty()) { + const auto firstRangeStartRawPoint = + aRanges.GetFirstRangeStartPoint(); + if (MOZ_LIKELY(firstRangeStartRawPoint.IsSet())) { + Result 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 +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 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

, so we don't need the suggested + // position. + unwrappedCreateNewDivElementResult.IgnoreCaretPointSuggestion(); + + MOZ_ASSERT(unwrappedCreateNewDivElementResult.GetNewNode()); + RefPtr newDivElement = + unwrappedCreateNewDivElementResult.UnwrapNewNode(); + // Set up the alignment on the div, using HTML or CSS + Result 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
element for empty last line so that it won't get + // deleted. + { + Result 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 HTMLEditor::AlignNodesAndDescendants( + nsTArray>& 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 transitionList; + HTMLEditor::MakeTransitionList(aArrayOfContents, transitionList); + + RefPtr 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 createdDivElement; + const bool useCSS = IsCSSEnabled(); + int32_t indexOfTransitionList = -1; + for (OwningNonNull& 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 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 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 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 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 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 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 = + 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 +HTMLEditor::AlignContentsInAllTableCellsAndListItems( + Element& aElement, const nsAString& aAlignType) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // Gather list of table cells or list items + AutoTArray, 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 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 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 `

` element. + nsCOMPtr 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 `

` element, + // just set `align` attribute of it. + nsCOMPtr 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 `

` element to set `align` attribute. + // XXX Don't insert the new `

` element until we set `align` attribute + // for avoiding running mutation event listeners. + Result 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 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 = 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 +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 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 +already_AddRefed HTMLEditor::CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMRangeType& aRange) { + MOZ_DIAGNOSTIC_ASSERT(aRange.IsPositioned()); + return CreateRangeIncludingAdjuscentWhiteSpaces(aRange.StartRef(), + aRange.EndRef()); +} + +template +already_AddRefed 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 endPoint = aEndPoint.template To(); + 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 range = + nsRange::Create(startPoint.ToRawRangeBoundary(), + endPoint.ToRawRangeBoundary(), IgnoreErrors()); + NS_WARNING_ASSERTION(range, "nsRange::Create() failed"); + return range.forget(); +} + +Result HTMLEditor::MaybeSplitElementsAtEveryBRElement( + nsTArray>& 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& content = aArrayOfContents[i]; + if (HTMLEditUtils::IsInlineElement(content) && + HTMLEditUtils::IsContainerNode(content) && !content->IsText()) { + AutoTArray, 24> arrayOfInlineContents; + // MOZ_KnownLive because 'aArrayOfContents' is guaranteed to keep it + // alive. + Result 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 +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 mostAncestorInlineContentAtEnd = + HTMLEditUtils::GetMostDistantAncestorInlineElement( + *aRangeItem.mEndContainer->AsContent(), &aEditingHost, + aAncestorLimiter); + + if (mostAncestorInlineContentAtEnd) { + Result 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()))) { + NS_WARNING( + "HTMLEditor::SplitNodeDeepWithTransaction(SplitAtEdges::" + "eDoNotCreateEmptyContainer) caused changing editing host"); + return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE); + } + const auto splitPointAtEnd = + unwrappedSplitEndInlineResult.AtSplitPoint(); + 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 mostAncestorInlineContentAtStart = + HTMLEditUtils::GetMostDistantAncestorInlineElement( + *aRangeItem.mStartContainer->AsContent(), &aEditingHost, + aAncestorLimiter); + + if (mostAncestorInlineContentAtStart) { + Result 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(); + 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 HTMLEditor::SplitElementsAtEveryBRElement( + nsIContent& aMostAncestorToBeSplit, + nsTArray>& aOutArrayOfContents) { + MOZ_ASSERT(IsEditActionDataAvailable()); + + // First build up a list of all the break nodes inside the inline container. + AutoTArray, 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 nextContent = &aMostAncestorToBeSplit; + EditorDOMPoint pointToPutCaret; + for (OwningNonNull& brElement : arrayOfBRElements) { + EditorDOMPoint atBRNode(brElement); + if (NS_WARN_IF(!atBRNode.IsSet())) { + return Err(NS_ERROR_FAILURE); + } + Result 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 moveBRElementResult = + MoveNodeWithTransaction( + MOZ_KnownLive(brElement), + unwrappedSplitNodeResult.AtNextContent()); + 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>& aArrayOfContents, + nsTArray& 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 +HTMLEditor::HandleInsertParagraphInHeadingElement( + Element& aHeadingElement, const EditorDOMPoint& aPointToSplit) { + MOZ_ASSERT(IsTopLevelEditSubActionDataAvailable()); + + auto splitHeadingResult = + [this, &aPointToSplit, &aHeadingElement]() + MOZ_CAN_RUN_SCRIPT -> Result { + // 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 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 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
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(); + 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 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(); + 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
element here is odd because non-editable + //
elements also work as
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
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
element. + nsStaticAtom& newParagraphTagName = + &DefaultParagraphSeparatorTagName() == nsGkAtoms::br + ? *nsGkAtoms::p + : DefaultParagraphSeparatorTagName(); + // We want a wrapper element even if we separate with a
. + // MOZ_KnownLive(newParagraphTagName) because it's available until shutdown. + Result 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
element in the following paragraph. + unwrappedCreateNewParagraphElementResult.IgnoreCaretPointSuggestion(); + MOZ_ASSERT(unwrappedCreateNewParagraphElementResult.GetNewNode()); + EditorDOMPoint pointToPutCaret( + unwrappedCreateNewParagraphElementResult.GetNewNode(), 0u); + return InsertParagraphResult( + unwrappedCreateNewParagraphElementResult.UnwrapNewNode(), + std::move(pointToPutCaret)); +} + +Result 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., |foo [] | + if (aCandidatePointToSplit.IsStartOfContainer()) { + EditorDOMPoint candidatePoint(aCandidatePointToSplit); + for (nsIContent* container = + aCandidatePointToSplit.GetContainerAs(); + 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
element? + break; + } + } + return candidatePoint; + } + + // We also need to check if selection is at invisible
element at end + // of an element because editor inserts a
element when + // user types Enter key after a white-space which is at middle of + // element and when setting selection at end of the element, + // selection becomes referring the
element. We may need to change this + // behavior later if it'd be standardized. + if (aCandidatePointToSplit.IsEndOfContainer() || + aCandidatePointToSplit.IsBRElementAtEndOfContainer()) { + // If there are 2
elements, the first
element is visible. E.g., + // |boo[]

|, we should split the + // element. Otherwise, E.g., |boo[]
|, + // we should not split the element and ignore inline elements in it. + bool foundBRElement = + aCandidatePointToSplit.IsBRElementAtEndOfContainer(); + EditorDOMPoint candidatePoint(aCandidatePointToSplit); + for (nsIContent* container = + aCandidatePointToSplit.GetContainerAs(); + 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
element, we assume found node is + // visible
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 brElement; + if (createNewParagraph && pointToSplit.GetContainer() == &aParentDivOrP) { + // We are try to split only the current paragraph. Therefore, we don't need + // to create new
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
element, we need to create a
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(), + {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 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
element, we need to create a
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(), + {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()); + MOZ_ASSERT(pointToInsertBR.IsSet()); + Result 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
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
element. + + // XXX We split a text node here if caret is middle of it to insert + //
element **before** splitting aParentDivOrP. Then, if + // the
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 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 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
after the left node if given node was split + // above. + const auto pointToInsertBR = + EditorDOMPoint::After(*pointToSplit.ContainerAs