/*

* Copyright (C) 2004-2020 Apple Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "FrameSelection.h"

#include "AXObjectCache.h"

#include "CharacterData.h"

#include "ColorBlending.h"

#include "DeleteSelectionCommand.h"

#include "Document.h"

#include "Editing.h"

#include "Editor.h"

#include "EditorClient.h"

#include "Element.h"

#include "ElementIterator.h"

#include "Event.h"

#include "EventNames.h"

#include "FloatQuad.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLBodyElement.h"

#include "HTMLFormElement.h"

#include "HTMLFrameElement.h"

#include "HTMLIFrameElement.h"

#include "HTMLNames.h"

#include "HTMLSelectElement.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "InlineRunAndOffset.h"

#include "LegacyInlineTextBox.h"

#include "Logging.h"

#include "Page.h"

#include "Range.h"

#include "RenderLayer.h"

#include "RenderLayerScrollableArea.h"

#include "RenderText.h"

#include "RenderTextControl.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "RenderedPosition.h"

#include "ScriptDisallowedScope.h"

#include "Settings.h"

#include "SimpleRange.h"

#include "SpatialNavigation.h"

#include "StyleProperties.h"

#include "TypingCommand.h"

#include "VisibleUnits.h"

#include <stdio.h>

#include <wtf/text/CString.h>

#include <wtf/text/TextStream.h>

#if PLATFORM(IOS_FAMILY)

#include "Chrome.h"

#include "ChromeClient.h"

#include "Color.h"

#include "RenderObject.h"

#include "RenderStyle.h"

#include "SelectionGeometry.h"

#endif

namespace WebCore {

using namespace HTMLNames;

static inline LayoutUnit NoXPosForVerticalArrowNavigation()

{

return LayoutUnit::min();

}

CaretBase::CaretBase(CaretVisibility visibility)

: m_caretRectNeedsUpdate(true)

, m_caretVisibility(visibility)

{

}

DragCaretController::DragCaretController()

: CaretBase(Visible)

{

}

bool DragCaretController::isContentRichlyEditable() const

{

return isRichlyEditablePosition(m_position.deepEquivalent());

}

IntRect DragCaretController::caretRectInRootViewCoordinates() const

{

if (!hasCaret())

return { };

if (auto* document = m_position.deepEquivalent().document()) {

if (auto* documentView = document->view())

return documentView->contentsToRootView(m_position.absoluteCaretBounds());

}

return { };

}

IntRect DragCaretController::editableElementRectInRootViewCoordinates() const

{

if (!hasCaret())

return { };

RefPtr<ContainerNode> editableContainer;

if (auto* formControl = enclosingTextFormControl(m_position.deepEquivalent()))

editableContainer = formControl;

else

editableContainer = highestEditableRoot(m_position.deepEquivalent());

if (!editableContainer)

return { };

auto* renderer = editableContainer->renderer();

if (!renderer)

return { };

if (auto* view = editableContainer->document().view())

return view->contentsToRootView(renderer->absoluteBoundingBoxRect()); // FIXME: Wrong for elements with visible layout overflow.

return { };

}

static inline bool shouldAlwaysUseDirectionalSelection(Document* document)

{

return !document || document->editor().behavior().shouldConsiderSelectionAsDirectional();

}

FrameSelection::FrameSelection(Document* document)

: m_document(makeWeakPtr(document))

, m_granularity(TextGranularity::CharacterGranularity)

#if ENABLE(TEXT_CARET)

, m_caretBlinkTimer(*this, &FrameSelection::caretBlinkTimerFired)

#endif

, m_appearanceUpdateTimer(*this, &FrameSelection::appearanceUpdateTimerFired)

, m_caretInsidePositionFixed(false)

, m_absCaretBoundsDirty(true)

, m_caretPaint(true)

, m_isCaretBlinkingSuspended(false)

, m_focused(document && document->frame() && document->page() && document->page()->focusController().focusedFrame() == document->frame())

, m_shouldShowBlockCursor(false)

, m_pendingSelectionUpdate(false)

, m_alwaysAlignCursorOnScrollWhenRevealingSelection(false)

#if PLATFORM(IOS_FAMILY)

, m_updateAppearanceEnabled(false)

, m_caretBlinks(true)

#endif

{

if (shouldAlwaysUseDirectionalSelection(m_document.get()))

m_selection.setIsDirectional(true);

bool activeAndFocused = isFocusedAndActive();

if (activeAndFocused)

setSelectionFromNone();

#if USE(UIKIT_EDITING)

// Caret blinking (blinks | does not blink)

setCaretVisible(activeAndFocused);

#else

setCaretVisibility(activeAndFocused ? Visible : Hidden, ShouldUpdateAppearance::No);

#endif

}

Element* FrameSelection::rootEditableElementOrDocumentElement() const

{

Element* selectionRoot = m_selection.rootEditableElement();

return selectionRoot ? selectionRoot : m_document->documentElement();

}

void FrameSelection::moveTo(const VisiblePosition& position, EUserTriggered userTriggered, CursorAlignOnScroll align)

{

setSelection(VisibleSelection(position.deepEquivalent(), position.deepEquivalent(), position.affinity(), m_selection.isDirectional()),

defaultSetSelectionOptions(userTriggered), AXTextStateChangeIntent(), align);

}

void FrameSelection::moveTo(const VisiblePosition& base, const VisiblePosition& extent, EUserTriggered userTriggered)

{

const bool selectionHasDirection = true;

setSelection(VisibleSelection(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), selectionHasDirection), defaultSetSelectionOptions(userTriggered));

}

void FrameSelection::moveTo(const Position& position, Affinity affinity, EUserTriggered userTriggered)

{

setSelection(VisibleSelection(position, affinity, m_selection.isDirectional()), defaultSetSelectionOptions(userTriggered));

}

void FrameSelection::moveTo(const Position& base, const Position& extent, Affinity affinity, EUserTriggered userTriggered)

{

const bool selectionHasDirection = true;

setSelection(VisibleSelection(base, extent, affinity, selectionHasDirection), defaultSetSelectionOptions(userTriggered));

}

void FrameSelection::moveWithoutValidationTo(const Position& base, const Position& extent, bool selectionHasDirection, bool shouldSetFocus, SelectionRevealMode revealMode, const AXTextStateChangeIntent& intent)

{

VisibleSelection newSelection;

newSelection.setWithoutValidation(base, extent);

newSelection.setIsDirectional(selectionHasDirection);

AXTextStateChangeIntent newIntent = intent.type == AXTextStateChangeTypeUnknown ? AXTextStateChangeIntent(AXTextStateChangeTypeSelectionMove, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityUnknown, false }) : intent;

auto options = defaultSetSelectionOptions();

if (!shouldSetFocus)

options.add(DoNotSetFocus);

switch (revealMode) {

case SelectionRevealMode::DoNotReveal:

break;

case SelectionRevealMode::Reveal:

options.add(RevealSelection);

break;

case SelectionRevealMode::RevealUpToMainFrame:

options.add(RevealSelectionUpToMainFrame);

break;

case SelectionRevealMode::DelegateMainFrameScroll:

options.add(DelegateMainFrameScroll);

break;

}

setSelection(newSelection, options, newIntent);

}

void DragCaretController::setCaretPosition(const VisiblePosition& position)

{

if (Node* node = m_position.deepEquivalent().deprecatedNode())

invalidateCaretRect(node);

m_position = position;

setCaretRectNeedsUpdate();

Document* document = nullptr;

if (Node* node = m_position.deepEquivalent().deprecatedNode()) {

invalidateCaretRect(node);

document = &node->document();

}

if (m_position.isNull() || m_position.isOrphan())

clearCaretRect();

else

updateCaretRect(*document, m_position);

}

static void adjustEndpointsAtBidiBoundary(VisiblePosition& visibleBase, VisiblePosition& visibleExtent)

{

RenderedPosition base(visibleBase);

RenderedPosition extent(visibleExtent);

if (base.isNull() || extent.isNull() || base.isEquivalent(extent))

return;

if (base.atLeftBoundaryOfBidiRun()) {

if (!extent.atRightBoundaryOfBidiRun(base.bidiLevelOnRight())

&& base.isEquivalent(extent.leftBoundaryOfBidiRun(base.bidiLevelOnRight()))) {

visibleBase = base.positionAtLeftBoundaryOfBiDiRun();

return;

}

return;

}

if (base.atRightBoundaryOfBidiRun()) {

if (!extent.atLeftBoundaryOfBidiRun(base.bidiLevelOnLeft())

&& base.isEquivalent(extent.rightBoundaryOfBidiRun(base.bidiLevelOnLeft()))) {

visibleBase = base.positionAtRightBoundaryOfBiDiRun();

return;

}

return;

}

if (extent.atLeftBoundaryOfBidiRun() && extent.isEquivalent(base.leftBoundaryOfBidiRun(extent.bidiLevelOnRight()))) {

visibleExtent = extent.positionAtLeftBoundaryOfBiDiRun();

return;

}

if (extent.atRightBoundaryOfBidiRun() && extent.isEquivalent(base.rightBoundaryOfBidiRun(extent.bidiLevelOnLeft()))) {

visibleExtent = extent.positionAtRightBoundaryOfBiDiRun();

return;

}

}

void FrameSelection::setSelectionByMouseIfDifferent(const VisibleSelection& passedNewSelection, TextGranularity granularity,

EndPointsAdjustmentMode endpointsAdjustmentMode)

{

VisibleSelection newSelection = passedNewSelection;

bool isDirectional = shouldAlwaysUseDirectionalSelection(m_document.get()) || newSelection.isDirectional();

VisiblePosition base = m_originalBase.isNotNull() ? m_originalBase : newSelection.visibleBase();

VisiblePosition newBase = base;

VisiblePosition extent = newSelection.visibleExtent();

VisiblePosition newExtent = extent;

if (endpointsAdjustmentMode == EndPointsAdjustmentMode::AdjustAtBidiBoundary)

adjustEndpointsAtBidiBoundary(newBase, newExtent);

if (newBase != base || newExtent != extent) {

m_originalBase = base;

newSelection.setBase(newBase);

newSelection.setExtent(newExtent);

} else if (m_originalBase.isNotNull()) {

if (m_selection.base() == newSelection.base())

newSelection.setBase(m_originalBase);

m_originalBase = { };

}

newSelection.setIsDirectional(isDirectional); // Adjusting base and extent will make newSelection always directional

if (m_selection == newSelection || !shouldChangeSelection(newSelection))

return;

AXTextStateChangeIntent intent;

if (AXObjectCache::accessibilityEnabled() && newSelection.isCaret())

intent = AXTextStateChangeIntent(AXTextStateChangeTypeSelectionMove, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityUnknown, false });

else

intent = AXTextStateChangeIntent();

setSelection(newSelection, defaultSetSelectionOptions() | FireSelectEvent, intent, AlignCursorOnScrollIfNeeded, granularity);

}

bool FrameSelection::setSelectionWithoutUpdatingAppearance(const VisibleSelection& newSelectionPossiblyWithoutDirection, OptionSet<SetSelectionOption> options, CursorAlignOnScroll align, TextGranularity granularity)

{

bool closeTyping = options.contains(CloseTyping);

bool shouldClearTypingStyle = options.contains(ClearTypingStyle);

VisibleSelection newSelection = newSelectionPossiblyWithoutDirection;

if (shouldAlwaysUseDirectionalSelection(m_document.get()))

newSelection.setIsDirectional(true);

// <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at FrameSelection::setSelection

// if document->frame() == m_document->frame() we can get into an infinite loop

if (Document* newSelectionDocument = newSelection.base().document()) {

if (RefPtr<Frame> newSelectionFrame = newSelectionDocument->frame()) {

if (m_document && newSelectionFrame != m_document->frame() && newSelectionDocument != m_document) {

newSelectionDocument->selection().setSelection(newSelection, options, AXTextStateChangeIntent(), align, granularity);

// It's possible that during the above set selection, this FrameSelection has been modified by

// selectFrameElementInParentIfFullySelected, but that the selection is no longer valid since

// the frame is about to be destroyed. If this is the case, clear our selection.

if (newSelectionFrame->hasOneRef() && m_selection.isNoneOrOrphaned())

clear();

return false;

}

}

}

VisibleSelection oldSelection = m_selection;

bool willMutateSelection = oldSelection != newSelection;

if (willMutateSelection && m_document)

m_document->editor().selectionWillChange();

{

ScriptDisallowedScope::InMainThread scriptDisallowedScope;

if (newSelection.isOrphan()) {

ASSERT_NOT_REACHED();

clear();

return false;

}

if (!m_document || (!m_document->frame() && !newSelection.document())) {

m_selection = newSelection;

updateAssociatedLiveRange();

return false;

}

bool selectionEndpointsBelongToMultipleDocuments = newSelection.base().document() && !newSelection.document();

bool selectionIsInAnotherDocument = newSelection.document() && newSelection.document() != m_document.get();

bool selectionIsInDetachedDocument = newSelection.document() && !newSelection.document()->frame();

if (selectionEndpointsBelongToMultipleDocuments || selectionIsInAnotherDocument || selectionIsInDetachedDocument) {

clear();

return false;

}

ASSERT(m_document->frame());

if (closeTyping)

TypingCommand::closeTyping(*m_document);

if (shouldClearTypingStyle)

clearTypingStyle();

m_granularity = granularity;

m_selection = newSelection;

updateAssociatedLiveRange();

}

// Selection offsets should increase when LF is inserted before the caret in InsertLineBreakCommand. See <https://webkit.org/b/56061>.

if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(newSelection.start()))

textControl->selectionChanged(options.contains(FireSelectEvent));

if (!willMutateSelection)

return false;

setCaretRectNeedsUpdate();

if (!newSelection.isNone() && !(options & DoNotSetFocus)) {

auto* oldFocusedElement = m_document->focusedElement();

setFocusedElementIfNeeded();

if (!m_document->frame())

return false;

// FIXME: Should not be needed.

if (m_document->focusedElement() != oldFocusedElement)

m_document->updateStyleIfNeeded();

}

// Always clear the x position used for vertical arrow navigation.

// It will be restored by the vertical arrow navigation code if necessary.

m_xPosForVerticalArrowNavigation = std::nullopt;

selectFrameElementInParentIfFullySelected();

m_document->editor().respondToChangedSelection(oldSelection, options);

// https://www.w3.org/TR/selection-api/#selectionchange-event

// FIXME: Spec doesn't specify which task source to use.

m_document->queueTaskToDispatchEvent(TaskSource::UserInteraction, Event::create(eventNames().selectionchangeEvent, Event::CanBubble::No, Event::IsCancelable::No));

return true;

}

void FrameSelection::setSelection(const VisibleSelection& selection, OptionSet<SetSelectionOption> options, AXTextStateChangeIntent intent, CursorAlignOnScroll align, TextGranularity granularity)

{

LOG_WITH_STREAM(Selection, stream << "FrameSelection::setSelection " << selection);

RefPtr protectedDocument { m_document.get() };

if (!setSelectionWithoutUpdatingAppearance(selection, options, align, granularity))

return;

if (options & RevealSelectionUpToMainFrame)

m_selectionRevealMode = SelectionRevealMode::RevealUpToMainFrame;

else if (options & RevealSelection)

m_selectionRevealMode = SelectionRevealMode::Reveal;

else if (options & DelegateMainFrameScroll)

m_selectionRevealMode = SelectionRevealMode::DelegateMainFrameScroll;

else

m_selectionRevealMode = SelectionRevealMode::DoNotReveal;

m_alwaysAlignCursorOnScrollWhenRevealingSelection = align == AlignCursorOnScrollAlways;

m_selectionRevealIntent = intent;

m_pendingSelectionUpdate = true;

if (protectedDocument->hasPendingStyleRecalc())

return;

auto frameView = protectedDocument->view();

if (frameView && frameView->layoutContext().isLayoutPending())

return;

updateAndRevealSelection(intent, options.contains(SmoothScroll) ? ScrollBehavior::Smooth : ScrollBehavior::Instant, options.contains(RevealSelectionBounds) ? RevealExtentOption::DoNotRevealExtent : RevealExtentOption::RevealExtent);

if (options & IsUserTriggered) {

if (auto* client = protectedDocument->editor().client())

client->didEndUserTriggeredSelectionChanges();

}

}

static void updateSelectionByUpdatingLayoutOrStyle(Document& document)

{

#if ENABLE(TEXT_CARET)

document.updateLayoutIgnorePendingStylesheets();

#else

document.updateStyleIfNeeded();

#endif

}

void FrameSelection::setNeedsSelectionUpdate(RevealSelectionAfterUpdate revealMode)

{

m_selectionRevealIntent = AXTextStateChangeIntent();

if (revealMode == RevealSelectionAfterUpdate::Forced)

m_selectionRevealMode = SelectionRevealMode::Reveal;

m_pendingSelectionUpdate = true;

if (RenderView* view = m_document->renderView())

view->selection().clear();

}

void FrameSelection::updateAndRevealSelection(const AXTextStateChangeIntent& intent, ScrollBehavior scrollBehavior, RevealExtentOption revealExtent)

{

if (!m_pendingSelectionUpdate)

return;

m_pendingSelectionUpdate = false;

updateAppearance();

if (m_selectionRevealMode != SelectionRevealMode::DoNotReveal) {

ScrollAlignment alignment;

if (m_document->editor().behavior().shouldCenterAlignWhenSelectionIsRevealed())

alignment = m_alwaysAlignCursorOnScrollWhenRevealingSelection ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded;

else

alignment = m_alwaysAlignCursorOnScrollWhenRevealingSelection ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded;

revealSelection(m_selectionRevealMode, alignment, revealExtent, scrollBehavior);

}

notifyAccessibilityForSelectionChange(intent);

}

void FrameSelection::updateDataDetectorsForSelection()

{

#if ENABLE(TELEPHONE_NUMBER_DETECTION) && !PLATFORM(IOS_FAMILY)

m_document->editor().scanSelectionForTelephoneNumbers();

#endif

}

static bool removingNodeRemovesPosition(Node& node, const Position& position)

{

if (!position.anchorNode())

return false;

if (position.anchorNode() == &node)

return true;

if (!is<Element>(node))

return false;

return downcast<Element>(node).containsIncludingShadowDOM(position.anchorNode());

}

void DragCaretController::nodeWillBeRemoved(Node& node)

{

if (!hasCaret() || !node.isConnected())

return;

if (!removingNodeRemovesPosition(node, m_position.deepEquivalent()))

return;

if (RenderView* view = node.document().renderView())

view->selection().clear();

clear();

}

void FrameSelection::nodeWillBeRemoved(Node& node)

{

// There can't be a selection inside a fragment, so if a fragment's node is being removed,

// the selection in the document that created the fragment needs no adjustment.

if (isNone() || !node.isConnected())

return;

respondToNodeModification(node, removingNodeRemovesPosition(node, m_selection.base()), removingNodeRemovesPosition(node, m_selection.extent()),

removingNodeRemovesPosition(node, m_selection.start()), removingNodeRemovesPosition(node, m_selection.end()));

}

void FrameSelection::respondToNodeModification(Node& node, bool baseRemoved, bool extentRemoved, bool startRemoved, bool endRemoved)

{

bool clearRenderTreeSelection = false;

bool clearDOMTreeSelection = false;

if (startRemoved || endRemoved) {

Position start = m_selection.start();

Position end = m_selection.end();

if (startRemoved)

updatePositionForNodeRemoval(start, node);

if (endRemoved)

updatePositionForNodeRemoval(end, node);

if (start.isNotNull() && end.isNotNull()) {

if (m_selection.isBaseFirst())

m_selection.setWithoutValidation(start, end);

else

m_selection.setWithoutValidation(end, start);

} else

clearDOMTreeSelection = true;

clearRenderTreeSelection = true;

} else if (baseRemoved || extentRemoved) {

// The base and/or extent are about to be removed, but the start and end aren't.

// Change the base and extent to the start and end, but don't re-validate the

// selection, since doing so could move the start and end into the node

// that is about to be removed.

if (m_selection.isBaseFirst())

m_selection.setWithoutValidation(m_selection.start(), m_selection.end());

else

m_selection.setWithoutValidation(m_selection.end(), m_selection.start());

} else if (isRange()) {

if (auto range = m_selection.firstRange(); range && intersects<ComposedTree>(*range, node)) {

// If we did nothing here, when this node's renderer was destroyed, the rect that it

// occupied would be invalidated, but, selection gaps that change as a result of

// the removal wouldn't be invalidated.

// FIXME: Don't do so much unnecessary invalidation.

clearRenderTreeSelection = true;

}

}

if (clearRenderTreeSelection) {

if (auto* renderView = node.document().renderView()) {

renderView->selection().clear();

// Trigger a selection update so the selection will be set again.

m_selectionRevealIntent = AXTextStateChangeIntent();

m_pendingSelectionUpdate = true;

renderView->frameView().scheduleSelectionUpdate();

}

}

if (clearDOMTreeSelection)

setSelection(VisibleSelection(), DoNotSetFocus);

}

static void updatePositionAfterAdoptingTextReplacement(Position& position, CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength)

{

if (!position.anchorNode() || position.anchorNode() != node || position.anchorType() != Position::PositionIsOffsetInAnchor)

return;

// See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation

ASSERT(position.offsetInContainerNode() >= 0);

unsigned positionOffset = static_cast<unsigned>(position.offsetInContainerNode());

// Replacing text can be viewed as a deletion followed by insertion.

if (positionOffset >= offset && positionOffset <= offset + oldLength)

position.moveToOffset(offset);

// Adjust the offset if the position is after the end of the deleted contents

// (positionOffset > offset + oldLength) to avoid having a stale offset.

if (positionOffset > offset + oldLength)

position.moveToOffset(positionOffset - oldLength + newLength);

ASSERT(static_cast<unsigned>(position.offsetInContainerNode()) <= node->length());

}

void FrameSelection::textWasReplaced(CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength)

{

// The fragment check is a performance optimization. See http://trac.webkit.org/changeset/30062.

if (isNone() || !node || !node->isConnected())

return;

Position base = m_selection.base();

Position extent = m_selection.extent();

Position start = m_selection.start();

Position end = m_selection.end();

updatePositionAfterAdoptingTextReplacement(base, node, offset, oldLength, newLength);

updatePositionAfterAdoptingTextReplacement(extent, node, offset, oldLength, newLength);

updatePositionAfterAdoptingTextReplacement(start, node, offset, oldLength, newLength);

updatePositionAfterAdoptingTextReplacement(end, node, offset, oldLength, newLength);

if (base != m_selection.base() || extent != m_selection.extent() || start != m_selection.start() || end != m_selection.end()) {

VisibleSelection newSelection;

if (base != extent)

newSelection.setWithoutValidation(base, extent);

else if (m_selection.isDirectional() && !m_selection.isBaseFirst())

newSelection.setWithoutValidation(end, start);

else

newSelection.setWithoutValidation(start, end);

setSelection(newSelection, DoNotSetFocus);

}

}

TextDirection FrameSelection::directionOfEnclosingBlock()

{

return WebCore::directionOfEnclosingBlock(m_selection.extent());

}

TextDirection FrameSelection::directionOfSelection()

{

// Get bot VisiblePositions first because visibleStart() and visibleEnd()

// can cause layout, which has the potential to invalidate lineboxes.

auto startPosition = m_selection.visibleStart();

auto endPosition = m_selection.visibleEnd();

auto startRun = startPosition.inlineRunAndOffset().run;

auto endRun = endPosition.inlineRunAndOffset().run;

if (startRun && endRun && startRun->direction() == endRun->direction())

return startRun->direction();

return directionOfEnclosingBlock();

}

void FrameSelection::willBeModified(EAlteration alter, SelectionDirection direction)

{

if (alter != AlterationExtend)

return;

Position start = m_selection.start();

Position end = m_selection.end();

bool baseIsStart = true;

if (m_selection.isDirectional()) {

// Make base and extent match start and end so we extend the user-visible selection.

// This only matters for cases where base and extend point to different positions than

// start and end (e.g. after a double-click to select a word).

if (m_selection.isBaseFirst())

baseIsStart = true;

else

baseIsStart = false;

} else {

switch (direction) {

case SelectionDirection::Right:

if (directionOfSelection() == TextDirection::LTR)

baseIsStart = true;

else

baseIsStart = false;

break;

case SelectionDirection::Forward:

baseIsStart = true;

break;

case SelectionDirection::Left:

if (directionOfSelection() == TextDirection::LTR)

baseIsStart = false;

else

baseIsStart = true;

break;

case SelectionDirection::Backward:

baseIsStart = false;

break;

}

}

if (baseIsStart) {

m_selection.setBase(start);

m_selection.setExtent(end);

} else {

m_selection.setBase(end);

m_selection.setExtent(start);

}

}

VisiblePosition FrameSelection::positionForPlatform(bool isGetStart) const

{

// FIXME: VisibleSelection should be fixed to ensure as an invariant that

// base/extent always point to the same nodes as start/end, but which points

// to which depends on the value of isBaseFirst. Then this can be changed

// to just return m_sel.extent().

if (m_document && m_document->editor().behavior().shouldAlwaysExtendSelectionFromExtentEndpoint())

return m_selection.isBaseFirst() ? m_selection.visibleEnd() : m_selection.visibleStart();

return isGetStart ? m_selection.visibleStart() : m_selection.visibleEnd();

}

VisiblePosition FrameSelection::startForPlatform() const

{

return positionForPlatform(true);

}

VisiblePosition FrameSelection::endForPlatform() const

{

return positionForPlatform(false);

}

VisiblePosition FrameSelection::nextWordPositionForPlatform(const VisiblePosition& originalPosition)

{

VisiblePosition positionAfterCurrentWord = nextWordPosition(originalPosition);

if (m_document && m_document->editor().behavior().shouldSkipSpaceWhenMovingRight()) {

// In order to skip spaces when moving right, we advance one

// word further and then move one word back. Given the

// semantics of previousWordPosition() this will put us at the

// beginning of the word following.

VisiblePosition positionAfterSpacingAndFollowingWord = nextWordPosition(positionAfterCurrentWord);

if (positionAfterSpacingAndFollowingWord != positionAfterCurrentWord)

positionAfterCurrentWord = previousWordPosition(positionAfterSpacingAndFollowingWord);

bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord == previousWordPosition(nextWordPosition(originalPosition));

if (movingBackwardsMovedPositionToStartOfCurrentWord)

positionAfterCurrentWord = positionAfterSpacingAndFollowingWord;

}

return positionAfterCurrentWord;

}

static void adjustPositionForUserSelectAll(VisiblePosition& pos, bool isForward)

{

if (Node* rootUserSelectAll = Position::rootUserSelectAllForNode(pos.deepEquivalent().anchorNode()))

pos = isForward ? positionAfterNode(rootUserSelectAll).downstream(CanCrossEditingBoundary) : positionBeforeNode(rootUserSelectAll).upstream(CanCrossEditingBoundary);

}

VisiblePosition FrameSelection::modifyExtendingRight(TextGranularity granularity)

{

VisiblePosition pos(m_selection.extent(), m_selection.affinity());

// The difference between modifyExtendingRight and modifyExtendingForward is:

// modifyExtendingForward always extends forward logically.

// modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,

// it extends forward logically if the enclosing block is TextDirection::LTR,

// but it extends backward logically if the enclosing block is TextDirection::RTL.

switch (granularity) {

case TextGranularity::CharacterGranularity:

if (directionOfEnclosingBlock() == TextDirection::LTR)

pos = pos.next(CannotCrossEditingBoundary);

else

pos = pos.previous(CannotCrossEditingBoundary);

break;

case TextGranularity::WordGranularity:

if (directionOfEnclosingBlock() == TextDirection::LTR)

pos = nextWordPositionForPlatform(pos);

else

pos = previousWordPosition(pos);

break;

case TextGranularity::LineBoundary:

if (directionOfEnclosingBlock() == TextDirection::LTR)

pos = modifyExtendingForward(granularity);

else

pos = modifyExtendingBackward(granularity);

break;

case TextGranularity::SentenceGranularity:

case TextGranularity::LineGranularity:

case TextGranularity::ParagraphGranularity:

case TextGranularity::SentenceBoundary:

case TextGranularity::ParagraphBoundary:

case TextGranularity::DocumentBoundary:

// FIXME: implement all of the above?

pos = modifyExtendingForward(granularity);

break;

case TextGranularity::DocumentGranularity:

ASSERT_NOT_REACHED();

break;

}

adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == TextDirection::LTR);

return pos;

}

VisiblePosition FrameSelection::modifyExtendingForward(TextGranularity granularity)

{

VisiblePosition pos(m_selection.extent(), m_selection.affinity());

switch (granularity) {

case TextGranularity::CharacterGranularity:

pos = pos.next(CannotCrossEditingBoundary);

break;

case TextGranularity::WordGranularity:

pos = nextWordPositionForPlatform(pos);

break;

case TextGranularity::SentenceGranularity:

pos = nextSentencePosition(pos);

break;

case TextGranularity::LineGranularity:

pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(Extent));

break;

case TextGranularity::ParagraphGranularity:

pos = nextParagraphPosition(pos, lineDirectionPointForBlockDirectionNavigation(Extent));

break;

case TextGranularity::DocumentGranularity:

ASSERT_NOT_REACHED();

break;

case TextGranularity::SentenceBoundary:

pos = endOfSentence(endForPlatform());

break;

case TextGranularity::LineBoundary:

pos = logicalEndOfLine(endForPlatform());

break;

case TextGranularity::ParagraphBoundary:

pos = endOfParagraph(endForPlatform());

break;

case TextGranularity::DocumentBoundary:

pos = endForPlatform();

if (isEditablePosition(pos.deepEquivalent()))

pos = endOfEditableContent(pos);

else

pos = endOfDocument(pos);

break;

}

adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == TextDirection::LTR);

return pos;

}

VisiblePosition FrameSelection::modifyMovingRight(TextGranularity granularity, bool* reachedBoundary)

{

if (reachedBoundary)

*reachedBoundary = false;

VisiblePosition pos;

switch (granularity) {

case TextGranularity::CharacterGranularity:

if (isRange()) {

if (directionOfSelection() == TextDirection::LTR)

pos = VisiblePosition(m_selection.end(), m_selection.affinity());

else

pos = VisiblePosition(m_selection.start(), m_selection.affinity());

} else

pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).right(true, reachedBoundary);

break;

case TextGranularity::WordGranularity: {

bool skipsSpaceWhenMovingRight = m_document && m_document->editor().behavior().shouldSkipSpaceWhenMovingRight();

VisiblePosition currentPosition(m_selection.extent(), m_selection.affinity());

pos = rightWordPosition(currentPosition, skipsSpaceWhenMovingRight);

if (reachedBoundary)

*reachedBoundary = pos == currentPosition;

break;

}

case TextGranularity::SentenceGranularity:

case TextGranularity::LineGranularity:

case TextGranularity::ParagraphGranularity:

case TextGranularity::SentenceBoundary:

case TextGranularity::ParagraphBoundary:

case TextGranularity::DocumentBoundary:

// FIXME: Implement all of the above.

pos = modifyMovingForward(granularity, reachedBoundary);

break;

case TextGranularity::LineBoundary:

pos = rightBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock(), reachedBoundary);

break;

case TextGranularity::DocumentGranularity:

ASSERT_NOT_REACHED();

break;

}

return pos;

}

VisiblePosition FrameSelection::modifyMovingForward(TextGranularity granularity, bool* reachedBoundary)

{

if (reachedBoundary)

*reachedBoundary = false;

VisiblePosition currentPosition;

switch (granularity) {

case TextGranularity::WordGranularity:

case TextGranularity::SentenceGranularity:

currentPosition = VisiblePosition(m_selection.extent(), m_selection.affinity());

break;

case TextGranularity::LineGranularity:

case TextGranularity::ParagraphGranularity:

case TextGranularity::SentenceBoundary:

case TextGranularity::ParagraphBoundary:

case TextGranularity::DocumentBoundary:

currentPosition = endForPlatform();

break;

default:

break;

}

VisiblePosition pos;

// FIXME: Stay in editable content for the less common granularities.

switch (granularity) {

case TextGranularity::CharacterGranularity:

if (isRange())

pos = VisiblePosition(m_selection.end(), m_selection.affinity());

else

pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).next(CannotCrossEditingBoundary, reachedBoundary);

break;

case TextGranularity::WordGranularity:

pos = nextWordPositionForPlatform(currentPosition);

break;

case TextGranularity::SentenceGranularity:

pos = nextSentencePosition(currentPosition);

break;

case TextGranularity::LineGranularity: {

// down-arrowing from a range selection that ends at the start of a line needs

// to leave the selection at that line start (no need to call nextLinePosition!)

pos = currentPosition;

if (!isRange() || !isStartOfLine(pos))

pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(Start));

break;

}

case TextGranularity::ParagraphGranularity:

pos = nextParagraphPosition(currentPosition, lineDirectionPointForBlockDirectionNavigation(Start));

break;

case TextGranularity::DocumentGranularity:

ASSERT_NOT_REACHED();

break;

case TextGranularity::SentenceBoundary:

pos = endOfSentence(currentPosition);

break;

case TextGranularity::LineBoundary:

pos = logicalEndOfLine(endForPlatform(), reachedBoundary);

break;

case TextGranularity::ParagraphBoundary:

pos = endOfParagraph(currentPosition);

break;

case TextGranularity::DocumentBoundary:

pos = currentPosition;

if (isEditablePosition(pos.deepEquivalent()))

pos = endOfEditableContent(pos);

else

pos = endOfDocument(pos);

break;

}

switch (granularity) {

case TextGranularity::WordGranularity:

case TextGranularity::SentenceGranularity:

case TextGranularity::LineGranularity:

case TextGranularity::ParagraphGranularity:

case TextGranularity::SentenceBoundary:

case TextGranularity::ParagraphBoundary:

case TextGranularity::DocumentBoundary:

if (reachedBoundary)

*reachedBoundary = pos == currentPosition;

break;

default:

break;

}

return pos;

}

VisiblePosition FrameSelection::modifyExtendingLeft(TextGranularity granularity)

{

VisiblePosition pos(m_selection.extent(), m_selection.affinity());

// The difference between modifyExtendingLeft and modifyExtendingBackward is:

// modifyExtendingBackward always extends backward logically.

// modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,

// it extends backward logically if the enclosing block is TextDirection::LTR,

// but it extends forward logically if the enclosing block is TextDirection::RTL.

switch (granularity) {

case TextGranularity::CharacterGranularity:

if (directionOfEnclosingBlock() == TextDirection::LTR)

pos = pos.previous(CannotCrossEditingBoundary);

else

pos = pos.next(CannotCrossEditingBoundary);

break;

case TextGranularity::WordGranularity:

if (directionOfEnclosingBlock() == TextDirection::LTR)