tor-browser

SelectionState.cpp (26196B)

---

/* -*- 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 "SelectionState.h"

#include "AutoClonedRangeArray.h"  // for AutoClonedRangeArray
#include "EditorUtils.h"           // for EditorUtils
#include "EditorLineBreak.h"       // for EditorLineBreak
#include "HTMLEditHelpers.h"       // for DeleteRangeResult

#include "ErrorList.h"
#include "mozilla/Assertions.h"    // for MOZ_ASSERT, etc.
#include "mozilla/IntegerRange.h"  // for IntegerRange
#include "mozilla/Likely.h"        // For MOZ_LIKELY and MOZ_UNLIKELY
#include "mozilla/RangeUtils.h"    // for RangeUtils
#include "mozilla/dom/RangeBinding.h"
#include "mozilla/dom/Selection.h"  // for Selection
#include "nsAString.h"              // for nsAString::Length
#include "nsCycleCollectionParticipant.h"
#include "nsDebug.h"          // for NS_WARNING, etc.
#include "nsError.h"          // for NS_OK, etc.
#include "nsIContent.h"       // for nsIContent
#include "nsISupportsImpl.h"  // for nsRange::Release
#include "nsRange.h"          // for nsRange

namespace mozilla {

using namespace dom;

/*****************************************************************************
* mozilla::RangeItem
*****************************************************************************/

nsINode* RangeItem::GetRoot() const {
 if (MOZ_UNLIKELY(!IsPositioned())) {
   return nullptr;
 }
 nsINode* rootNode = RangeUtils::ComputeRootNode(mStartContainer);
 if (mStartContainer == mEndContainer) {
   return rootNode;
 }
 return MOZ_LIKELY(rootNode == RangeUtils::ComputeRootNode(mEndContainer))
            ? rootNode
            : nullptr;
}

/******************************************************************************
* 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.
******************************************************************************/

template nsresult RangeUpdater::SelAdjCreateNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjCreateNode(
   const EditorRawDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(
   const EditorRawDOMPoint& aPoint);

SelectionState::SelectionState(const AutoClonedSelectionRangeArray& aRanges)
   : mDirection(aRanges.GetDirection()) {
 mArray.SetCapacity(aRanges.Ranges().Length());
 for (const OwningNonNull<nsRange>& range : aRanges.Ranges()) {
   RefPtr<RangeItem> rangeItem = new RangeItem();
   rangeItem->StoreRange(range);
   mArray.AppendElement(std::move(rangeItem));
 }
}

void SelectionState::SaveSelection(Selection& aSelection) {
 // if we need more items in the array, new them
 if (mArray.Length() < aSelection.RangeCount()) {
   for (uint32_t i = mArray.Length(); i < aSelection.RangeCount(); i++) {
     mArray.AppendElement();
     mArray[i] = new RangeItem();
   }
 } else if (mArray.Length() > aSelection.RangeCount()) {
   // else if we have too many, delete them
   mArray.TruncateLength(aSelection.RangeCount());
 }

 // now store the selection ranges
 const uint32_t rangeCount = aSelection.RangeCount();
 for (const uint32_t i : IntegerRange(rangeCount)) {
   MOZ_ASSERT(aSelection.RangeCount() == rangeCount);
   const nsRange* range = aSelection.GetRangeAt(i);
   MOZ_ASSERT(range);
   if (MOZ_UNLIKELY(NS_WARN_IF(!range))) {
     continue;
   }
   mArray[i]->StoreRange(*range);
 }

 mDirection = aSelection.GetDirection();
}

nsresult SelectionState::RestoreSelection(Selection& aSelection) {
 // clear out selection
 IgnoredErrorResult ignoredError;
 aSelection.RemoveAllRanges(ignoredError);
 NS_WARNING_ASSERTION(!ignoredError.Failed(),
                      "Selection::RemoveAllRanges() failed, but ignored");

 aSelection.SetDirection(mDirection);

 ErrorResult error;
 const CopyableAutoTArray<RefPtr<RangeItem>, 10> rangeItems(mArray);
 for (const RefPtr<RangeItem>& rangeItem : rangeItems) {
   RefPtr<nsRange> range = rangeItem->GetRange();
   if (!range) {
     NS_WARNING("RangeItem::GetRange() failed");
     return NS_ERROR_FAILURE;
   }
   aSelection.AddRangeAndSelectFramesAndNotifyListeners(*range, error);
   if (error.Failed()) {
     NS_WARNING(
         "Selection::AddRangeAndSelectFramesAndNotifyListeners() failed");
     return error.StealNSResult();
   }
 }
 return NS_OK;
}

void SelectionState::ApplyTo(AutoClonedSelectionRangeArray& aRanges) {
 aRanges.RemoveAllRanges();
 aRanges.SetDirection(mDirection);
 for (const RefPtr<RangeItem>& rangeItem : mArray) {
   RefPtr<nsRange> range = rangeItem->GetRange();
   if (MOZ_UNLIKELY(!range)) {
     continue;
   }
   aRanges.Ranges().AppendElement(std::move(range));
 }
}

bool SelectionState::Equals(const SelectionState& aOther) const {
 if (mArray.Length() != aOther.mArray.Length()) {
   return false;
 }
 if (mArray.IsEmpty()) {
   return false;  // XXX Why?
 }
 if (mDirection != aOther.mDirection) {
   return false;
 }

 for (uint32_t i : IntegerRange(mArray.Length())) {
   if (NS_WARN_IF(!mArray[i]) || NS_WARN_IF(!aOther.mArray[i]) ||
       !mArray[i]->Equals(*aOther.mArray[i])) {
     return false;
   }
 }
 // if we got here, they are equal
 return true;
}

/******************************************************************************
* mozilla::RangeUpdater
*
* Class for updating nsRanges in response to editor actions.
******************************************************************************/

RangeUpdater::RangeUpdater() : mLocked(false) {}

void RangeUpdater::RegisterRangeItem(RangeItem& aRangeItem) {
 if (mArray.Contains(&aRangeItem)) {
   NS_ERROR("tried to register an already registered range");
   return;  // don't register it again.  It would get doubly adjusted.
 }
 mArray.AppendElement(&aRangeItem);
}

void RangeUpdater::DropRangeItem(RangeItem& aRangeItem) {
 NS_WARNING_ASSERTION(
     mArray.Contains(&aRangeItem),
     "aRangeItem is not in the range, but tried to removed from it");
 mArray.RemoveElement(&aRangeItem);
}

void RangeUpdater::RegisterSelectionState(SelectionState& aSelectionState) {
 for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     continue;
   }
   RegisterRangeItem(*rangeItem);
 }
}

