From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- editor/libeditor/DeleteRangeTransaction.cpp | 399 ++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 editor/libeditor/DeleteRangeTransaction.cpp (limited to 'editor/libeditor/DeleteRangeTransaction.cpp') diff --git a/editor/libeditor/DeleteRangeTransaction.cpp b/editor/libeditor/DeleteRangeTransaction.cpp new file mode 100644 index 0000000000..6262f31fd0 --- /dev/null +++ b/editor/libeditor/DeleteRangeTransaction.cpp @@ -0,0 +1,399 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DeleteRangeTransaction.h" + +#include "DeleteContentTransactionBase.h" +#include "DeleteNodeTransaction.h" +#include "DeleteTextTransaction.h" +#include "EditTransactionBase.h" +#include "EditorBase.h" +#include "EditorDOMPoint.h" +#include "EditorUtils.h" +#include "HTMLEditUtils.h" + +#include "mozilla/Assertions.h" +#include "mozilla/ContentIterator.h" +#include "mozilla/Logging.h" +#include "mozilla/mozalloc.h" +#include "mozilla/RangeBoundary.h" +#include "mozilla/StaticPrefs_editor.h" +#include "mozilla/ToString.h" +#include "mozilla/dom/Selection.h" + +#include "nsAtom.h" +#include "nsCOMPtr.h" +#include "nsDebug.h" +#include "nsError.h" +#include "nsGkAtoms.h" +#include "nsIContent.h" +#include "nsINode.h" +#include "nsAString.h" + +namespace mozilla { + +using namespace dom; + +using EditorType = EditorUtils::EditorType; + +DeleteRangeTransaction::DeleteRangeTransaction(EditorBase& aEditorBase, + const nsRange& aRangeToDelete) + : mEditorBase(&aEditorBase), mRangeToDelete(aRangeToDelete.CloneRange()) {} + +NS_IMPL_CYCLE_COLLECTION_INHERITED(DeleteRangeTransaction, + EditAggregateTransaction, mEditorBase, + mRangeToDelete, mPointToPutCaret) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction) +NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction) + +void DeleteRangeTransaction::AppendChild( + DeleteContentTransactionBase& aTransaction) { + mChildren.AppendElement(aTransaction); +} + +nsresult +DeleteRangeTransaction::MaybeExtendDeletingRangeWithSurroundingWhitespace( + nsRange& aRange) const { + if (!mEditorBase->mEditActionData->SelectionCreatedByDoubleclick() || + !StaticPrefs:: + editor_word_select_delete_space_after_doubleclick_selection()) { + return NS_OK; + } + EditorRawDOMPoint startPoint(aRange.StartRef()); + EditorRawDOMPoint endPoint(aRange.EndRef()); + const bool maybeRangeStartsAfterWhiteSpace = + startPoint.IsInTextNode() && !startPoint.IsStartOfContainer(); + const bool maybeRangeEndsAtWhiteSpace = + endPoint.IsInTextNode() && !endPoint.IsEndOfContainer(); + + if (!maybeRangeStartsAfterWhiteSpace && !maybeRangeEndsAtWhiteSpace) { + // no whitespace before or after word => nothing to do here. + return NS_OK; + } + + const bool precedingCharIsWhitespace = + maybeRangeStartsAfterWhiteSpace + ? startPoint.IsPreviousCharASCIISpaceOrNBSP() + : false; + const bool trailingCharIsWhitespace = + maybeRangeEndsAtWhiteSpace ? endPoint.IsCharASCIISpaceOrNBSP() : false; + + // if possible, try to remove the preceding whitespace + // so the caret is at the end of the previous word. + if (precedingCharIsWhitespace) { + // "one [two]", "one [two] three" or "one [two], three" + ErrorResult err; + aRange.SetStart(startPoint.PreviousPoint(), err); + if (auto rv = err.StealNSResult(); NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "MaybeExtendDeletingRangeWithSurroundingWhitespace" + " failed to update the start of the deleting range"); + return rv; + } + } else if (trailingCharIsWhitespace) { + // "[one] two" + ErrorResult err; + aRange.SetEnd(endPoint.NextPoint(), err); + if (auto rv = err.StealNSResult(); NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "MaybeExtendDeletingRangeWithSurroundingWhitespace" + " failed to update the end of the deleting range"); + return rv; + } + } + + return NS_OK; +} + +NS_IMETHODIMP DeleteRangeTransaction::DoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + if (NS_WARN_IF(!mEditorBase) || NS_WARN_IF(!mRangeToDelete)) { + return NS_ERROR_NOT_AVAILABLE; + } + + // Swap mRangeToDelete out into a stack variable, so we make sure to null it + // out on return from this function. Once this function returns, we no longer + // need mRangeToDelete, and keeping it alive in the long term slows down all + // DOM mutations because it's observing them. + RefPtr rangeToDelete; + rangeToDelete.swap(mRangeToDelete); + + MaybeExtendDeletingRangeWithSurroundingWhitespace(*rangeToDelete); + + // build the child transactions + // XXX We should move this to the constructor. Then, we don't need to make + // this class has mRangeToDelete with nullptr since transaction instances + // may be created a lot and live long. + { + EditorRawDOMRange extendedRange(*rangeToDelete); + MOZ_ASSERT(extendedRange.IsPositionedAndValid()); + + if (extendedRange.InSameContainer()) { + // the selection begins and ends in the same node + nsresult rv = AppendTransactionsToDeleteIn(extendedRange); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionsToDeleteIn() failed"); + return rv; + } + } else { + // If the range ends at end of a node, we may need to extend the range to + // make ContentSubtreeIterator iterates close tag of the unnecessary nodes + // in AppendTransactionsToDeleteNodesEntirelyIn. + for (EditorRawDOMPoint endOfRange = extendedRange.EndRef(); + endOfRange.IsInContentNode() && endOfRange.IsEndOfContainer() && + endOfRange.GetContainer() != extendedRange.StartRef().GetContainer(); + endOfRange = extendedRange.EndRef()) { + extendedRange.SetEnd( + EditorRawDOMPoint::After(*endOfRange.ContainerAs())); + } + + // the selection ends in a different node from where it started. delete + // the relevant content in the start node + nsresult rv = AppendTransactionToDeleteText(extendedRange.StartRef(), + nsIEditor::eNext); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionToDeleteText() failed"); + return rv; + } + // delete the intervening nodes + rv = AppendTransactionsToDeleteNodesWhoseEndBoundaryIn(extendedRange); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "AppendTransactionsToDeleteNodesWhoseEndBoundaryIn() failed"); + return rv; + } + // delete the relevant content in the end node + rv = AppendTransactionToDeleteText(extendedRange.EndRef(), + nsIEditor::ePrevious); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionToDeleteText() failed"); + return rv; + } + } + } + + // if we've successfully built this aggregate transaction, then do it. + nsresult rv = EditAggregateTransaction::DoTransaction(); + if (NS_FAILED(rv)) { + NS_WARNING("EditAggregateTransaction::DoTransaction() failed"); + return rv; + } + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + mPointToPutCaret = rangeToDelete->StartRef(); + if (MOZ_UNLIKELY(!mPointToPutCaret.IsSetAndValid())) { + for (const OwningNonNull& transaction : + Reversed(mChildren)) { + if (const DeleteContentTransactionBase* deleteContentTransaction = + transaction->GetAsDeleteContentTransactionBase()) { + mPointToPutCaret = deleteContentTransaction->SuggestPointToPutCaret(); + if (mPointToPutCaret.IsSetAndValid()) { + break; + } + continue; + } + MOZ_ASSERT_UNREACHABLE( + "Child transactions must be DeleteContentTransactionBase"); + } + } + return NS_OK; +} + +NS_IMETHODIMP DeleteRangeTransaction::UndoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + nsresult rv = EditAggregateTransaction::UndoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::UndoTransaction() failed"); + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + return rv; +} + +NS_IMETHODIMP DeleteRangeTransaction::RedoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + nsresult rv = EditAggregateTransaction::RedoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::RedoTransaction() failed"); + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + return rv; +} + +nsresult DeleteRangeTransaction::AppendTransactionsToDeleteIn( + const EditorRawDOMRange& aRangeToDelete) { + if (NS_WARN_IF(!aRangeToDelete.IsPositionedAndValid())) { + return NS_ERROR_INVALID_ARG; + } + MOZ_ASSERT(aRangeToDelete.InSameContainer()); + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + // see what kind of node we have + if (Text* textNode = aRangeToDelete.StartRef().GetContainerAs()) { + if (mEditorBase->IsHTMLEditor() && + NS_WARN_IF( + !EditorUtils::IsEditableContent(*textNode, EditorType::HTML))) { + // Just ignore to append the transaction for non-editable node. + return NS_OK; + } + // if the node is a chardata node, then delete chardata content + uint32_t textLengthToDelete; + if (aRangeToDelete.Collapsed()) { + textLengthToDelete = 1; + } else { + textLengthToDelete = + aRangeToDelete.EndRef().Offset() - aRangeToDelete.StartRef().Offset(); + MOZ_DIAGNOSTIC_ASSERT(textLengthToDelete > 0); + } + + RefPtr deleteTextTransaction = + DeleteTextTransaction::MaybeCreate(*mEditorBase, *textNode, + aRangeToDelete.StartRef().Offset(), + textLengthToDelete); + // If the text node isn't editable, it should be never undone/redone. + // So, the transaction shouldn't be recorded. + if (!deleteTextTransaction) { + NS_WARNING("DeleteTextTransaction::MaybeCreate() failed"); + return NS_ERROR_FAILURE; + } + AppendChild(*deleteTextTransaction); + return NS_OK; + } + + MOZ_ASSERT(mEditorBase->IsHTMLEditor()); + + // Even if we detect invalid range, we should ignore it for removing + // specified range's nodes as far as possible. + // XXX This is super expensive. Probably, we should make + // DeleteNodeTransaction() can treat multiple siblings. + for (nsIContent* child = aRangeToDelete.StartRef().GetChild(); + child && child != aRangeToDelete.EndRef().GetChild(); + child = child->GetNextSibling()) { + if (NS_WARN_IF(!HTMLEditUtils::IsRemovableNode(*child))) { + continue; // Should we abort? + } + RefPtr deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *child); + if (deleteNodeTransaction) { + AppendChild(*deleteNodeTransaction); + } + } + + return NS_OK; +} + +nsresult DeleteRangeTransaction::AppendTransactionToDeleteText( + const EditorRawDOMPoint& aMaybePointInText, nsIEditor::EDirection aAction) { + if (NS_WARN_IF(!aMaybePointInText.IsSetAndValid())) { + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + if (!aMaybePointInText.IsInTextNode()) { + return NS_OK; + } + + // If the node is a text node, then delete text before or after the point. + Text& textNode = *aMaybePointInText.ContainerAs(); + uint32_t startOffset, numToDelete; + if (nsIEditor::eNext == aAction) { + startOffset = aMaybePointInText.Offset(); + numToDelete = textNode.TextDataLength() - startOffset; + } else { + startOffset = 0; + numToDelete = aMaybePointInText.Offset(); + } + + if (!numToDelete) { + return NS_OK; + } + + RefPtr deleteTextTransaction = + DeleteTextTransaction::MaybeCreate(*mEditorBase, textNode, startOffset, + numToDelete); + // If the text node isn't editable, it should be never undone/redone. + // So, the transaction shouldn't be recorded. + if (MOZ_UNLIKELY(!deleteTextTransaction)) { + NS_WARNING("DeleteTextTransaction::MaybeCreate() failed"); + return NS_ERROR_FAILURE; + } + AppendChild(*deleteTextTransaction); + return NS_OK; +} + +nsresult +DeleteRangeTransaction::AppendTransactionsToDeleteNodesWhoseEndBoundaryIn( + const EditorRawDOMRange& aRangeToDelete) { + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + ContentSubtreeIterator subtreeIter; + nsresult rv = subtreeIter.Init(aRangeToDelete.StartRef().ToRawRangeBoundary(), + aRangeToDelete.EndRef().ToRawRangeBoundary()); + if (NS_FAILED(rv)) { + NS_WARNING("ContentSubtreeIterator::Init() failed"); + return rv; + } + + for (; !subtreeIter.IsDone(); subtreeIter.Next()) { + nsINode* node = subtreeIter.GetCurrentNode(); + if (NS_WARN_IF(!node) || NS_WARN_IF(!node->IsContent())) { + return NS_ERROR_FAILURE; + } + + if (NS_WARN_IF(!HTMLEditUtils::IsRemovableNode(*node->AsContent()))) { + continue; + } + RefPtr deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *node->AsContent()); + if (deleteNodeTransaction) { + AppendChild(*deleteNodeTransaction); + } + } + return NS_OK; +} + +} // namespace mozilla -- cgit v1.2.3