Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 591 insertions, 0 deletions

diff --git a/editor/libeditor/SelectionState.h b/editor/libeditor/SelectionState.h
new file mode 100644
index 0000000000..d62f2a7e7b
--- /dev/null
+++ b/editor/libeditor/SelectionState.h
@@ -0,0 +1,591 @@
+/* -*- 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/. */
+
+#ifndef mozilla_SelectionState_h
+#define mozilla_SelectionState_h
+
+#include "mozilla/EditorDOMPoint.h"
+#include "mozilla/EditorForwards.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/OwningNonNull.h"
+#include "nsCOMPtr.h"
+#include "nsDirection.h"
+#include "nsINode.h"
+#include "nsRange.h"
+#include "nsTArray.h"
+#include "nscore.h"
+
+class nsCycleCollectionTraversalCallback;
+class nsRange;
+namespace mozilla {
+namespace dom {
+class Element;
+class Selection;
+class Text;
+}  // namespace dom
+
+/**
+ * A helper struct for saving/setting ranges.
+ */
+struct RangeItem final {
+  RangeItem() : mStartOffset(0), mEndOffset(0) {}
+
+ private:
+  // Private destructor, to discourage deletion outside of Release():
+  ~RangeItem() = default;
+
+ public:
+  void StoreRange(const nsRange& aRange);
+  void StoreRange(const EditorRawDOMPoint& aStartPoint,
+                  const EditorRawDOMPoint& aEndPoint) {
+    MOZ_ASSERT(aStartPoint.IsSet());
+    MOZ_ASSERT(aEndPoint.IsSet());
+    mStartContainer = aStartPoint.GetContainer();
+    mStartOffset = aStartPoint.Offset();
+    mEndContainer = aEndPoint.GetContainer();
+    mEndOffset = aEndPoint.Offset();
+  }
+  void Clear() {
+    mStartContainer = mEndContainer = nullptr;
+    mStartOffset = mEndOffset = 0;
+  }
+  already_AddRefed<nsRange> GetRange() const;
+
+  // Same as the API of dom::AbstractRange
+  [[nodiscard]] nsINode* GetRoot() const;
+  [[nodiscard]] bool Collapsed() const {
+    return mStartContainer == mEndContainer && mStartOffset == mEndOffset;
+  }
+  [[nodiscard]] bool IsPositioned() const {
+    return mStartContainer && mEndContainer;
+  }
+  [[nodiscard]] bool Equals(const RangeItem& aOther) const {
+    return mStartContainer == aOther.mStartContainer &&
+           mEndContainer == aOther.mEndContainer &&
+           mStartOffset == aOther.mStartOffset &&
+           mEndOffset == aOther.mEndOffset;
+  }
+  template <typename EditorDOMPointType = EditorDOMPoint>
+  EditorDOMPointType StartPoint() const {
+    return EditorDOMPointType(mStartContainer, mStartOffset);
+  }
+  template <typename EditorDOMPointType = EditorDOMPoint>
+  EditorDOMPointType EndPoint() const {
+    return EditorDOMPointType(mEndContainer, mEndOffset);
+  }
+
+  NS_INLINE_DECL_MAIN_THREAD_ONLY_CYCLE_COLLECTING_NATIVE_REFCOUNTING(RangeItem)
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(RangeItem)
+
+  nsCOMPtr<nsINode> mStartContainer;
+  nsCOMPtr<nsINode> mEndContainer;
+  uint32_t mStartOffset;
+  uint32_t mEndOffset;
+};
+
+/**
+ * mozilla::SelectionState
+ *
+ * Class for recording selection info.  Stores selection as collection of
+ * { {startnode, startoffset} , {endnode, endoffset} } tuples.  Can't store
+ * ranges since dom gravity will possibly change the ranges.
+ */
+
+class SelectionState final {
+ public:
+  SelectionState() = default;
+  explicit SelectionState(const AutoRangeArray& aRanges);
+
+  /**
+   * Same as the API as dom::Selection
+   */
+  [[nodiscard]] bool IsCollapsed() const {
+    if (mArray.Length() != 1) {
+      return false;
+    }
+    return mArray[0]->Collapsed();
+  }
+
+  void RemoveAllRanges() {
+    mArray.Clear();
+    mDirection = eDirNext;
+  }
+
+  [[nodiscard]] uint32_t RangeCount() const { return mArray.Length(); }
+
+  /**
+   * Saving all ranges of aSelection.
+   */
+  void SaveSelection(dom::Selection& aSelection);
+
+  /**
+   * Setting aSelection to have all ranges stored by this instance.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
+  RestoreSelection(dom::Selection& aSelection);
+
+  /**
+   * Setting aRanges to have all ranges stored by this instance.
+   */
+  void ApplyTo(AutoRangeArray& aRanges);
+
+  /**
+   * HasOnlyCollapsedRange() returns true only when there is a positioned range
+   * which is collapsed.  I.e., the selection represents a caret point.
+   */
+  [[nodiscard]] bool HasOnlyCollapsedRange() const {
+    if (mArray.Length() != 1) {
+      return false;
+    }
+    if (!mArray[0]->IsPositioned() || !mArray[0]->Collapsed()) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Equals() returns true only when there are same number of ranges and
+   * all their containers and offsets are exactly same.  This won't check
+   * the validity of each range with the current DOM tree.
+   */
+  [[nodiscard]] bool Equals(const SelectionState& aOther) const;
+
+  /**
+   * Returns common root node of all ranges' start and end containers.
+   * Some of them have different root nodes, this returns nullptr.
+   */
+  [[nodiscard]] nsINode* GetCommonRootNode() const {
+    nsINode* rootNode = nullptr;
+    for (const RefPtr<RangeItem>& rangeItem : mArray) {
+      nsINode* newRootNode = rangeItem->GetRoot();
+      if (!newRootNode || (rootNode && rootNode != newRootNode)) {
+        return nullptr;
+      }
+      rootNode = newRootNode;
+    }
+    return rootNode;
+  }
+
+ private:
+  CopyableAutoTArray<RefPtr<RangeItem>, 1> mArray;
+  nsDirection mDirection = eDirNext;
+
+  friend class RangeUpdater;
+  friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
+                                          SelectionState&, const char*,
+                                          uint32_t);
+  friend void ImplCycleCollectionUnlink(SelectionState&);
+};
+
+inline void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& aCallback, SelectionState& aField,
+    const char* aName, uint32_t aFlags = 0) {
+  ImplCycleCollectionTraverse(aCallback, aField.mArray, aName, aFlags);
+}
+
+inline void ImplCycleCollectionUnlink(SelectionState& aField) {
+  ImplCycleCollectionUnlink(aField.mArray);
+}
+
+class MOZ_STACK_CLASS RangeUpdater final {
+ public:
+  RangeUpdater();
+
+  void RegisterRangeItem(RangeItem& aRangeItem);
+  void DropRangeItem(RangeItem& aRangeItem);
+  void RegisterSelectionState(SelectionState& aSelectionState);
+  void DropSelectionState(SelectionState& aSelectionState);
+
+  // editor selection gravity routines.  Note that we can't always depend on
+  // DOM Range gravity to do what we want to the "real" selection.  For
+  // instance, if you move a node, that corresponds to deleting it and
+  // reinserting it. DOM Range gravity will promote the selection out of the
+  // node on deletion, which is not what you want if you know you are
+  // reinserting it.
+  template <typename PT, typename CT>
+  nsresult SelAdjCreateNode(const EditorDOMPointBase<PT, CT>& aPoint);
+  template <typename PT, typename CT>
+  nsresult SelAdjInsertNode(const EditorDOMPointBase<PT, CT>& aPoint);
+  void SelAdjDeleteNode(nsINode& aNode);
+
+  /**
+   * SelAdjSplitNode() is called immediately after spliting aOriginalNode
+   * and inserted aNewContent into the DOM tree.
+   *
+   * @param aOriginalContent    The node which was split.
+   * @param aSplitOffset        The old offset in aOriginalContent at splitting
+   *                            it.
+   * @param aNewContent         The new content node which was inserted into
+   *                            the DOM tree.
+   * @param aSplitNodeDirection Whether aNewNode was inserted before or after
+   *                            aOriginalContent.
+   */
+  nsresult SelAdjSplitNode(nsIContent& aOriginalContent, uint32_t aSplitOffset,
+                           nsIContent& aNewContent,
+                           SplitNodeDirection aSplitNodeDirection);
+
+  /**
+   * SelAdjJoinNodes() is called immediately after joining aRemovedContent and
+   * the container of aStartOfRightContent.
+   *
+   * @param aStartOfRightContent    The container is joined content node which
+   *                                now has all children or text data which were
+   *                                in aRemovedContent.  And this points where
+   *                                the joined position.
+   * @param aRemovedContent         The removed content.
+   * @param aOldPointAtRightContent The point where the right content node was
+   *                                before joining them.  The offset must have
+   *                                been initialized before the joining.
+   */
+  nsresult SelAdjJoinNodes(const EditorRawDOMPoint& aStartOfRightContent,
+                           const nsIContent& aRemovedContent,
+                           const EditorDOMPoint& aOldPointAtRightContent,
+                           JoinNodesDirection aJoinNodesDirection);
+  void SelAdjInsertText(const dom::Text& aTextNode, uint32_t aOffset,
+                        uint32_t aInsertedLength);
+  void SelAdjDeleteText(const dom::Text& aTextNode, uint32_t aOffset,
+                        uint32_t aDeletedLength);
+  void SelAdjReplaceText(const dom::Text& aTextNode, uint32_t aOffset,
+                         uint32_t aReplacedLength, uint32_t aInsertedLength);
+  // the following gravity routines need will/did sandwiches, because the other
+  // gravity routines will be called inside of these sandwiches, but should be
+  // ignored.
+  void WillReplaceContainer() {
+    // XXX Isn't this possible with mutation event listener?
+    NS_WARNING_ASSERTION(!mLocked, "Has already been locked");
+    mLocked = true;
+  }
+  void DidReplaceContainer(const dom::Element& aRemovedElement,
+                           dom::Element& aInsertedElement);
+  void WillRemoveContainer() {
+    // XXX Isn't this possible with mutation event listener?
+    NS_WARNING_ASSERTION(!mLocked, "Has already been locked");
+    mLocked = true;
+  }
+  void DidRemoveContainer(const dom::Element& aRemovedElement,
+                          nsINode& aRemovedElementContainerNode,
+                          uint32_t aOldOffsetOfRemovedElement,
+                          uint32_t aOldChildCountOfRemovedElement);
+  void WillInsertContainer() {
+    // XXX Isn't this possible with mutation event listener?
+    NS_WARNING_ASSERTION(!mLocked, "Has already been locked");
+    mLocked = true;
+  }
+  void DidInsertContainer() {
+    NS_WARNING_ASSERTION(mLocked, "Not locked");
+    mLocked = false;
+  }
+  void DidMoveNode(const nsINode& aOldParent, uint32_t aOldOffset,
+                   const nsINode& aNewParent, uint32_t aNewOffset);
+
+ private:
+  // TODO: A lot of loop in these methods check whether each item `nullptr` or
+  //       not. We should make it not nullable later.
+  nsTArray<RefPtr<RangeItem>> mArray;
+  bool mLocked;
+};
+
+/**
+ * Helper class for using SelectionState.  Stack based class for doing
+ * preservation of dom points across editor actions.
+ */
+
+class MOZ_STACK_CLASS AutoTrackDOMPoint final {
+ public:
+  AutoTrackDOMPoint() = delete;
+  AutoTrackDOMPoint(RangeUpdater& aRangeUpdater, nsCOMPtr<nsINode>* aNode,
+                    uint32_t* aOffset)
+      : mRangeUpdater(aRangeUpdater),
+        mNode(aNode),
+        mOffset(aOffset),
+        mRangeItem(do_AddRef(new RangeItem())) {
+    mRangeItem->mStartContainer = *mNode;
+    mRangeItem->mEndContainer = *mNode;
+    mRangeItem->mStartOffset = *mOffset;
+    mRangeItem->mEndOffset = *mOffset;
+    mRangeUpdater.RegisterRangeItem(mRangeItem);
+  }
+
+  AutoTrackDOMPoint(RangeUpdater& aRangeUpdater, EditorDOMPoint* aPoint)
+      : mRangeUpdater(aRangeUpdater),
+        mNode(nullptr),
+        mOffset(nullptr),
+        mPoint(Some(aPoint->IsSet() ? aPoint : nullptr)),
+        mRangeItem(do_AddRef(new RangeItem())) {
+    if (!aPoint->IsSet()) {
+      mIsTracking = false;
+      return;  // Nothing should be tracked.
+    }
+    mRangeItem->mStartContainer = aPoint->GetContainer();
+    mRangeItem->mEndContainer = aPoint->GetContainer();
+    mRangeItem->mStartOffset = aPoint->Offset();
+    mRangeItem->mEndOffset = aPoint->Offset();
+    mRangeUpdater.RegisterRangeItem(mRangeItem);
+  }
+
+  ~AutoTrackDOMPoint() { FlushAndStopTracking(); }
+
+  void FlushAndStopTracking() {
+    if (!mIsTracking) {
+      return;
+    }
+    mIsTracking = false;
+    if (mPoint.isSome()) {
+      mRangeUpdater.DropRangeItem(mRangeItem);
+      // Setting `mPoint` with invalid DOM point causes hitting `NS_ASSERTION()`
+      // and the number of times may be too many.  (E.g., 1533913.html hits
+      // over 700 times!)  We should just put warning instead.
+      if (NS_WARN_IF(!mRangeItem->mStartContainer)) {
+        mPoint.ref()->Clear();
+        return;
+      }
+      if (NS_WARN_IF(mRangeItem->mStartContainer->Length() <
+                     mRangeItem->mStartOffset)) {
+        mPoint.ref()->SetToEndOf(mRangeItem->mStartContainer);
+        return;
+      }
+      mPoint.ref()->Set(mRangeItem->mStartContainer, mRangeItem->mStartOffset);
+      return;
+    }
+    mRangeUpdater.DropRangeItem(mRangeItem);
+    *mNode = mRangeItem->mStartContainer;
+    *mOffset = mRangeItem->mStartOffset;
+  }
+
+  void StopTracking() { mIsTracking = false; }
+
+ private:
+  RangeUpdater& mRangeUpdater;
+  // Allow tracking nsINode until nsNode is gone
+  nsCOMPtr<nsINode>* mNode;
+  uint32_t* mOffset;
+  Maybe<EditorDOMPoint*> mPoint;
+  OwningNonNull<RangeItem> mRangeItem;
+  bool mIsTracking = true;
+};
+
+class MOZ_STACK_CLASS AutoTrackDOMRange final {
+ public:
+  AutoTrackDOMRange() = delete;
+  AutoTrackDOMRange(RangeUpdater& aRangeUpdater, EditorDOMPoint* aStartPoint,
+                    EditorDOMPoint* aEndPoint)
+      : mRangeRefPtr(nullptr), mRangeOwningNonNull(nullptr) {
+    mStartPointTracker.emplace(aRangeUpdater, aStartPoint);
+    mEndPointTracker.emplace(aRangeUpdater, aEndPoint);
+  }
+  AutoTrackDOMRange(RangeUpdater& aRangeUpdater, EditorDOMRange* aRange)
+      : mRangeRefPtr(nullptr), mRangeOwningNonNull(nullptr) {
+    mStartPointTracker.emplace(
+        aRangeUpdater, const_cast<EditorDOMPoint*>(&aRange->StartRef()));
+    mEndPointTracker.emplace(aRangeUpdater,
+                             const_cast<EditorDOMPoint*>(&aRange->EndRef()));
+  }
+  AutoTrackDOMRange(RangeUpdater& aRangeUpdater, RefPtr<nsRange>* aRange)
+      : mStartPoint((*aRange)->StartRef()),
+        mEndPoint((*aRange)->EndRef()),
+        mRangeRefPtr(aRange),
+        mRangeOwningNonNull(nullptr) {
+    mStartPointTracker.emplace(aRangeUpdater, &mStartPoint);
+    mEndPointTracker.emplace(aRangeUpdater, &mEndPoint);
+  }
+  AutoTrackDOMRange(RangeUpdater& aRangeUpdater, OwningNonNull<nsRange>* aRange)
+      : mStartPoint((*aRange)->StartRef()),
+        mEndPoint((*aRange)->EndRef()),
+        mRangeRefPtr(nullptr),
+        mRangeOwningNonNull(aRange) {
+    mStartPointTracker.emplace(aRangeUpdater, &mStartPoint);
+    mEndPointTracker.emplace(aRangeUpdater, &mEndPoint);
+  }
+  ~AutoTrackDOMRange() { FlushAndStopTracking(); }
+
+  void FlushAndStopTracking() {
+    if (!mStartPointTracker && !mEndPointTracker) {
+      return;
+    }
+    mStartPointTracker.reset();
+    mEndPointTracker.reset();
+    if (!mRangeRefPtr && !mRangeOwningNonNull) {
+      // This must be created with EditorDOMRange or EditorDOMPoints.  In the
+      // cases, destroying mStartPointTracker and mEndPointTracker has done
+      // everything which we need to do.
+      return;
+    }
+    // Otherwise, update the DOM ranges by ourselves.
+    if (mRangeRefPtr) {
+      (*mRangeRefPtr)
+          ->SetStartAndEnd(mStartPoint.ToRawRangeBoundary(),
+                           mEndPoint.ToRawRangeBoundary());
+      return;
+    }
+    if (mRangeOwningNonNull) {
+      (*mRangeOwningNonNull)
+          ->SetStartAndEnd(mStartPoint.ToRawRangeBoundary(),
+                           mEndPoint.ToRawRangeBoundary());
+      return;
+    }
+  }
+
+  void StopTracking() {
+    if (mStartPointTracker) {
+      mStartPointTracker->StopTracking();
+    }
+    if (mEndPointTracker) {
+      mEndPointTracker->StopTracking();
+    }
+  }
+  void StopTrackingStartBoundary() {
+    MOZ_ASSERT(!mRangeRefPtr,
+               "StopTrackingStartBoundary() is not available when tracking "
+               "RefPtr<nsRange>");
+    MOZ_ASSERT(!mRangeOwningNonNull,
+               "StopTrackingStartBoundary() is not available when tracking "
+               "OwningNonNull<nsRange>");
+    if (!mStartPointTracker) {
+      return;
+    }
+    mStartPointTracker->StopTracking();
+  }
+  void StopTrackingEndBoundary() {
+    MOZ_ASSERT(!mRangeRefPtr,
+               "StopTrackingEndBoundary() is not available when tracking "
+               "RefPtr<nsRange>");
+    MOZ_ASSERT(!mRangeOwningNonNull,
+               "StopTrackingEndBoundary() is not available when tracking "
+               "OwningNonNull<nsRange>");
+    if (!mEndPointTracker) {
+      return;
+    }
+    mEndPointTracker->StopTracking();
+  }
+
+ private:
+  Maybe<AutoTrackDOMPoint> mStartPointTracker;
+  Maybe<AutoTrackDOMPoint> mEndPointTracker;
+  EditorDOMPoint mStartPoint;
+  EditorDOMPoint mEndPoint;
+  RefPtr<nsRange>* mRangeRefPtr;
+  OwningNonNull<nsRange>* mRangeOwningNonNull;
+};
+
+/**
+ * Another helper class for SelectionState.  Stack based class for doing
+ * Will/DidReplaceContainer()
+ */
+
+class MOZ_STACK_CLASS AutoReplaceContainerSelNotify final {
+ public:
+  AutoReplaceContainerSelNotify() = delete;
+  // FYI: Marked as `MOZ_CAN_RUN_SCRIPT` for avoiding to use strong pointers
+  //      for the members.
+  MOZ_CAN_RUN_SCRIPT
+  AutoReplaceContainerSelNotify(RangeUpdater& aRangeUpdater,
+                                dom::Element& aOriginalElement,
+                                dom::Element& aNewElement)
+      : mRangeUpdater(aRangeUpdater),
+        mOriginalElement(aOriginalElement),
+        mNewElement(aNewElement) {
+    mRangeUpdater.WillReplaceContainer();
+  }
+
+  ~AutoReplaceContainerSelNotify() {
+    mRangeUpdater.DidReplaceContainer(mOriginalElement, mNewElement);
+  }
+
+ private:
+  RangeUpdater& mRangeUpdater;
+  dom::Element& mOriginalElement;
+  dom::Element& mNewElement;
+};
+
+/**
+ * Another helper class for SelectionState.  Stack based class for doing
+ * Will/DidRemoveContainer()
+ */
+
+class MOZ_STACK_CLASS AutoRemoveContainerSelNotify final {
+ public:
+  AutoRemoveContainerSelNotify() = delete;
+  AutoRemoveContainerSelNotify(RangeUpdater& aRangeUpdater,
+                               const EditorRawDOMPoint& aAtRemovingElement)
+      : mRangeUpdater(aRangeUpdater),
+        mRemovingElement(*aAtRemovingElement.GetChild()->AsElement()),
+        mParentNode(*aAtRemovingElement.GetContainer()),
+        mOffsetInParent(aAtRemovingElement.Offset()),
+        mChildCountOfRemovingElement(mRemovingElement->GetChildCount()) {
+    MOZ_ASSERT(aAtRemovingElement.IsSet());
+    mRangeUpdater.WillRemoveContainer();
+  }
+
+  ~AutoRemoveContainerSelNotify() {
+    mRangeUpdater.DidRemoveContainer(mRemovingElement, mParentNode,
+                                     mOffsetInParent,
+                                     mChildCountOfRemovingElement);
+  }
+
+ private:
+  RangeUpdater& mRangeUpdater;
+  OwningNonNull<dom::Element> mRemovingElement;
+  OwningNonNull<nsINode> mParentNode;
+  uint32_t mOffsetInParent;
+  uint32_t mChildCountOfRemovingElement;
+};
+
+/**
+ * Another helper class for SelectionState.  Stack based class for doing
+ * Will/DidInsertContainer()
+ * XXX The lock state isn't useful if the edit action is triggered from
+ *     a mutation event listener so that looks like that we can remove
+ *     this class.
+ */
+
+class MOZ_STACK_CLASS AutoInsertContainerSelNotify final {
+ private:
+  RangeUpdater& mRangeUpdater;
+
+ public:
+  AutoInsertContainerSelNotify() = delete;
+  explicit AutoInsertContainerSelNotify(RangeUpdater& aRangeUpdater)
+      : mRangeUpdater(aRangeUpdater) {
+    mRangeUpdater.WillInsertContainer();
+  }
+
+  ~AutoInsertContainerSelNotify() { mRangeUpdater.DidInsertContainer(); }
+};
+
+/**
+ * Another helper class for SelectionState.  Stack based class for doing
+ * DidMoveNode()
+ */
+
+class MOZ_STACK_CLASS AutoMoveNodeSelNotify final {
+ public:
+  AutoMoveNodeSelNotify() = delete;
+  AutoMoveNodeSelNotify(RangeUpdater& aRangeUpdater,
+                        const EditorRawDOMPoint& aOldPoint,
+                        const EditorRawDOMPoint& aNewPoint)
+      : mRangeUpdater(aRangeUpdater),
+        mOldParent(*aOldPoint.GetContainer()),
+        mNewParent(*aNewPoint.GetContainer()),
+        mOldOffset(aOldPoint.Offset()),
+        mNewOffset(aNewPoint.Offset()) {
+    MOZ_ASSERT(aOldPoint.IsSet());
+    MOZ_ASSERT(aNewPoint.IsSet());
+  }
+
+  ~AutoMoveNodeSelNotify() {
+    mRangeUpdater.DidMoveNode(mOldParent, mOldOffset, mNewParent, mNewOffset);
+  }
+
+ private:
+  RangeUpdater& mRangeUpdater;
+  nsINode& mOldParent;
+  nsINode& mNewParent;
+  const uint32_t mOldOffset;
+  const uint32_t mNewOffset;
+};
+
+}  // namespace mozilla
+
+#endif  // #ifndef mozilla_SelectionState_h