void RangeUpdater::DropSelectionState(SelectionState& aSelectionState) {
 for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     continue;
   }
   DropRangeItem(*rangeItem);
 }
}

// gravity methods:

template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjCreateNode(
   const EditorDOMPointBase<PT, CT>& aPoint) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return NS_OK;
 }
 if (mArray.IsEmpty()) {
   return NS_OK;
 }

 if (NS_WARN_IF(!aPoint.IsSetAndValid())) {
   return NS_ERROR_INVALID_ARG;
 }

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     return NS_ERROR_FAILURE;
   }
   if (rangeItem->mStartContainer == aPoint.GetContainer() &&
       rangeItem->mStartOffset > aPoint.Offset()) {
     rangeItem->mStartOffset++;
   }
   if (rangeItem->mEndContainer == aPoint.GetContainer() &&
       rangeItem->mEndOffset > aPoint.Offset()) {
     rangeItem->mEndOffset++;
   }
 }
 return NS_OK;
}

template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjInsertNode(
   const EditorDOMPointBase<PT, CT>& aPoint) {
 nsresult rv = SelAdjCreateNode(aPoint);
 NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
                      "RangeUpdater::SelAdjCreateNode() failed");
 return rv;
}

void RangeUpdater::SelAdjDeleteNode(nsINode& aNodeToDelete) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return;
 }

 if (mArray.IsEmpty()) {
   return;
 }

 EditorRawDOMPoint atNodeToDelete(&aNodeToDelete);
 NS_ASSERTION(atNodeToDelete.IsSetAndValid(),
              "aNodeToDelete must be an orphan node or this is called "
              "during mutation");
 // check for range endpoints that are after aNodeToDelete and in the same
 // parent
 for (RefPtr<RangeItem>& rangeItem : mArray) {
   MOZ_ASSERT(rangeItem);

   if (rangeItem->mStartContainer == atNodeToDelete.GetContainer() &&
       rangeItem->mStartOffset > atNodeToDelete.Offset()) {
     rangeItem->mStartOffset--;
   }
   if (rangeItem->mEndContainer == atNodeToDelete.GetContainer() &&
       rangeItem->mEndOffset > atNodeToDelete.Offset()) {
     rangeItem->mEndOffset--;
   }

   // check for range endpoints that are in aNodeToDelete
   if (rangeItem->mStartContainer == &aNodeToDelete) {
     rangeItem->mStartContainer = atNodeToDelete.GetContainer();
     rangeItem->mStartOffset = atNodeToDelete.Offset();
   }
   if (rangeItem->mEndContainer == &aNodeToDelete) {
     rangeItem->mEndContainer = atNodeToDelete.GetContainer();
     rangeItem->mEndOffset = atNodeToDelete.Offset();
   }

   // check for range endpoints that are in descendants of aNodeToDelete
   bool updateEndBoundaryToo = false;
   if (EditorUtils::IsDescendantOf(*rangeItem->mStartContainer,
                                   aNodeToDelete)) {
     updateEndBoundaryToo =
         rangeItem->mStartContainer == rangeItem->mEndContainer;
     rangeItem->mStartContainer = atNodeToDelete.GetContainer();
     rangeItem->mStartOffset = atNodeToDelete.Offset();
   }

   // avoid having to call IsDescendantOf() for common case of range startnode
   // == range endnode.
   if (updateEndBoundaryToo ||
       EditorUtils::IsDescendantOf(*rangeItem->mEndContainer, aNodeToDelete)) {
     rangeItem->mEndContainer = atNodeToDelete.GetContainer();
     rangeItem->mEndOffset = atNodeToDelete.Offset();
   }
 }
}

