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

#include "mozilla/AutoRestore.h"

#include "mozilla/EventStates.h"

#include "mozilla/HTMLEditor.h"

#include "mozilla/PresShell.h"

#include "nsCOMPtr.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 "nsIContentIterator.h"

#include "nsIDocumentEncoder.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 "nsContentUtils.h"

#include "nsThreadUtils.h"

#include "mozilla/Preferences.h"

#include "nsPresContext.h"

#include "nsIPresShell.h"

#include "nsCaret.h"

#include "mozilla/MouseEvents.h"

#include "mozilla/TextEvents.h"

#include "nsITimer.h"

// notifications

#include "nsIDocument.h"

#include "nsISelectionController.h" //for the enums

#include "nsCopySupport.h"

#include "nsIClipboard.h"

#include "nsIFrameInlines.h"

#include "nsIBidiKeyboard.h"

#include "nsError.h"

#include "mozilla/AutoCopyListener.h"

#include "mozilla/dom/Element.h"

#include "mozilla/dom/Selection.h"

#include "mozilla/dom/ShadowRoot.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;

//#define DEBUG_TABLE 1

static bool IsValidSelectionPoint(nsFrameSelection *aFrameSel, nsINode *aNode);

static nsAtom *GetTag(nsINode *aNode);

// returns the parent

static nsINode* ParentOffset(nsINode *aNode, int32_t *aChildOffset);

static nsINode* GetCellParent(nsINode *aDomNode);

#ifdef PRINT_RANGE

static void printRange(nsRange *aDomRange);

#define DEBUG_OUT_RANGE(x)  printRange(x)

#else

#define DEBUG_OUT_RANGE(x)

#endif // PRINT_RANGE

/******************************************************************************

 * nsPeekOffsetStruct

 ******************************************************************************/

//#define DEBUG_SELECTION // uncomment for printf describing every collapse and extend.

//#define DEBUG_NAVIGATION

//#define DEBUG_TABLE_SELECTION 1

nsPeekOffsetStruct::nsPeekOffsetStruct(nsSelectionAmount aAmount,

                                       nsDirection aDirection,

                                       int32_t aStartOffset,

                                       nsPoint aDesiredPos,

                                       bool aJumpLines,

                                       bool aScrollViewStop,

                                       bool aIsKeyboardSelect,

                                       bool aVisual,

                                       bool aExtend,

                                       EWordMovementType aWordMovementType)

  : mAmount(aAmount)

  , mDirection(aDirection)

  , mStartOffset(aStartOffset)

  , mDesiredPos(aDesiredPos)

  , mWordMovementType(aWordMovementType)

  , mJumpLines(aJumpLines)

  , mScrollViewStop(aScrollViewStop)

  , mIsKeyboardSelect(aIsKeyboardSelect)

  , mVisual(aVisual)

  , mExtend(aExtend)

  , mResultContent()

  , mResultFrame(nullptr)

  , mContentOffset(0)

  , mAttach(CARET_ASSOCIATE_BEFORE)

{

}

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

};

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

IsValidSelectionPoint(nsFrameSelection *aFrameSel, nsINode *aNode)

{

  if (!aFrameSel || !aNode)

    return false;

  nsIContent *limiter = aFrameSel->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 = aFrameSel->GetAncestorLimiter();

  return !limiter || nsContentUtils::ContentIsDescendantOf(aNode, limiter);

}

namespace mozilla {

struct MOZ_RAII AutoPrepareFocusRange

{

