Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 3378 insertions, 0 deletions

diff --git a/layout/generic/nsFrameSelection.cpp b/layout/generic/nsFrameSelection.cpp
new file mode 100644
index 0000000000..8cc3a66ee1
--- /dev/null
+++ b/layout/generic/nsFrameSelection.cpp
@@ -0,0 +1,3378 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/*
+ * Implementation of nsFrameSelection
+ */
+
+#include "nsFrameSelection.h"
+
+#include "mozilla/intl/BidiEmbeddingLevel.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/HTMLEditor.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/Logging.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ScrollTypes.h"
+#include "mozilla/StaticAnalysisFunctions.h"
+#include "mozilla/StaticPrefs_bidi.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/Unused.h"
+
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsString.h"
+#include "nsISelectionListener.h"
+#include "nsContentCID.h"
+#include "nsDeviceContext.h"
+#include "nsIContent.h"
+#include "nsRange.h"
+#include "nsITableCellLayout.h"
+#include "nsTArray.h"
+#include "nsTableWrapperFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsTextFragment.h"
+#include <algorithm>
+#include "nsContentUtils.h"
+#include "nsCSSFrameConstructor.h"
+
+#include "nsGkAtoms.h"
+#include "nsIFrameTraversal.h"
+#include "nsLayoutUtils.h"
+#include "nsLayoutCID.h"
+#include "nsBidiPresUtils.h"
+static NS_DEFINE_CID(kFrameTraversalCID, NS_FRAMETRAVERSAL_CID);
+#include "nsTextFrame.h"
+
+#include "nsThreadUtils.h"
+#include "mozilla/Preferences.h"
+
+#include "mozilla/PresShell.h"
+#include "nsPresContext.h"
+#include "nsCaret.h"
+
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TextEvents.h"
+
+// notifications
+#include "mozilla/dom/Document.h"
+
+#include "nsISelectionController.h"  //for the enums
+#include "nsCopySupport.h"
+#include "nsIClipboard.h"
+#include "nsIFrameInlines.h"
+
+#include "nsError.h"
+#include "mozilla/AutoCopyListener.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Highlight.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/ShadowRoot.h"
+#include "mozilla/dom/StaticRange.h"
+#include "mozilla/dom/Text.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/SelectionBinding.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/Telemetry.h"
+
+#include "nsFocusManager.h"
+#include "nsPIDOMWindow.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static LazyLogModule sFrameSelectionLog("FrameSelection");
+
+// #define DEBUG_TABLE 1
+
+/**
+ * Add cells to the selection inside of the given cells range.
+ *
+ * @param  aTable             [in] HTML table element
+ * @param  aStartRowIndex     [in] row index where the cells range starts
+ * @param  aStartColumnIndex  [in] column index where the cells range starts
+ * @param  aEndRowIndex       [in] row index where the cells range ends
+ * @param  aEndColumnIndex    [in] column index where the cells range ends
+ */
+static nsresult AddCellsToSelection(const nsIContent* aTableContent,
+                                    int32_t aStartRowIndex,
+                                    int32_t aStartColumnIndex,
+                                    int32_t aEndRowIndex,
+                                    int32_t aEndColumnIndex,
+                                    Selection& aNormalSelection);
+
+static nsAtom* GetTag(nsINode* aNode);
+
+static nsINode* GetClosestInclusiveTableCellAncestor(nsINode* aDomNode);
+MOZ_CAN_RUN_SCRIPT_BOUNDARY static nsresult CreateAndAddRange(
+    nsINode* aContainer, int32_t aOffset, Selection& aNormalSelection);
+static nsresult SelectCellElement(nsIContent* aCellElement,
+                                  Selection& aNormalSelection);
+
+#ifdef XP_MACOSX
+static nsresult UpdateSelectionCacheOnRepaintSelection(Selection* aSel);
+#endif  // XP_MACOSX
+
+#ifdef PRINT_RANGE
+static void printRange(nsRange* aDomRange);
+#  define DEBUG_OUT_RANGE(x) printRange(x)
+#else
+#  define DEBUG_OUT_RANGE(x)
+#endif  // PRINT_RANGE
+
+/******************************************************************************
+ * mozilla::PeekOffsetStruct
+ ******************************************************************************/
+
+// #define DEBUG_SELECTION // uncomment for printf describing every collapse and
+//  extend. #define DEBUG_NAVIGATION
+
+// #define DEBUG_TABLE_SELECTION 1
+
+namespace mozilla {
+
+PeekOffsetStruct::PeekOffsetStruct(nsSelectionAmount aAmount,
+                                   nsDirection aDirection, int32_t aStartOffset,
+                                   nsPoint aDesiredCaretPos,
+                                   const PeekOffsetOptions aOptions,
+                                   EWordMovementType aWordMovementType)
+    : mAmount(aAmount),
+      mDirection(aDirection),
+      mStartOffset(aStartOffset),
+      mDesiredCaretPos(aDesiredCaretPos),
+      mWordMovementType(aWordMovementType),
+      mOptions(aOptions),
+      mResultContent(),
+      mResultFrame(nullptr),
+      mContentOffset(0),
+      mAttach(CARET_ASSOCIATE_BEFORE) {}
+
+}  // namespace mozilla
+
+// Array which contains index of each SelecionType in Selection::mDOMSelections.
+// For avoiding using if nor switch to retrieve the index, this needs to have
+// -1 for SelectionTypes which won't be created its Selection instance.
+static const int8_t kIndexOfSelections[] = {
+    -1,  // SelectionType::eInvalid
+    -1,  // SelectionType::eNone
+    0,   // SelectionType::eNormal
+    1,   // SelectionType::eSpellCheck
+    2,   // SelectionType::eIMERawClause
+    3,   // SelectionType::eIMESelectedRawClause
+    4,   // SelectionType::eIMEConvertedClause
+    5,   // SelectionType::eIMESelectedClause
+    6,   // SelectionType::eAccessibility
+    7,   // SelectionType::eFind
+    8,   // SelectionType::eURLSecondary
+    9,   // SelectionType::eURLStrikeout
+    -1,  // SelectionType::eHighlight
+};
+
+inline int8_t GetIndexFromSelectionType(SelectionType aSelectionType) {
+  // The enum value of eInvalid is -1 and the others are sequential value
+  // starting from 0.  Therefore, |SelectionType + 1| is the index of
+  // kIndexOfSelections.
+  return kIndexOfSelections[static_cast<int8_t>(aSelectionType) + 1];
+}
+
+/*
+The limiter is used specifically for the text areas and textfields
+In that case it is the DIV tag that is anonymously created for the text
+areas/fields.  Text nodes and BR nodes fall beneath it.  In the case of a
+BR node the limiter will be the parent and the offset will point before or
+after the BR node.  In the case of the text node the parent content is
+the text node itself and the offset will be the exact character position.
+The offset is not important to check for validity.  Simply look at the
+passed in content.  If it equals the limiter then the selection point is valid.
+If its parent it the limiter then the point is also valid.  In the case of
+NO limiter all points are valid since you are in a topmost iframe. (browser
+or composer)
+*/
+bool nsFrameSelection::IsValidSelectionPoint(nsINode* aNode) const {
+  if (!aNode) {
+    return false;
+  }
+
+  nsIContent* limiter = GetLimiter();
+  if (limiter && limiter != aNode && limiter != aNode->GetParent()) {
+    // if newfocus == the limiter. that's ok. but if not there and not parent
+    // bad
+    return false;  // not in the right content. tLimiter said so
+  }
+
+  limiter = GetAncestorLimiter();
+  return !limiter || aNode->IsInclusiveDescendantOf(limiter);
+}
+
+namespace mozilla {
+struct MOZ_RAII AutoPrepareFocusRange {
+  AutoPrepareFocusRange(Selection* aSelection,
+                        const bool aMultiRangeSelection) {
+    MOZ_ASSERT(aSelection);
+    MOZ_ASSERT(aSelection->GetType() == SelectionType::eNormal);
+
+    if (aSelection->mStyledRanges.mRanges.Length() <= 1) {
+      return;
+    }
+
+    if (aSelection->mFrameSelection->IsUserSelectionReason()) {
+      mUserSelect.emplace(aSelection);
+    }
+
+    nsTArray<StyledRange>& ranges = aSelection->mStyledRanges.mRanges;
+    if (!aSelection->mUserInitiated || aMultiRangeSelection) {
+      // Scripted command or the user is starting a new explicit multi-range
+      // selection.
+      for (StyledRange& entry : ranges) {
+        MOZ_ASSERT(entry.mRange->IsDynamicRange());
+        entry.mRange->AsDynamicRange()->SetIsGenerated(false);
+      }
+      return;
+    }
+
+    if (!IsAnchorRelativeOperation(
+            aSelection->mFrameSelection->mSelectionChangeReasons)) {
+      return;
+    }
+
+    // This operation is against the anchor but our current mAnchorFocusRange
+    // represents the focus in a multi-range selection.  The anchor from a user
+    // perspective is the most distant generated range on the opposite side.
+    // Find that range and make it the mAnchorFocusRange.
+    nsRange* const newAnchorFocusRange =
+        FindGeneratedRangeMostDistantFromAnchor(*aSelection);
+
+    if (!newAnchorFocusRange) {
+      // There are no generated ranges - that's fine.
+      return;
+    }
+
+    // Setup the new mAnchorFocusRange and mark the old one as generated.
+    if (aSelection->mAnchorFocusRange) {
+      aSelection->mAnchorFocusRange->SetIsGenerated(true);
+    }
+
+    newAnchorFocusRange->SetIsGenerated(false);
+    aSelection->mAnchorFocusRange = newAnchorFocusRange;
+
+    RemoveGeneratedRanges(*aSelection);
+
+    if (aSelection->mFrameSelection) {
+      aSelection->mFrameSelection->InvalidateDesiredCaretPos();
+    }
+  }
+
+ private:
+  static nsRange* FindGeneratedRangeMostDistantFromAnchor(
+      const Selection& aSelection) {
+    const nsTArray<StyledRange>& ranges = aSelection.mStyledRanges.mRanges;
+    const size_t len = ranges.Length();
+    nsRange* result{nullptr};
+    if (aSelection.GetDirection() == eDirNext) {
+      for (size_t i = 0; i < len; ++i) {
+        // This function is only called for selections with type == eNormal.
+        // (see MOZ_ASSERT in constructor).
+        // Therefore, all ranges must be dynamic.
+        if (ranges[i].mRange->AsDynamicRange()->IsGenerated()) {
+          result = ranges[i].mRange->AsDynamicRange();
+          break;
+        }
+      }
+    } else {
+      size_t i = len;
+      while (i--) {
+        if (ranges[i].mRange->AsDynamicRange()->IsGenerated()) {
+          result = ranges[i].mRange->AsDynamicRange();
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  static void RemoveGeneratedRanges(Selection& aSelection) {
+    RefPtr<nsPresContext> presContext = aSelection.GetPresContext();
+    nsTArray<StyledRange>& ranges = aSelection.mStyledRanges.mRanges;
+    size_t i = ranges.Length();
+    while (i--) {
+      // This function is only called for selections with type == eNormal.
+      // (see MOZ_ASSERT in constructor).
+      // Therefore, all ranges must be dynamic.
+      if (!ranges[i].mRange->IsDynamicRange()) {
+        continue;
+      }
+      nsRange* range = ranges[i].mRange->AsDynamicRange();
+      if (range->IsGenerated()) {
+        range->UnregisterSelection(aSelection);
+        aSelection.SelectFrames(presContext, *range, false);
+        ranges.RemoveElementAt(i);
+      }
+    }
+  }
+
+  /**
+   * @aParam aSelectionChangeReasons can be multiple of the reasons defined in
+             nsISelectionListener.idl.
+   */
+  static bool IsAnchorRelativeOperation(const int16_t aSelectionChangeReasons) {
+    return aSelectionChangeReasons &
+           (nsISelectionListener::DRAG_REASON |
+            nsISelectionListener::MOUSEDOWN_REASON |
+            nsISelectionListener::MOUSEUP_REASON |
+            nsISelectionListener::COLLAPSETOSTART_REASON);
+  }
+
+  Maybe<Selection::AutoUserInitiated> mUserSelect;
+};
+
+}  // namespace mozilla
+
+////////////BEGIN nsFrameSelection methods
+
+template Result<RefPtr<nsRange>, nsresult>
+nsFrameSelection::CreateRangeExtendedToSomewhere(
+    nsDirection aDirection, const nsSelectionAmount aAmount,
+    CaretMovementStyle aMovementStyle);
+template Result<RefPtr<StaticRange>, nsresult>
+nsFrameSelection::CreateRangeExtendedToSomewhere(
+    nsDirection aDirection, const nsSelectionAmount aAmount,
+    CaretMovementStyle aMovementStyle);
+
+nsFrameSelection::nsFrameSelection(PresShell* aPresShell, nsIContent* aLimiter,
+                                   const bool aAccessibleCaretEnabled) {
+  for (size_t i = 0; i < ArrayLength(mDomSelections); i++) {
+    mDomSelections[i] = new Selection(kPresentSelectionTypes[i], this);
+  }
+
+#ifdef XP_MACOSX
+  // On macOS, cache the current selection to send to service menu of macOS.
+  bool enableAutoCopy = true;
+  AutoCopyListener::Init(nsIClipboard::kSelectionCache);
+#else   // #ifdef XP_MACOSX
+  // Check to see if the auto-copy pref is enabled and make the normal
+  // Selection notifies auto-copy listener of its changes.
+  bool enableAutoCopy = AutoCopyListener::IsPrefEnabled();
+  if (enableAutoCopy) {
+    AutoCopyListener::Init(nsIClipboard::kSelectionClipboard);
+  }
+#endif  // #ifdef XP_MACOSX #else
+
+  if (enableAutoCopy) {
+    int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+    if (mDomSelections[index]) {
+      mDomSelections[index]->NotifyAutoCopy();
+    }
+  }
+
+  mPresShell = aPresShell;
+  mDragState = false;
+  mLimiters.mLimiter = aLimiter;
+
+  // This should only ever be initialized on the main thread, so we are OK here.
+  MOZ_ASSERT(NS_IsMainThread());
+
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+
+  mAccessibleCaretEnabled = aAccessibleCaretEnabled;
+  if (mAccessibleCaretEnabled) {
+    mDomSelections[index]->MaybeNotifyAccessibleCaretEventHub(aPresShell);
+  }
+
+  if (mDomSelections[index]) {
+    mDomSelections[index]->EnableSelectionChangeEvent();
+  }
+}
+
+nsFrameSelection::~nsFrameSelection() = default;
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsFrameSelection)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsFrameSelection)
+  for (size_t i = 0; i < ArrayLength(tmp->mDomSelections); ++i) {
+    tmp->mDomSelections[i] = nullptr;
+  }
+  tmp->mHighlightSelections.Clear();
+
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(
+      mTableSelection.mClosestInclusiveTableCellAncestor)
+  tmp->mTableSelection.mMode = TableSelectionMode::None;
+  tmp->mTableSelection.mDragSelectingCells = false;
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTableSelection.mStartSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTableSelection.mEndSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTableSelection.mAppendStartSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTableSelection.mUnselectCellOnMouseUp)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mMaintainedRange.mRange)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mLimiters.mLimiter)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mLimiters.mAncestorLimiter)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsFrameSelection)
+  if (tmp->mPresShell && tmp->mPresShell->GetDocument() &&
+      nsCCUncollectableMarker::InGeneration(
+          cb, tmp->mPresShell->GetDocument()->GetMarkedCCGeneration())) {
+    return NS_SUCCESS_INTERRUPTED_TRAVERSE;
+  }
+  for (size_t i = 0; i < ArrayLength(tmp->mDomSelections); ++i) {
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDomSelections[i])
+  }
+
+  for (const auto& value : tmp->mHighlightSelections) {
+    CycleCollectionNoteChild(cb, value.second().get(),
+                             "mHighlightSelections[]");
+  }
+
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(
+      mTableSelection.mClosestInclusiveTableCellAncestor)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTableSelection.mStartSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTableSelection.mEndSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTableSelection.mAppendStartSelectedCell)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTableSelection.mUnselectCellOnMouseUp)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMaintainedRange.mRange)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLimiters.mLimiter)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLimiters.mAncestorLimiter)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+bool nsFrameSelection::Caret::IsVisualMovement(
+    bool aContinueSelection, CaretMovementStyle aMovementStyle) const {
+  int32_t movementFlag = StaticPrefs::bidi_edit_caret_movement_style();
+  return aMovementStyle == eVisual ||
+         (aMovementStyle == eUsePrefStyle &&
+          (movementFlag == 1 || (movementFlag == 2 && !aContinueSelection)));
+}
+
+// Get the x (or y, in vertical writing mode) position requested
+// by the Key Handling for line-up/down
+nsresult nsFrameSelection::DesiredCaretPos::FetchPos(
+    nsPoint& aDesiredCaretPos, const PresShell& aPresShell,
+    Selection& aNormalSelection) const {
+  MOZ_ASSERT(aNormalSelection.GetType() == SelectionType::eNormal);
+
+  if (mIsSet) {
+    aDesiredCaretPos = mValue;
+    return NS_OK;
+  }
+
+  RefPtr<nsCaret> caret = aPresShell.GetCaret();
+  if (!caret) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  caret->SetSelection(&aNormalSelection);
+
+  nsRect coord;
+  nsIFrame* caretFrame = caret->GetGeometry(&coord);
+  if (!caretFrame) {
+    return NS_ERROR_FAILURE;
+  }
+  nsPoint viewOffset(0, 0);
+  nsView* view = nullptr;
+  caretFrame->GetOffsetFromView(viewOffset, &view);
+  if (view) {
+    coord += viewOffset;
+  }
+  aDesiredCaretPos = coord.TopLeft();
+  return NS_OK;
+}
+
+void nsFrameSelection::InvalidateDesiredCaretPos()  // do not listen to
+                                                    // mDesiredCaretPos.mValue;
+                                                    // you must get another.
+{
+  mDesiredCaretPos.Invalidate();
+}
+
+void nsFrameSelection::DesiredCaretPos::Invalidate() { mIsSet = false; }
+
+void nsFrameSelection::DesiredCaretPos::Set(const nsPoint& aPos) {
+  mValue = aPos;
+  mIsSet = true;
+}
+
+nsresult nsFrameSelection::ConstrainFrameAndPointToAnchorSubtree(
+    nsIFrame* aFrame, const nsPoint& aPoint, nsIFrame** aRetFrame,
+    nsPoint& aRetPoint) const {
+  //
+  // The whole point of this method is to return a frame and point that
+  // that lie within the same valid subtree as the anchor node's frame,
+  // for use with the method GetContentAndOffsetsFromPoint().
+  //
+  // A valid subtree is defined to be one where all the content nodes in
+  // the tree have a valid parent-child relationship.
+  //
+  // If the anchor frame and aFrame are in the same subtree, aFrame will
+  // be returned in aRetFrame. If they are in different subtrees, we
+  // return the frame for the root of the subtree.
+  //
+
+  if (!aFrame || !aRetFrame) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  *aRetFrame = aFrame;
+  aRetPoint = aPoint;
+
+  //
+  // Get the frame and content for the selection's anchor point!
+  //
+
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  if (!mDomSelections[index]) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  nsCOMPtr<nsIContent> anchorContent =
+      do_QueryInterface(mDomSelections[index]->GetAnchorNode());
+  if (!anchorContent) {
+    return NS_ERROR_FAILURE;
+  }
+
+  //
+  // Now find the root of the subtree containing the anchor's content.
+  //
+
+  NS_ENSURE_STATE(mPresShell);
+  RefPtr<PresShell> presShell = mPresShell;
+  nsIContent* anchorRoot = anchorContent->GetSelectionRootContent(presShell);
+  NS_ENSURE_TRUE(anchorRoot, NS_ERROR_UNEXPECTED);
+
+  //
+  // Now find the root of the subtree containing aFrame's content.
+  //
+
+  nsCOMPtr<nsIContent> content = aFrame->GetContent();
+
+  if (content) {
+    nsIContent* contentRoot = content->GetSelectionRootContent(presShell);
+    NS_ENSURE_TRUE(contentRoot, NS_ERROR_UNEXPECTED);
+
+    if (anchorRoot == contentRoot) {
+      // If the aFrame's content isn't the capturing content, it should be
+      // a descendant.  At this time, we can return simply.
+      nsIContent* capturedContent = PresShell::GetCapturingContent();
+      if (capturedContent != content) {
+        return NS_OK;
+      }
+
+      // Find the frame under the mouse cursor with the root frame.
+      // At this time, don't use the anchor's frame because it may not have
+      // fixed positioned frames.
+      nsIFrame* rootFrame = presShell->GetRootFrame();
+      nsPoint ptInRoot = aPoint + aFrame->GetOffsetTo(rootFrame);
+      nsIFrame* cursorFrame =
+          nsLayoutUtils::GetFrameForPoint(RelativeTo{rootFrame}, ptInRoot);
+
+      // If the mouse cursor in on a frame which is descendant of same
+      // selection root, we can expand the selection to the frame.
+      if (cursorFrame && cursorFrame->PresShell() == presShell) {
+        nsCOMPtr<nsIContent> cursorContent = cursorFrame->GetContent();
+        NS_ENSURE_TRUE(cursorContent, NS_ERROR_FAILURE);
+        nsIContent* cursorContentRoot =
+            cursorContent->GetSelectionRootContent(presShell);
+        NS_ENSURE_TRUE(cursorContentRoot, NS_ERROR_UNEXPECTED);
+        if (cursorContentRoot == anchorRoot) {
+          *aRetFrame = cursorFrame;
+          aRetPoint = aPoint + aFrame->GetOffsetTo(cursorFrame);
+          return NS_OK;
+        }
+      }
+      // Otherwise, e.g., the cursor isn't on any frames (e.g., the mouse
+      // cursor is out of the window), we should use the frame of the anchor
+      // root.
+    }
+  }
+
+  //
+  // When we can't find a frame which is under the mouse cursor and has a same
+  // selection root as the anchor node's, we should return the selection root
+  // frame.
+  //
+
+  *aRetFrame = anchorRoot->GetPrimaryFrame();
+
+  if (!*aRetFrame) {
+    return NS_ERROR_FAILURE;
+  }
+
+  //
+  // Now make sure that aRetPoint is converted to the same coordinate
+  // system used by aRetFrame.
+  //
+
+  aRetPoint = aPoint + aFrame->GetOffsetTo(*aRetFrame);
+
+  return NS_OK;
+}
+
+void nsFrameSelection::SetCaretBidiLevelAndMaybeSchedulePaint(
+    mozilla::intl::BidiEmbeddingLevel aLevel) {
+  // If the current level is undefined, we have just inserted new text.
+  // In this case, we don't want to reset the keyboard language
+  mCaret.mBidiLevel = aLevel;
+
+  RefPtr<nsCaret> caret;
+  if (mPresShell && (caret = mPresShell->GetCaret())) {
+    caret->SchedulePaint();
+  }
+}
+
+mozilla::intl::BidiEmbeddingLevel nsFrameSelection::GetCaretBidiLevel() const {
+  return mCaret.mBidiLevel;
+}
+
+void nsFrameSelection::UndefineCaretBidiLevel() {
+  mCaret.mBidiLevel = mozilla::intl::BidiEmbeddingLevel(mCaret.mBidiLevel |
+                                                        BIDI_LEVEL_UNDEFINED);
+}
+
+#ifdef PRINT_RANGE
+void printRange(nsRange* aDomRange) {
+  if (!aDomRange) {
+    printf("NULL Range\n");
+  }
+  nsINode* startNode = aDomRange->GetStartContainer();
+  nsINode* endNode = aDomRange->GetEndContainer();
+  int32_t startOffset = aDomRange->StartOffset();
+  int32_t endOffset = aDomRange->EndOffset();
+
+  printf("range: 0x%lx\t start: 0x%lx %ld, \t end: 0x%lx,%ld\n",
+         (unsigned long)aDomRange, (unsigned long)startNode, (long)startOffset,
+         (unsigned long)endNode, (long)endOffset);
+}
+#endif /* PRINT_RANGE */
+
+static nsAtom* GetTag(nsINode* aNode) {
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
+  if (!content) {
+    MOZ_ASSERT_UNREACHABLE("bad node passed to GetTag()");
+    return nullptr;
+  }
+
+  return content->NodeInfo()->NameAtom();
+}
+
+/**
+ * https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor.
+ */
+static nsINode* GetClosestInclusiveTableCellAncestor(nsINode* aDomNode) {
+  if (!aDomNode) return nullptr;
+  nsINode* current = aDomNode;
+  // Start with current node and look for a table cell
+  while (current) {
+    nsAtom* tag = GetTag(current);
+    if (tag == nsGkAtoms::td || tag == nsGkAtoms::th) return current;
+    current = current->GetParent();
+  }
+  return nullptr;
+}
+
+static nsDirection GetCaretDirection(const nsIFrame& aFrame,
+                                     nsDirection aDirection,
+                                     bool aVisualMovement) {
+  const mozilla::intl::BidiDirection paragraphDirection =
+      nsBidiPresUtils::ParagraphDirection(&aFrame);
+  return (aVisualMovement &&
+          paragraphDirection == mozilla::intl::BidiDirection::RTL)
+             ? nsDirection(1 - aDirection)
+             : aDirection;
+}
+
+nsresult nsFrameSelection::MoveCaret(nsDirection aDirection,
+                                     bool aContinueSelection,
+                                     const nsSelectionAmount aAmount,
+                                     CaretMovementStyle aMovementStyle) {
+  NS_ENSURE_STATE(mPresShell);
+  // Flush out layout, since we need it to be up to date to do caret
+  // positioning.
+  OwningNonNull<PresShell> presShell(*mPresShell);
+  presShell->FlushPendingNotifications(FlushType::Layout);
+
+  if (!mPresShell) {
+    return NS_OK;
+  }
+
+  nsPresContext* context = mPresShell->GetPresContext();
+  if (!context) {
+    return NS_ERROR_FAILURE;
+  }
+
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  const RefPtr<Selection> sel = mDomSelections[index];
+  if (!sel) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  int32_t scrollFlags = Selection::SCROLL_FOR_CARET_MOVE;
+  if (sel->IsEditorSelection()) {
+    // If caret moves in editor, it should cause scrolling even if it's in
+    // overflow: hidden;.
+    scrollFlags |= Selection::SCROLL_OVERFLOW_HIDDEN;
+  }
+
+  const bool doCollapse = [&] {
+    if (sel->IsCollapsed() || aContinueSelection) {
+      return false;
+    }
+    if (aAmount > eSelectLine) {
+      return false;
+    }
+    int32_t caretStyle = StaticPrefs::layout_selection_caret_style();
+    return caretStyle == 2 || (caretStyle == 0 && aAmount != eSelectLine);
+  }();
+
+  if (doCollapse) {
+    if (aDirection == eDirPrevious) {
+      SetChangeReasons(nsISelectionListener::COLLAPSETOSTART_REASON);
+      mCaret.mHint = CARET_ASSOCIATE_AFTER;
+    } else {
+      SetChangeReasons(nsISelectionListener::COLLAPSETOEND_REASON);
+      mCaret.mHint = CARET_ASSOCIATE_BEFORE;
+    }
+  } else {
+    SetChangeReasons(nsISelectionListener::KEYPRESS_REASON);
+  }
+
+  mCaretMoveAmount = aAmount;
+
+  AutoPrepareFocusRange prep(sel, false);
+
+  // we must keep this around and revalidate it when its just UP/DOWN
+  nsPoint desiredPos(0, 0);
+
+  if (aAmount == eSelectLine) {
+    nsresult result = mDesiredCaretPos.FetchPos(desiredPos, *mPresShell, *sel);
+    if (NS_FAILED(result)) {
+      return result;
+    }
+    mDesiredCaretPos.Set(desiredPos);
+  }
+
+  bool visualMovement =
+      mCaret.IsVisualMovement(aContinueSelection, aMovementStyle);
+  nsIFrame* frame = sel->GetPrimaryFrameForFocusNode(visualMovement);
+  if (!frame) {
+    return NS_ERROR_FAILURE;
+  }
+
+  Result<bool, nsresult> isIntraLineCaretMove = IsIntraLineCaretMove(aAmount);
+  nsDirection direction{aDirection};
+  if (isIntraLineCaretMove.isErr()) {
+    return isIntraLineCaretMove.unwrapErr();
+  }
+  if (isIntraLineCaretMove.inspect()) {
+    // Forget old caret position for moving caret to different line since
+    // caret position may be changed.
+    mDesiredCaretPos.Invalidate();
+    direction = GetCaretDirection(*frame, aDirection, visualMovement);
+  }
+
+  if (doCollapse) {
+    const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();
+    if (anchorFocusRange) {
+      RefPtr<nsINode> node;
+      uint32_t offset;
+      if (visualMovement && nsBidiPresUtils::IsReversedDirectionFrame(frame)) {
+        direction = nsDirection(1 - direction);
+      }
+      if (direction == eDirPrevious) {
+        node = anchorFocusRange->GetStartContainer();
+        offset = anchorFocusRange->StartOffset();
+      } else {
+        node = anchorFocusRange->GetEndContainer();
+        offset = anchorFocusRange->EndOffset();
+      }
+      sel->CollapseInLimiter(node, offset);
+    }
+    sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,
+                        ScrollAxis(), ScrollAxis(), scrollFlags);
+    return NS_OK;
+  }
+
+  CaretAssociateHint tHint(mCaret.mHint);  // temporary variable so we dont set
+                                           // mCaret.mHint until it is necessary
+
+  Result<PeekOffsetStruct, nsresult> result = PeekOffsetForCaretMove(
+      direction, aContinueSelection, aAmount, aMovementStyle, desiredPos);
+  nsresult rv;
+  if (result.isOk() && result.inspect().mResultContent) {
+    const PeekOffsetStruct& pos = result.inspect();
+    nsIFrame* theFrame;
+    int32_t currentOffset, frameStart, frameEnd;
+
+    if (aAmount <= eSelectWordNoSpace) {
+      // For left/right, PeekOffset() sets pos.mResultFrame correctly, but does
+      // not set pos.mAttachForward, so determine the hint here based on the
+      // result frame and offset: If we're at the end of a text frame, set the
+      // hint to ASSOCIATE_BEFORE to indicate that we want the caret displayed
+      // at the end of this frame, not at the beginning of the next one.
+      theFrame = pos.mResultFrame;
+      std::tie(frameStart, frameEnd) = theFrame->GetOffsets();
+      currentOffset = pos.mContentOffset;
+      if (frameEnd == currentOffset && !(frameStart == 0 && frameEnd == 0))
+        tHint = CARET_ASSOCIATE_BEFORE;
+      else
+        tHint = CARET_ASSOCIATE_AFTER;
+    } else {
+      // For up/down and home/end, pos.mResultFrame might not be set correctly,
+      // or not at all. In these cases, get the frame based on the content and
+      // hint returned by PeekOffset().
+      tHint = pos.mAttach;
+      theFrame = GetFrameForNodeOffset(pos.mResultContent, pos.mContentOffset,
+                                       tHint, &currentOffset);
+      if (!theFrame) return NS_ERROR_FAILURE;
+
+      std::tie(frameStart, frameEnd) = theFrame->GetOffsets();
+    }
+
+    if (context->BidiEnabled()) {
+      switch (aAmount) {
+        case eSelectBeginLine:
+        case eSelectEndLine: {
+          // In Bidi contexts, PeekOffset calculates pos.mContentOffset
+          // differently depending on whether the movement is visual or logical.
+          // For visual movement, pos.mContentOffset depends on the direction-
+          // ality of the first/last frame on the line (theFrame), and the caret
+          // directionality must correspond.
+          FrameBidiData bidiData = theFrame->GetBidiData();
+          SetCaretBidiLevelAndMaybeSchedulePaint(
+              visualMovement ? bidiData.embeddingLevel : bidiData.baseLevel);
+          break;
+        }
+        default:
+          // If the current position is not a frame boundary, it's enough just
+          // to take the Bidi level of the current frame
+          if ((pos.mContentOffset != frameStart &&
+               pos.mContentOffset != frameEnd) ||
+              eSelectLine == aAmount) {
+            SetCaretBidiLevelAndMaybeSchedulePaint(
+                theFrame->GetEmbeddingLevel());
+          } else {
+            BidiLevelFromMove(mPresShell, pos.mResultContent,
+                              pos.mContentOffset, aAmount, tHint);
+          }
+      }
+    }
+    // "pos" is on the stack, so pos.mResultContent has stack lifetime, so using
+    // MOZ_KnownLive is ok.
+    const FocusMode focusMode = aContinueSelection
+                                    ? FocusMode::kExtendSelection
+                                    : FocusMode::kCollapseToNewPoint;
+    rv = TakeFocus(MOZ_KnownLive(*pos.mResultContent), pos.mContentOffset,
+                   pos.mContentOffset, tHint, focusMode);
+  } else if (aAmount <= eSelectWordNoSpace && direction == eDirNext &&
+             !aContinueSelection) {
+    // Collapse selection if PeekOffset failed, we either
+    //  1. bumped into the BRFrame, bug 207623
+    //  2. had select-all in a text input (DIV range), bug 352759.
+    bool isBRFrame = frame->IsBrFrame();
+    RefPtr<nsINode> node = sel->GetFocusNode();
+    sel->CollapseInLimiter(node, sel->FocusOffset());
+    // Note: 'frame' might be dead here.
+    if (!isBRFrame) {
+      mCaret.mHint = CARET_ASSOCIATE_BEFORE;  // We're now at the end of the
+                                              // frame to the left.
+    }
+    rv = NS_OK;
+  } else {
+    rv = result.isErr() ? result.unwrapErr() : NS_OK;
+  }
+  if (NS_SUCCEEDED(rv)) {
+    rv = sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,
+                             ScrollAxis(), ScrollAxis(), scrollFlags);
+  }
+
+  return rv;
+}
+
+Result<PeekOffsetStruct, nsresult> nsFrameSelection::PeekOffsetForCaretMove(
+    nsDirection aDirection, bool aContinueSelection,
+    const nsSelectionAmount aAmount, CaretMovementStyle aMovementStyle,
+    const nsPoint& aDesiredCaretPos) const {
+  Selection* selection =
+      mDomSelections[GetIndexFromSelectionType(SelectionType::eNormal)];
+  if (!selection) {
+    return Err(NS_ERROR_NULL_POINTER);
+  }
+
+  const bool visualMovement =
+      mCaret.IsVisualMovement(aContinueSelection, aMovementStyle);
+
+  int32_t offsetused = 0;
+  nsIFrame* frame =
+      selection->GetPrimaryFrameForFocusNode(visualMovement, &offsetused);
+  if (!frame) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  // set data using mLimiters.mLimiter to stop on scroll views.  If we have a
+  // limiter then we stop peeking when we hit scrollable views.  If no limiter
+  // then just let it go ahead
+  PeekOffsetOptions options{PeekOffsetOption::JumpLines,
+                            PeekOffsetOption::IsKeyboardSelect};
+  if (mLimiters.mLimiter) {
+    options += PeekOffsetOption::ScrollViewStop;
+  }
+  if (visualMovement) {
+    options += PeekOffsetOption::Visual;
+  }
+  if (aContinueSelection) {
+    options += PeekOffsetOption::Extend;
+  }
+  if (selection->IsEditorSelection()) {
+    options += PeekOffsetOption::ForceEditableRegion;
+  }
+  PeekOffsetStruct pos(aAmount, aDirection, offsetused, aDesiredCaretPos,
+                       options);
+  nsresult rv = frame->PeekOffset(&pos);
+  if (NS_FAILED(rv)) {
+    return Err(rv);
+  }
+  return pos;
+}
+
+nsPrevNextBidiLevels nsFrameSelection::GetPrevNextBidiLevels(
+    nsIContent* aNode, uint32_t aContentOffset, bool aJumpLines) const {
+  return GetPrevNextBidiLevels(aNode, aContentOffset, mCaret.mHint, aJumpLines);
+}
+
+// static
+nsPrevNextBidiLevels nsFrameSelection::GetPrevNextBidiLevels(
+    nsIContent* aNode, uint32_t aContentOffset, CaretAssociateHint aHint,
+    bool aJumpLines) {
+  // Get the level of the frames on each side
+  nsIFrame* currentFrame;
+  int32_t currentOffset;
+  nsDirection direction;
+
+  nsPrevNextBidiLevels levels{};
+  levels.SetData(nullptr, nullptr, mozilla::intl::BidiEmbeddingLevel::LTR(),
+                 mozilla::intl::BidiEmbeddingLevel::LTR());
+
+  currentFrame = GetFrameForNodeOffset(
+      aNode, static_cast<int32_t>(aContentOffset), aHint, &currentOffset);
+  if (!currentFrame) {
+    return levels;
+  }
+
+  auto [frameStart, frameEnd] = currentFrame->GetOffsets();
+
+  if (0 == frameStart && 0 == frameEnd) {
+    direction = eDirPrevious;
+  } else if (frameStart == currentOffset) {
+    direction = eDirPrevious;
+  } else if (frameEnd == currentOffset) {
+    direction = eDirNext;
+  } else {
+    // we are neither at the beginning nor at the end of the frame, so we have
+    // no worries
+    mozilla::intl::BidiEmbeddingLevel currentLevel =
+        currentFrame->GetEmbeddingLevel();
+    levels.SetData(currentFrame, currentFrame, currentLevel, currentLevel);
+    return levels;
+  }
+
+  PeekOffsetOptions peekOffsetOptions{PeekOffsetOption::ScrollViewStop};
+  if (aJumpLines) {
+    peekOffsetOptions += PeekOffsetOption::JumpLines;
+  }
+  nsIFrame* newFrame =
+      currentFrame->GetFrameFromDirection(direction, peekOffsetOptions).mFrame;
+
+  FrameBidiData currentBidi = currentFrame->GetBidiData();
+  mozilla::intl::BidiEmbeddingLevel currentLevel = currentBidi.embeddingLevel;
+  mozilla::intl::BidiEmbeddingLevel newLevel =
+      newFrame ? newFrame->GetEmbeddingLevel() : currentBidi.baseLevel;
+
+  // If not jumping lines, disregard br frames, since they might be positioned
+  // incorrectly.
+  // XXX This could be removed once bug 339786 is fixed.
+  if (!aJumpLines) {
+    if (currentFrame->IsBrFrame()) {
+      currentFrame = nullptr;
+      currentLevel = currentBidi.baseLevel;
+    }
+    if (newFrame && newFrame->IsBrFrame()) {
+      newFrame = nullptr;
+      newLevel = currentBidi.baseLevel;
+    }
+  }
+
+  if (direction == eDirNext)
+    levels.SetData(currentFrame, newFrame, currentLevel, newLevel);
+  else
+    levels.SetData(newFrame, currentFrame, newLevel, currentLevel);
+
+  return levels;
+}
+
+nsresult nsFrameSelection::GetFrameFromLevel(
+    nsIFrame* aFrameIn, nsDirection aDirection,
+    mozilla::intl::BidiEmbeddingLevel aBidiLevel, nsIFrame** aFrameOut) const {
+  NS_ENSURE_STATE(mPresShell);
+  mozilla::intl::BidiEmbeddingLevel foundLevel =
+      mozilla::intl::BidiEmbeddingLevel::LTR();
+  nsIFrame* foundFrame = aFrameIn;
+
+  nsCOMPtr<nsIFrameEnumerator> frameTraversal;
+  nsresult result;
+  nsCOMPtr<nsIFrameTraversal> trav(
+      do_CreateInstance(kFrameTraversalCID, &result));
+  if (NS_FAILED(result)) return result;
+
+  result =
+      trav->NewFrameTraversal(getter_AddRefs(frameTraversal),
+                              mPresShell->GetPresContext(), aFrameIn, eLeaf,
+                              false,  // aVisual
+                              false,  // aLockInScrollView
+                              false,  // aFollowOOFs
+                              false   // aSkipPopupChecks
+      );
+  if (NS_FAILED(result)) return result;
+
+  do {
+    *aFrameOut = foundFrame;
+    foundFrame = frameTraversal->Traverse(aDirection == eDirNext);
+    if (!foundFrame) return NS_ERROR_FAILURE;
+    foundLevel = foundFrame->GetEmbeddingLevel();
+
+  } while (foundLevel > aBidiLevel);
+
+  return NS_OK;
+}
+
+nsresult nsFrameSelection::MaintainSelection(nsSelectionAmount aAmount) {
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  if (!mDomSelections[index]) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  mMaintainedRange.MaintainAnchorFocusRange(*mDomSelections[index], aAmount);
+
+  return NS_OK;
+}
+
+void nsFrameSelection::BidiLevelFromMove(PresShell* aPresShell,
+                                         nsIContent* aNode,
+                                         uint32_t aContentOffset,
+                                         nsSelectionAmount aAmount,
+                                         CaretAssociateHint aHint) {
+  switch (aAmount) {
+    // Movement within the line: the new cursor Bidi level is the level of the
+    // last character moved over
+    case eSelectCharacter:
+    case eSelectCluster:
+    case eSelectWord:
+    case eSelectWordNoSpace:
+    case eSelectBeginLine:
+    case eSelectEndLine:
+    case eSelectNoAmount: {
+      nsPrevNextBidiLevels levels =
+          GetPrevNextBidiLevels(aNode, aContentOffset, aHint, false);
+
+      SetCaretBidiLevelAndMaybeSchedulePaint(aHint == CARET_ASSOCIATE_BEFORE
+                                                 ? levels.mLevelBefore
+                                                 : levels.mLevelAfter);
+      break;
+    }
+      /*
+    // Up and Down: the new cursor Bidi level is the smaller of the two
+    surrounding characters case eSelectLine: case eSelectParagraph:
+      GetPrevNextBidiLevels(aContext, aNode, aContentOffset, &firstFrame,
+    &secondFrame, &firstLevel, &secondLevel);
+      aPresShell->SetCaretBidiLevelAndMaybeSchedulePaint(std::min(firstLevel,
+    secondLevel)); break;
+      */
+
+    default:
+      UndefineCaretBidiLevel();
+  }
+}
+
+void nsFrameSelection::BidiLevelFromClick(nsIContent* aNode,
+                                          uint32_t aContentOffset) {
+  nsIFrame* clickInFrame = nullptr;
+  int32_t OffsetNotUsed;
+
+  clickInFrame = GetFrameForNodeOffset(aNode, aContentOffset, mCaret.mHint,
+                                       &OffsetNotUsed);
+  if (!clickInFrame) return;
+
+  SetCaretBidiLevelAndMaybeSchedulePaint(clickInFrame->GetEmbeddingLevel());
+}
+
+void nsFrameSelection::MaintainedRange::AdjustNormalSelection(
+    const nsIContent* aContent, const int32_t aOffset,
+    Selection& aNormalSelection) const {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  if (!mRange || !aContent) {
+    return;
+  }
+
+  nsINode* rangeStartNode = mRange->GetStartContainer();
+  nsINode* rangeEndNode = mRange->GetEndContainer();
+  const uint32_t rangeStartOffset = mRange->StartOffset();
+  const uint32_t rangeEndOffset = mRange->EndOffset();
+
+  NS_ASSERTION(aOffset >= 0, "aOffset should not be negative");
+  const Maybe<int32_t> relToStart =
+      nsContentUtils::ComparePoints_AllowNegativeOffsets(
+          rangeStartNode, rangeStartOffset, aContent, aOffset);
+  if (NS_WARN_IF(!relToStart)) {
+    // Potentially handle this properly when Selection across Shadow DOM
+    // boundary is implemented
+    // (https://bugzilla.mozilla.org/show_bug.cgi?id=1607497).
+    return;
+  }
+
+  const Maybe<int32_t> relToEnd =
+      nsContentUtils::ComparePoints_AllowNegativeOffsets(
+          rangeEndNode, rangeEndOffset, aContent, aOffset);
+  if (NS_WARN_IF(!relToEnd)) {
+    // Potentially handle this properly when Selection across Shadow DOM
+    // boundary is implemented
+    // (https://bugzilla.mozilla.org/show_bug.cgi?id=1607497).
+    return;
+  }
+
+  // If aContent/aOffset is inside (or at the edge of) the maintained
+  // selection, or if it is on the "anchor" side of the maintained selection,
+  // we need to do something.
+  if ((*relToStart <= 0 && *relToEnd >= 0) ||
+      (*relToStart > 0 && aNormalSelection.GetDirection() == eDirNext) ||
+      (*relToEnd < 0 && aNormalSelection.GetDirection() == eDirPrevious)) {
+    // Set the current range to the maintained range.
+    aNormalSelection.ReplaceAnchorFocusRange(mRange);
+    // Set the direction of the selection so that the anchor will be on the
+    // far side of the maintained selection, relative to aContent/aOffset.
+    aNormalSelection.SetDirection(*relToStart > 0 ? eDirPrevious : eDirNext);
+  }
+}
+
+void nsFrameSelection::MaintainedRange::AdjustContentOffsets(
+    nsIFrame::ContentOffsets& aOffsets, const bool aScrollViewStop) const {
+  // Adjust offsets according to maintained amount
+  if (mRange && mAmount != eSelectNoAmount) {
+    nsINode* rangenode = mRange->GetStartContainer();
+    int32_t rangeOffset = mRange->StartOffset();
+    const Maybe<int32_t> relativePosition = nsContentUtils::ComparePoints(
+        rangenode, rangeOffset, aOffsets.content, aOffsets.offset);
+    if (NS_WARN_IF(!relativePosition)) {
+      // Potentially handle this properly when Selection across Shadow DOM
+      // boundary is implemented
+      // (https://bugzilla.mozilla.org/show_bug.cgi?id=1607497).
+      return;
+    }
+
+    nsDirection direction = *relativePosition > 0 ? eDirPrevious : eDirNext;
+    nsSelectionAmount amount = mAmount;
+    if (amount == eSelectBeginLine && direction == eDirNext) {
+      amount = eSelectEndLine;
+    }
+
+    int32_t offset;
+    nsIFrame* frame = GetFrameForNodeOffset(aOffsets.content, aOffsets.offset,
+                                            CARET_ASSOCIATE_AFTER, &offset);
+
+    PeekOffsetOptions peekOffsetOptions{};
+    if (aScrollViewStop) {
+      peekOffsetOptions += PeekOffsetOption::ScrollViewStop;
+    }
+    if (frame && amount == eSelectWord && direction == eDirPrevious) {
+      // To avoid selecting the previous word when at start of word,
+      // first move one character forward.
+      PeekOffsetStruct charPos(eSelectCharacter, eDirNext, offset,
+                               nsPoint(0, 0), peekOffsetOptions);
+      if (NS_SUCCEEDED(frame->PeekOffset(&charPos))) {
+        frame = charPos.mResultFrame;
+        offset = charPos.mContentOffset;
+      }
+    }
+
+    PeekOffsetStruct pos(amount, direction, offset, nsPoint(0, 0),
+                         peekOffsetOptions);
+    if (frame && NS_SUCCEEDED(frame->PeekOffset(&pos)) && pos.mResultContent) {
+      aOffsets.content = pos.mResultContent;
+      aOffsets.offset = pos.mContentOffset;
+    }
+  }
+}
+
+void nsFrameSelection::MaintainedRange::MaintainAnchorFocusRange(
+    const Selection& aNormalSelection, const nsSelectionAmount aAmount) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  mAmount = aAmount;
+
+  const nsRange* anchorFocusRange = aNormalSelection.GetAnchorFocusRange();
+  if (anchorFocusRange && aAmount != eSelectNoAmount) {
+    mRange = anchorFocusRange->CloneRange();
+    return;
+  }
+
+  mRange = nullptr;
+}
+
+nsresult nsFrameSelection::HandleClick(nsIContent* aNewFocus,
+                                       uint32_t aContentOffset,
+                                       uint32_t aContentEndOffset,
+                                       const FocusMode aFocusMode,
+                                       CaretAssociateHint aHint) {
+  if (!aNewFocus) return NS_ERROR_INVALID_ARG;
+
+  if (MOZ_LOG_TEST(sFrameSelectionLog, LogLevel::Debug)) {
+    const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+    MOZ_LOG(sFrameSelectionLog, LogLevel::Debug,
+            ("%s: selection=%p, new focus=%p, offsets=(%u,%u), focus mode=%i",
+             __FUNCTION__,
+             mDomSelections[index] ? mDomSelections[index].get() : nullptr,
+             aNewFocus, aContentOffset, aContentEndOffset,
+             static_cast<int>(aFocusMode)));
+  }
+
+  mDesiredCaretPos.Invalidate();
+
+  if (aFocusMode != FocusMode::kExtendSelection) {
+    mMaintainedRange.mRange = nullptr;
+    if (!IsValidSelectionPoint(aNewFocus)) {
+      mLimiters.mAncestorLimiter = nullptr;
+    }
+  }
+
+  // Don't take focus when dragging off of a table
+  if (!mTableSelection.mDragSelectingCells) {
+    BidiLevelFromClick(aNewFocus, aContentOffset);
+    SetChangeReasons(nsISelectionListener::MOUSEDOWN_REASON +
+                     nsISelectionListener::DRAG_REASON);
+
+    const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+    RefPtr<Selection> selection = mDomSelections[index];
+    MOZ_ASSERT(selection);
+
+    if (aFocusMode == FocusMode::kExtendSelection) {
+      mMaintainedRange.AdjustNormalSelection(aNewFocus, aContentOffset,
+                                             *selection);
+    }
+
+    AutoPrepareFocusRange prep(selection,
+                               aFocusMode == FocusMode::kMultiRangeSelection);
+    return TakeFocus(*aNewFocus, aContentOffset, aContentEndOffset, aHint,
+                     aFocusMode);
+  }
+
+  return NS_OK;
+}
+
+void nsFrameSelection::HandleDrag(nsIFrame* aFrame, const nsPoint& aPoint) {
+  if (!aFrame || !mPresShell) {
+    return;
+  }
+
+  nsresult result;
+  nsIFrame* newFrame = 0;
+  nsPoint newPoint;
+
+  result = ConstrainFrameAndPointToAnchorSubtree(aFrame, aPoint, &newFrame,
+                                                 newPoint);
+  if (NS_FAILED(result)) return;
+  if (!newFrame) return;
+
+  nsIFrame::ContentOffsets offsets =
+      newFrame->GetContentOffsetsFromPoint(newPoint);
+  if (!offsets.content) return;
+
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  RefPtr<Selection> selection = mDomSelections[index];
+  if (newFrame->IsSelected() && selection) {
+    // `MOZ_KnownLive` required because of
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1636889.
+    mMaintainedRange.AdjustNormalSelection(MOZ_KnownLive(offsets.content),
+                                           offsets.offset, *selection);
+  }
+
+  const bool scrollViewStop = mLimiters.mLimiter != nullptr;
+  mMaintainedRange.AdjustContentOffsets(offsets, scrollViewStop);
+
+  // TODO: no click has happened, rename `HandleClick`.
+  HandleClick(MOZ_KnownLive(offsets.content) /* bug 1636889 */, offsets.offset,
+              offsets.offset, FocusMode::kExtendSelection, offsets.associate);
+}
+
+nsresult nsFrameSelection::StartAutoScrollTimer(nsIFrame* aFrame,
+                                                const nsPoint& aPoint,
+                                                uint32_t aDelay) {
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  if (!mDomSelections[index]) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  RefPtr<Selection> selection = mDomSelections[index];
+  return selection->StartAutoScrollTimer(aFrame, aPoint, aDelay);
+}
+
+void nsFrameSelection::StopAutoScrollTimer() {
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  if (!mDomSelections[index]) {
+    return;
+  }
+
+  mDomSelections[index]->StopAutoScrollTimer();
+}
+
+// static
+nsINode* nsFrameSelection::TableSelection::IsContentInActivelyEditableTableCell(
+    nsPresContext* aContext, nsIContent* aContent) {
+  if (!aContext) {
+    return nullptr;
+  }
+
+  RefPtr<HTMLEditor> htmlEditor = nsContentUtils::GetHTMLEditor(aContext);
+  if (!htmlEditor) {
+    return nullptr;
+  }
+
+  nsINode* inclusiveTableCellAncestor =
+      GetClosestInclusiveTableCellAncestor(aContent);
+  if (!inclusiveTableCellAncestor) {
+    return nullptr;
+  }
+
+  const Element* editingHost = htmlEditor->ComputeEditingHost();
+  if (!editingHost) {
+    return nullptr;
+  }
+
+  const bool editableCell =
+      inclusiveTableCellAncestor->IsInclusiveDescendantOf(editingHost);
+  return editableCell ? inclusiveTableCellAncestor : nullptr;
+}
+
+namespace {
+struct ParentAndOffset {
+  explicit ParentAndOffset(const nsINode& aNode)
+      : mParent{aNode.GetParent()},
+        mOffset{mParent ? mParent->ComputeIndexOf_Deprecated(&aNode) : 0} {}
+
+  nsINode* mParent;
+
+  // 0, if there's no parent.
+  int32_t mOffset;
+};
+
+}  // namespace
+/**
+hard to go from nodes to frames, easy the other way!
+ */
+nsresult nsFrameSelection::TakeFocus(nsIContent& aNewFocus,
+                                     uint32_t aContentOffset,
+                                     uint32_t aContentEndOffset,
+                                     CaretAssociateHint aHint,
+                                     const FocusMode aFocusMode) {
+  NS_ENSURE_STATE(mPresShell);
+
+  if (!IsValidSelectionPoint(&aNewFocus)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  MOZ_LOG(sFrameSelectionLog, LogLevel::Verbose,
+          ("%s: new focus=%p, offsets=(%u, %u), hint=%i, focusMode=%i",
+           __FUNCTION__, &aNewFocus, aContentOffset, aContentEndOffset,
+           static_cast<int>(aHint), static_cast<int>(aFocusMode)));
+
+  mPresShell->FrameSelectionWillTakeFocus(*this);
+
+  // Clear all table selection data
+  mTableSelection.mMode = TableSelectionMode::None;
+  mTableSelection.mDragSelectingCells = false;
+  mTableSelection.mStartSelectedCell = nullptr;
+  mTableSelection.mEndSelectedCell = nullptr;
+  mTableSelection.mAppendStartSelectedCell = nullptr;
+  mCaret.mHint = aHint;
+
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  if (!mDomSelections[index]) return NS_ERROR_NULL_POINTER;
+
+  Maybe<Selection::AutoUserInitiated> userSelect;
+  if (IsUserSelectionReason()) {
+    userSelect.emplace(mDomSelections[index]);
+  }
+
+  // traverse through document and unselect crap here
+  switch (aFocusMode) {
+    case FocusMode::kCollapseToNewPoint:
+      [[fallthrough]];
+    case FocusMode::kMultiRangeSelection: {
+      // single click? setting cursor down
+      const Batching saveBatching =
+          mBatching;  // hack to use the collapse code.
+      mBatching.mCounter = 1;
+
+      RefPtr<Selection> selection = mDomSelections[index];
+
+      if (aFocusMode == FocusMode::kMultiRangeSelection) {
+        // Remove existing collapsed ranges as there's no point in having
+        // non-anchor/focus collapsed ranges.
+        selection->RemoveCollapsedRanges();
+
+        ErrorResult error;
+        RefPtr<nsRange> newRange = nsRange::Create(
+            &aNewFocus, aContentOffset, &aNewFocus, aContentOffset, error);
+        if (NS_WARN_IF(error.Failed())) {
+          return error.StealNSResult();
+        }
+        MOZ_ASSERT(newRange);
+        selection->AddRangeAndSelectFramesAndNotifyListeners(*newRange,
+                                                             IgnoreErrors());
+      } else {
+        bool oldDesiredPosSet =
+            mDesiredCaretPos.mIsSet;  // need to keep old desired
+                                      // position if it was set.
+        selection->CollapseInLimiter(&aNewFocus, aContentOffset);
+        mDesiredCaretPos.mIsSet =
+            oldDesiredPosSet;  // now reset desired pos back.
+      }
+
+      mBatching = saveBatching;
+
+      if (aContentEndOffset != aContentOffset) {
+        selection->Extend(&aNewFocus, aContentEndOffset);
+      }
+
+      // find out if we are inside a table. if so, find out which one and which
+      // cell once we do that, the next time we get a takefocus, check the
+      // parent tree. if we are no longer inside same table ,cell then switch to
+      // table selection mode. BUT only do this in an editor
+
+      NS_ENSURE_STATE(mPresShell);
+      RefPtr<nsPresContext> context = mPresShell->GetPresContext();
+      mTableSelection.mClosestInclusiveTableCellAncestor = nullptr;
+      if (nsINode* inclusiveTableCellAncestor =
+              TableSelection::IsContentInActivelyEditableTableCell(
+                  context, &aNewFocus)) {
+        mTableSelection.mClosestInclusiveTableCellAncestor =
+            inclusiveTableCellAncestor;
+        MOZ_LOG(sFrameSelectionLog, LogLevel::Debug,
+                ("%s: Collapsing into new cell", __FUNCTION__));
+      }
+
+      break;
+    }
+    case FocusMode::kExtendSelection: {
+      // Now update the range list:
+      nsINode* inclusiveTableCellAncestor =
+          GetClosestInclusiveTableCellAncestor(&aNewFocus);
+      if (mTableSelection.mClosestInclusiveTableCellAncestor &&
+          inclusiveTableCellAncestor &&
+          inclusiveTableCellAncestor !=
+              mTableSelection
+                  .mClosestInclusiveTableCellAncestor)  // switch to cell
+                                                        // selection mode
+      {
+        MOZ_LOG(sFrameSelectionLog, LogLevel::Debug,
+                ("%s: moving into new cell", __FUNCTION__));
+
+        WidgetMouseEvent event(false, eVoidEvent, nullptr,
+                               WidgetMouseEvent::eReal);
+
+        // Start selecting in the cell we were in before
+        ParentAndOffset parentAndOffset{
+            *mTableSelection.mClosestInclusiveTableCellAncestor};
+        if (parentAndOffset.mParent) {
+          const nsresult result = HandleTableSelection(
+              parentAndOffset.mParent, parentAndOffset.mOffset,
+              TableSelectionMode::Cell, &event);
+          if (NS_WARN_IF(NS_FAILED(result))) {
+            return result;
+          }
+        }
+
+        // Find the parent of this new cell and extend selection to it
+        parentAndOffset = ParentAndOffset{*inclusiveTableCellAncestor};
+
+        // XXXX We need to REALLY get the current key shift state
+        //  (we'd need to add event listener -- let's not bother for now)
+        event.mModifiers &= ~MODIFIER_SHIFT;  // aContinueSelection;
+        if (parentAndOffset.mParent) {
+          mTableSelection.mClosestInclusiveTableCellAncestor =
+              inclusiveTableCellAncestor;
+          // Continue selection into next cell
+          const nsresult result = HandleTableSelection(
+              parentAndOffset.mParent, parentAndOffset.mOffset,
+              TableSelectionMode::Cell, &event);
+          if (NS_WARN_IF(NS_FAILED(result))) {
+            return result;
+          }
+        }
+      } else {
+        RefPtr<Selection> selection = mDomSelections[index];
+        // XXXX Problem: Shift+click in browser is appending text selection to
+        // selected table!!!
+        //   is this the place to erase selected cells ?????
+        uint32_t offset =
+            (selection->GetDirection() == eDirNext &&
+             aContentEndOffset > aContentOffset)  // didn't go far enough
+                ? aContentEndOffset  // this will only redraw the diff
+                : aContentOffset;
+        selection->Extend(&aNewFocus, offset);
+      }
+      break;
+    }
+  }
+
+  // Don't notify selection listeners if batching is on:
+  if (IsBatching()) {
+    return NS_OK;
+  }
+
+  // Be aware, the Selection instance may be destroyed after this call.
+  return NotifySelectionListeners(SelectionType::eNormal);
+}
+
+UniquePtr<SelectionDetails> nsFrameSelection::LookUpSelection(
+    nsIContent* aContent, int32_t aContentOffset, int32_t aContentLength,
+    bool aSlowCheck) const {
+  if (!aContent || !mPresShell) {
+    return nullptr;
+  }
+
+  // TODO: Layout should use `uint32_t` for handling offset in DOM nodes
+  //       (for example: bug 1735262)
+  MOZ_ASSERT(aContentOffset >= 0);
+  MOZ_ASSERT(aContentLength >= 0);
+  if (MOZ_UNLIKELY(aContentOffset < 0) || MOZ_UNLIKELY(aContentLength < 0)) {
+    return nullptr;
+  }
+
+  UniquePtr<SelectionDetails> details;
+
+  for (size_t j = 0; j < ArrayLength(mDomSelections); j++) {
+    if (mDomSelections[j]) {
+      details = mDomSelections[j]->LookUpSelection(
+          aContent, static_cast<uint32_t>(aContentOffset),
+          static_cast<uint32_t>(aContentLength), std::move(details),
+          kPresentSelectionTypes[j], aSlowCheck);
+    }
+  }
+
+  // This may seem counter intuitive at first. Highlight selections need to be
+  // iterated from back to front:
+  //
+  //  - `mHighlightSelections` is ordered by insertion, i.e. if two or more
+  //  highlights overlap, the latest must take precedence.
+  //  - however, the `LookupSelection()` algorithm reverses the order by setting
+  //    the current `details` as `mNext`.
+  for (const auto& iter : Reversed(mHighlightSelections)) {
+    details = iter.second()->LookUpSelection(
+        aContent, static_cast<uint32_t>(aContentOffset),
+        static_cast<uint32_t>(aContentLength), std::move(details),
+        SelectionType::eHighlight, aSlowCheck);
+  }
+
+  return details;
+}
+
+void nsFrameSelection::SetDragState(bool aState) {
+  if (mDragState == aState) return;
+
+  mDragState = aState;
+
+  if (!mDragState) {
+    mTableSelection.mDragSelectingCells = false;
+    // Notify that reason is mouse up.
+    SetChangeReasons(nsISelectionListener::MOUSEUP_REASON);
+
+    // flag is set to false in `NotifySelectionListeners`.
+    // since this function call is part of click event, this would immediately
+    // reset the flag, rendering it useless.
+    AutoRestore<bool> restoreIsDoubleClickSelectionFlag(
+        mIsDoubleClickSelection);
+    // Be aware, the Selection instance may be destroyed after this call.
+    NotifySelectionListeners(SelectionType::eNormal);
+  }
+}
+
+Selection* nsFrameSelection::GetSelection(SelectionType aSelectionType) const {
+  int8_t index = GetIndexFromSelectionType(aSelectionType);
+  if (index < 0) return nullptr;
+
+  return mDomSelections[index];
+}
+
+void nsFrameSelection::AddHighlightSelection(
+    const nsAtom* aHighlightName, const mozilla::dom::Highlight& aHighlight) {
+  RefPtr<Selection> selection =
+      aHighlight.CreateHighlightSelection(aHighlightName, this);
+  if (auto iter =
+          std::find_if(mHighlightSelections.begin(), mHighlightSelections.end(),
+                       [&aHighlightName](auto const& aElm) {
+                         return aElm.first() == aHighlightName;
+                       });
+      iter != mHighlightSelections.end()) {
+    iter->second() = std::move(selection);
+  } else {
+    mHighlightSelections.AppendElement(
+        CompactPair<RefPtr<const nsAtom>, RefPtr<Selection>>(
+            aHighlightName, std::move(selection)));
+  }
+}
+
+void nsFrameSelection::RemoveHighlightSelection(const nsAtom* aHighlightName) {
+  if (auto iter =
+          std::find_if(mHighlightSelections.begin(), mHighlightSelections.end(),
+                       [&aHighlightName](auto const& aElm) {
+                         return aElm.first() == aHighlightName;
+                       });
+      iter != mHighlightSelections.end()) {
+    RefPtr<Selection> selection = iter->second();
+    selection->RemoveAllRanges(IgnoreErrors());
+    mHighlightSelections.RemoveElementAt(iter);
+  }
+}
+
+void nsFrameSelection::AddHighlightSelectionRange(
+    const nsAtom* aHighlightName, const mozilla::dom::Highlight& aHighlight,
+    mozilla::dom::AbstractRange& aRange) {
+  if (auto iter =
+          std::find_if(mHighlightSelections.begin(), mHighlightSelections.end(),
+                       [&aHighlightName](auto const& aElm) {
+                         return aElm.first() == aHighlightName;
+                       });
+      iter != mHighlightSelections.end()) {
+    RefPtr<Selection> selection = iter->second();
+    selection->AddHighlightRangeAndSelectFramesAndNotifyListeners(aRange);
+  } else {
+    // if the selection does not exist yet, add all of its ranges and exit.
+    RefPtr<Selection> selection =
+        aHighlight.CreateHighlightSelection(aHighlightName, this);
+    mHighlightSelections.AppendElement(
+        CompactPair<RefPtr<const nsAtom>, RefPtr<Selection>>(
+            aHighlightName, std::move(selection)));
+  }
+}
+
+void nsFrameSelection::RemoveHighlightSelectionRange(
+    const nsAtom* aHighlightName, mozilla::dom::AbstractRange& aRange) {
+  if (auto iter =
+          std::find_if(mHighlightSelections.begin(), mHighlightSelections.end(),
+                       [&aHighlightName](auto const& aElm) {
+                         return aElm.first() == aHighlightName;
+                       });
+      iter != mHighlightSelections.end()) {
+    // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
+    RefPtr<Selection> selection = iter->second();
+    selection->RemoveRangeAndUnselectFramesAndNotifyListeners(aRange,
+                                                              IgnoreErrors());
+  }
+}
+
+nsresult nsFrameSelection::ScrollSelectionIntoView(SelectionType aSelectionType,
+                                                   SelectionRegion aRegion,
+                                                   int16_t aFlags) const {
+  int8_t index = GetIndexFromSelectionType(aSelectionType);
+  if (index < 0) return NS_ERROR_INVALID_ARG;
+
+  if (!mDomSelections[index]) return NS_ERROR_NULL_POINTER;
+
+  ScrollAxis verticalScroll = ScrollAxis();
+  int32_t flags = Selection::SCROLL_DO_FLUSH;
+  if (aFlags & nsISelectionController::SCROLL_SYNCHRONOUS) {
+    flags |= Selection::SCROLL_SYNCHRONOUS;
+  } else if (aFlags & nsISelectionController::SCROLL_FIRST_ANCESTOR_ONLY) {
+    flags |= Selection::SCROLL_FIRST_ANCESTOR_ONLY;
+  }
+  if (aFlags & nsISelectionController::SCROLL_OVERFLOW_HIDDEN) {
+    flags |= Selection::SCROLL_OVERFLOW_HIDDEN;
+  }
+  if (aFlags & nsISelectionController::SCROLL_CENTER_VERTICALLY) {
+    verticalScroll =
+        ScrollAxis(WhereToScroll::Center, WhenToScroll::IfNotFullyVisible);
+  }
+  if (aFlags & nsISelectionController::SCROLL_FOR_CARET_MOVE) {
+    flags |= Selection::SCROLL_FOR_CARET_MOVE;
+  }
+
+  // After ScrollSelectionIntoView(), the pending notifications might be
+  // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
+  RefPtr<Selection> sel = mDomSelections[index];
+  return sel->ScrollIntoView(aRegion, verticalScroll, ScrollAxis(), flags);
+}
+
+nsresult nsFrameSelection::RepaintSelection(SelectionType aSelectionType) {
+  int8_t index = GetIndexFromSelectionType(aSelectionType);
+  if (index < 0) return NS_ERROR_INVALID_ARG;
+  if (!mDomSelections[index]) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_STATE(mPresShell);
+
+// On macOS, update the selection cache to the new active selection
+// aka the current selection.
+#ifdef XP_MACOSX
+  // Check that we're in the an active window and, if this is Web content,
+  // in the frontmost tab.
+  Document* doc = mPresShell->GetDocument();
+  if (doc && IsInActiveTab(doc) && aSelectionType == SelectionType::eNormal) {
+    UpdateSelectionCacheOnRepaintSelection(mDomSelections[index]);
+  }
+#endif
+  return mDomSelections[index]->Repaint(mPresShell->GetPresContext());
+}
+
+static bool IsDisplayContents(const nsIContent* aContent) {
+  return aContent->IsElement() && aContent->AsElement()->IsDisplayContents();
+}
+
+bool nsFrameSelection::AdjustFrameForLineStart(nsIFrame*& aFrame,
+                                               int32_t& aFrameOffset) {
+  if (!aFrame->HasSignificantTerminalNewline()) {
+    return false;
+  }
+
+  auto [start, end] = aFrame->GetOffsets();
+  if (aFrameOffset != end) {
+    return false;
+  }
+
+  nsIFrame* nextSibling = aFrame->GetNextSibling();
+  if (!nextSibling) {
+    return false;
+  }
+
+  aFrame = nextSibling;
+  std::tie(start, end) = aFrame->GetOffsets();
+  aFrameOffset = start;
+  return true;
+}
+
+// static
+nsIFrame* nsFrameSelection::GetFrameForNodeOffset(nsIContent* aNode,
+                                                  int32_t aOffset,
+                                                  CaretAssociateHint aHint,
+                                                  int32_t* aReturnOffset) {
+  if (!aNode || !aReturnOffset) return nullptr;
+
+  if (aOffset < 0) return nullptr;
+
+  if (!aNode->GetPrimaryFrame() && !IsDisplayContents(aNode)) {
+    return nullptr;
+  }
+
+  nsIFrame* returnFrame = nullptr;
+  nsCOMPtr<nsIContent> theNode;
+
+  while (true) {
+    *aReturnOffset = aOffset;
+
+    theNode = aNode;
+
+    if (aNode->IsElement()) {
+      int32_t childIndex = 0;
+      int32_t numChildren = theNode->GetChildCount();
+
+      if (aHint == CARET_ASSOCIATE_BEFORE) {
+        if (aOffset > 0) {
+          childIndex = aOffset - 1;
+        } else {
+          childIndex = aOffset;
+        }
+      } else {
+        NS_ASSERTION(aHint == CARET_ASSOCIATE_AFTER, "unknown direction");
+        if (aOffset >= numChildren) {
+          if (numChildren > 0) {
+            childIndex = numChildren - 1;
+          } else {
+            childIndex = 0;
+          }
+        } else {
+          childIndex = aOffset;
+        }
+      }
+
+      if (childIndex > 0 || numChildren > 0) {
+        nsCOMPtr<nsIContent> childNode =
+            theNode->GetChildAt_Deprecated(childIndex);
+
+        if (!childNode) {
+          break;
+        }
+
+        theNode = childNode;
+      }
+
+      // Now that we have the child node, check if it too
+      // can contain children. If so, descend into child.
+      if (theNode->IsElement() && theNode->GetChildCount() &&
+          !theNode->HasIndependentSelection()) {
+        aNode = theNode;
+        aOffset = aOffset > childIndex ? theNode->GetChildCount() : 0;
+        continue;
+      } else {
+        // Check to see if theNode is a text node. If it is, translate
+        // aOffset into an offset into the text node.
+
+        RefPtr<Text> textNode = theNode->GetAsText();
+        if (textNode) {
+          if (theNode->GetPrimaryFrame()) {
+            if (aOffset > childIndex) {
+              uint32_t textLength = textNode->Length();
+
+              *aReturnOffset = (int32_t)textLength;
+            } else {
+              *aReturnOffset = 0;
+            }
+          } else {
+            int32_t numChildren = aNode->GetChildCount();
+            int32_t newChildIndex = aHint == CARET_ASSOCIATE_BEFORE
+                                        ? childIndex - 1
+                                        : childIndex + 1;
+
+            if (newChildIndex >= 0 && newChildIndex < numChildren) {
+              nsCOMPtr<nsIContent> newChildNode =
+                  aNode->GetChildAt_Deprecated(newChildIndex);
+              if (!newChildNode) {
+                return nullptr;
+              }
+
+              aNode = newChildNode;
+              aOffset =
+                  aHint == CARET_ASSOCIATE_BEFORE ? aNode->GetChildCount() : 0;
+              continue;
+            } else {
+              // newChildIndex is illegal which means we're at first or last
+              // child. Just use original node to get the frame.
+              theNode = aNode;
+            }
+          }
+        }
+      }
+    }
+
+    // If the node is a ShadowRoot, the frame needs to be adjusted,
+    // because a ShadowRoot does not get a frame. Its children are rendered
+    // as children of the host.
+    if (ShadowRoot* shadow = ShadowRoot::FromNode(theNode)) {
+      theNode = shadow->GetHost();
+    }
+
+    returnFrame = theNode->GetPrimaryFrame();
+    if (!returnFrame) {
+      if (aHint == CARET_ASSOCIATE_BEFORE) {
+        if (aOffset > 0) {
+          --aOffset;
+          continue;
+        } else {
+          break;
+        }
+      } else {
+        int32_t end = theNode->GetChildCount();
+        if (aOffset < end) {
+          ++aOffset;
+          continue;
+        } else {
+          break;
+        }
+      }
+    }
+
+    break;
+  }  // end while
+
+  if (!returnFrame) return nullptr;
+
+  // If we ended up here and were asked to position the caret after a visible
+  // break, let's return the frame on the next line instead if it exists.
+  if (aOffset > 0 && (uint32_t)aOffset >= aNode->Length() &&
+      theNode == aNode->GetLastChild()) {
+    nsIFrame* newFrame;
+    nsLayoutUtils::IsInvisibleBreak(theNode, &newFrame);
+    if (newFrame) {
+      returnFrame = newFrame;
+      *aReturnOffset = 0;
+    }
+  }
+
+  // find the child frame containing the offset we want
+  returnFrame->GetChildFrameContainingOffset(
+      *aReturnOffset, aHint == CARET_ASSOCIATE_AFTER, &aOffset, &returnFrame);
+  return returnFrame;
+}
+
+nsIFrame* nsFrameSelection::GetFrameToPageSelect() const {
+  if (NS_WARN_IF(!mPresShell)) {
+    return nullptr;
+  }
+
+  nsIFrame* rootFrameToSelect;
+  if (mLimiters.mLimiter) {
+    rootFrameToSelect = mLimiters.mLimiter->GetPrimaryFrame();
+    if (NS_WARN_IF(!rootFrameToSelect)) {
+      return nullptr;
+    }
+  } else if (mLimiters.mAncestorLimiter) {
+    rootFrameToSelect = mLimiters.mAncestorLimiter->GetPrimaryFrame();
+    if (NS_WARN_IF(!rootFrameToSelect)) {
+      return nullptr;
+    }
+  } else {
+    rootFrameToSelect = mPresShell->GetRootScrollFrame();
+    if (NS_WARN_IF(!rootFrameToSelect)) {
+      return nullptr;
+    }
+  }
+
+  nsCOMPtr<nsIContent> contentToSelect = mPresShell->GetContentForScrolling();
+  if (contentToSelect) {
+    // If there is selected content, look for nearest and vertical scrollable
+    // parent under the root frame.
+    for (nsIFrame* frame = contentToSelect->GetPrimaryFrame();
+         frame && frame != rootFrameToSelect; frame = frame->GetParent()) {
+      nsIScrollableFrame* scrollableFrame = do_QueryFrame(frame);
+      if (!scrollableFrame) {
+        continue;
+      }
+      ScrollStyles scrollStyles = scrollableFrame->GetScrollStyles();
+      if (scrollStyles.mVertical == StyleOverflow::Hidden) {
+        continue;
+      }
+      layers::ScrollDirections directions =
+          scrollableFrame->GetAvailableScrollingDirections();
+      if (directions.contains(layers::ScrollDirection::eVertical)) {
+        // If there is sub scrollable frame, let's use its page size to select.
+        return frame;
+      }
+    }
+  }
+  // Otherwise, i.e., there is no scrollable frame or only the root frame is
+  // scrollable, let's return the root frame because Shift + PageUp/PageDown
+  // should expand the selection in the root content even if it's not
+  // scrollable.
+  return rootFrameToSelect;
+}
+
+nsresult nsFrameSelection::PageMove(bool aForward, bool aExtend,
+                                    nsIFrame* aFrame,
+                                    SelectionIntoView aSelectionIntoView) {
+  MOZ_ASSERT(aFrame);
+
+  // expected behavior for PageMove is to scroll AND move the caret
+  // and remain relative position of the caret in view. see Bug 4302.
+
+  // Get the scrollable frame.  If aFrame is not scrollable, this is nullptr.
+  nsIScrollableFrame* scrollableFrame = aFrame->GetScrollTargetFrame();
+  // Get the scrolled frame.  If aFrame is not scrollable, this is aFrame
+  // itself.
+  nsIFrame* scrolledFrame =
+      scrollableFrame ? scrollableFrame->GetScrolledFrame() : aFrame;
+  if (!scrolledFrame) {
+    return NS_OK;
+  }
+
+  // find out where the caret is.
+  // we should know mDesiredCaretPos.mValue value of nsFrameSelection, but I
+  // havent seen that behavior in other windows applications yet.
+  RefPtr<Selection> selection = GetSelection(SelectionType::eNormal);
+  if (!selection) {
+    return NS_OK;
+  }
+
+  nsRect caretPos;
+  nsIFrame* caretFrame = nsCaret::GetGeometry(selection, &caretPos);
+  if (!caretFrame) {
+    return NS_OK;
+  }
+
+  // If the scrolled frame is outside of current selection limiter,
+  // we need to scroll the frame but keep moving selection in the limiter.
+  nsIFrame* frameToClick = scrolledFrame;
+  if (!IsValidSelectionPoint(scrolledFrame->GetContent())) {
+    frameToClick = GetFrameToPageSelect();
+    if (NS_WARN_IF(!frameToClick)) {
+      return NS_OK;
+    }
+  }
+
+  if (scrollableFrame) {
+    // If there is a scrollable frame, adjust pseudo-click position with page
+    // scroll amount.
+    // XXX This may scroll more than one page if ScrollSelectionIntoView is
+    //     called later because caret may not fully visible.  E.g., if
+    //     clicking line will be visible only half height with scrolling
+    //     the frame, ScrollSelectionIntoView additionally scrolls to show
+    //     the caret entirely.
+    if (aForward) {
+      caretPos.y += scrollableFrame->GetPageScrollAmount().height;
+    } else {
+      caretPos.y -= scrollableFrame->GetPageScrollAmount().height;
+    }
+  } else {
+    // Otherwise, adjust pseudo-click position with the frame size.
+    if (aForward) {
+      caretPos.y += frameToClick->GetSize().height;
+    } else {
+      caretPos.y -= frameToClick->GetSize().height;
+    }
+  }
+
+  caretPos += caretFrame->GetOffsetTo(frameToClick);
+
+  // get a content at desired location
+  nsPoint desiredPoint;
+  desiredPoint.x = caretPos.x;
+  desiredPoint.y = caretPos.y + caretPos.height / 2;
+  nsIFrame::ContentOffsets offsets =
+      frameToClick->GetContentOffsetsFromPoint(desiredPoint);
+
+  if (!offsets.content) {
+    // XXX Do we need to handle ScrollSelectionIntoView in this case?
+    return NS_OK;
+  }
+
+  // First, place the caret.
+  bool selectionChanged;
+  {
+    // We don't want any script to run until we check whether selection is
+    // modified by HandleClick.
+    SelectionBatcher ensureNoSelectionChangeNotifications(selection,
+                                                          __FUNCTION__);
+
+    RangeBoundary oldAnchor = selection->AnchorRef();
+    RangeBoundary oldFocus = selection->FocusRef();
+
+    const FocusMode focusMode =
+        aExtend ? FocusMode::kExtendSelection : FocusMode::kCollapseToNewPoint;
+    HandleClick(MOZ_KnownLive(offsets.content) /* bug 1636889 */,
+                offsets.offset, offsets.offset, focusMode,
+                CARET_ASSOCIATE_AFTER);
+
+    selectionChanged = selection->AnchorRef() != oldAnchor ||
+                       selection->FocusRef() != oldFocus;
+  }
+
+  bool doScrollSelectionIntoView = !(
+      aSelectionIntoView == SelectionIntoView::IfChanged && !selectionChanged);
+
+  // Then, scroll the given frame one page.
+  if (scrollableFrame) {
+    // If we'll call ScrollSelectionIntoView later and selection wasn't
+    // changed and we scroll outside of selection limiter, we shouldn't use
+    // smooth scroll here because nsIScrollableFrame uses normal runnable,
+    // but ScrollSelectionIntoView uses early runner and it cancels the
+    // pending smooth scroll.  Therefore, if we used smooth scroll in such
+    // case, ScrollSelectionIntoView would scroll to show caret instead of
+    // page scroll of an element outside selection limiter.
+    ScrollMode scrollMode = doScrollSelectionIntoView && !selectionChanged &&
+                                    scrolledFrame != frameToClick
+                                ? ScrollMode::Instant
+                                : ScrollMode::Smooth;
+    scrollableFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),
+                              ScrollUnit::PAGES, scrollMode);
+  }
+
+  // Finally, scroll selection into view if requested.
+  if (!doScrollSelectionIntoView) {
+    return NS_OK;
+  }
+  return ScrollSelectionIntoView(
+      SelectionType::eNormal, nsISelectionController::SELECTION_FOCUS_REGION,
+      nsISelectionController::SCROLL_SYNCHRONOUS |
+          nsISelectionController::SCROLL_FOR_CARET_MOVE);
+}
+
+nsresult nsFrameSelection::PhysicalMove(int16_t aDirection, int16_t aAmount,
+                                        bool aExtend) {
+  NS_ENSURE_STATE(mPresShell);
+  // Flush out layout, since we need it to be up to date to do caret
+  // positioning.
+  OwningNonNull<PresShell> presShell(*mPresShell);
+  presShell->FlushPendingNotifications(FlushType::Layout);
+
+  if (!mPresShell) {
+    return NS_OK;
+  }
+
+  // Check that parameters are safe
+  if (aDirection < 0 || aDirection > 3 || aAmount < 0 || aAmount > 1) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsPresContext* context = mPresShell->GetPresContext();
+  if (!context) {
+    return NS_ERROR_FAILURE;
+  }
+
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  RefPtr<Selection> sel = mDomSelections[index];
+  if (!sel) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Map the abstract movement amounts (0-1) to direction-specific
+  // selection units.
+  static const nsSelectionAmount inlineAmount[] = {eSelectCluster, eSelectWord};
+  static const nsSelectionAmount blockPrevAmount[] = {eSelectLine,
+                                                      eSelectBeginLine};
+  static const nsSelectionAmount blockNextAmount[] = {eSelectLine,
+                                                      eSelectEndLine};
+
+  struct PhysicalToLogicalMapping {
+    nsDirection direction;
+    const nsSelectionAmount* amounts;
+  };
+  static const PhysicalToLogicalMapping verticalLR[4] = {
+      {eDirPrevious, blockPrevAmount},  // left
+      {eDirNext, blockNextAmount},      // right
+      {eDirPrevious, inlineAmount},     // up
+      {eDirNext, inlineAmount}          // down
+  };
+  static const PhysicalToLogicalMapping verticalRL[4] = {
+      {eDirNext, blockNextAmount},
+      {eDirPrevious, blockPrevAmount},
+      {eDirPrevious, inlineAmount},
+      {eDirNext, inlineAmount}};
+  static const PhysicalToLogicalMapping horizontal[4] = {
+      {eDirPrevious, inlineAmount},
+      {eDirNext, inlineAmount},
+      {eDirPrevious, blockPrevAmount},
+      {eDirNext, blockNextAmount}};
+
+  WritingMode wm;
+  nsIFrame* frame = sel->GetPrimaryFrameForFocusNode(true);
+  if (frame) {
+    if (!frame->Style()->IsTextCombined()) {
+      wm = frame->GetWritingMode();
+    } else {
+      // Using different direction for horizontal-in-vertical would
+      // make it hard to navigate via keyboard. Inherit the moving
+      // direction from its parent.
+      MOZ_ASSERT(frame->IsTextFrame());
+      wm = frame->GetParent()->GetWritingMode();
+      MOZ_ASSERT(wm.IsVertical(),
+                 "Text combined "
+                 "can only appear in vertical text");
+    }
+  }
+
+  const PhysicalToLogicalMapping& mapping =
+      wm.IsVertical()
+          ? wm.IsVerticalLR() ? verticalLR[aDirection] : verticalRL[aDirection]
+          : horizontal[aDirection];
+
+  nsresult rv =
+      MoveCaret(mapping.direction, aExtend, mapping.amounts[aAmount], eVisual);
+  if (NS_FAILED(rv)) {
+    // If we tried to do a line move, but couldn't move in the given direction,
+    // then we'll "promote" this to a line-edge move instead.
+    if (mapping.amounts[aAmount] == eSelectLine) {
+      rv = MoveCaret(mapping.direction, aExtend, mapping.amounts[aAmount + 1],
+                     eVisual);
+    }
+    // And if it was a next-word move that failed (which can happen when
+    // eat_space_to_next_word is true, see bug 1153237), then just move forward
+    // to the line-edge.
+    else if (mapping.amounts[aAmount] == eSelectWord &&
+             mapping.direction == eDirNext) {
+      rv = MoveCaret(eDirNext, aExtend, eSelectEndLine, eVisual);
+    }
+  }
+
+  return rv;
+}
+
+nsresult nsFrameSelection::CharacterMove(bool aForward, bool aExtend) {
+  return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectCluster,
+                   eUsePrefStyle);
+}
+
+nsresult nsFrameSelection::WordMove(bool aForward, bool aExtend) {
+  return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectWord,
+                   eUsePrefStyle);
+}
+
+nsresult nsFrameSelection::LineMove(bool aForward, bool aExtend) {
+  return MoveCaret(aForward ? eDirNext : eDirPrevious, aExtend, eSelectLine,
+                   eUsePrefStyle);
+}
+
+nsresult nsFrameSelection::IntraLineMove(bool aForward, bool aExtend) {
+  if (aForward) {
+    return MoveCaret(eDirNext, aExtend, eSelectEndLine, eLogical);
+  } else {
+    return MoveCaret(eDirPrevious, aExtend, eSelectBeginLine, eLogical);
+  }
+}
+
+template <typename RangeType>
+Result<RefPtr<RangeType>, nsresult>
+nsFrameSelection::CreateRangeExtendedToSomewhere(
+    nsDirection aDirection, const nsSelectionAmount aAmount,
+    CaretMovementStyle aMovementStyle) {
+  MOZ_ASSERT(aDirection == eDirNext || aDirection == eDirPrevious);
+  MOZ_ASSERT(aAmount == eSelectCharacter || aAmount == eSelectCluster ||
+             aAmount == eSelectWord || aAmount == eSelectBeginLine ||
+             aAmount == eSelectEndLine);
+  MOZ_ASSERT(aMovementStyle == eLogical || aMovementStyle == eVisual ||
+             aMovementStyle == eUsePrefStyle);
+
+  if (!mPresShell) {
+    return Err(NS_ERROR_UNEXPECTED);
+  }
+  OwningNonNull<PresShell> presShell(*mPresShell);
+  presShell->FlushPendingNotifications(FlushType::Layout);
+  if (!mPresShell) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  Selection* selection =
+      mDomSelections[GetIndexFromSelectionType(SelectionType::eNormal)];
+  if (!selection || selection->RangeCount() != 1) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  RefPtr<const nsRange> firstRange = selection->GetRangeAt(0);
+  if (!firstRange || !firstRange->IsPositioned()) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  Result<PeekOffsetStruct, nsresult> result = PeekOffsetForCaretMove(
+      aDirection, true, aAmount, aMovementStyle, nsPoint(0, 0));
+  if (result.isErr()) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  const PeekOffsetStruct& pos = result.inspect();
+  RefPtr<RangeType> range;
+  if (NS_WARN_IF(!pos.mResultContent)) {
+    return range;
+  }
+  if (aDirection == eDirPrevious) {
+    range = RangeType::Create(
+        RawRangeBoundary(pos.mResultContent, pos.mContentOffset),
+        firstRange->EndRef(), IgnoreErrors());
+  } else {
+    range = RangeType::Create(
+        firstRange->StartRef(),
+        RawRangeBoundary(pos.mResultContent, pos.mContentOffset),
+        IgnoreErrors());
+  }
+  return range;
+}
+
+//////////END FRAMESELECTION
+
+LazyLogModule gBatchLog("SelectionBatch");
+
+void nsFrameSelection::StartBatchChanges(const char* aRequesterFuncName) {
+  MOZ_LOG(gBatchLog, LogLevel::Info,
+          ("%p%snsFrameSelection::StartBatchChanges(%s)", this,
+           std::string((mBatching.mCounter + 1) * 2, ' ').c_str(),
+           aRequesterFuncName));
+  mBatching.mCounter++;
+}
+
+void nsFrameSelection::EndBatchChanges(const char* aRequesterFuncName,
+                                       int16_t aReasons) {
+  MOZ_LOG(gBatchLog, LogLevel::Info,
+          ("%p%snsFrameSelection::EndBatchChanges  (%s, %s)", this,
+           std::string(mBatching.mCounter * 2, ' ').c_str(), aRequesterFuncName,
+           SelectionChangeReasonsToCString(aReasons).get()));
+  MOZ_ASSERT(mBatching.mCounter > 0, "Bad mBatching.mCounter");
+  mBatching.mCounter--;
+
+  if (mBatching.mCounter == 0 && mBatching.mChangesDuringBatching) {
+    AddChangeReasons(aReasons);
+    mCaretMoveAmount = eSelectNoAmount;
+    mBatching.mChangesDuringBatching = false;
+    // Be aware, the Selection instance may be destroyed after this call.
+    NotifySelectionListeners(SelectionType::eNormal);
+  }
+}
+
+nsresult nsFrameSelection::NotifySelectionListeners(
+    SelectionType aSelectionType) {
+  int8_t index = GetIndexFromSelectionType(aSelectionType);
+  if (index >= 0 && mDomSelections[index]) {
+    RefPtr<Selection> selection = mDomSelections[index];
+    selection->NotifySelectionListeners();
+    mCaretMoveAmount = eSelectNoAmount;
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+// Start of Table Selection methods
+
+static bool IsCell(nsIContent* aContent) {
+  return aContent->IsAnyOfHTMLElements(nsGkAtoms::td, nsGkAtoms::th);
+}
+
+// static
+nsITableCellLayout* nsFrameSelection::GetCellLayout(
+    const nsIContent* aCellContent) {
+  nsITableCellLayout* cellLayoutObject =
+      do_QueryFrame(aCellContent->GetPrimaryFrame());
+  return cellLayoutObject;
+}
+
+nsresult nsFrameSelection::ClearNormalSelection() {
+  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  RefPtr<Selection> selection = mDomSelections[index];
+  if (!selection) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  ErrorResult err;
+  selection->RemoveAllRanges(err);
+  return err.StealNSResult();
+}
+
+static nsIContent* GetFirstSelectedContent(const nsRange* aRange) {
+  if (!aRange) {
+    return nullptr;
+  }
+
+  MOZ_ASSERT(aRange->GetStartContainer(), "Must have start parent!");
+  MOZ_ASSERT(aRange->GetStartContainer()->IsElement(), "Unexpected parent");
+
+  return aRange->GetChildAtStartOffset();
+}
+
+// Table selection support.
+// TODO: Separate table methods into a separate nsITableSelection interface
+nsresult nsFrameSelection::HandleTableSelection(nsINode* aParentContent,
+                                                int32_t aContentOffset,
+                                                TableSelectionMode aTarget,
+                                                WidgetMouseEvent* aMouseEvent) {
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  RefPtr<Selection> selection = mDomSelections[index];
+  if (!selection) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  return mTableSelection.HandleSelection(aParentContent, aContentOffset,
+                                         aTarget, aMouseEvent, mDragState,
+                                         *selection);
+}
+
+nsresult nsFrameSelection::TableSelection::HandleSelection(
+    nsINode* aParentContent, int32_t aContentOffset, TableSelectionMode aTarget,
+    WidgetMouseEvent* aMouseEvent, bool aDragState,
+    Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  NS_ENSURE_TRUE(aParentContent, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(aMouseEvent, NS_ERROR_NULL_POINTER);
+
+  if (aDragState && mDragSelectingCells &&
+      aTarget == TableSelectionMode::Table) {
+    // We were selecting cells and user drags mouse in table border or inbetween
+    // cells,
+    //  just do nothing
+    return NS_OK;
+  }
+
+  RefPtr<nsIContent> childContent =
+      aParentContent->GetChildAt_Deprecated(aContentOffset);
+
+  // When doing table selection, always set the direction to next so
+  // we can be sure that anchorNode's offset always points to the
+  // selected cell
+  aNormalSelection.SetDirection(eDirNext);
+
+  // Stack-class to wrap all table selection changes in
+  //  BeginBatchChanges() / EndBatchChanges()
+  SelectionBatcher selectionBatcher(&aNormalSelection, __FUNCTION__);
+
+  if (aDragState && mDragSelectingCells) {
+    return HandleDragSelecting(aTarget, childContent, aMouseEvent,
+                               aNormalSelection);
+  }
+
+  return HandleMouseUpOrDown(aTarget, aDragState, childContent, aParentContent,
+                             aContentOffset, aMouseEvent, aNormalSelection);
+}
+
+class nsFrameSelection::TableSelection::RowAndColumnRelation {
+ public:
+  static Result<RowAndColumnRelation, nsresult> Create(
+      const nsIContent* aFirst, const nsIContent* aSecond) {
+    RowAndColumnRelation result;
+
+    nsresult errorResult =
+        GetCellIndexes(aFirst, result.mFirst.mRow, result.mFirst.mColumn);
+    if (NS_FAILED(errorResult)) {
+      return Err(errorResult);
+    }
+
+    errorResult =
+        GetCellIndexes(aSecond, result.mSecond.mRow, result.mSecond.mColumn);
+    if (NS_FAILED(errorResult)) {
+      return Err(errorResult);
+    }
+
+    return result;
+  }
+
+  bool IsSameColumn() const { return mFirst.mColumn == mSecond.mColumn; }
+
+  bool IsSameRow() const { return mFirst.mRow == mSecond.mRow; }
+
+ private:
+  RowAndColumnRelation() = default;
+
+  struct RowAndColumn {
+    int32_t mRow = 0;
+    int32_t mColumn = 0;
+  };
+
+  RowAndColumn mFirst;
+  RowAndColumn mSecond;
+};
+
+nsresult nsFrameSelection::TableSelection::HandleDragSelecting(
+    TableSelectionMode aTarget, nsIContent* aChildContent,
+    const WidgetMouseEvent* aMouseEvent, Selection& aNormalSelection) {
+  // We are drag-selecting
+  if (aTarget != TableSelectionMode::Table) {
+    // If dragging in the same cell as last event, do nothing
+    if (mEndSelectedCell == aChildContent) {
+      return NS_OK;
+    }
+
+#ifdef DEBUG_TABLE_SELECTION
+    printf(
+        " mStartSelectedCell = %p, "
+        "mEndSelectedCell = %p, aChildContent = %p "
+        "\n",
+        mStartSelectedCell.get(), mEndSelectedCell.get(), aChildContent);
+#endif
+    // aTarget can be any "cell mode",
+    //  so we can easily drag-select rows and columns
+    // Once we are in row or column mode,
+    //  we can drift into any cell to stay in that mode
+    //  even if aTarget = TableSelectionMode::Cell
+
+    if (mMode == TableSelectionMode::Row ||
+        mMode == TableSelectionMode::Column) {
+      if (mEndSelectedCell) {
+        Result<RowAndColumnRelation, nsresult> rowAndColumnRelation =
+            RowAndColumnRelation::Create(mEndSelectedCell, aChildContent);
+
+        if (rowAndColumnRelation.isErr()) {
+          return rowAndColumnRelation.unwrapErr();
+        }
+
+        if ((mMode == TableSelectionMode::Row &&
+             rowAndColumnRelation.inspect().IsSameRow()) ||
+            (mMode == TableSelectionMode::Column &&
+             rowAndColumnRelation.inspect().IsSameColumn())) {
+          return NS_OK;
+        }
+      }
+#ifdef DEBUG_TABLE_SELECTION
+      printf(" Dragged into a new column or row\n");
+#endif
+      // Continue dragging row or column selection
+
+      return SelectRowOrColumn(aChildContent, aNormalSelection);
+    }
+    if (mMode == TableSelectionMode::Cell) {
+#ifdef DEBUG_TABLE_SELECTION
+      printf("HandleTableSelection: Dragged into a new cell\n");
+#endif
+      // Trick for quick selection of rows and columns
+      // Hold down shift, then start selecting in one direction
+      // If next cell dragged into is in same row, select entire row,
+      //   if next cell is in same column, select entire column
+      if (mStartSelectedCell && aMouseEvent->IsShift()) {
+        Result<RowAndColumnRelation, nsresult> rowAndColumnRelation =
+            RowAndColumnRelation::Create(mStartSelectedCell, aChildContent);
+        if (rowAndColumnRelation.isErr()) {
+          return rowAndColumnRelation.unwrapErr();
+        }
+
+        if (rowAndColumnRelation.inspect().IsSameRow() ||
+            rowAndColumnRelation.inspect().IsSameColumn()) {
+          // Force new selection block
+          mStartSelectedCell = nullptr;
+          aNormalSelection.RemoveAllRanges(IgnoreErrors());
+
+          if (rowAndColumnRelation.inspect().IsSameRow()) {
+            mMode = TableSelectionMode::Row;
+          } else {
+            mMode = TableSelectionMode::Column;
+          }
+
+          return SelectRowOrColumn(aChildContent, aNormalSelection);
+        }
+      }
+
+      // Reselect block of cells to new end location
+      return SelectBlockOfCells(mStartSelectedCell, aChildContent,
+                                aNormalSelection);
+    }
+  }
+  // Do nothing if dragging in table, but outside a cell
+  return NS_OK;
+}
+
+nsresult nsFrameSelection::TableSelection::HandleMouseUpOrDown(
+    TableSelectionMode aTarget, bool aDragState, nsIContent* aChildContent,
+    nsINode* aParentContent, int32_t aContentOffset,
+    const WidgetMouseEvent* aMouseEvent, Selection& aNormalSelection) {
+  nsresult result = NS_OK;
+  // Not dragging  -- mouse event is down or up
+  if (aDragState) {
+#ifdef DEBUG_TABLE_SELECTION
+    printf("HandleTableSelection: Mouse down event\n");
+#endif
+    // Clear cell we stored in mouse-down
+    mUnselectCellOnMouseUp = nullptr;
+
+    if (aTarget == TableSelectionMode::Cell) {
+      bool isSelected = false;
+
+      // Check if we have other selected cells
+      nsIContent* previousCellNode =
+          GetFirstSelectedContent(GetFirstCellRange(aNormalSelection));
+      if (previousCellNode) {
+        // We have at least 1 other selected cell
+
+        // Check if new cell is already selected
+        nsIFrame* cellFrame = aChildContent->GetPrimaryFrame();
+        if (!cellFrame) {
+          return NS_ERROR_NULL_POINTER;
+        }
+        isSelected = cellFrame->IsSelected();
+      } else {
+        // No cells selected -- remove non-cell selection
+        aNormalSelection.RemoveAllRanges(IgnoreErrors());
+      }
+      mDragSelectingCells = true;  // Signal to start drag-cell-selection
+      mMode = aTarget;
+      // Set start for new drag-selection block (not appended)
+      mStartSelectedCell = aChildContent;
+      // The initial block end is same as the start
+      mEndSelectedCell = aChildContent;
+
+      if (isSelected) {
+        // Remember this cell to (possibly) unselect it on mouseup
+        mUnselectCellOnMouseUp = aChildContent;
+#ifdef DEBUG_TABLE_SELECTION
+        printf(
+            "HandleTableSelection: Saving "
+            "mUnselectCellOnMouseUp\n");
+#endif
+      } else {
+        // Select an unselected cell
+        // but first remove existing selection if not in same table
+        if (previousCellNode &&
+            !IsInSameTable(previousCellNode, aChildContent)) {
+          aNormalSelection.RemoveAllRanges(IgnoreErrors());
+          // Reset selection mode that is cleared in RemoveAllRanges
+          mMode = aTarget;
+        }
+
+        return ::SelectCellElement(aChildContent, aNormalSelection);
+      }
+
+      return NS_OK;
+    }
+    if (aTarget == TableSelectionMode::Table) {
+      // TODO: We currently select entire table when clicked between cells,
+      //  should we restrict to only around border?
+      //  *** How do we get location data for cell and click?
+      mDragSelectingCells = false;
+      mStartSelectedCell = nullptr;
+      mEndSelectedCell = nullptr;
+
+      // Remove existing selection and select the table
+      aNormalSelection.RemoveAllRanges(IgnoreErrors());
+      return CreateAndAddRange(aParentContent, aContentOffset,
+                               aNormalSelection);
+    }
+    if (aTarget == TableSelectionMode::Row ||
+        aTarget == TableSelectionMode::Column) {
+#ifdef DEBUG_TABLE_SELECTION
+      printf("aTarget == %d\n", aTarget);
+#endif
+
+      // Start drag-selecting mode so multiple rows/cols can be selected
+      // Note: Currently, nsIFrame::GetDataForTableSelection
+      //       will never call us for row or column selection on mouse down
+      mDragSelectingCells = true;
+
+      // Force new selection block
+      mStartSelectedCell = nullptr;
+      aNormalSelection.RemoveAllRanges(IgnoreErrors());
+      // Always do this AFTER RemoveAllRanges
+      mMode = aTarget;
+
+      return SelectRowOrColumn(aChildContent, aNormalSelection);
+    }
+  } else {
+#ifdef DEBUG_TABLE_SELECTION
+    printf(
+        "HandleTableSelection: Mouse UP event. "
+        "mDragSelectingCells=%d, "
+        "mStartSelectedCell=%p\n",
+        mDragSelectingCells, mStartSelectedCell.get());
+#endif
+    // First check if we are extending a block selection
+    const uint32_t rangeCount = aNormalSelection.RangeCount();
+
+    if (rangeCount > 0 && aMouseEvent->IsShift() && mAppendStartSelectedCell &&
+        mAppendStartSelectedCell != aChildContent) {
+      // Shift key is down: append a block selection
+      mDragSelectingCells = false;
+
+      return SelectBlockOfCells(mAppendStartSelectedCell, aChildContent,
+                                aNormalSelection);
+    }
+
+    if (mDragSelectingCells) {
+      mAppendStartSelectedCell = mStartSelectedCell;
+    }
+
+    mDragSelectingCells = false;
+    mStartSelectedCell = nullptr;
+    mEndSelectedCell = nullptr;
+
+    // Any other mouseup actions require that Ctrl or Cmd key is pressed
+    //  else stop table selection mode
+    bool doMouseUpAction = false;
+#ifdef XP_MACOSX
+    doMouseUpAction = aMouseEvent->IsMeta();
+#else
+    doMouseUpAction = aMouseEvent->IsControl();
+#endif
+    if (!doMouseUpAction) {
+#ifdef DEBUG_TABLE_SELECTION
+      printf(
+          "HandleTableSelection: Ending cell selection on mouseup: "
+          "mAppendStartSelectedCell=%p\n",
+          mAppendStartSelectedCell.get());
+#endif
+      return NS_OK;
+    }
+    // Unselect a cell only if it wasn't
+    //  just selected on mousedown
+    if (aChildContent == mUnselectCellOnMouseUp) {
+      // Scan ranges to find the cell to unselect (the selection range to
+      // remove)
+      // XXXbz it's really weird that this lives outside the loop, so once we
+      // find one we keep looking at it even if we find no more cells...
+      nsINode* previousCellParent = nullptr;
+#ifdef DEBUG_TABLE_SELECTION
+      printf(
+          "HandleTableSelection: Unselecting "
+          "mUnselectCellOnMouseUp; "
+          "rangeCount=%d\n",
+          rangeCount);
+#endif
+      for (const uint32_t i : IntegerRange(rangeCount)) {
+        MOZ_ASSERT(aNormalSelection.RangeCount() == rangeCount);
+        // Strong reference, because sometimes we want to remove
+        // this range, and then we might be the only owner.
+        RefPtr<nsRange> range = aNormalSelection.GetRangeAt(i);
+        if (MOZ_UNLIKELY(!range)) {
+          return NS_ERROR_NULL_POINTER;
+        }
+
+        nsINode* container = range->GetStartContainer();
+        if (!container) {
+          return NS_ERROR_NULL_POINTER;
+        }
+
+        int32_t offset = range->StartOffset();
+        // Be sure previous selection is a table cell
+        nsIContent* child = range->GetChildAtStartOffset();
+        if (child && IsCell(child)) {
+          previousCellParent = container;
+        }
+
+        // We're done if we didn't find parent of a previously-selected cell
+        if (!previousCellParent) {
+          break;
+        }
+
+        if (previousCellParent == aParentContent && offset == aContentOffset) {
+          // Cell is already selected
+          if (rangeCount == 1) {
+#ifdef DEBUG_TABLE_SELECTION
+            printf("HandleTableSelection: Unselecting single selected cell\n");
+#endif
+            // This was the only cell selected.
+            // Collapse to "normal" selection inside the cell
+            mStartSelectedCell = nullptr;
+            mEndSelectedCell = nullptr;
+            mAppendStartSelectedCell = nullptr;
+            // TODO: We need a "Collapse to just before deepest child" routine
+            // Even better, should we collapse to just after the LAST deepest
+            // child
+            //  (i.e., at the end of the cell's contents)?
+            return aNormalSelection.CollapseInLimiter(aChildContent, 0);
+          }
+#ifdef DEBUG_TABLE_SELECTION
+          printf(
+              "HandleTableSelection: Removing cell from multi-cell "
+              "selection\n");
+#endif
+          // Unselecting the start of previous block
+          // XXX What do we use now!
+          if (aChildContent == mAppendStartSelectedCell) {
+            mAppendStartSelectedCell = nullptr;
+          }
+
+          // Deselect cell by removing its range from selection
+          ErrorResult err;
+          aNormalSelection.RemoveRangeAndUnselectFramesAndNotifyListeners(
+              *range, err);
+          return err.StealNSResult();
+        }
+      }
+      mUnselectCellOnMouseUp = nullptr;
+    }
+  }
+  return result;
+}
+
+nsresult nsFrameSelection::TableSelection::SelectBlockOfCells(
+    nsIContent* aStartCell, nsIContent* aEndCell, Selection& aNormalSelection) {
+  NS_ENSURE_TRUE(aStartCell, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(aEndCell, NS_ERROR_NULL_POINTER);
+  mEndSelectedCell = aEndCell;
+
+  nsresult result = NS_OK;
+
+  // If new end cell is in a different table, do nothing
+  const RefPtr<const nsIContent> table = IsInSameTable(aStartCell, aEndCell);
+  if (!table) {
+    return NS_OK;
+  }
+
+  // Get starting and ending cells' location in the cellmap
+  int32_t startRowIndex, startColIndex, endRowIndex, endColIndex;
+  result = GetCellIndexes(aStartCell, startRowIndex, startColIndex);
+  if (NS_FAILED(result)) return result;
+  result = GetCellIndexes(aEndCell, endRowIndex, endColIndex);
+  if (NS_FAILED(result)) return result;
+
+  if (mDragSelectingCells) {
+    // Drag selecting: remove selected cells outside of new block limits
+    // TODO: `UnselectCells`'s return value shouldn't be ignored.
+    UnselectCells(table, startRowIndex, startColIndex, endRowIndex, endColIndex,
+                  true, aNormalSelection);
+  }
+
+  // Note that we select block in the direction of user's mouse dragging,
+  //  which means start cell may be after the end cell in either row or column
+  return AddCellsToSelection(table, startRowIndex, startColIndex, endRowIndex,
+                             endColIndex, aNormalSelection);
+}
+
+nsresult nsFrameSelection::TableSelection::UnselectCells(
+    const nsIContent* aTableContent, int32_t aStartRowIndex,
+    int32_t aStartColumnIndex, int32_t aEndRowIndex, int32_t aEndColumnIndex,
+    bool aRemoveOutsideOfCellRange, mozilla::dom::Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  nsTableWrapperFrame* tableFrame =
+      do_QueryFrame(aTableContent->GetPrimaryFrame());
+  if (!tableFrame) return NS_ERROR_FAILURE;
+
+  int32_t minRowIndex = std::min(aStartRowIndex, aEndRowIndex);
+  int32_t maxRowIndex = std::max(aStartRowIndex, aEndRowIndex);
+  int32_t minColIndex = std::min(aStartColumnIndex, aEndColumnIndex);
+  int32_t maxColIndex = std::max(aStartColumnIndex, aEndColumnIndex);
+
+  // Strong reference because we sometimes remove the range
+  RefPtr<nsRange> range = GetFirstCellRange(aNormalSelection);
+  nsIContent* cellNode = GetFirstSelectedContent(range);
+  MOZ_ASSERT(!range || cellNode, "Must have cellNode if had a range");
+
+  int32_t curRowIndex, curColIndex;
+  while (cellNode) {
+    nsresult result = GetCellIndexes(cellNode, curRowIndex, curColIndex);
+    if (NS_FAILED(result)) return result;
+
+#ifdef DEBUG_TABLE_SELECTION
+    if (!range) printf("RemoveCellsToSelection -- range is null\n");
+#endif
+
+    if (range) {
+      if (aRemoveOutsideOfCellRange) {
+        if (curRowIndex < minRowIndex || curRowIndex > maxRowIndex ||
+            curColIndex < minColIndex || curColIndex > maxColIndex) {
+          aNormalSelection.RemoveRangeAndUnselectFramesAndNotifyListeners(
+              *range, IgnoreErrors());
+          // Since we've removed the range, decrement pointer to next range
+          mSelectedCellIndex--;
+        }
+
+      } else {
+        // Remove cell from selection if it belongs to the given cells range or
+        // it is spanned onto the cells range.
+        nsTableCellFrame* cellFrame =
+            tableFrame->GetCellFrameAt(curRowIndex, curColIndex);
+
+        uint32_t origRowIndex = cellFrame->RowIndex();
+        uint32_t origColIndex = cellFrame->ColIndex();
+        uint32_t actualRowSpan =
+            tableFrame->GetEffectiveRowSpanAt(origRowIndex, origColIndex);
+        uint32_t actualColSpan =
+            tableFrame->GetEffectiveColSpanAt(curRowIndex, curColIndex);
+        if (origRowIndex <= static_cast<uint32_t>(maxRowIndex) &&
+            maxRowIndex >= 0 &&
+            origRowIndex + actualRowSpan - 1 >=
+                static_cast<uint32_t>(minRowIndex) &&
+            origColIndex <= static_cast<uint32_t>(maxColIndex) &&
+            maxColIndex >= 0 &&
+            origColIndex + actualColSpan - 1 >=
+                static_cast<uint32_t>(minColIndex)) {
+          aNormalSelection.RemoveRangeAndUnselectFramesAndNotifyListeners(
+              *range, IgnoreErrors());
+          // Since we've removed the range, decrement pointer to next range
+          mSelectedCellIndex--;
+        }
+      }
+    }
+
+    range = GetNextCellRange(aNormalSelection);
+    cellNode = GetFirstSelectedContent(range);
+    MOZ_ASSERT(!range || cellNode, "Must have cellNode if had a range");
+  }
+
+  return NS_OK;
+}
+
+nsresult SelectCellElement(nsIContent* aCellElement,
+                           Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  nsIContent* parent = aCellElement->GetParent();
+
+  // Get child offset
+  const int32_t offset = parent->ComputeIndexOf_Deprecated(aCellElement);
+
+  return CreateAndAddRange(parent, offset, aNormalSelection);
+}
+
+static nsresult AddCellsToSelection(const nsIContent* aTableContent,
+                                    int32_t aStartRowIndex,
+                                    int32_t aStartColumnIndex,
+                                    int32_t aEndRowIndex,
+                                    int32_t aEndColumnIndex,
+                                    Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  nsTableWrapperFrame* tableFrame =
+      do_QueryFrame(aTableContent->GetPrimaryFrame());
+  if (!tableFrame) {  // Check that |table| is a table.
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult result = NS_OK;
+  uint32_t row = aStartRowIndex;
+  while (true) {
+    uint32_t col = aStartColumnIndex;
+    while (true) {
+      nsTableCellFrame* cellFrame = tableFrame->GetCellFrameAt(row, col);
+
+      // Skip cells that are spanned from previous locations or are already
+      // selected
+      if (cellFrame) {
+        uint32_t origRow = cellFrame->RowIndex();
+        uint32_t origCol = cellFrame->ColIndex();
+        if (origRow == row && origCol == col && !cellFrame->IsSelected()) {
+          result = SelectCellElement(cellFrame->GetContent(), aNormalSelection);
+          if (NS_FAILED(result)) {
+            return result;
+          }
+        }
+      }
+      // Done when we reach end column
+      if (col == static_cast<uint32_t>(aEndColumnIndex)) {
+        break;
+      }
+
+      if (aStartColumnIndex < aEndColumnIndex) {
+        col++;
+      } else {
+        col--;
+      }
+    }
+    if (row == static_cast<uint32_t>(aEndRowIndex)) {
+      break;
+    }
+
+    if (aStartRowIndex < aEndRowIndex) {
+      row++;
+    } else {
+      row--;
+    }
+  }
+  return result;
+}
+
+nsresult nsFrameSelection::RemoveCellsFromSelection(nsIContent* aTable,
+                                                    int32_t aStartRowIndex,
+                                                    int32_t aStartColumnIndex,
+                                                    int32_t aEndRowIndex,
+                                                    int32_t aEndColumnIndex) {
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  const RefPtr<mozilla::dom::Selection> selection = mDomSelections[index];
+  if (!selection) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  return mTableSelection.UnselectCells(aTable, aStartRowIndex,
+                                       aStartColumnIndex, aEndRowIndex,
+                                       aEndColumnIndex, false, *selection);
+}
+
+nsresult nsFrameSelection::RestrictCellsToSelection(nsIContent* aTable,
+                                                    int32_t aStartRowIndex,
+                                                    int32_t aStartColumnIndex,
+                                                    int32_t aEndRowIndex,
+                                                    int32_t aEndColumnIndex) {
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  const RefPtr<mozilla::dom::Selection> selection = mDomSelections[index];
+  if (!selection) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  return mTableSelection.UnselectCells(aTable, aStartRowIndex,
+                                       aStartColumnIndex, aEndRowIndex,
+                                       aEndColumnIndex, true, *selection);
+}
+
+Result<nsFrameSelection::TableSelection::FirstAndLastCell, nsresult>
+nsFrameSelection::TableSelection::FindFirstAndLastCellOfRowOrColumn(
+    const nsIContent& aCellContent) const {
+  const nsIContent* table = GetParentTable(&aCellContent);
+  if (!table) {
+    return Err(NS_ERROR_NULL_POINTER);
+  }
+
+  // Get table and cell layout interfaces to access
+  // cell data based on cellmap location
+  // Frames are not ref counted, so don't use an nsCOMPtr
+  nsTableWrapperFrame* tableFrame = do_QueryFrame(table->GetPrimaryFrame());
+  if (!tableFrame) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  nsITableCellLayout* cellLayout = GetCellLayout(&aCellContent);
+  if (!cellLayout) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  // Get location of target cell:
+  int32_t rowIndex, colIndex;
+  nsresult result = cellLayout->GetCellIndexes(rowIndex, colIndex);
+  if (NS_FAILED(result)) {
+    return Err(result);
+  }
+
+  // Be sure we start at proper beginning
+  // (This allows us to select row or col given ANY cell!)
+  if (mMode == TableSelectionMode::Row) {
+    colIndex = 0;
+  }
+  if (mMode == TableSelectionMode::Column) {
+    rowIndex = 0;
+  }
+
+  FirstAndLastCell firstAndLastCell;
+  while (true) {
+    // Loop through all cells in column or row to find first and last
+    nsCOMPtr<nsIContent> curCellContent =
+        tableFrame->GetCellAt(rowIndex, colIndex);
+    if (!curCellContent) {
+      break;
+    }
+
+    if (!firstAndLastCell.mFirst) {
+      firstAndLastCell.mFirst = curCellContent;
+    }
+
+    firstAndLastCell.mLast = std::move(curCellContent);
+
+    // Move to next cell in cellmap, skipping spanned locations
+    if (mMode == TableSelectionMode::Row) {
+      colIndex += tableFrame->GetEffectiveRowSpanAt(rowIndex, colIndex);
+    } else {
+      rowIndex += tableFrame->GetEffectiveRowSpanAt(rowIndex, colIndex);
+    }
+  }
+  return firstAndLastCell;
+}
+
+nsresult nsFrameSelection::TableSelection::SelectRowOrColumn(
+    nsIContent* aCellContent, Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  if (!aCellContent) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  Result<FirstAndLastCell, nsresult> firstAndLastCell =
+      FindFirstAndLastCellOfRowOrColumn(*aCellContent);
+  if (firstAndLastCell.isErr()) {
+    return firstAndLastCell.unwrapErr();
+  }
+
+  // Use SelectBlockOfCells:
+  // This will replace existing selection,
+  //  but allow unselecting by dragging out of selected region
+  if (firstAndLastCell.inspect().mFirst && firstAndLastCell.inspect().mLast) {
+    nsresult rv{NS_OK};
+
+    if (!mStartSelectedCell) {
+      // We are starting a new block, so select the first cell
+      rv = ::SelectCellElement(firstAndLastCell.inspect().mFirst,
+                               aNormalSelection);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+      mStartSelectedCell = firstAndLastCell.inspect().mFirst;
+    }
+
+    rv = SelectBlockOfCells(mStartSelectedCell,
+                            firstAndLastCell.inspect().mLast, aNormalSelection);
+
+    // This gets set to the cell at end of row/col,
+    //   but we need it to be the cell under cursor
+    mEndSelectedCell = aCellContent;
+    return rv;
+  }
+
+#if 0
+// This is a more efficient strategy that appends row to current selection,
+//  but doesn't allow dragging OFF of an existing selection to unselect!
+  do {
+    // Loop through all cells in column or row
+    result = tableLayout->GetCellDataAt(rowIndex, colIndex,
+                                        getter_AddRefs(cellElement),
+                                        curRowIndex, curColIndex,
+                                        rowSpan, colSpan,
+                                        actualRowSpan, actualColSpan,
+                                        isSelected);
+    if (NS_FAILED(result)) return result;
+    // We're done when cell is not found
+    if (!cellElement) break;
+
+
+    // Check spans else we infinitely loop
+    NS_ASSERTION(actualColSpan, "actualColSpan is 0!");
+    NS_ASSERTION(actualRowSpan, "actualRowSpan is 0!");
+
+    // Skip cells that are already selected or span from outside our region
+    if (!isSelected && rowIndex == curRowIndex && colIndex == curColIndex)
+    {
+      result = SelectCellElement(cellElement);
+      if (NS_FAILED(result)) return result;
+    }
+    // Move to next row or column in cellmap, skipping spanned locations
+    if (mMode == TableSelectionMode::Row)
+      colIndex += actualColSpan;
+    else
+      rowIndex += actualRowSpan;
+  }
+  while (cellElement);
+#endif
+
+  return NS_OK;
+}
+
+// static
+nsIContent* nsFrameSelection::GetFirstCellNodeInRange(const nsRange* aRange) {
+  if (!aRange) return nullptr;
+
+  nsIContent* childContent = aRange->GetChildAtStartOffset();
+  if (!childContent) return nullptr;
+  // Don't return node if not a cell
+  if (!IsCell(childContent)) return nullptr;
+
+  return childContent;
+}
+
+nsRange* nsFrameSelection::TableSelection::GetFirstCellRange(
+    const mozilla::dom::Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  nsRange* firstRange = aNormalSelection.GetRangeAt(0);
+  if (!GetFirstCellNodeInRange(firstRange)) {
+    return nullptr;
+  }
+
+  // Setup for next cell
+  mSelectedCellIndex = 1;
+
+  return firstRange;
+}
+
+nsRange* nsFrameSelection::TableSelection::GetNextCellRange(
+    const mozilla::dom::Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  nsRange* range =
+      aNormalSelection.GetRangeAt(AssertedCast<uint32_t>(mSelectedCellIndex));
+
+  // Get first node in next range of selection - test if it's a cell
+  if (!GetFirstCellNodeInRange(range)) {
+    return nullptr;
+  }
+
+  // Setup for next cell
+  mSelectedCellIndex++;
+
+  return range;
+}
+
+// static
+nsresult nsFrameSelection::GetCellIndexes(const nsIContent* aCell,
+                                          int32_t& aRowIndex,
+                                          int32_t& aColIndex) {
+  if (!aCell) return NS_ERROR_NULL_POINTER;
+
+  aColIndex = 0;  // initialize out params
+  aRowIndex = 0;
+
+  nsITableCellLayout* cellLayoutObject = GetCellLayout(aCell);
+  if (!cellLayoutObject) return NS_ERROR_FAILURE;
+  return cellLayoutObject->GetCellIndexes(aRowIndex, aColIndex);
+}
+
+// static
+nsIContent* nsFrameSelection::IsInSameTable(const nsIContent* aContent1,
+                                            const nsIContent* aContent2) {
+  if (!aContent1 || !aContent2) return nullptr;
+
+  nsIContent* tableNode1 = GetParentTable(aContent1);
+  nsIContent* tableNode2 = GetParentTable(aContent2);
+
+  // Must be in the same table.  Note that we want to return false for
+  // the test if both tables are null.
+  return (tableNode1 == tableNode2) ? tableNode1 : nullptr;
+}
+
+// static
+nsIContent* nsFrameSelection::GetParentTable(const nsIContent* aCell) {
+  if (!aCell) {
+    return nullptr;
+  }
+
+  for (nsIContent* parent = aCell->GetParent(); parent;
+       parent = parent->GetParent()) {
+    if (parent->IsHTMLElement(nsGkAtoms::table)) {
+      return parent;
+    }
+  }
+
+  return nullptr;
+}
+
+nsresult nsFrameSelection::SelectCellElement(nsIContent* aCellElement) {
+  const int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+  const RefPtr<Selection> selection = mDomSelections[index];
+  if (!selection) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  return ::SelectCellElement(aCellElement, *selection);
+}
+
+nsresult CreateAndAddRange(nsINode* aContainer, int32_t aOffset,
+                           Selection& aNormalSelection) {
+  MOZ_ASSERT(aNormalSelection.Type() == SelectionType::eNormal);
+
+  if (!aContainer) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Set range around child at given offset
+  ErrorResult error;
+  RefPtr<nsRange> range =
+      nsRange::Create(aContainer, aOffset, aContainer, aOffset + 1, error);
+  if (NS_WARN_IF(error.Failed())) {
+    return error.StealNSResult();
+  }
+  MOZ_ASSERT(range);
+
+  ErrorResult err;
+  aNormalSelection.AddRangeAndSelectFramesAndNotifyListeners(*range, err);
+  return err.StealNSResult();
+}
+
+// End of Table Selection
+
+void nsFrameSelection::SetAncestorLimiter(nsIContent* aLimiter) {
+  if (mLimiters.mAncestorLimiter != aLimiter) {
+    mLimiters.mAncestorLimiter = aLimiter;
+    int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+    if (!mDomSelections[index]) return;
+
+    if (!IsValidSelectionPoint(mDomSelections[index]->GetFocusNode())) {
+      ClearNormalSelection();
+      if (mLimiters.mAncestorLimiter) {
+        SetChangeReasons(nsISelectionListener::NO_REASON);
+        nsCOMPtr<nsIContent> limiter(mLimiters.mAncestorLimiter);
+        const nsresult rv = TakeFocus(*limiter, 0, 0, CARET_ASSOCIATE_BEFORE,
+                                      FocusMode::kCollapseToNewPoint);
+        Unused << NS_WARN_IF(NS_FAILED(rv));
+        // TODO: in case of failure, propagate it to the callers.
+      }
+    }
+  }
+}
+
+void nsFrameSelection::SetDelayedCaretData(WidgetMouseEvent* aMouseEvent) {
+  if (aMouseEvent) {
+    mDelayedMouseEvent.mIsValid = true;
+    mDelayedMouseEvent.mIsShift = aMouseEvent->IsShift();
+    mDelayedMouseEvent.mClickCount = aMouseEvent->mClickCount;
+  } else {
+    mDelayedMouseEvent.mIsValid = false;
+  }
+}
+
+void nsFrameSelection::DisconnectFromPresShell() {
+  if (mAccessibleCaretEnabled) {
+    int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
+    mDomSelections[index]->StopNotifyingAccessibleCaretEventHub();
+  }
+
+  StopAutoScrollTimer();
+  for (size_t i = 0; i < ArrayLength(mDomSelections); i++) {
+    mDomSelections[i]->Clear(nullptr);
+  }
+  mPresShell = nullptr;
+}
+
+#ifdef XP_MACOSX
+/**
+ * See Bug 1288453.
+ *
+ * Update the selection cache on repaint to handle when a pre-existing
+ * selection becomes active aka the current selection.
+ *
+ * 1. Change the current selection by click n dragging another selection.
+ *   - Make a selection on content page. Make a selection in a text editor.
+ *   - You can click n drag the content selection to make it active again.
+ * 2. Change the current selection when switching to a tab with a selection.
+ *   - Make selection in tab.
+ *   - Switching tabs will make its respective selection active.
+ *
+ * Therefore, we only update the selection cache on a repaint
+ * if the current selection being repainted is not an empty selection.
+ *
+ * If the current selection is empty. The current selection cache
+ * would be cleared by AutoCopyListener::OnSelectionChange().
+ */
+static nsresult UpdateSelectionCacheOnRepaintSelection(Selection* aSel) {
+  PresShell* presShell = aSel->GetPresShell();
+  if (!presShell) {
+    return NS_OK;
+  }
+  nsCOMPtr<Document> aDoc = presShell->GetDocument();
+
+  if (aDoc && aSel && !aSel->IsCollapsed()) {
+    return nsCopySupport::EncodeDocumentWithContextAndPutToClipboard(
+        aSel, aDoc, nsIClipboard::kSelectionCache, false);
+  }
+
+  return NS_OK;
+}
+#endif  // XP_MACOSX
+
+// mozilla::AutoCopyListener
+
+int16_t AutoCopyListener::sClipboardID = -1;
+
+/*
+ * What we do now:
+ * On every selection change, we copy to the clipboard anew, creating a
+ * HTML buffer, a transferable, an nsISupportsString and
+ * a huge mess every time.  This is basically what
+ * nsCopySupport::EncodeDocumentWithContextAndPutToClipboard() does to move the
+ * selection into the clipboard for Edit->Copy.
+ *
+ * What we should do, to make our end of the deal faster:
+ * Create a singleton transferable with our own magic converter.  When selection
+ * changes (use a quick cache to detect ``real'' changes), we put the new
+ * Selection in the transferable.  Our magic converter will take care of
+ * transferable->whatever-other-format when the time comes to actually
+ * hand over the clipboard contents.
+ *
+ * Other issues:
+ * - which X clipboard should we populate?
+ * - should we use a different one than Edit->Copy, so that inadvertant
+ *   selections (or simple clicks, which currently cause a selection
+ *   notification, regardless of if they're in the document which currently has
+ *   selection!) don't lose the contents of the ``application''?  Or should we
+ *   just put some intelligence in the ``is this a real selection?'' code to
+ *   protect our selection against clicks in other documents that don't create
+ *   selections?
+ * - maybe we should just never clear the X clipboard?  That would make this
+ *   problem just go away, which is very tempting.
+ *
+ * On macOS,
+ * nsIClipboard::kSelectionCache is the flag for current selection cache.
+ * Set the current selection cache on the parent process in
+ * widget cocoa nsClipboard whenever selection changes.
+ */
+
+// static
+void AutoCopyListener::OnSelectionChange(Document* aDocument,
+                                         Selection& aSelection,
+                                         int16_t aReason) {
+  MOZ_ASSERT(IsValidClipboardID(sClipboardID));
+
+  // For now, we should prevent any updates caused by a call of Selection API.
+  // We should allow this in some cases later, though. See the valid usage in
+  // bug 1567160.
+  if (aReason & nsISelectionListener::JS_REASON) {
+    return;
+  }
+
+  if (sClipboardID == nsIClipboard::kSelectionCache) {
+    // Do nothing if this isn't in the active window and,
+    // in the case of Web content, in the frontmost tab.
+    if (!aDocument || !IsInActiveTab(aDocument)) {
+      return;
+    }
+  }
+
+  static const int16_t kResasonsToHandle =
+      nsISelectionListener::MOUSEUP_REASON |
+      nsISelectionListener::SELECTALL_REASON |
+      nsISelectionListener::KEYPRESS_REASON;
+  if (!(aReason & kResasonsToHandle)) {
+    return;  // Don't care if we are still dragging.
+  }
+
+  if (!aDocument || aSelection.IsCollapsed()) {
+#ifdef DEBUG_CLIPBOARD
+    fprintf(stderr, "CLIPBOARD: no selection/collapsed selection\n");
+#endif
+    if (sClipboardID != nsIClipboard::kSelectionCache) {
+      // XXX Should we clear X clipboard?
+      return;
+    }
+
+    // If on macOS, clear the current selection transferable cached
+    // on the parent process (nsClipboard) when the selection is empty.
+    DebugOnly<nsresult> rv = nsCopySupport::ClearSelectionCache();
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "nsCopySupport::ClearSelectionCache() failed");
+    return;
+  }
+
+  DebugOnly<nsresult> rv =
+      nsCopySupport::EncodeDocumentWithContextAndPutToClipboard(
+          &aSelection, aDocument, sClipboardID, false);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "nsCopySupport::EncodeDocumentWithContextAndPutToClipboard() failed");
+}