nsresult RangeUpdater::SelAdjSplitNode(nsIContent& aOriginalContent,
                                      uint32_t aSplitOffset,
                                      nsIContent& aNewContent) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return NS_OK;
 }

 if (mArray.IsEmpty()) {
   return NS_OK;
 }

 EditorRawDOMPoint atNewNode(&aNewContent);
 if (NS_WARN_IF(!atNewNode.IsSetAndValid())) {
   return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE;
 }

 auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aContainer,
                           uint32_t& aOffset) -> void {
   if (aContainer == atNewNode.GetContainer()) {
     // When we create a right node, we insert it after the left node.
     // In this case,
     // - `{}<left/>` should become `{}<left/><right/>` (0 -> 0)
     // - `<left/>{}` should become `<left/><right/>{}` (1 -> 2)
     // - `{<left/>}` should become `{<left/><right/>}` (0 -> 0, 1 -> 2}
     // Therefore, we need to increate the offset only when the offset equals
     // or is larger than the offset at the right node.
     if (aOffset >= atNewNode.Offset()) {
       aOffset++;
     }
   }
   // If point is in the range which are moved from aOriginalContent to
   // aNewContent, we need to change its container to aNewContent and may need
   // to adjust the offset. If point is in the range which are not moved from
   // aOriginalContent, we may need to adjust the offset.
   if (aContainer != &aOriginalContent) {
     return;
   }
   if (aOffset >= aSplitOffset) {
     aContainer = &aNewContent;
     aOffset -= aSplitOffset;
   }
 };

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     return NS_ERROR_FAILURE;
   }
   AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
   AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
 }
 return NS_OK;
}

nsresult RangeUpdater::SelAdjJoinNodes(
   const EditorRawDOMPoint& aStartOfRightContent,
   const nsIContent& aRemovedContent,
   const EditorDOMPoint& aOldPointAtRightContent) {
 MOZ_ASSERT(aStartOfRightContent.IsSetAndValid());
 MOZ_ASSERT(aOldPointAtRightContent.IsSet());  // Invalid point in most cases
 MOZ_ASSERT(aOldPointAtRightContent.HasOffset());

 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return NS_OK;
 }

 if (mArray.IsEmpty()) {
   return NS_OK;
 }

 auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aContainer,
                           uint32_t& aOffset) -> void {
   // FYI: Typically, containers of aOldPointAtRightContent and
   //      aStartOfRightContent are same.  They are different when one of the
   //      node was moved to somewhere and they are joined by undoing splitting
   //      a node.
   if (aContainer == &aRemovedContent) {
     // If the point is in the removed content, move the point to the new
     // point in the joined node.  If left node content is moved into
     // right node, the offset should be same.  Otherwise, we need to advance
     // the offset to length of the removed content.
     aContainer = aStartOfRightContent.GetContainer();
     aOffset += aStartOfRightContent.Offset();
   }
   // TODO: If aOldPointAtRightContent.GetContainer() was in aRemovedContent,
   //       we fail to adjust container and offset here because we need to
   //       make point to where aRemoveContent was.  However, collecting all
   //       ancestors of the right content may be expensive.  What's the best
   //       approach to fix this?
   else if (aContainer == aOldPointAtRightContent.GetContainer()) {
     // If the point is in common parent of joined content nodes and it
     // pointed after the right content node, decrease the offset.
     if (aOffset > aOldPointAtRightContent.Offset()) {
       aOffset--;
     }
     // If it pointed the right content node, adjust it to point ex-first
     // content of the right node.
     else if (aOffset == aOldPointAtRightContent.Offset()) {
       aContainer = aStartOfRightContent.GetContainer();
       aOffset = aStartOfRightContent.Offset();
     }
   }
 };

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     return NS_ERROR_FAILURE;
   }
   AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
   AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
 }

 return NS_OK;
}