  AutoPrepareFocusRange(Selection* aSelection,

                        bool aContinueSelection,

                        bool aMultipleSelection

                        MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

  {

    MOZ_GUARD_OBJECT_NOTIFIER_INIT;

    if (aSelection->mRanges.Length() <= 1) {

      return;

    }

    if (aSelection->mFrameSelection->IsUserSelectionReason()) {

      mUserSelect.emplace(aSelection);

    }

    bool userSelection = aSelection->mUserInitiated;

    nsTArray<RangeData>& ranges = aSelection->mRanges;

    if (!userSelection ||

        (!aContinueSelection && aMultipleSelection)) {

      // Scripted command or the user is starting a new explicit multi-range

      // selection.

      for (RangeData& entry : ranges) {

        entry.mRange->SetIsGenerated(false);

      }

      return;

    }

    int16_t reason = aSelection->mFrameSelection->mSelectionChangeReason;

    bool isAnchorRelativeOp = (reason & (nsISelectionListener::DRAG_REASON |

                                         nsISelectionListener::MOUSEDOWN_REASON |

                                         nsISelectionListener::MOUSEUP_REASON |

                                         nsISelectionListener::COLLAPSETOSTART_REASON));

    if (!isAnchorRelativeOp) {

      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.

    const size_t len = ranges.Length();

    size_t newAnchorFocusIndex = size_t(-1);

    if (aSelection->GetDirection() == eDirNext) {

      for (size_t i = 0; i < len; ++i) {

        if (ranges[i].mRange->IsGenerated()) {

          newAnchorFocusIndex = i;

          break;

        }

      }

    } else {

      size_t i = len;

      while (i--) {

        if (ranges[i].mRange->IsGenerated()) {

          newAnchorFocusIndex = i;

          break;

        }

      }

    }

    if (newAnchorFocusIndex == size_t(-1)) {

      // 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);

    }

    nsRange* range = ranges[newAnchorFocusIndex].mRange;

    range->SetIsGenerated(false);

    aSelection->mAnchorFocusRange = range;

    // Remove all generated ranges (including the old mAnchorFocusRange).

    RefPtr<nsPresContext> presContext = aSelection->GetPresContext();

    size_t i = len;

    while (i--) {

      range = aSelection->mRanges[i].mRange;

      if (range->IsGenerated()) {

        range->SetSelection(nullptr);

        aSelection->SelectFrames(presContext, range, false);

        aSelection->mRanges.RemoveElementAt(i);

      }

    }

    if (aSelection->mFrameSelection) {

      aSelection->mFrameSelection->InvalidateDesiredPos();

    }

  }

  Maybe<Selection::AutoUserInitiated> mUserSelect;

  MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

};

} // namespace mozilla

////////////BEGIN nsFrameSelection methods

nsFrameSelection::nsFrameSelection()

{

  for (size_t i = 0; i < ArrayLength(mDomSelections); i++) {

    mDomSelections[i] = new Selection(this);

    mDomSelections[i]->SetType(kPresentSelectionTypes[i]);

  }

#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();

    }

  }

}

nsFrameSelection::~nsFrameSelection()

{

}

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;

  }

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCellParent)

  tmp->mSelectingTableCellMode = TableSelection::None;

  tmp->mDragSelectingCells = false;

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mStartSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEndSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mAppendStartSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mUnselectCellOnMouseUp)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mMaintainRange)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mLimiter)

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mAncestorLimiter)

NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsFrameSelection)

  if (tmp->mShell && tmp->mShell->GetDocument() &&

      nsCCUncollectableMarker::InGeneration(cb,

                                            tmp->mShell->GetDocument()->

                                              GetMarkedCCGeneration())) {

    return NS_SUCCESS_INTERRUPTED_TRAVERSE;

  }

  for (size_t i = 0; i < ArrayLength(tmp->mDomSelections); ++i) {

    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDomSelections[i])

  }

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCellParent)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStartSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAppendStartSelectedCell)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUnselectCellOnMouseUp)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMaintainRange)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLimiter)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAncestorLimiter)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsFrameSelection, AddRef)

NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsFrameSelection, Release)

// Get the x (or y, in vertical writing mode) position requested

// by the Key Handling for line-up/down

nsresult

nsFrameSelection::FetchDesiredPos(nsPoint &aDesiredPos)

{

  if (!mShell) {

    NS_ERROR("fetch desired position failed");

    return NS_ERROR_FAILURE;

  }

  if (mDesiredPosSet) {

    aDesiredPos = mDesiredPos;

    return NS_OK;

  }

  RefPtr<nsCaret> caret = mShell->GetCaret();

  if (!caret) {

    return NS_ERROR_NULL_POINTER;

  }

  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);

  caret->SetSelection(mDomSelections[index]);

  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;

  }

  aDesiredPos = coord.TopLeft();

  return NS_OK;

}

void

nsFrameSelection::InvalidateDesiredPos() // do not listen to mDesiredPos;

                                         // you must get another.

{

  mDesiredPosSet = false;

}

void

nsFrameSelection::SetDesiredPos(nsPoint aPos)

{

  mDesiredPos = aPos;

  mDesiredPosSet = true;

}

nsresult

nsFrameSelection::ConstrainFrameAndPointToAnchorSubtree(nsIFrame* aFrame,

                                                        const nsPoint& aPoint,

                                                        nsIFrame** aRetFrame,

                                                        nsPoint& aRetPoint)

