Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 399 insertions, 0 deletions

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<nsRange> 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<nsIContent>()));
+      }
+
+      // 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<EditTransactionBase>& 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<Text>()) {
+    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 =
+        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 =
+        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<Text>();
+  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 =
+      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 =
+        DeleteNodeTransaction::MaybeCreate(*mEditorBase, *node->AsContent());
+    if (deleteNodeTransaction) {
+      AppendChild(*deleteNodeTransaction);
+    }
+  }
+  return NS_OK;
+}
+
+}  // namespace mozilla