void RangeUpdater::SelAdjReplaceText(const Text& aTextNode, uint32_t aOffset,
                                    uint32_t aReplacedLength,
                                    uint32_t aInsertedLength) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return;
 }

 // First, adjust selection for insertion because when offset is in the
 // replaced range, it's adjusted to aOffset and never modified by the
 // insertion if we adjust selection for deletion first.
 SelAdjInsertText(aTextNode, aOffset, aInsertedLength);

 // Then, adjust selection for deletion.
 SelAdjDeleteText(aTextNode, aOffset, aReplacedLength);
}

void RangeUpdater::SelAdjInsertText(const Text& aTextNode, uint32_t aOffset,
                                   uint32_t aInsertedLength) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return;
 }

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   MOZ_ASSERT(rangeItem);

   if (rangeItem->mStartContainer == &aTextNode &&
       rangeItem->mStartOffset > aOffset) {
     rangeItem->mStartOffset += aInsertedLength;
   }
   if (rangeItem->mEndContainer == &aTextNode &&
       rangeItem->mEndOffset > aOffset) {
     rangeItem->mEndOffset += aInsertedLength;
   }
 }
}

void RangeUpdater::SelAdjDeleteText(const Text& aTextNode, uint32_t aOffset,
                                   uint32_t aDeletedLength) {
 if (mLocked) {
   // lock set by Will/DidReplaceParent, etc...
   return;
 }

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   MOZ_ASSERT(rangeItem);

   if (rangeItem->mStartContainer == &aTextNode &&
       rangeItem->mStartOffset > aOffset) {
     if (rangeItem->mStartOffset >= aDeletedLength) {
       rangeItem->mStartOffset -= aDeletedLength;
     } else {
       rangeItem->mStartOffset = 0;
     }
   }
   if (rangeItem->mEndContainer == &aTextNode &&
       rangeItem->mEndOffset > aOffset) {
     if (rangeItem->mEndOffset >= aDeletedLength) {
       rangeItem->mEndOffset -= aDeletedLength;
     } else {
       rangeItem->mEndOffset = 0;
     }
   }
 }
}

void RangeUpdater::DidReplaceContainer(const Element& aRemovedElement,
                                      Element& aInsertedElement) {
 if (NS_WARN_IF(!mLocked)) {
   return;
 }
 mLocked = false;

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     return;
   }

   if (rangeItem->mStartContainer == &aRemovedElement) {
     rangeItem->mStartContainer = &aInsertedElement;
   }
   if (rangeItem->mEndContainer == &aRemovedElement) {
     rangeItem->mEndContainer = &aInsertedElement;
   }
 }
}

