⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 267363 in webkit


Ignore:
Timestamp:
Sep 21, 2020, 1:28:24 PM (6 years ago)
Author:
Darin Adler
Message:

Next step towards eliminating deprecated legacy positions
​https://bugs.webkit.org/show_bug.cgi?id=216751

Reviewed by Sam Weinig.

Source/WebCore:

Eliminating our old deprecated legacy editing positions is probably a relatively long
road. This next step starts using the makeContainerOffsetPosition function in more
places, requesting that we not use any of the deprecated legacy position logic. Also
renames createLegacyEditingPosition to makeDeprecatedLegacyPosition. The hard part of
this project will be removing code that is not inside Position that depends on the old
style of position/offset pairs. For this patch, tried to stick to converting cases
where it seems clear we don't depend on the legacy behavior. Flaw in that is that we
might still depend on legacy behavior where it's unconditionally implemented, without
checking the flag on the m_isLegacyEditingPosition Position class; that will be a
problem long term, should not be in this patch.

  • dom/Position.h:

(WebCore::createLegacyEditingPosition): Deleted.

  • accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::visiblePositionForTextMarkerData):
(WebCore::AXObjectCache::rangeMatchesTextNearRange):
(WebCore::AXObjectCache::visiblePositionFromCharacterOffset):
(WebCore::AXObjectCache::localCaretRectForCharacterOffset):
(WebCore::AXObjectCache::indexForCharacterOffset):

  • accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::stringForRange const):

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::linkClickPoint):
(WebCore::AccessibilityRenderObject::setSelectedTextRange):
(WebCore::AccessibilityRenderObject::setSelectedVisiblePositionRange const):

  • accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:

(-[WebAccessibilityObjectWrapper arrayOfTextForTextMarkers:attributed:]):

  • accessibility/mac/WebAccessibilityObjectWrapperMac.mm:

(-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):

  • dom/Position.cpp:

(WebCore::Position::previous const):
(WebCore::Position::next const):
(WebCore::Position::downstream const):

  • dom/PositionIterator.cpp:

(WebCore::PositionIterator::operator Position const):

  • dom/Range.cpp:

(WebCore::Range::expand):

  • editing/AlternativeTextController.cpp:

(WebCore::AlternativeTextController::applyAutocorrectionBeforeTypingIfAppropriate):
(WebCore::AlternativeTextController::processMarkersOnTextToBeReplacedByResult):
(WebCore::AlternativeTextController::applyAlternativeTextToRange):

  • editing/ApplyStyleCommand.cpp:

(WebCore::ApplyStyleCommand::applyBlockStyle):

  • editing/CompositeEditCommand.cpp:

(WebCore::CompositeEditCommand::moveParagraphs):

  • editing/DeleteSelectionCommand.cpp:

(WebCore::DeleteSelectionCommand::handleGeneralDelete):

  • editing/Editing.cpp:

(WebCore::visiblePositionForIndex):
(WebCore::visiblePositionForIndexUsingCharacterIterator):
(WebCore::isNodeVisiblyContainedWithin):

  • editing/Editor.cpp:

(WebCore::Editor::canDeleteRange const):
(WebCore::Editor::selectComposition):
(WebCore::Editor::advanceToNextMisspelling):
(WebCore::Editor::markAndReplaceFor):
(WebCore::Editor::firstRectForRange const):
(WebCore::extendSelection):
(WebCore::Editor::adjustedSelectionRange):

  • editing/FrameSelection.cpp:

(WebCore::FrameSelection::elementRangeContainingCaretSelection const):

  • editing/InsertListCommand.cpp:

(WebCore::InsertListCommand::doApplyForSingleParagraph):

  • editing/RenderedPosition.cpp:

(WebCore::RenderedPosition::positionAtLeftBoundaryOfBiDiRun const):
(WebCore::RenderedPosition::positionAtRightBoundaryOfBiDiRun const):

  • editing/TextCheckingHelper.cpp:

(WebCore::expandToParagraphBoundary):
(WebCore::TextCheckingParagraph::expandRangeToNextEnd):
(WebCore::TextCheckingHelper::findFirstMisspelledWordOrUngrammaticalPhrase const):

  • editing/TextIterator.cpp:

(WebCore::resolveCharacterRange):

  • editing/VisiblePosition.cpp:

(WebCore::VisiblePosition::leftVisuallyDistinctCandidate const):
(WebCore::VisiblePosition::rightVisuallyDistinctCandidate const):

  • editing/VisibleSelection.cpp:

(WebCore::VisibleSelection::appendTrailingWhitespace):

  • editing/VisibleUnits.cpp:

(WebCore::previousRootInlineBoxCandidatePosition):
(WebCore::nextRootInlineBoxCandidatePosition):
(WebCore::previousBoundary):
(WebCore::nextBoundary):
(WebCore::startOfDocument):
(WebCore::endOfDocument):
(WebCore::closestWordBoundaryForPosition):
(WebCore::wordBoundaryForPositionWithoutCrossingLine):

  • editing/cocoa/HTMLConverter.mm:

(HTMLConverter::HTMLConverter):

  • editing/ios/EditorIOS.mm:

(WebCore::Editor::setTextAsChildOfElement):

  • editing/markup.cpp:

(WebCore::serializePreservingVisualAppearance):
(WebCore::contextPreservesNewline):
(WebCore::createFragmentFromText):

  • page/DragController.cpp:

(WebCore::DragController::insertDroppedImagePlaceholdersAtCaret):

  • page/Page.cpp:

(WebCore::Page::replaceRangesWithText):

  • page/ios/FrameIOS.mm:

(WebCore::Frame::interpretationsForCurrentRoot const):

  • platform/DragImage.cpp:

(WebCore::createDragImageForRange):

  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::positionForBox const):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::createVisiblePosition const):
(WebCore::RenderObject::collectSelectionRectsInternal):

  • testing/Internals.cpp:

(WebCore::Internals::setSelectionWithoutValidation):
Replaced calls to createLegacyEditingPosition with calls to
makeDeprecatedLegacyPosition or makeContainerOffsetPosition.

Source/WebKit:

  • WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::selectWithGesture):
(WebKit::WebPage::extendSelection):
(WebKit::WebPage::updateSelectionWithExtentPointAndBoundary):
(WebKit::WebPage::requestAutocorrectionData):
(WebKit::WebPage::applyAutocorrectionInternal):
(WebKit::focusedElementPositionInformation):
(WebKit::dataDetectorLinkPositionInformation):
(WebKit::WebPage::requestDocumentEditingContext):
Replaced calls to createLegacyEditingPosition with calls to
makeDeprecatedLegacyPosition or makeContainerOffsetPosition.

Source/WebKitLegacy/ios:

  • WebCoreSupport/WebVisiblePosition.mm:

(-[DOMNode startPosition]):
(-[DOMNode endPosition]):
Replaced calls to createLegacyEditingPosition with calls to
makeDeprecatedLegacyPosition or makeContainerOffsetPosition.

Source/WebKitLegacy/mac:

  • DOM/DOMUIKitExtensions.mm:

(-[DOMNode rangeOfContainingParagraph]):

  • WebView/WebFrame.mm:

(-[WebFrame spaceFollowsWordInRange:]):
(-[WebFrame caretRectAtNode:offset:affinity:]):
(-[WebFrame focusedNodeHasContent]):
Replaced calls to createLegacyEditingPosition with calls to
makeDeprecatedLegacyPosition or makeContainerOffsetPosition.