{

  //

  // 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(mShell);

  nsIContent* anchorRoot = anchorContent->GetSelectionRootContent(mShell);

  NS_ENSURE_TRUE(anchorRoot, NS_ERROR_UNEXPECTED);

  //

  // Now find the root of the subtree containing aFrame's content.

  //

  nsIContent* content = aFrame->GetContent();

  if (content)

  {

    nsIContent* contentRoot = content->GetSelectionRootContent(mShell);

    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 = nsIPresShell::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 = mShell->GetRootFrame();

      nsPoint ptInRoot = aPoint + aFrame->GetOffsetTo(rootFrame);

      nsIFrame* cursorFrame =

        nsLayoutUtils::GetFrameForPoint(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() == mShell)

      {

        nsIContent* cursorContent = cursorFrame->GetContent();

        NS_ENSURE_TRUE(cursorContent, NS_ERROR_FAILURE);

        nsIContent* cursorContentRoot =

          cursorContent->GetSelectionRootContent(mShell);

        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::SetCaretBidiLevel(nsBidiLevel 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

  mCaretBidiLevel = aLevel;

  RefPtr<nsCaret> caret;

  if (mShell && (caret = mShell->GetCaret())) {

    caret->SchedulePaint();

  }

}

nsBidiLevel

nsFrameSelection::GetCaretBidiLevel() const

{

  return mCaretBidiLevel;

}

void

nsFrameSelection::UndefineCaretBidiLevel()

{

  mCaretBidiLevel |= 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();

}

// Returns the parent

nsINode*

ParentOffset(nsINode *aNode, int32_t *aChildOffset)

{

  if (!aNode || !aChildOffset)

    return nullptr;

  nsIContent* parent = aNode->GetParent();

  if (parent)

  {

    *aChildOffset = parent->ComputeIndexOf(aNode);

    return parent;

  }

  return nullptr;

}

static nsINode*

GetCellParent(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;

}

void

nsFrameSelection::Init(nsIPresShell *aShell, nsIContent *aLimiter,

                       bool aAccessibleCaretEnabled)

{

  mShell = aShell;

  mDragState = false;

  mDesiredPosSet = false;

  mLimiter = aLimiter;

  mCaretMovementStyle =

    Preferences::GetInt("bidi.edit.caret_movement_style", 2);

  // This should only ever be initialized on the main thread, so we are OK here.

  static bool prefCachesInitialized = false;

  if (!prefCachesInitialized) {

    prefCachesInitialized = true;

    Preferences::AddBoolVarCache(&sSelectionEventsEnabled,

                                 "dom.select_events.enabled", false);

    Preferences::AddBoolVarCache(&sSelectionEventsOnTextControlsEnabled,

                                 "dom.select_events.textcontrols.enabled", false);

  }

  mAccessibleCaretEnabled = aAccessibleCaretEnabled;

  if (mAccessibleCaretEnabled) {

    int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);

    mDomSelections[index]->MaybeNotifyAccessibleCaretEventHub(aShell);

  }

  bool plaintextControl = (aLimiter != nullptr);

  bool initSelectEvents = plaintextControl ?

                            sSelectionEventsOnTextControlsEnabled :

                            sSelectionEventsEnabled;

  nsIDocument* doc = aShell->GetDocument();

  if (initSelectEvents ||

      (doc && nsContentUtils::IsSystemPrincipal(doc->NodePrincipal()))) {

    int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);

    if (mDomSelections[index]) {

      mDomSelections[index]->EnableSelectionChangeEvent();

    }

  }

}

bool nsFrameSelection::sSelectionEventsEnabled = false;

bool nsFrameSelection::sSelectionEventsOnTextControlsEnabled = false;

nsresult

nsFrameSelection::MoveCaret(nsDirection       aDirection,

                            bool              aContinueSelection,

                            nsSelectionAmount aAmount,

                            CaretMovementStyle aMovementStyle)

{

  bool visualMovement = aMovementStyle == eVisual ||

    (aMovementStyle == eUsePrefStyle &&

      (mCaretMovementStyle == 1 ||

        (mCaretMovementStyle == 2 && !aContinueSelection)));

  NS_ENSURE_STATE(mShell);

  // Flush out layout, since we need it to be up to date to do caret

  // positioning.

  mShell->FlushPendingNotifications(FlushType::Layout);

  if (!mShell) {

    return NS_OK;

  }

  nsPresContext *context = mShell->GetPresContext();

  if (!context)

    return NS_ERROR_FAILURE;

  nsPoint desiredPos(0, 0); //we must keep this around and revalidate it when its just UP/DOWN

  int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);

  RefPtr<Selection> sel = mDomSelections[index];

  if (!sel)

    return NS_ERROR_NULL_POINTER;

  int32_t scrollFlags = Selection::SCROLL_FOR_CARET_MOVE;

  nsINode* focusNode = sel->GetFocusNode();

  if (focusNode &&

      (focusNode->IsEditable() ||

       (focusNode->IsElement() &&

        focusNode->AsElement()->State().

          HasState(NS_EVENT_STATE_MOZ_READWRITE)))) {

    // If caret moves in editor, it should cause scrolling even if it's in

    // overflow: hidden;.

    scrollFlags |= Selection::SCROLL_OVERFLOW_HIDDEN;

  }

  int32_t caretStyle = Preferences::GetInt("layout.selection.caret_style", 0);

  if (caretStyle == 0

#ifdef XP_WIN

      && aAmount != eSelectLine

#endif

     ) {

    // Put caret at the selection edge in the |aDirection| direction.

    caretStyle = 2;

  }

  bool doCollapse = !sel->IsCollapsed() && !aContinueSelection && caretStyle == 2 &&

                    aAmount <= eSelectLine;

  if (doCollapse) {

    if (aDirection == eDirPrevious) {

      PostReason(nsISelectionListener::COLLAPSETOSTART_REASON);

      mHint = CARET_ASSOCIATE_AFTER;

    } else {

      PostReason(nsISelectionListener::COLLAPSETOEND_REASON);

      mHint = CARET_ASSOCIATE_BEFORE;

    }

  } else {

    PostReason(nsISelectionListener::KEYPRESS_REASON);

  }

  AutoPrepareFocusRange prep(sel, aContinueSelection, false);

  if (aAmount == eSelectLine) {

    nsresult result = FetchDesiredPos(desiredPos);

    if (NS_FAILED(result)) {

      return result;

    }

    SetDesiredPos(desiredPos);

  }

  if (doCollapse) {

    const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();

    if (anchorFocusRange) {

      nsINode* node;

      int32_t offset;

      if (aDirection == eDirPrevious) {

        node =  anchorFocusRange->GetStartContainer();

        offset = anchorFocusRange->StartOffset();

      } else {

        node = anchorFocusRange->GetEndContainer();

        offset = anchorFocusRange->EndOffset();

      }

      sel->Collapse(node, offset);

    }

    sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,

                        nsIPresShell::ScrollAxis(),

                        nsIPresShell::ScrollAxis(), scrollFlags);

    return NS_OK;

  }

  nsIFrame *frame;

  int32_t offsetused = 0;

  nsresult result = sel->GetPrimaryFrameForFocusNode(&frame, &offsetused,

                                                     visualMovement);

  if (NS_FAILED(result) || !frame)

    return NS_FAILED(result) ? result : NS_ERROR_FAILURE;

  //set data using 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

  nsPeekOffsetStruct pos(aAmount, eDirPrevious, offsetused, desiredPos,

                         true, mLimiter != nullptr, true, visualMovement,

                         aContinueSelection);

  nsBidiDirection paraDir = nsBidiPresUtils::ParagraphDirection(frame);

  CaretAssociateHint tHint(mHint); //temporary variable so we dont set mHint until it is necessary

  switch (aAmount){

   case eSelectCharacter:

    case eSelectCluster:

    case eSelectWord:

    case eSelectWordNoSpace:

      InvalidateDesiredPos();

      pos.mAmount = aAmount;

      pos.mDirection = (visualMovement && paraDir == NSBIDI_RTL)

                       ? nsDirection(1 - aDirection) : aDirection;

      break;

    case eSelectLine:

      pos.mAmount = aAmount;

      pos.mDirection = aDirection;

      break;

    case eSelectBeginLine:

    case eSelectEndLine:

      InvalidateDesiredPos();

      pos.mAmount = aAmount;

      pos.mDirection = (visualMovement && paraDir == NSBIDI_RTL)

                       ? nsDirection(1 - aDirection) : aDirection;

      break;

    default:

      return NS_ERROR_FAILURE;

  }

  if (NS_SUCCEEDED(result = frame->PeekOffset(&pos)) && pos.mResultContent)

  {

    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;

      theFrame->GetOffsets(frameStart, frameEnd);

      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;

      theFrame->GetOffsets(frameStart, frameEnd);

    }

    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();

          SetCaretBidiLevel(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) {

            SetCaretBidiLevel(theFrame->GetEmbeddingLevel());

          }

          else {

            BidiLevelFromMove(mShell, pos.mResultContent, pos.mContentOffset,

                              aAmount, tHint);

          }

      }

    }

    result = TakeFocus(pos.mResultContent, pos.mContentOffset, pos.mContentOffset,

                       tHint, aContinueSelection, false);

  } else if (aAmount <= eSelectWordNoSpace && aDirection == 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();

    sel->Collapse(sel->GetFocusNode(), sel->FocusOffset());

    // Note: 'frame' might be dead here.

    if (!isBRFrame) {

      mHint = CARET_ASSOCIATE_BEFORE; // We're now at the end of the frame to the left.

    }

    result = NS_OK;

  }

  if (NS_SUCCEEDED(result))

  {

    result = mDomSelections[index]->

      ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,

                     nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis(),

                     scrollFlags);

  }

  return result;

}

nsPrevNextBidiLevels

nsFrameSelection::GetPrevNextBidiLevels(nsIContent *aNode,