void RangeUpdater::DidRemoveContainer(const Element& aRemovedElement,
                                     nsINode& aRemovedElementContainerNode,
                                     uint32_t aOldOffsetOfRemovedElement,
                                     uint32_t aOldChildCountOfRemovedElement) {
 if (NS_WARN_IF(!mLocked)) {
   return;
 }
 mLocked = false;

 for (RefPtr<RangeItem>& rangeItem : mArray) {
   if (NS_WARN_IF(!rangeItem)) {
     return;
   }

   if (rangeItem->mStartContainer == &aRemovedElement) {
     rangeItem->mStartContainer = &aRemovedElementContainerNode;
     rangeItem->mStartOffset += aOldOffsetOfRemovedElement;
   } else if (rangeItem->mStartContainer == &aRemovedElementContainerNode &&
              rangeItem->mStartOffset > aOldOffsetOfRemovedElement) {
     rangeItem->mStartOffset += aOldChildCountOfRemovedElement - 1;
   }

   if (rangeItem->mEndContainer == &aRemovedElement) {
     rangeItem->mEndContainer = &aRemovedElementContainerNode;
     rangeItem->mEndOffset += aOldOffsetOfRemovedElement;
   } else if (rangeItem->mEndContainer == &aRemovedElementContainerNode &&
              rangeItem->mEndOffset > aOldOffsetOfRemovedElement) {
     rangeItem->mEndOffset += aOldChildCountOfRemovedElement - 1;
   }
 }
}

void RangeUpdater::DidMoveNodes(
   const nsTArray<SimpleEditorDOMPoint>& aOldPoints,
   const SimpleEditorDOMPoint& aExpectedDestination,
   const nsTArray<SimpleEditorDOMPoint>& aNewPoints) {
 if (mLocked) {
   // Do nothing if moving nodes is occurred while changing the container.
   return;
 }

 AutoTArray<SimpleEditorRawDOMPoint, 12> oldPoints;
 oldPoints.SetCapacity(aOldPoints.Length());
 for (const size_t i : IntegerRange(aOldPoints.Length())) {
   const SimpleEditorDOMPoint& oldPoint = aOldPoints[i];
   if (MOZ_UNLIKELY(oldPoints.IsEmpty())) {
     oldPoints.AppendElement(SimpleEditorRawDOMPoint(
         oldPoint.mContainer, oldPoint.mChild, oldPoint.Offset()));
     continue;
   }
   // Adjust offset as if preceding children removed before because if each
   // node is moved separately, the old offset does not contain the old
   // previous siblings which were moved togather.  Therefore, if moved in the
   // same container and before the offset, we don't need to adjust the offset.
   // If we moved to previous point in the same container, the old point does
   // not need to be adjusted.
   if (MOZ_UNLIKELY(aExpectedDestination.mContainer == oldPoint.mContainer) &&
       aExpectedDestination.Offset() < oldPoint.Offset()) {
     oldPoints.AppendElement(SimpleEditorRawDOMPoint(
         oldPoint.mContainer, oldPoint.mChild, oldPoint.Offset()));
     continue;
   }
   // If we moved the next sibling of the previously moved content, the
   // sibling start position is same as the previous one.
   if (oldPoints.LastElement().mChild->GetNextSibling() == oldPoint.mChild) {
     oldPoints.AppendElement(
         SimpleEditorRawDOMPoint(oldPoint.mContainer, oldPoint.mChild,
                                 oldPoints.LastElement().Offset()));
     continue;
   }
   // If the moved content was not the next sibling of the previous moved
   // content, we need to count the number of previous siblings which we
   // moved and decrease the count from the offset.  That's the offset if we
   // moved each node separately.
   uint32_t offset = oldPoint.Offset();
   for (const SimpleEditorRawDOMPoint& precedingPoint : oldPoints) {
     if (precedingPoint.mContainer == oldPoint.mContainer &&
         precedingPoint.Offset() < oldPoint.Offset()) {
       offset--;
     }
   }
   oldPoints.AppendElement(
       SimpleEditorRawDOMPoint{oldPoint.mContainer, oldPoint.mChild, offset});
 }

 size_t newPointIndex = 0;
 for (const SimpleEditorRawDOMPoint& oldPoint : oldPoints) {
   const SimpleEditorDOMPoint* newPoint =
       newPointIndex < aNewPoints.Length() &&
               oldPoint.mChild == aNewPoints[newPointIndex].mChild
           ? &aNewPoints[newPointIndex++]
           : nullptr;
   auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aNode, uint32_t& aOffset) {
     // If the node was removed, we should adjust the point around aOldPoint.
     if (!newPoint || !newPoint->mContainer) {
       // If the point was in the removed container, the point should be moved
       // where the node was.
       if (aNode->IsInclusiveDescendantOf(oldPoint.mChild)) {
         aNode = oldPoint.mContainer;
         aOffset = std::min(oldPoint.Offset(), aNode->Length());
         return;
       }
       // If the point was where the node was or latter, fix the position.
       if (aNode == oldPoint.mContainer) {
         if (aOffset > oldPoint.Offset()) {
           aOffset--;
         }
         if (aOffset > aNode->Length()) {
           aOffset = aNode->Length();
         }
         return;
       }
       return;
     }
     // The node was moved to another point, at least.
     if (aNode == oldPoint.mContainer) {
       // If previously pointed the moved content, it should keep pointing it.
       if (aOffset == oldPoint.Offset()) {
         aNode = newPoint->mContainer;
         aOffset = newPoint->Offset();
       } else if (aOffset > oldPoint.Offset()) {
         aOffset--;
       }
       return;
     }
     if (aNode == newPoint->mContainer) {
       if (aOffset > newPoint->Offset()) {
         aOffset++;
       }
     }
   };
   for (RefPtr<RangeItem>& rangeItem : mArray) {
     if (NS_WARN_IF(!rangeItem)) {
       return;
     }

     AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
     AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
   }
 }
}