Location:
trunk/Source
Files:
41 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r267362 r267363  
     12020-09-20  Darin Adler  <darin@apple.com>
     2
     3        Next step towards eliminating deprecated legacy positions
     4        https://bugs.webkit.org/show_bug.cgi?id=216751
     5
     6        Reviewed by Sam Weinig.
     7
     8        Eliminating our old deprecated legacy editing positions is probably a relatively long
     9        road. This next step starts using the makeContainerOffsetPosition function in more
     10        places, requesting that we not use any of the deprecated legacy position logic. Also
     11        renames createLegacyEditingPosition to makeDeprecatedLegacyPosition. The hard part of
     12        this project will be removing code that is not inside Position that depends on the old
     13        style of position/offset pairs. For this patch, tried to stick to converting cases
     14        where it seems clear we don't depend on the legacy behavior. Flaw in that is that we
     15        might still depend on legacy behavior where it's unconditionally implemented, without
     16        checking the flag on the m_isLegacyEditingPosition Position class; that will be a
     17        problem long term, should not be in this patch.
     18
     19        * dom/Position.h:
     20        (WebCore::createLegacyEditingPosition): Deleted.
     21
     22        * accessibility/AXObjectCache.cpp:
     23        (WebCore::AXObjectCache::visiblePositionForTextMarkerData):
     24        (WebCore::AXObjectCache::rangeMatchesTextNearRange):
     25        (WebCore::AXObjectCache::visiblePositionFromCharacterOffset):
     26        (WebCore::AXObjectCache::localCaretRectForCharacterOffset):
     27        (WebCore::AXObjectCache::indexForCharacterOffset):
     28        * accessibility/AccessibilityObject.cpp:
     29        (WebCore::AccessibilityObject::stringForRange const):
     30        * accessibility/AccessibilityRenderObject.cpp:
     31        (WebCore::AccessibilityRenderObject::linkClickPoint):
     32        (WebCore::AccessibilityRenderObject::setSelectedTextRange):
     33        (WebCore::AccessibilityRenderObject::setSelectedVisiblePositionRange const):
     34        * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
     35        (-[WebAccessibilityObjectWrapper arrayOfTextForTextMarkers:attributed:]):
     36        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
     37        (-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):
     38        * dom/Position.cpp:
     39        (WebCore::Position::previous const):
     40        (WebCore::Position::next const):
     41        (WebCore::Position::downstream const):
     42        * dom/PositionIterator.cpp:
     43        (WebCore::PositionIterator::operator Position const):
     44        * dom/Range.cpp:
     45        (WebCore::Range::expand):
     46        * editing/AlternativeTextController.cpp:
     47        (WebCore::AlternativeTextController::applyAutocorrectionBeforeTypingIfAppropriate):
     48        (WebCore::AlternativeTextController::processMarkersOnTextToBeReplacedByResult):
     49        (WebCore::AlternativeTextController::applyAlternativeTextToRange):
     50        * editing/ApplyStyleCommand.cpp:
     51        (WebCore::ApplyStyleCommand::applyBlockStyle):
     52        * editing/CompositeEditCommand.cpp:
     53        (WebCore::CompositeEditCommand::moveParagraphs):
     54        * editing/DeleteSelectionCommand.cpp:
     55        (WebCore::DeleteSelectionCommand::handleGeneralDelete):
     56        * editing/Editing.cpp:
     57        (WebCore::visiblePositionForIndex):
     58        (WebCore::visiblePositionForIndexUsingCharacterIterator):
     59        (WebCore::isNodeVisiblyContainedWithin):
     60        * editing/Editor.cpp:
     61        (WebCore::Editor::canDeleteRange const):
     62        (WebCore::Editor::selectComposition):
     63        (WebCore::Editor::advanceToNextMisspelling):
     64        (WebCore::Editor::markAndReplaceFor):
     65        (WebCore::Editor::firstRectForRange const):
     66        (WebCore::extendSelection):
     67        (WebCore::Editor::adjustedSelectionRange):
     68        * editing/FrameSelection.cpp:
     69        (WebCore::FrameSelection::elementRangeContainingCaretSelection const):
     70        * editing/InsertListCommand.cpp:
     71        (WebCore::InsertListCommand::doApplyForSingleParagraph):
     72        * editing/RenderedPosition.cpp:
     73        (WebCore::RenderedPosition::positionAtLeftBoundaryOfBiDiRun const):
     74        (WebCore::RenderedPosition::positionAtRightBoundaryOfBiDiRun const):
     75        * editing/TextCheckingHelper.cpp:
     76        (WebCore::expandToParagraphBoundary):
     77        (WebCore::TextCheckingParagraph::expandRangeToNextEnd):
     78        (WebCore::TextCheckingHelper::findFirstMisspelledWordOrUngrammaticalPhrase const):
     79        * editing/TextIterator.cpp:
     80        (WebCore::resolveCharacterRange):
     81        * editing/VisiblePosition.cpp:
     82        (WebCore::VisiblePosition::leftVisuallyDistinctCandidate const):
     83        (WebCore::VisiblePosition::rightVisuallyDistinctCandidate const):
     84        * editing/VisibleSelection.cpp:
     85        (WebCore::VisibleSelection::appendTrailingWhitespace):
     86        * editing/VisibleUnits.cpp:
     87        (WebCore::previousRootInlineBoxCandidatePosition):
     88        (WebCore::nextRootInlineBoxCandidatePosition):
     89        (WebCore::previousBoundary):
     90        (WebCore::nextBoundary):
     91        (WebCore::startOfDocument):
     92        (WebCore::endOfDocument):
     93        (WebCore::closestWordBoundaryForPosition):
     94        (WebCore::wordBoundaryForPositionWithoutCrossingLine):
     95        * editing/cocoa/HTMLConverter.mm:
     96        (HTMLConverter::HTMLConverter):
     97        * editing/ios/EditorIOS.mm:
     98        (WebCore::Editor::setTextAsChildOfElement):
     99        * editing/markup.cpp:
     100        (WebCore::serializePreservingVisualAppearance):
     101        (WebCore::contextPreservesNewline):
     102        (WebCore::createFragmentFromText):
     103        * page/DragController.cpp:
     104        (WebCore::DragController::insertDroppedImagePlaceholdersAtCaret):
     105        * page/Page.cpp:
     106        (WebCore::Page::replaceRangesWithText):
     107        * page/ios/FrameIOS.mm:
     108        (WebCore::Frame::interpretationsForCurrentRoot const):
     109        * platform/DragImage.cpp:
     110        (WebCore::createDragImageForRange):
     111        * rendering/RenderBlockFlow.cpp:
     112        (WebCore::RenderBlockFlow::positionForBox const):
     113        * rendering/RenderObject.cpp:
     114        (WebCore::RenderObject::createVisiblePosition const):
     115        (WebCore::RenderObject::collectSelectionRectsInternal):
     116        * testing/Internals.cpp:
     117        (WebCore::Internals::setSelectionWithoutValidation):
     118        Replaced calls to createLegacyEditingPosition with calls to
     119        makeDeprecatedLegacyPosition or makeContainerOffsetPosition.
     120
    11212020-09-20  Darin Adler  <darin@apple.com>
    2122

  • trunk/Source/WebCore/accessibility/AXObjectCache.cpp

    r267166 r267363  
    18181818        return VisiblePosition();
    18191819   
    1820     // FIXME: Accessability should make it clear these are DOM-compliant offsets or store Position objects.
    1821     VisiblePosition visiblePos = VisiblePosition(createLegacyEditingPosition(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
     1820    VisiblePosition visiblePos = VisiblePosition(makeContainerOffsetPosition(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
    18221821    Position deepPos = visiblePos.deepEquivalent();
    18231822    if (deepPos.isNull())
    … …  
    20032002    // Create a large enough range for searching the text within.
    20042003    unsigned textLength = matchText.length();
    2005     auto startPosition = visiblePositionForPositionWithOffset(createLegacyEditingPosition(originalRange.start), -textLength);
    2006     auto endPosition = visiblePositionForPositionWithOffset(createLegacyEditingPosition(originalRange.start), 2 * textLength);
     2004    auto startPosition = visiblePositionForPositionWithOffset(makeContainerOffsetPosition(originalRange.start), -textLength);
     2005    auto endPosition = visiblePositionForPositionWithOffset(makeContainerOffsetPosition(originalRange.start), 2 * textLength);
    20072006    if (startPosition.isNull())
    20082007        startPosition = firstPositionInOrBeforeNode(originalRange.start.container.ptr());
    … …  
    23192318    if (!range)
    23202319        return { };
    2321     return createLegacyEditingPosition(range->start);
     2320    return makeContainerOffsetPosition(range->start);
    23222321}
    23232322
    … …  
    28722871        return IntRect();
    28732872
    2874     auto [inlineBox, caretOffset] = createLegacyEditingPosition(range->start).inlineBoxAndOffset(Affinity::Downstream);
     2873    auto [inlineBox, caretOffset] = makeContainerOffsetPosition(range->start).inlineBoxAndOffset(Affinity::Downstream);
    28752874    if (inlineBox)
    28762875        renderer = &inlineBox->renderer();
    … …  
    30063005    if (!range)
    30073006        return 0;
    3008     return obj->indexForVisiblePosition(createLegacyEditingPosition(range->start));
     3007    return obj->indexForVisiblePosition(makeContainerOffsetPosition(range->start));
    30093008}
    30103009

  • trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

    r267166 r267363  
    12381238            if (it.text().length() != 1 || !isSpaceOrNewline(it.text()[0])) {
    12391239                // FIXME: Seems like the position should be based on it.range(), not range.
    1240                 builder.append(listMarkerTextForNodeAndPosition(it.node(), VisiblePosition(createLegacyEditingPosition(range.start))));
     1240                builder.append(listMarkerTextForNodeAndPosition(it.node(), VisiblePosition(makeDeprecatedLegacyPosition(range.start))));
    12411241            }
    12421242            it.appendTextToStringBuilder(builder);

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r267320 r267363  
    921921     */
    922922    if (auto range = elementRange()) {
    923         auto start = VisiblePosition { createLegacyEditingPosition(range->start) };
     923        auto start = VisiblePosition { makeContainerOffsetPosition(range->start) };
    924924        auto end = nextVisiblePosition(start);
    925925        if (isPointInRange(*range, makeBoundaryPoint(end)))
    … …  
    16551655        auto start = visiblePositionForIndexUsingCharacterIterator(node, range.start);
    16561656        if (!isPointInRange(*elementRange, makeBoundaryPoint(start)))
    1657             start = createLegacyEditingPosition(elementRange->start);
     1657            start = makeContainerOffsetPosition(elementRange->start);
    16581658        auto end = visiblePositionForIndexUsingCharacterIterator(node, range.start + range.length);
    16591659        if (!isPointInRange(*elementRange, makeBoundaryPoint(end)))
    1660             end = createLegacyEditingPosition(elementRange->start);
     1660            end = makeContainerOffsetPosition(elementRange->start);
    16611661        m_renderer->frame().selection().setSelection(VisibleSelection(start, end), FrameSelection::defaultSetSelectionOptions(UserTriggered));
    16621662    }
    … …  
    22092209        if (auto elementRange = this->elementRange()) {
    22102210            if (!isPointInRange(*elementRange, makeBoundaryPoint(start)))
    2211                 start = createLegacyEditingPosition(elementRange->start);
     2211                start = makeContainerOffsetPosition(elementRange->start);
    22122212        }
    22132213

  • trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm

    r265278 r267363  
    23212321                    continue;
    23222322
    2323                 String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(createLegacyEditingPosition(it.range().start)));
     2323                String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, makeContainerOffsetPosition(it.range().start));
    23242324               
    23252325                if (!listMarkerText.isEmpty())
    … …  
    23282328                [array addObject:it.text().createNSString().get()];
    23292329            } else {
    2330                 String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(createLegacyEditingPosition(it.range().start)));
     2330                String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, makeContainerOffsetPosition(it.range().start));
    23312331
    23322332                if (!listMarkerText.isEmpty()) {

  • trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm

    r266986 r267363  
    12551255            if (it.text().length()) {
    12561256                // Add the text of the list marker item if necessary.
    1257                 String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(createLegacyEditingPosition(it.range().start)));
     1257                String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, makeContainerOffsetPosition(it.range().start));
    12581258                if (!listMarkerText.isEmpty())
    12591259                    AXAttributedStringAppendText(attrString.get(), &node, listMarkerText, spellCheck);

  • trunk/Source/WebCore/dom/Position.cpp

    r267220 r267363  
    373373        return positionAfterNode(previousSibling);
    374374
    375     return makeDeprecatedLegacyPosition(parent, node->computeNodeIndex());
     375    return makeContainerOffsetPosition(parent, node->computeNodeIndex());
    376376}
    377377
    … …  
    421421        return positionBeforeNode(nextSibling);
    422422
    423     return makeDeprecatedLegacyPosition(parent, node->computeNodeIndex() + 1);
     423    return makeContainerOffsetPosition(parent, node->computeNodeIndex() + 1);
    424424}
    425425
    … …  
    842842            if (&currentNode != startNode) {
    843843                ASSERT(currentPosition.atStartOfNode());
    844                 return makeDeprecatedLegacyPosition(&currentNode, textRenderer.caretMinOffset());
     844                return makeContainerOffsetPosition(&currentNode, textRenderer.caretMinOffset());
    845845            }
    846846

  • trunk/Source/WebCore/dom/Position.h

    r266986 r267363  
    350350}
    351351
    352 // FIXME: Delete this after changing all callers to use the makeDeprecatedLegacyPosition name.
    353 inline Position createLegacyEditingPosition(Node* node, unsigned offset)
    354 {
    355     return makeDeprecatedLegacyPosition(node, offset);
    356 }
    357 
    358 // FIXME: Delete this after changing all callers to use the makeDeprecatedLegacyPosition name.
    359 inline Position createLegacyEditingPosition(const BoundaryPoint& point)
    360 {
    361     return makeDeprecatedLegacyPosition(point);
    362 }
    363 
    364352} // namespace WebCore
    365353

  • trunk/Source/WebCore/dom/PositionIterator.cpp

    r260207 r267363  
    5252    if (m_anchorNode->hasChildNodes())
    5353        return lastPositionInOrAfterNode(m_anchorNode);
    54     return createLegacyEditingPosition(m_anchorNode, m_offsetInAnchor);
     54    return makeDeprecatedLegacyPosition(m_anchorNode, m_offsetInAnchor);
    5555}
    5656

  • trunk/Source/WebCore/dom/Range.cpp

    r267313 r267363  
    994994ExceptionOr<void> Range::expand(const String& unit)
    995995{
    996     auto start = VisiblePosition { makeDeprecatedLegacyPosition(&startContainer(), startOffset()) };
    997     auto end = VisiblePosition { makeDeprecatedLegacyPosition(&endContainer(), endOffset()) };
     996    auto start = VisiblePosition { makeContainerOffsetPosition(&startContainer(), startOffset()) };
     997    auto end = VisiblePosition { makeContainerOffsetPosition(&endContainer(), endOffset()) };
    998998    if (unit == "word") {
    999999        start = startOfWord(start);

  • trunk/Source/WebCore/editing/AlternativeTextController.cpp

    r265509 r267363  
    207207    Position caretPosition = m_document.selection().selection().start();
    208208
    209     if (createLegacyEditingPosition(m_rangeWithAlternative->end) == caretPosition) {
     209    if (makeDeprecatedLegacyPosition(m_rangeWithAlternative->end) == caretPosition) {
    210210        handleAlternativeTextUIResult(dismissSoon(ReasonForDismissingAlternativeTextAccepted));
    211211        return true;
    … …  
    213213   
    214214    // Pending correction should always be where caret is. But in case this is not always true, we still want to dismiss the panel without accepting the correction.
    215     ASSERT(createLegacyEditingPosition(m_rangeWithAlternative->end) == caretPosition);
     215    ASSERT(makeDeprecatedLegacyPosition(m_rangeWithAlternative->end) == caretPosition);
    216216    dismiss(ReasonForDismissingAlternativeTextIgnored);
    217217    return false;
    … …  
    518518        return false;
    519519
    520     auto precedingCharacterRange = makeSimpleRange(createLegacyEditingPosition(rangeWithAlternative.start).previous(), rangeWithAlternative.start);
     520    auto precedingCharacterRange = makeSimpleRange(makeDeprecatedLegacyPosition(rangeWithAlternative.start).previous(), rangeWithAlternative.start);
    521521    if (!precedingCharacterRange)
    522522        return false;
    … …  
    600600
    601601    // Take note of the location of autocorrection so that we can add marker after the replacement took place.
    602     auto paragraphStart = makeBoundaryPoint(startOfParagraph(createLegacyEditingPosition(range.start)));
     602    auto paragraphStart = makeBoundaryPoint(startOfParagraph(makeDeprecatedLegacyPosition(range.start)));
    603603    if (!paragraphStart)
    604604        return;

  • trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

    r266660 r267363  
    280280    }
    281281   
    282     auto startPosition = createLegacyEditingPosition(resolveCharacterLocation(scope, startIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
    283     auto endPosition = createLegacyEditingPosition(resolveCharacterLocation(scope, endIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
     282    auto startPosition = makeDeprecatedLegacyPosition(resolveCharacterLocation(scope, startIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
     283    auto endPosition = makeDeprecatedLegacyPosition(resolveCharacterLocation(scope, endIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
    284284    updateStartEnd(startPosition, endPosition);
    285285}

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r266557 r267363  
    15031503        // in a call to rangeFromLocationAndLength with a location past the end
    15041504        // of the document (which will return null).
    1505         auto start = createLegacyEditingPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*editableRoot), destinationIndex + *startIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
    1506         auto end = createLegacyEditingPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*editableRoot), destinationIndex + *endIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
     1505        auto start = makeDeprecatedLegacyPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*editableRoot), destinationIndex + *startIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
     1506        auto end = makeDeprecatedLegacyPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*editableRoot), destinationIndex + *endIndex, TextIteratorEmitsCharactersBetweenAllVisiblePositions));
    15071507        setEndingSelection({ start, end, Affinity::Downstream, originalIsDirectional });
    15081508    }

  • trunk/Source/WebCore/editing/DeleteSelectionCommand.cpp

    r266557 r267363  
    650650                    }
    651651                    removeChildrenInRange(*m_downstreamEnd.deprecatedNode(), offset, m_downstreamEnd.deprecatedEditingOffset());
    652                     m_downstreamEnd = createLegacyEditingPosition(m_downstreamEnd.deprecatedNode(), offset);
     652                    m_downstreamEnd = makeDeprecatedLegacyPosition(m_downstreamEnd.deprecatedNode(), offset);
    653653                }
    654654            }

  • trunk/Source/WebCore/editing/Editing.cpp

    r266557 r267363  
    10921092    if (!scope)
    10931093        return { };
    1094     return { createLegacyEditingPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*scope), index, TextIteratorEmitsCharactersBetweenAllVisiblePositions)) };
     1094    return { makeDeprecatedLegacyPosition(resolveCharacterLocation(makeRangeSelectingNodeContents(*scope), index, TextIteratorEmitsCharactersBetweenAllVisiblePositions)) };
    10951095}
    10961096
    … …  
    11081108        it.advance(1);
    11091109        if (!it.atEnd())
    1110             return { createLegacyEditingPosition(it.range().start) };
    1111     }
    1112 
    1113     return { createLegacyEditingPosition((it.atEnd() ? range : it.range()).end), Affinity::Upstream };
     1110            return { makeDeprecatedLegacyPosition(it.range().start) };
     1111    }
     1112
     1113    return { makeDeprecatedLegacyPosition((it.atEnd() ? range : it.range()).end), Affinity::Upstream };
    11141114}
    11151115
    … …  
    11281128        return true;
    11291129
    1130     auto startPosition = createLegacyEditingPosition(range.start);
    1131     auto endPosition = createLegacyEditingPosition(range.end);
     1130    auto startPosition = makeDeprecatedLegacyPosition(range.start);
     1131    auto endPosition = makeDeprecatedLegacyPosition(range.end);
    11321132
    11331133    bool startIsVisuallySame = visiblePositionBeforeNode(node) == startPosition;

  • trunk/Source/WebCore/editing/Editor.cpp

    r266987 r267363  
    514514    if (range.collapsed()) {
    515515        // FIXME: We sometimes allow deletions at the start of editable roots, like when the caret is in an empty list item.
    516         auto previous = VisiblePosition { createLegacyEditingPosition(range.start) }.previous();
     516        auto previous = VisiblePosition { makeDeprecatedLegacyPosition(range.start) }.previous();
    517517        if (previous.isNull() || previous.deepEquivalent().deprecatedNode()->rootEditableElement() != range.start.container->rootEditableElement())
    518518            return false;
    … …  
    19261926    // See <http://bugs.webkit.org/show_bug.cgi?id=15781>
    19271927    VisibleSelection selection;
    1928     selection.setWithoutValidation(createLegacyEditingPosition(range->start), createLegacyEditingPosition(range->end));
     1928    selection.setWithoutValidation(makeDeprecatedLegacyPosition(range->start), makeDeprecatedLegacyPosition(range->end));
    19291929    m_document.selection().setSelection(selection, { });
    19301930}
    … …  
    22012201    }
    22022202
    2203     auto position = createLegacyEditingPosition(spellingSearchRange.start);
     2203    auto position = makeDeprecatedLegacyPosition(spellingSearchRange.start);
    22042204    if (!isEditablePosition(position)) {
    22052205        // This shouldn't happen in very often because the Spelling menu items aren't enabled unless the
    … …  
    22262226    // at a word boundary. Going back by one char and then forward by a word does the trick.
    22272227    if (startedWithSelection) {
    2228         auto oneBeforeStart = VisiblePosition(createLegacyEditingPosition(spellingSearchRange.start)).previous();
     2228        auto oneBeforeStart = VisiblePosition(makeContainerOffsetPosition(spellingSearchRange.start)).previous();
    22292229        if (oneBeforeStart.isNotNull())
    22302230            spellingSearchRange.start = *makeBoundaryPoint(endOfWord(oneBeforeStart));
    … …  
    29102910        if (restoreSelectionAfterChange && selectionOffset <= extendedParagraph.rangeLength()) {
    29112911            auto selectionRange = extendedParagraph.subrange({ 0, selectionOffset });
    2912             m_document.selection().moveTo(createLegacyEditingPosition(selectionRange.end), Affinity::Downstream);
     2912            m_document.selection().moveTo(makeContainerOffsetPosition(selectionRange.end), Affinity::Downstream);
    29132913        } else {
    29142914            // If this fails for any reason, the fallback is to go one position beyond the last replacement
    … …  
    33323332    range.start.document().updateLayout();
    33333333
    3334     VisiblePosition start(createLegacyEditingPosition(range.start));
     3334    VisiblePosition start(makeDeprecatedLegacyPosition(range.start));
    33353335
    33363336    if (range.collapsed()) {
    … …  
    33423342    }
    33433343
    3344     VisiblePosition end(createLegacyEditingPosition(range.end), Affinity::Upstream);
     3344    VisiblePosition end(makeDeprecatedLegacyPosition(range.end), Affinity::Upstream);
    33453345
    33463346    if (inSameLine(start, end))
    … …  
    36773677static SimpleRange extendSelection(const SimpleRange& range, unsigned charactersToExtend)
    36783678{
    3679     auto start = createLegacyEditingPosition(range.start);
    3680     auto end = createLegacyEditingPosition(range.end);
     3679    auto start = makeDeprecatedLegacyPosition(range.start);
     3680    auto end = makeDeprecatedLegacyPosition(range.end);
    36813681    for (unsigned i = 0; i < charactersToExtend; ++i) {
    36823682        start = start.previous(Character);
    … …  
    42294229    if (range) {
    42304230        if (auto enclosingAnchor = enclosingElementWithTag(firstPositionInNode(commonInclusiveAncestor(*range).get()), HTMLNames::aTag)) {
    4231             if (firstPositionInOrBeforeNode(range->start.container.ptr()) >= createLegacyEditingPosition(range->start))
     4231            if (firstPositionInOrBeforeNode(range->start.container.ptr()) >= makeDeprecatedLegacyPosition(range->start))
    42324232                range->start = makeBoundaryPointBeforeNodeContents(*enclosingAnchor);
    42334233        }

  • trunk/Source/WebCore/editing/FrameSelection.cpp

    r267329 r267363  
    25082508        return WTF::nullopt;
    25092509
    2510     auto start = VisiblePosition(createLegacyEditingPosition(element, 0));
    2511     auto end = VisiblePosition(createLegacyEditingPosition(element, element->countChildNodes()));
     2510    auto start = VisiblePosition(makeContainerOffsetPosition(element, 0));
     2511    auto end = VisiblePosition(makeContainerOffsetPosition(element, element->countChildNodes()));
    25122512    if (start.isNull() || end.isNull())
    25132513        return WTF::nullopt;

  • trunk/Source/WebCore/editing/InsertListCommand.cpp

    r265190 r267363  
    232232        // If the entire list is selected, then convert the whole list.
    233233        if (switchListType && isNodeVisiblyContainedWithin(*listNode, currentSelection)) {
    234             bool rangeStartIsInList = visiblePositionBeforeNode(*listNode) == createLegacyEditingPosition(currentSelection.start);
    235             bool rangeEndIsInList = visiblePositionAfterNode(*listNode) == createLegacyEditingPosition(currentSelection.end);
     234            bool rangeStartIsInList = visiblePositionBeforeNode(*listNode) == makeDeprecatedLegacyPosition(currentSelection.start);
     235            bool rangeEndIsInList = visiblePositionAfterNode(*listNode) == makeDeprecatedLegacyPosition(currentSelection.end);
    236236
    237237            RefPtr<HTMLElement> newList = createHTMLElement(document(), listTag);

  • trunk/Source/WebCore/editing/RenderedPosition.cpp

    r266557 r267363  
    196196
    197197    if (atLeftmostOffsetInBox())
    198         return createLegacyEditingPosition(m_renderer->node(), m_offset);
    199 
    200     return createLegacyEditingPosition(nextLeafOnLine()->renderer().node(), nextLeafOnLine()->caretLeftmostOffset());
     198        return makeDeprecatedLegacyPosition(m_renderer->node(), m_offset);
     199
     200    return makeDeprecatedLegacyPosition(nextLeafOnLine()->renderer().node(), nextLeafOnLine()->caretLeftmostOffset());
    201201}
    202202
    … …  
    206206
    207207    if (atRightmostOffsetInBox())
    208         return createLegacyEditingPosition(m_renderer->node(), m_offset);
    209 
    210     return createLegacyEditingPosition(previousLeafOnLine()->renderer().node(), previousLeafOnLine()->caretRightmostOffset());
     208        return makeDeprecatedLegacyPosition(m_renderer->node(), m_offset);
     209
     210    return makeDeprecatedLegacyPosition(previousLeafOnLine()->renderer().node(), previousLeafOnLine()->caretRightmostOffset());
    211211}
    212212

  • trunk/Source/WebCore/editing/TextCheckingHelper.cpp

    r266987 r267363  
    107107static SimpleRange expandToParagraphBoundary(const SimpleRange& range)
    108108{
    109     auto start = makeBoundaryPoint(startOfParagraph(createLegacyEditingPosition(range.start)));
    110     auto end = makeBoundaryPoint(endOfParagraph(createLegacyEditingPosition(range.end)));
     109    auto start = makeBoundaryPoint(startOfParagraph(makeDeprecatedLegacyPosition(range.start)));
     110    auto end = makeBoundaryPoint(endOfParagraph(makeDeprecatedLegacyPosition(range.end)));
    111111    if (!start || !end)
    112112        return range;
    … …  
    130130{
    131131    paragraphRange();
    132     if (auto end = makeBoundaryPoint(endOfParagraph(startOfNextParagraph(createLegacyEditingPosition(m_paragraphRange->start)))))
     132    if (auto end = makeBoundaryPoint(endOfParagraph(startOfNextParagraph(makeDeprecatedLegacyPosition(m_paragraphRange->start)))))
    133133        m_paragraphRange->end = WTFMove(*end);
    134134    invalidateParagraphRangeValues();
    … …  
    304304    // Determine the character offset from the start of the paragraph to the start of the original search range,
    305305    // since we will want to ignore results in this area.
    306     auto paragraphRange = *makeSimpleRange(startOfParagraph(createLegacyEditingPosition(m_range.start)), m_range.end);
     306    auto paragraphRange = *makeSimpleRange(startOfParagraph(makeDeprecatedLegacyPosition(m_range.start)), m_range.end);
    307307    auto totalRangeLength = characterCount(paragraphRange);
    308     paragraphRange.end = *makeBoundaryPoint(endOfParagraph(createLegacyEditingPosition(m_range.start)));
     308    paragraphRange.end = *makeBoundaryPoint(endOfParagraph(makeDeprecatedLegacyPosition(m_range.start)));
    309309   
    310310    auto rangeStartOffset = characterCount({ paragraphRange.start, m_range.start });
    … …  
    318318        uint64_t currentStartOffset = firstIteration ? rangeStartOffset : 0;
    319319        uint64_t currentEndOffset = currentLength;
    320         if (inSameParagraph(createLegacyEditingPosition(paragraphRange.start), createLegacyEditingPosition(m_range.end))) {
     320        if (inSameParagraph(makeDeprecatedLegacyPosition(paragraphRange.start), makeDeprecatedLegacyPosition(m_range.end))) {
    321321            // Determine the character offset from the end of the original search range to the end of the paragraph,
    322322            // since we will want to ignore results in this area.
    … …  
    400400            break;
    401401
    402         auto nextStart = startOfNextParagraph(createLegacyEditingPosition(paragraphRange.end));
     402        auto nextStart = startOfNextParagraph(makeDeprecatedLegacyPosition(paragraphRange.end));
    403403        auto nextParagraphRange = makeSimpleRange(nextStart, endOfParagraph(nextStart));
    404404        if (!nextParagraphRange)

  • trunk/Source/WebCore/editing/TextIterator.cpp

    r266557 r267363  
    23832383                    textRunRange.end = it.range().start;
    23842384                else {
    2385                     if (auto end = makeBoundaryPoint(VisiblePosition(createLegacyEditingPosition(textRunRange.start)).next().deepEquivalent()))
     2385                    if (auto end = makeBoundaryPoint(VisiblePosition(makeDeprecatedLegacyPosition(textRunRange.start)).next().deepEquivalent()))
    23862386                        textRunRange.end = *end;
    23872387                }

  • trunk/Source/WebCore/editing/VisiblePosition.cpp

    r266986 r267363  
    243243        }
    244244
    245         p = createLegacyEditingPosition(renderer->node(), offset);
     245        p = makeDeprecatedLegacyPosition(renderer->node(), offset);
    246246
    247247        if ((p.isCandidate() && p.downstream() != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
    … …  
    409409        }
    410410
    411         p = createLegacyEditingPosition(renderer->node(), offset);
     411        p = makeDeprecatedLegacyPosition(renderer->node(), offset);
    412412
    413413        if ((p.isCandidate() && p.downstream() != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())

  • trunk/Source/WebCore/editing/VisibleSelection.cpp

    r267362 r267363  
    213213        if ((!isSpaceOrNewline(c) && c != noBreakSpace) || c == '\n')
    214214            break;
    215         m_end = createLegacyEditingPosition(charIt.range().end);
     215        m_end = makeDeprecatedLegacyPosition(charIt.range().end);
    216216    }
    217217}

  • trunk/Source/WebCore/editing/VisibleUnits.cpp

    r266557 r267363  
    9191
    9292        Position pos = previousNode->hasTagName(brTag) ? positionBeforeNode(previousNode) :
    93             createLegacyEditingPosition(previousNode, caretMaxOffset(*previousNode));
     93            makeDeprecatedLegacyPosition(previousNode, caretMaxOffset(*previousNode));
    9494       
    9595        if (pos.isCandidate())
    … …  
    113113
    114114        Position pos;
    115         pos = createLegacyEditingPosition(nextNode, caretMinOffset(*nextNode));
     115        pos = makeDeprecatedLegacyPosition(nextNode, caretMinOffset(*nextNode));
    116116       
    117117        if (pos.isCandidate())
    … …  
    610610
    611611    if (!next)
    612         return it.atEnd() ? createLegacyEditingPosition(searchRange->start) : position;
     612        return it.atEnd() ? makeDeprecatedLegacyPosition(searchRange->start) : position;
    613613
    614614    auto& node = (it.atEnd() ? *searchRange : it.range()).start.container.get();
    615615    if ((!suffixLength && is<Text>(node) && next <= downcast<Text>(node).length()) || (node.renderer() && node.renderer()->isBR() && !next)) {
    616616        // The next variable contains a usable index into a text node.
    617         return createLegacyEditingPosition(&node, next);
     617        return makeDeprecatedLegacyPosition(&node, next);
    618618    }
    619619
    … …  
    623623        charIt.advance(string.size() - suffixLength - next);
    624624    // FIXME: charIt can get out of shadow host.
    625     return createLegacyEditingPosition(charIt.range().end);
     625    return makeDeprecatedLegacyPosition(charIt.range().end);
    626626}
    627627
    … …  
    653653   
    654654    if (it.atEnd() && next == string.size())
    655         pos = createLegacyEditingPosition(searchRange->end);
     655        pos = makeDeprecatedLegacyPosition(searchRange->end);
    656656    else if (next > prefixLength) {
    657657        // Use the character iterator to translate the next value into a DOM position.
    … …  
    659659        charIt.advance(next - prefixLength - 1);
    660660        auto characterRange = charIt.range();
    661         pos = createLegacyEditingPosition(characterRange.end);
     661        pos = makeDeprecatedLegacyPosition(characterRange.end);
    662662       
    663663        if (charIt.text()[0] == '\n') {
    664664            // FIXME: workaround for collapsed range (where only start position is correct) emitted for some emitted newlines (see rdar://5192593)
    665             if (VisiblePosition(pos) == VisiblePosition(createLegacyEditingPosition(characterRange.start))) {
     665            if (VisiblePosition(pos) == VisiblePosition(makeDeprecatedLegacyPosition(characterRange.start))) {
    666666                charIt.advance(1);
    667                 pos = createLegacyEditingPosition(charIt.range().start);
     667                pos = makeDeprecatedLegacyPosition(charIt.range().start);
    668668            }
    669669        }
    … …  
    14331433    // position to null, even when there's a valid candidate to be had, because the root HTML element
    14341434    // is not content editable.  So we construct directly from the valid candidate.
    1435     Position firstCandidate = nextCandidate(createLegacyEditingPosition(node->document().documentElement(), 0));
     1435    Position firstCandidate = nextCandidate(makeDeprecatedLegacyPosition(node->document().documentElement(), 0));
    14361436    if (firstCandidate.isNull())
    14371437        return VisiblePosition();
    … …  
    14521452    // when descending from the root element, so we construct the visible position directly from a
    14531453    // valid candidate.
    1454     Position lastPosition = createLegacyEditingPosition(node->document().documentElement(), node->document().documentElement()->countChildNodes());
     1454    Position lastPosition = makeDeprecatedLegacyPosition(node->document().documentElement(), node->document().documentElement()->countChildNodes());
    14551455    Position lastCandidate = previousCandidate(lastPosition);
    14561456    if (lastCandidate.isNull())
    … …  
    19381938        // The position lies within a word.
    19391939        if (auto wordRange = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
    1940             result = createLegacyEditingPosition(wordRange->start);
     1940            result = makeDeprecatedLegacyPosition(wordRange->start);
    19411941            if (distanceBetweenPositions(position, result) > 1)
    1942                 result = createLegacyEditingPosition(wordRange->end);
     1942                result = makeDeprecatedLegacyPosition(wordRange->end);
    19431943        }
    19441944    } else if (atBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Backward)) {
    … …  
    19951995        auto adjustedPosition = position;
    19961996        if (auto wordRange = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
    1997             adjustedPosition = createLegacyEditingPosition(wordRange->start);
     1997            adjustedPosition = makeDeprecatedLegacyPosition(wordRange->start);
    19981998            if (distanceBetweenPositions(position, adjustedPosition) > 1)
    1999                 adjustedPosition = createLegacyEditingPosition(wordRange->end);
     1999                adjustedPosition = makeDeprecatedLegacyPosition(wordRange->end);
    20002000        }
    20012001        return { adjustedPosition, WithinWordBoundary::Yes };

  • trunk/Source/WebCore/editing/cocoa/HTMLConverter.mm

    r266487 r267363  
    353353
    354354HTMLConverter::HTMLConverter(const SimpleRange& range)
    355     : m_start(createLegacyEditingPosition(range.start))
    356     , m_end(createLegacyEditingPosition(range.end))
     355    : m_start(makeContainerOffsetPosition(range.start))
     356    , m_end(makeContainerOffsetPosition(range.end))
    357357{
    358358    _attrStr = [[NSMutableAttributedString alloc] init];

  • trunk/Source/WebCore/editing/ios/EditorIOS.mm

    r266618 r267363  
    340340    element.replaceAllChildrenWithNewText(text);
    341341
    342     VisiblePosition afterContents = createLegacyEditingPosition(&element, element.countChildNodes());
     342    VisiblePosition afterContents = makeContainerOffsetPosition(&element, element.countChildNodes());
    343343    if (afterContents.isNull())
    344344        return;

  • trunk/Source/WebCore/editing/markup.cpp

    r266487 r267363  
    936936String serializePreservingVisualAppearance(const SimpleRange& range, Vector<Node*>* nodes, AnnotateForInterchange annotate, ConvertBlocksToInlines convertBlocksToInlines, ResolveURLs resolveURLs)
    937937{
    938     return serializePreservingVisualAppearanceInternal(createLegacyEditingPosition(range.start), createLegacyEditingPosition(range.end),
     938    return serializePreservingVisualAppearanceInternal(makeDeprecatedLegacyPosition(range.start), makeDeprecatedLegacyPosition(range.end),
    939939        nodes, resolveURLs, SerializeComposedTree::No,
    940940        annotate, convertBlocksToInlines, StandardFontFamilySerializationMode::Keep, MSOListMode::DoNotPreserve);
    … …  
    11151115static bool contextPreservesNewline(const SimpleRange& context)
    11161116{
    1117     auto container = VisiblePosition(createLegacyEditingPosition(context.start)).deepEquivalent().containerNode();
     1117    auto container = VisiblePosition(makeDeprecatedLegacyPosition(context.start)).deepEquivalent().containerNode();
    11181118    return container && container->renderer() && container->renderer()->style().preserveNewline();
    11191119}
    … …  
    11581158
    11591159    // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
    1160     auto start = createLegacyEditingPosition(context.start);
     1160    auto start = makeDeprecatedLegacyPosition(context.start);
    11611161    auto block = enclosingBlock(start.firstNode().get());
    11621162    bool useClonesOfEnclosingBlock = block

  • trunk/Source/WebCore/page/DragController.cpp

    r266295 r267363  
    14911491
    14921492    frame->selection().clear();
    1493     caretController.setCaretPosition(createLegacyEditingPosition(m_droppedImagePlaceholderRange->start));
     1493    caretController.setCaretPosition(makeDeprecatedLegacyPosition(m_droppedImagePlaceholderRange->start));
    14941494}
    14951495

  • trunk/Source/WebCore/page/Page.cpp

    r267254 r267363  
    896896
    897897    for (auto& range : rangesToReplace) {
    898         auto highestRoot = makeRefPtr(highestEditableRoot(createLegacyEditingPosition(range.start)));
    899         if (!highestRoot || highestRoot != highestEditableRoot(createLegacyEditingPosition(range.end)) || !highestRoot->document().frame())
     898        auto highestRoot = makeRefPtr(highestEditableRoot(makeDeprecatedLegacyPosition(range.start)));
     899        if (!highestRoot || highestRoot != highestEditableRoot(makeDeprecatedLegacyPosition(range.end)) || !highestRoot->document().frame())
    900900            continue;
    901901        auto scope = makeRangeSelectingNodeContents(*highestRoot);

  • trunk/Source/WebCore/page/ios/FrameIOS.mm

    r266557 r267363  
    741741    interpretations.grow(interpretationsCount);
    742742
    743     Position precedingTextStartPosition = createLegacyEditingPosition(root, 0);
     743    Position precedingTextStartPosition = makeDeprecatedLegacyPosition(root, 0);
    744744
    745745    unsigned combinationsSoFar = 1;
    … …  
    771771            combinationsSoFar *= interpretationsCountForCurrentMarker;
    772772
    773             precedingTextStartPosition = createLegacyEditingPosition(rangeForMarker.end);
     773            precedingTextStartPosition = makeDeprecatedLegacyPosition(rangeForMarker.end);
    774774        }
    775775    }

  • trunk/Source/WebCore/platform/DragImage.cpp

    r265228 r267363  
    161161
    162162    // To snapshot the range, temporarily select it and take selection snapshot.
    163     Position start = createLegacyEditingPosition(range.start);
     163    Position start = makeDeprecatedLegacyPosition(range.start);
    164164    Position candidate = start.downstream();
    165165    if (candidate.deprecatedNode() && candidate.deprecatedNode()->renderer())
    166166        start = candidate;
    167167
    168     Position end = createLegacyEditingPosition(range.end);
     168    Position end = makeDeprecatedLegacyPosition(range.end);
    169169    candidate = end.upstream();
    170170    if (candidate.deprecatedNode() && candidate.deprecatedNode()->renderer())

  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r266557 r267363  
    34063406
    34073407    if (!box->renderer().nonPseudoNode())
    3408         return createLegacyEditingPosition(nonPseudoElement(), start ? caretMinOffset() : caretMaxOffset());
     3408        return makeDeprecatedLegacyPosition(nonPseudoElement(), start ? caretMinOffset() : caretMaxOffset());
    34093409
    34103410    if (!is<InlineTextBox>(*box))
    3411         return createLegacyEditingPosition(box->renderer().nonPseudoNode(), start ? box->renderer().caretMinOffset() : box->renderer().caretMaxOffset());
     3411        return makeDeprecatedLegacyPosition(box->renderer().nonPseudoNode(), start ? box->renderer().caretMinOffset() : box->renderer().caretMaxOffset());
    34123412
    34133413    auto& textBox = downcast<InlineTextBox>(*box);
    3414     return createLegacyEditingPosition(textBox.renderer().nonPseudoNode(), start ? textBox.start() : textBox.start() + textBox.len());
     3414    return makeDeprecatedLegacyPosition(textBox.renderer().nonPseudoNode(), start ? textBox.start() : textBox.start() + textBox.len());
    34153415}
    34163416

  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r266557 r267363  
    16721672        if (!node->hasEditableStyle()) {
    16731673            // If it can be found, we prefer a visually equivalent position that is editable.
    1674             Position position = createLegacyEditingPosition(node, offset);
     1674            Position position = makeDeprecatedLegacyPosition(node, offset);
    16751675            Position candidate = position.downstream(CanCrossEditingBoundary);
    16761676            if (candidate.deprecatedNode()->hasEditableStyle())
    … …  
    16811681        }
    16821682        // FIXME: Eliminate legacy editing positions
    1683         return VisiblePosition(createLegacyEditingPosition(node, offset), affinity);
     1683        return VisiblePosition(makeDeprecatedLegacyPosition(node, offset), affinity);
    16841684    }
    16851685
    … …  
    21492149        // extends all the way to include the <br>. VisiblePosition helps to
    21502150        // figure this out.
    2151         if (is<HTMLBRElement>(VisiblePosition(createLegacyEditingPosition(range.end)).deepEquivalent().firstNode()))
     2151        if (is<HTMLBRElement>(VisiblePosition(makeContainerOffsetPosition(range.end)).deepEquivalent().firstNode()))
    21522152            rects.last().setIsLineBreak(true);
    21532153    }

  • trunk/Source/WebCore/testing/Internals.cpp

    r267249 r267363  
    40054005{
    40064006    contextDocument()->frame()->selection().moveTo(
    4007         VisiblePosition { createLegacyEditingPosition(baseNode.ptr(), baseOffset) },
    4008         VisiblePosition { createLegacyEditingPosition(extentNode.get(), extentOffset) });
     4007        VisiblePosition { makeDeprecatedLegacyPosition(baseNode.ptr(), baseOffset) },
     4008        VisiblePosition { makeDeprecatedLegacyPosition(extentNode.get(), extentOffset) });
    40094009}
    40104010

  • trunk/Source/WebKit/ChangeLog

    r267359 r267363  
     12020-09-20  Darin Adler  <darin@apple.com>
     2
     3        Next step towards eliminating deprecated legacy positions
     4        https://bugs.webkit.org/show_bug.cgi?id=216751
     5
     6        Reviewed by Sam Weinig.
     7
     8        * WebProcess/WebPage/ios/WebPageIOS.mm:
     9        (WebKit::WebPage::selectWithGesture):
     10        (WebKit::WebPage::extendSelection):
     11        (WebKit::WebPage::updateSelectionWithExtentPointAndBoundary):
     12        (WebKit::WebPage::requestAutocorrectionData):
     13        (WebKit::WebPage::applyAutocorrectionInternal):
     14        (WebKit::focusedElementPositionInformation):
     15        (WebKit::dataDetectorLinkPositionInformation):
     16        (WebKit::WebPage::requestDocumentEditingContext):
     17        Replaced calls to createLegacyEditingPosition with calls to
     18        makeDeprecatedLegacyPosition or makeContainerOffsetPosition.
     19
    1202020-09-21  Wenson Hsieh  <wenson_hsieh@apple.com>
    221

  • trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm

    r266557 r267363  
    13621362            break;
    13631363        auto markedRange = frame.editor().compositionRange();
    1364         auto startPosition = VisiblePosition { createLegacyEditingPosition(markedRange->start) };
    1365         position = std::clamp(position, startPosition, VisiblePosition { createLegacyEditingPosition(markedRange->end) });
     1364        auto startPosition = VisiblePosition { makeDeprecatedLegacyPosition(markedRange->start) };
     1365        position = std::clamp(position, startPosition, VisiblePosition { makeDeprecatedLegacyPosition(markedRange->end) });
    13661366        if (wkGestureState != GestureRecognizerState::Began)
    13671367            flags = distanceBetweenPositions(startPosition, frame.selection().selection().start()) != distanceBetweenPositions(startPosition, position) ? PhraseBoundaryChanged : OptionSet<SelectionFlags> { };
    … …  
    13941394                if (m_startingGestureRange) {
    13951395                    auto& start = m_startingGestureRange->start;
    1396                     if (createLegacyEditingPosition(start) < position)
     1396                    if (makeDeprecatedLegacyPosition(start) < position)
    13971397                        range = makeSimpleRange(start, position);
    13981398                    else
    … …  
    14261426                break;
    14271427            range = m_currentWordRange;
    1428             if (position < createLegacyEditingPosition(range->start))
     1428            if (position < makeDeprecatedLegacyPosition(range->start))
    14291429                range->start = *makeBoundaryPoint(position);
    1430             if (position > createLegacyEditingPosition(range->end))
     1430            if (position > makeDeprecatedLegacyPosition(range->end))
    14311431                range->end = *makeBoundaryPoint(position);
    14321432            break;
    … …  
    17691769    bool shouldDispatchMouseEvents = shouldDispatchSyntheticMouseEventsWhenModifyingSelection();
    17701770    if (shouldDispatchMouseEvents) {
    1771         auto startLocationForSyntheticMouseEvents = frame.view()->contentsToRootView(VisiblePosition(createLegacyEditingPosition(wordRange->start)).absoluteCaretBounds()).center();
    1772         endLocationForSyntheticMouseEvents = frame.view()->contentsToRootView(VisiblePosition(createLegacyEditingPosition(wordRange->end)).absoluteCaretBounds()).center();
     1771        auto startLocationForSyntheticMouseEvents = frame.view()->contentsToRootView(VisiblePosition(makeDeprecatedLegacyPosition(wordRange->start)).absoluteCaretBounds()).center();
     1772        endLocationForSyntheticMouseEvents = frame.view()->contentsToRootView(VisiblePosition(makeDeprecatedLegacyPosition(wordRange->end)).absoluteCaretBounds()).center();
    17731773        dispatchSyntheticMouseEventsForSelectionGesture(SelectionTouch::Started, startLocationForSyntheticMouseEvents);
    17741774        dispatchSyntheticMouseEventsForSelectionGesture(SelectionTouch::Moved, endLocationForSyntheticMouseEvents);
    … …  
    21452145    }
    21462146
    2147     auto initialSelectionStartPosition = createLegacyEditingPosition(m_initialSelection->start);
    2148     auto initialSelectionEndPosition = createLegacyEditingPosition(m_initialSelection->end);
     2147    auto initialSelectionStartPosition = makeDeprecatedLegacyPosition(m_initialSelection->start);
     2148    auto initialSelectionEndPosition = makeDeprecatedLegacyPosition(m_initialSelection->end);
    21492149
    21502150    VisiblePosition selectionStart = initialSelectionStartPosition;
    21512151    VisiblePosition selectionEnd = initialSelectionEndPosition;
    21522152    if (position > initialSelectionEndPosition)
    2153         selectionEnd = createLegacyEditingPosition(newRange->end);
     2153        selectionEnd = makeDeprecatedLegacyPosition(newRange->end);
    21542154    else if (position < initialSelectionStartPosition)
    2155         selectionStart = createLegacyEditingPosition(newRange->start);
     2155        selectionStart = makeDeprecatedLegacyPosition(newRange->start);
    21562156
    21572157    if (auto range = makeSimpleRange(selectionStart, selectionEnd))
    … …  
    23062306    const unsigned maxSearchAttempts = 5;
    23072307    for (size_t i = 0;  i < maxSearchAttempts && textForRange != textForAutocorrection; ++i) {
    2308         auto position = createLegacyEditingPosition(range->start).previous();
    2309         if (position.isNull() || position == createLegacyEditingPosition(range->start))
     2308        auto position = makeDeprecatedLegacyPosition(range->start).previous();
     2309        if (position.isNull() || position == makeDeprecatedLegacyPosition(range->start))
    23102310            break;
    23112311        range = { { wordRangeFromPosition(position)->start, range->end } };
    … …  
    24132413    auto affinity = Affinity::Downstream;
    24142414    if (range && range->collapsed())
    2415         affinity = VisiblePosition(createLegacyEditingPosition(range->start), Affinity::Upstream).affinity();
     2415        affinity = VisiblePosition(makeDeprecatedLegacyPosition(range->start), Affinity::Upstream).affinity();
    24162416   
    24172417    frame.selection().setSelectedRange(range, affinity, WebCore::FrameSelection::ShouldCloseTyping::Yes);
    … …  
    25602560        return;
    25612561
    2562     auto startPosition = createLegacyEditingPosition(compositionRange->start);
    2563     auto endPosition = createLegacyEditingPosition(compositionRange->end);
     2562    auto startPosition = makeDeprecatedLegacyPosition(compositionRange->start);
     2563    auto endPosition = makeDeprecatedLegacyPosition(compositionRange->end);
    25642564    if (position < startPosition)
    25652565        position = startPosition;
    … …  
    26132613   
    26142614    auto range = makeRangeSelectingNodeContents(element);
    2615     info.textBefore = plainTextForDisplay(rangeExpandedByCharactersInDirectionAtWordBoundary(createLegacyEditingPosition(range.start),
     2615    info.textBefore = plainTextForDisplay(rangeExpandedByCharactersInDirectionAtWordBoundary(makeDeprecatedLegacyPosition(range.start),
    26162616        dataDetectionExtendedContextLength, SelectionDirection::Backward));
    2617     info.textAfter = plainTextForDisplay(rangeExpandedByCharactersInDirectionAtWordBoundary(createLegacyEditingPosition(range.end),
     2617    info.textAfter = plainTextForDisplay(rangeExpandedByCharactersInDirectionAtWordBoundary(makeDeprecatedLegacyPosition(range.end),
    26182618        dataDetectionExtendedContextLength, SelectionDirection::Forward));
    26192619}
    … …  
    41864186            return;
    41874187        }
    4188         auto midpoint = createLegacyEditingPosition(resolveCharacterLocation(scope, midpointLocation.unsafeGet()));
     4188        auto midpoint = makeDeprecatedLegacyPosition(resolveCharacterLocation(scope, midpointLocation.unsafeGet()));
    41894189
    41904190        startOfRangeOfInterestInSelection = startOfWord(midpoint);
    … …  
    42094209            // In the case where the client has requested marked text rects make sure that the context
    42104210            // range encompasses the entire marked text range so that we don't return a truncated result.
    4211             auto compositionStart = createLegacyEditingPosition(compositionRange->start);
    4212             auto compositionEnd = createLegacyEditingPosition(compositionRange->end);
     4211            auto compositionStart = makeDeprecatedLegacyPosition(compositionRange->start);
     4212            auto compositionEnd = makeDeprecatedLegacyPosition(compositionRange->end);
    42134213            if (contextBeforeStart > compositionStart)
    42144214                contextBeforeStart = compositionStart;
    … …  
    42304230    context.contextAfter = makeString(endOfRangeOfInterestInSelection, contextAfterEnd);
    42314231    if (compositionRange && intersects(rangeOfInterest, *compositionRange)) {
    4232         VisiblePosition compositionStart(createLegacyEditingPosition(compositionRange->start));
    4233         VisiblePosition compositionEnd(createLegacyEditingPosition(compositionRange->end));
     4232        VisiblePosition compositionStart(makeDeprecatedLegacyPosition(compositionRange->start));
     4233        VisiblePosition compositionEnd(makeDeprecatedLegacyPosition(compositionRange->end));
    42344234        context.markedText = makeString(compositionStart, compositionEnd);
    42354235        context.selectedRangeInMarkedText.location = distanceBetweenPositions(startOfRangeOfInterestInSelection, compositionStart);

  • trunk/Source/WebKitLegacy/ios/ChangeLog

    r266557 r267363  
     12020-09-20  Darin Adler  <darin@apple.com>
     2
     3        Next step towards eliminating deprecated legacy positions
     4        https://bugs.webkit.org/show_bug.cgi?id=216751
     5
     6        Reviewed by Sam Weinig.
     7
     8        * WebCoreSupport/WebVisiblePosition.mm:
     9        (-[DOMNode startPosition]):
     10        (-[DOMNode endPosition]):
     11        Replaced calls to createLegacyEditingPosition with calls to
     12        makeDeprecatedLegacyPosition or makeContainerOffsetPosition.
     13
    1142020-09-02  Darin Adler  <darin@apple.com>
    215

  • trunk/Source/WebKitLegacy/ios/WebCoreSupport/WebVisiblePosition.mm

    r266557 r267363  
    499499    auto& node = *core(self);
    500500    if (node.isContentEditable())
    501         return [WebVisiblePosition _wrapVisiblePosition:startOfEditableContent(VisiblePosition(createLegacyEditingPosition(&node, 0)))];
     501        return [WebVisiblePosition _wrapVisiblePosition:startOfEditableContent(VisiblePosition(makeDeprecatedLegacyPosition(&node, 0)))];
    502502    return [[self rangeOfContents] startPosition];
    503503}
    … …  
    508508    auto& node = *core(self);
    509509    if (node.isContentEditable())
    510         return [WebVisiblePosition _wrapVisiblePosition:endOfEditableContent(VisiblePosition(createLegacyEditingPosition(&node, 0)))];
     510        return [WebVisiblePosition _wrapVisiblePosition:endOfEditableContent(VisiblePosition(makeDeprecatedLegacyPosition(&node, 0)))];
    511511    return [[self rangeOfContents] endPosition];
    512512}

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r267222 r267363  
     12020-09-20  Darin Adler  <darin@apple.com>
     2
     3        Next step towards eliminating deprecated legacy positions
     4        https://bugs.webkit.org/show_bug.cgi?id=216751
     5
     6        Reviewed by Sam Weinig.
     7
     8        * DOM/DOMUIKitExtensions.mm:
     9        (-[DOMNode rangeOfContainingParagraph]):
     10        * WebView/WebFrame.mm:
     11        (-[WebFrame spaceFollowsWordInRange:]):
     12        (-[WebFrame caretRectAtNode:offset:affinity:]):
     13        (-[WebFrame focusedNodeHasContent]):
     14        Replaced calls to createLegacyEditingPosition with calls to
     15        makeDeprecatedLegacyPosition or makeContainerOffsetPosition.
     16
    1172020-09-17  Sam Weinig  <weinig@apple.com>
    218

  • trunk/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm

    r266557 r267363  
    224224- (DOMRange *)rangeOfContainingParagraph
    225225{
    226     VisiblePosition position(createLegacyEditingPosition(core(self), 0));
     226    VisiblePosition position(makeContainerOffsetPosition(core(self), 0));
    227227    return kit(makeSimpleRange(startOfParagraph(position), endOfParagraph(position)));
    228228}

  • trunk/Source/WebKitLegacy/mac/WebView/WebFrame.mm

    r266557 r267363  
    15591559- (BOOL)spaceFollowsWordInRange:(DOMRange *)range
    15601560{
    1561     return range && isSpaceOrNewline(WebCore::VisiblePosition(createLegacyEditingPosition(makeSimpleRange(core(range))->end)).characterAfter());
     1561    return range && isSpaceOrNewline(WebCore::VisiblePosition(makeDeprecatedLegacyPosition(makeSimpleRange(core(range))->end)).characterAfter());
    15621562}
    15631563
    … …  
    18051805- (NSRect)caretRectAtNode:(DOMNode *)node offset:(int)offset affinity:(NSSelectionAffinity)affinity
    18061806{
    1807     return [self _caretRectAtPosition:createLegacyEditingPosition(core(node), offset) affinity:affinity];
     1807    return [self _caretRectAtPosition:makeDeprecatedLegacyPosition(core(node), offset) affinity:affinity];
    18081808}
    18091809
    … …  
    23032303        return NO;
    23042304
    2305     WebCore::VisiblePosition first(createLegacyEditingPosition(root, 0));
    2306     WebCore::VisiblePosition last(createLegacyEditingPosition(root, root->countChildNodes()));
     2305    WebCore::VisiblePosition first(makeContainerOffsetPosition(root, 0));
     2306    WebCore::VisiblePosition last(makeContainerOffsetPosition(root, root->countChildNodes()));
    23072307    return first != last;
    23082308}
Note: See TracChangeset for help on using the changeset viewer.