/******************************************************************************
* mozilla::RangeItem
*
* Helper struct for SelectionState.  This stores range endpoints.
******************************************************************************/

NS_IMPL_CYCLE_COLLECTION(RangeItem, mStartContainer, mEndContainer)

void RangeItem::StoreRange(const nsRange& aRange) {
 mStartContainer = aRange.GetStartContainer();
 mStartOffset = aRange.StartOffset();
 mEndContainer = aRange.GetEndContainer();
 mEndOffset = aRange.EndOffset();
}

already_AddRefed<nsRange> RangeItem::GetRange() const {
 RefPtr<nsRange> range = nsRange::Create(
     mStartContainer, mStartOffset, mEndContainer, mEndOffset, IgnoreErrors());
 NS_WARNING_ASSERTION(range, "nsRange::Create() failed");
 return range.forget();
}

/******************************************************************************
* mozilla::AutoTrackDOMPoint
******************************************************************************/

AutoTrackDOMPoint::AutoTrackDOMPoint(RangeUpdater& aRangeUpdater,
                                    CaretPoint* aCaretPoint)
   : AutoTrackDOMPoint(aRangeUpdater, &aCaretPoint->mCaretPoint) {}

/******************************************************************************
* mozilla::AutoTrackDOMMoveNodeResult
******************************************************************************/

AutoTrackDOMMoveNodeResult::AutoTrackDOMMoveNodeResult(
   RangeUpdater& aRangeUpdater, MoveNodeResult* aMoveNodeResult)
   : mTrackCaretPoint(aRangeUpdater,
                      static_cast<CaretPoint*>(aMoveNodeResult)),
     mTrackNextInsertionPoint(aRangeUpdater,
                              &aMoveNodeResult->mNextInsertionPoint),
     mTrackMovedContentRange(aRangeUpdater,
                             &aMoveNodeResult->mMovedContentRange) {}

/******************************************************************************
* mozilla::AutoTrackDeleteRangeResult
******************************************************************************/

AutoTrackDOMDeleteRangeResult::AutoTrackDOMDeleteRangeResult(
   RangeUpdater& aRangeUpdater, DeleteRangeResult* aDeleteRangeResult)
   : mTrackCaretPoint(aRangeUpdater,
                      static_cast<CaretPoint*>(aDeleteRangeResult)),
     mTrackDeleteRange(aRangeUpdater, &aDeleteRangeResult->mDeleteRange) {}

/******************************************************************************
* mozilla::AutoTrackLineBreak
******************************************************************************/

AutoTrackLineBreak::AutoTrackLineBreak(RangeUpdater& aRangeUpdater,
                                      EditorLineBreak* aLineBreak)
   : mLineBreak(aLineBreak->IsPreformattedLineBreak() ? aLineBreak : nullptr),
     mPoint(mLineBreak ? mLineBreak->To<EditorDOMPoint>() : EditorDOMPoint()),
     mTracker(aRangeUpdater, &mPoint) {
 MOZ_ASSERT(aLineBreak->IsPreformattedLineBreak());
}

void AutoTrackLineBreak::FlushAndStopTracking() {
 if (!mLineBreak) {
   return;
 }
 mTracker.FlushAndStopTracking();
 if (mPoint.GetContainer() == mLineBreak->mContent) {
   mLineBreak->mOffsetInText = Some(mPoint.Offset());
 }
 mLineBreak = nullptr;
}

}  // namespace mozilla