Changeset 77980 in webkit


Ignore:
Timestamp:
Feb 8, 2011 3:13:22 PM (13 years ago)
Author:
leviw@chromium.org
Message:

2011-02-08 Levi Weintraub <leviw@chromium.org>

Reviewed by Ryosuke Niwa.

Stop instantiating legacy editing Positions in VisiblePosition
https://bugs.webkit.org/show_bug.cgi?id=52919

Changing usage of legacy VisiblePosition constructor. Since we were dealing
with positions from DOM Ranges, we're guaranteed a parent-anchored position.

  • WebView/WebFrame.mm: (-[WebFrame _caretRectAtPosition:affinity:]):
  • WebView/WebFrameInternal.h:
  • WebView/WebTextCompletionController.mm: (-[WebTextCompletionController doCompletion]):

2011-02-08 Levi Weintraub <leviw@chromium.org>

Reviewed by Ryosuke Niwa.

Stop instantiating legacy editing Positions in VisiblePosition
https://bugs.webkit.org/show_bug.cgi?id=52919

Changing VisiblePosition completely away from legacy positions.

No new tests since this is functionaly equivalent.

  • WebCore.exp.in: Removing the legacy VisiblePosition constructor and adding the PositionIsOffsetInAnchor symbol. If we must create VisiblePositions outside of WebCore, they should be parent anchored.
  • accessibility/AXObjectCache.cpp: (WebCore::AXObjectCache::visiblePositionForTextMarkerData):
  • accessibility/AccessibilityObject.cpp: (WebCore::startOfStyleRange): (WebCore::endOfStyleRange):
  • accessibility/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::visiblePositionForIndex):
  • accessibility/gtk/AccessibilityObjectWrapperAtk.cpp: (objectAndOffsetUnignored):
  • dom/Position.cpp: (WebCore::Position::upstream): Fixed to correctly respect PositionIsAfterAnchor (WebCore::Position::downstream): ditto
  • dom/Range.cpp: (WebCore::Range::editingStartPosition):
  • editing/Editor.cpp: (WebCore::Editor::canDeleteRange):
  • editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::doApply):
  • editing/SelectionController.cpp: (WebCore::SelectionController::selectFrameElementInParentIfFullySelected): (WebCore::SelectionController::setSelectedRange):
  • editing/TextIterator.cpp: (WebCore::TextIterator::shouldRepresentNodeOffsetZero):
  • editing/TypingCommand.cpp: (WebCore::TypingCommand::deleteKeyPressed):
  • editing/VisiblePosition.cpp: (WebCore::VisiblePosition::leftVisuallyDistinctCandidate): (WebCore::VisiblePosition::rightVisuallyDistinctCandidate): (WebCore::VisiblePosition::canonicalPosition): (WebCore::VisiblePosition::characterAfter): (WebCore::VisiblePosition::localCaretRect): (WebCore::makeRange): (WebCore::startVisiblePosition): (WebCore::endVisiblePosition): (WebCore::setStart): (WebCore::setEnd): (WebCore::isFirstVisiblePositionInNode): (WebCore::isLastVisiblePositionInNode):
  • editing/VisiblePosition.h: (WebCore::VisiblePosition::VisiblePosition):
  • editing/htmlediting.cpp: (WebCore::firstInSpecialElement): (WebCore::lastInSpecialElement): (WebCore::visiblePositionBeforeNode): (WebCore::visiblePositionAfterNode):
  • editing/visible_units.cpp: (WebCore::startPositionForLine): (WebCore::endPositionForLine): (WebCore::previousLinePosition): (WebCore::nextLinePosition): (WebCore::startOfParagraph): (WebCore::endOfParagraph): (WebCore::endOfBlock): (WebCore::startOfDocument): (WebCore::endOfDocument): (WebCore::logicalStartPositionForLine): (WebCore::logicalEndPositionForLine):
  • page/DOMSelection.cpp: (WebCore::DOMSelection::collapse): (WebCore::DOMSelection::setBaseAndExtent): (WebCore::DOMSelection::setPosition): (WebCore::DOMSelection::extend):
  • page/EventHandler.cpp: (WebCore::EventHandler::handleMousePressEventSingleClick):
  • rendering/RenderObject.cpp: (WebCore::RenderObject::createVisiblePosition):
  • rendering/RenderTextControl.cpp: (WebCore::RenderTextControl::visiblePositionForIndex):
  • svg/SVGTextContentElement.cpp: (WebCore::SVGTextContentElement::selectSubString):
Location:
trunk/Source
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r77979 r77980  
     12011-02-08  Levi Weintraub  <leviw@chromium.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        Stop instantiating legacy editing Positions in VisiblePosition
     6        https://bugs.webkit.org/show_bug.cgi?id=52919
     7
     8        Changing VisiblePosition completely away from legacy positions.
     9
     10        No new tests since this is functionaly equivalent.
     11
     12        * WebCore.exp.in: Removing the legacy VisiblePosition constructor and
     13        adding the PositionIsOffsetInAnchor symbol. If we must create VisiblePositions
     14        outside of WebCore, they should be parent anchored.
     15        * accessibility/AXObjectCache.cpp:
     16        (WebCore::AXObjectCache::visiblePositionForTextMarkerData):
     17        * accessibility/AccessibilityObject.cpp:
     18        (WebCore::startOfStyleRange):
     19        (WebCore::endOfStyleRange):
     20        * accessibility/AccessibilityRenderObject.cpp:
     21        (WebCore::AccessibilityRenderObject::visiblePositionForIndex):
     22        * accessibility/gtk/AccessibilityObjectWrapperAtk.cpp:
     23        (objectAndOffsetUnignored):
     24        * dom/Position.cpp:
     25        (WebCore::Position::upstream): Fixed to correctly respect PositionIsAfterAnchor
     26        (WebCore::Position::downstream): ditto
     27        * dom/Range.cpp:
     28        (WebCore::Range::editingStartPosition):
     29        * editing/Editor.cpp:
     30        (WebCore::Editor::canDeleteRange):
     31        * editing/ReplaceSelectionCommand.cpp:
     32        (WebCore::ReplaceSelectionCommand::doApply):
     33        * editing/SelectionController.cpp:
     34        (WebCore::SelectionController::selectFrameElementInParentIfFullySelected):
     35        (WebCore::SelectionController::setSelectedRange):
     36        * editing/TextIterator.cpp:
     37        (WebCore::TextIterator::shouldRepresentNodeOffsetZero):
     38        * editing/TypingCommand.cpp:
     39        (WebCore::TypingCommand::deleteKeyPressed):
     40        * editing/VisiblePosition.cpp:
     41        (WebCore::VisiblePosition::leftVisuallyDistinctCandidate):
     42        (WebCore::VisiblePosition::rightVisuallyDistinctCandidate):
     43        (WebCore::VisiblePosition::canonicalPosition):
     44        (WebCore::VisiblePosition::characterAfter):
     45        (WebCore::VisiblePosition::localCaretRect):
     46        (WebCore::makeRange):
     47        (WebCore::startVisiblePosition):
     48        (WebCore::endVisiblePosition):
     49        (WebCore::setStart):
     50        (WebCore::setEnd):
     51        (WebCore::isFirstVisiblePositionInNode):
     52        (WebCore::isLastVisiblePositionInNode):
     53        * editing/VisiblePosition.h:
     54        (WebCore::VisiblePosition::VisiblePosition):
     55        * editing/htmlediting.cpp:
     56        (WebCore::firstInSpecialElement):
     57        (WebCore::lastInSpecialElement):
     58        (WebCore::visiblePositionBeforeNode):
     59        (WebCore::visiblePositionAfterNode):
     60        * editing/visible_units.cpp:
     61        (WebCore::startPositionForLine):
     62        (WebCore::endPositionForLine):
     63        (WebCore::previousLinePosition):
     64        (WebCore::nextLinePosition):
     65        (WebCore::startOfParagraph):
     66        (WebCore::endOfParagraph):
     67        (WebCore::endOfBlock):
     68        (WebCore::startOfDocument):
     69        (WebCore::endOfDocument):
     70        (WebCore::logicalStartPositionForLine):
     71        (WebCore::logicalEndPositionForLine):
     72        * page/DOMSelection.cpp:
     73        (WebCore::DOMSelection::collapse):
     74        (WebCore::DOMSelection::setBaseAndExtent):
     75        (WebCore::DOMSelection::setPosition):
     76        (WebCore::DOMSelection::extend):
     77        * page/EventHandler.cpp:
     78        (WebCore::EventHandler::handleMousePressEventSingleClick):
     79        * rendering/RenderObject.cpp:
     80        (WebCore::RenderObject::createVisiblePosition):
     81        * rendering/RenderTextControl.cpp:
     82        (WebCore::RenderTextControl::visiblePositionForIndex):
     83        * svg/SVGTextContentElement.cpp:
     84        (WebCore::SVGTextContentElement::selectSubString):
     85
    1862011-02-08  Michael Saboff  <msaboff@apple.com>
    287
  • trunk/Source/WebCore/WebCore.exp.in

    r77950 r77980  
    403403__ZN7WebCore15StringTruncator14centerTruncateERKN3WTF6StringEfRKNS_4FontEb
    404404__ZN7WebCore15StringTruncator5widthERKN3WTF6StringERKNS_4FontEb
    405 __ZN7WebCore15VisiblePositionC1EPNS_4NodeEiNS_9EAffinityE
    406405__ZN7WebCore15VisiblePositionC1ERKNS_8PositionENS_9EAffinityE
    407406__ZN7WebCore15defaultLanguageEv
     
    786785__ZN7WebCore8IntPointC1ERK8_NSPoint
    787786__ZN7WebCore8PositionC1EN3WTF10PassRefPtrINS_4NodeEEEi
     787__ZN7WebCore8PositionC1EN3WTF10PassRefPtrINS_4NodeEEEiNS0_10AnchorTypeE
    788788__ZN7WebCore8Settings14setJavaEnabledEb
    789789__ZN7WebCore8Settings15setWebGLEnabledEb
  • trunk/Source/WebCore/accessibility/AXObjectCache.cpp

    r75031 r77980  
    574574        return VisiblePosition();
    575575   
    576     VisiblePosition visiblePos = VisiblePosition(textMarkerData.node, textMarkerData.offset, textMarkerData.affinity);
     576    // FIXME: Accessability should make it clear these are DOM-compliant offsets or store Position objects.
     577    VisiblePosition visiblePos = VisiblePosition(Position(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
    577578    Position deepPos = visiblePos.deepEquivalent();
    578579    if (deepPos.isNull())
  • trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

    r77820 r77980  
    337337    }
    338338
    339     return VisiblePosition(startRenderer->node(), 0, VP_DEFAULT_AFFINITY);
     339    return firstPositionInOrBeforeNode(startRenderer->node());
    340340}
    341341
     
    360360    }
    361361
    362     return lastDeepEditingPositionForNode(endRenderer->node());
     362    return lastPositionInOrAfterNode(endRenderer->node());
    363363}
    364364
  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r77286 r77980  
    24602460   
    24612461    if (index <= 0)
    2462         return VisiblePosition(node, 0, DOWNSTREAM);
     2462        return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    24632463   
    24642464    ExceptionCode ec = 0;
     
    24672467    CharacterIterator it(range.get());
    24682468    it.advance(index - 1);
    2469     return VisiblePosition(it.range()->endContainer(ec), it.range()->endOffset(ec), UPSTREAM);
     2469    return VisiblePosition(Position(it.range()->endContainer(ec), it.range()->endOffset(ec), Position::PositionIsOffsetInAnchor), UPSTREAM);
    24702470}
    24712471   
  • trunk/Source/WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp

    r77817 r77980  
    25012501    Node* node = realObject->node();
    25022502    if (node) {
    2503         VisiblePosition startPosition = VisiblePosition(node, 0, DOWNSTREAM);
     2503        VisiblePosition startPosition = VisiblePosition(positionBeforeNode(node), DOWNSTREAM);
    25042504        VisiblePosition endPosition = realObject->selection().visibleEnd();
    25052505
  • trunk/Source/WebCore/dom/Position.cpp

    r77062 r77980  
    514514    // iterate backward from there, looking for a qualified position
    515515    Node* boundary = enclosingVisualBoundary(startNode);
    516     PositionIterator lastVisible = *this;
     516    // FIXME: PositionIterator should respect Before and After positions.
     517    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? Position(m_anchorNode, caretMaxOffset(m_anchorNode.get())) : *this;
    517518    PositionIterator currentPos = lastVisible;
    518519    bool startEditable = startNode->isContentEditable();
     
    635636    // iterate forward from there, looking for a qualified position
    636637    Node* boundary = enclosingVisualBoundary(startNode);
    637     PositionIterator lastVisible = *this;
     638    // FIXME: PositionIterator should respect Before and After positions.
     639    PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? Position(m_anchorNode, caretMaxOffset(m_anchorNode.get())) : *this;
    638640    PositionIterator currentPos = lastVisible;
    639641    bool startEditable = startNode->isContentEditable();
  • trunk/Source/WebCore/dom/Range.cpp

    r75882 r77980  
    15711571    // with a spurious "mixed" style.
    15721572   
    1573     VisiblePosition visiblePosition(m_start.container(), m_start.offset(), VP_DEFAULT_AFFINITY);
     1573    VisiblePosition visiblePosition = Position(m_start.container(), m_start.offset(), Position::PositionIsOffsetInAnchor);
    15741574    if (visiblePosition.isNull())
    15751575        return Position();
  • trunk/Source/WebCore/editing/Editor.cpp

    r77835 r77980  
    294294   
    295295    if (range->collapsed(ec)) {
    296         VisiblePosition start(startContainer, range->startOffset(ec), DOWNSTREAM);
     296        VisiblePosition start(Position(startContainer, range->startOffset(ec), Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    297297        VisiblePosition previous = start.previous();
    298298        // FIXME: We sometimes allow deletions at the start of editable roots, like when the caret is in an empty list item.
  • trunk/Source/WebCore/editing/ReplaceSelectionCommand.cpp

    r76560 r77980  
    885885    VisiblePosition originalVisPosBeforeEndBR;
    886886    if (endBR)
    887         originalVisPosBeforeEndBR = VisiblePosition(endBR, 0, DOWNSTREAM).previous();
     887        originalVisPosBeforeEndBR = VisiblePosition(positionBeforeNode(endBR), DOWNSTREAM).previous();
    888888   
    889889    startBlock = enclosingBlock(insertionPos.node());
  • trunk/Source/WebCore/editing/SelectionController.cpp

    r76560 r77980  
    13161316    // Create compute positions before and after the element.
    13171317    unsigned ownerElementNodeIndex = ownerElement->nodeIndex();
    1318     VisiblePosition beforeOwnerElement(VisiblePosition(ownerElementParent, ownerElementNodeIndex, SEL_DEFAULT_AFFINITY));
    1319     VisiblePosition afterOwnerElement(VisiblePosition(ownerElementParent, ownerElementNodeIndex + 1, VP_UPSTREAM_IF_POSSIBLE));
     1318    VisiblePosition beforeOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex, Position::PositionIsOffsetInAnchor)));
     1319    VisiblePosition afterOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1, Position::PositionIsOffsetInAnchor), VP_UPSTREAM_IF_POSSIBLE));
    13201320
    13211321    // Focus on the parent frame, and then select from before this element to after.
     
    13881388   
    13891389    // FIXME: Can we provide extentAffinity?
    1390     VisiblePosition visibleStart(startContainer, startOffset, collapsed ? affinity : DOWNSTREAM);
    1391     VisiblePosition visibleEnd(endContainer, endOffset, SEL_DEFAULT_AFFINITY);
     1390    VisiblePosition visibleStart(Position(startContainer, startOffset, Position::PositionIsOffsetInAnchor), collapsed ? affinity : DOWNSTREAM);
     1391    VisiblePosition visibleEnd(Position(endContainer, endOffset, Position::PositionIsOffsetInAnchor), SEL_DEFAULT_AFFINITY);
    13921392    setSelection(VisibleSelection(visibleStart, visibleEnd), closeTyping);
    13931393    return true;
  • trunk/Source/WebCore/editing/TextIterator.cpp

    r77468 r77980  
    879879    // The currPos.isNotNull() check is needed because positions in non-HTML content
    880880    // (like SVG) do not have visible positions, and we don't want to emit for them either.
    881     VisiblePosition startPos = VisiblePosition(m_startContainer, m_startOffset, DOWNSTREAM);
    882     VisiblePosition currPos = VisiblePosition(m_node, 0, DOWNSTREAM);
     881    VisiblePosition startPos = VisiblePosition(Position(m_startContainer, m_startOffset, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
     882    VisiblePosition currPos = VisiblePosition(positionBeforeNode(m_node), DOWNSTREAM);
    883883    return startPos.isNotNull() && currPos.isNotNull() && !inSameLine(startPos, currPos);
    884884}
  • trunk/Source/WebCore/editing/TypingCommand.cpp

    r76560 r77980  
    496496        // If the caret is just after a table, select the table and don't delete anything.
    497497        } else if (Node* table = isFirstPositionAfterTable(visibleStart)) {
    498             setEndingSelection(VisibleSelection(positionAfterNode(table), endingSelection().start(), DOWNSTREAM));
     498            setEndingSelection(VisibleSelection(positionBeforeNode(table), endingSelection().start(), DOWNSTREAM));
    499499            typingAddedToOpenCommand(DeleteKey);
    500500            return;
  • trunk/Source/WebCore/editing/VisiblePosition.cpp

    r76107 r77980  
    4949}
    5050
    51 VisiblePosition::VisiblePosition(Node *node, int offset, EAffinity affinity)
    52 {
    53     ASSERT(offset >= 0);
    54     init(Position(node, offset), affinity);
    55 }
    56 
    5751void VisiblePosition::init(const Position& position, EAffinity affinity)
    5852{
     
    107101{
    108102    Position p = m_deepPosition;
    109     if (!p.node())
     103    if (p.isNull())
    110104        return Position();
    111105
     
    243237{
    244238    Position p = m_deepPosition;
    245     if (!p.node())
     239    if (p.isNull())
    246240        return Position();
    247241
     
    452446    // the appropriate renderer for VisiblePosition's like these, or b) canonicalize to the rightmost candidate
    453447    // unless the affinity is upstream.
    454     Node* node = position.node();
    455     if (!node)
     448    if (position.isNull())
    456449        return Position();
     450
     451    Node* node = position.containerNode();
    457452
    458453    ASSERT(node->document());
     
    511506    // is the one that will be inside the text node containing the character after this visible position.
    512507    Position pos = m_deepPosition.downstream();
    513     Node* node = pos.node();
    514     if (!node || !node->isTextNode())
     508    Node* node = pos.containerNode();
     509    if (!node || !node->isTextNode() || pos.anchorType() == Position::PositionIsAfterAnchor)
    515510        return 0;
    516     Text* textNode = static_cast<Text*>(pos.node());
    517     unsigned offset = pos.deprecatedEditingOffset();
     511    ASSERT(pos.anchorType() == Position::PositionIsBeforeAnchor || pos.anchorType() == Position::PositionIsOffsetInAnchor);
     512    Text* textNode = static_cast<Text*>(pos.containerNode());
     513    unsigned offset = pos.anchorType() == Position::PositionIsOffsetInAnchor ? pos.offsetInContainerNode() : 0;
    518514    unsigned length = textNode->length();
    519515    if (offset >= length)
     
    528524IntRect VisiblePosition::localCaretRect(RenderObject*& renderer) const
    529525{
    530     Node* node = m_deepPosition.node();
    531     if (!node) {
     526    if (m_deepPosition.isNull()) {
    532527        renderer = 0;
    533528        return IntRect();
    534529    }
     530    Node* node = m_deepPosition.containerNode();
    535531   
    536532    renderer = node->renderer();
     
    600596    Position s = start.deepEquivalent().parentAnchoredEquivalent();
    601597    Position e = end.deepEquivalent().parentAnchoredEquivalent();
    602     return Range::create(s.node()->document(), s.node(), s.deprecatedEditingOffset(), e.node(), e.deprecatedEditingOffset());
     598    return Range::create(s.containerNode()->document(), s.containerNode(), s.offsetInContainerNode(), e.containerNode(), e.offsetInContainerNode());
    603599}
    604600
     
    606602{
    607603    int exception = 0;
    608     return VisiblePosition(r->startContainer(exception), r->startOffset(exception), affinity);
     604    return VisiblePosition(Position(r->startContainer(exception), r->startOffset(exception), Position::PositionIsOffsetInAnchor), affinity);
    609605}
    610606
     
    612608{
    613609    int exception = 0;
    614     return VisiblePosition(r->endContainer(exception), r->endOffset(exception), affinity);
     610    return VisiblePosition(Position(r->endContainer(exception), r->endOffset(exception), Position::PositionIsOffsetInAnchor), affinity);
    615611}
    616612
     
    621617    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    622618    int code = 0;
    623     r->setStart(p.node(), p.deprecatedEditingOffset(), code);
     619    r->setStart(p.containerNode(), p.offsetInContainerNode(), code);
    624620    return code == 0;
    625621}
     
    631627    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    632628    int code = 0;
    633     r->setEnd(p.node(), p.deprecatedEditingOffset(), code);
     629    r->setEnd(p.containerNode(), p.offsetInContainerNode(), code);
    634630    return code == 0;
    635631}
     
    647643    if (visiblePosition.isNull())
    648644        return false;
    649    
    650     if (!visiblePosition.deepEquivalent().node()->isDescendantOf(node))
     645
     646    if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
    651647        return false;
    652        
     648
    653649    VisiblePosition previous = visiblePosition.previous();
    654650    return previous.isNull() || !previous.deepEquivalent().node()->isDescendantOf(node);
     
    659655    if (visiblePosition.isNull())
    660656        return false;
    661    
    662     if (!visiblePosition.deepEquivalent().node()->isDescendantOf(node))
     657
     658    if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
    663659        return false;
    664                
     660
    665661    VisiblePosition next = visiblePosition.next();
    666662    return next.isNull() || !next.deepEquivalent().node()->isDescendantOf(node);
  • trunk/Source/WebCore/editing/VisiblePosition.h

    r69836 r77980  
    5555    // otherwise it will be converted to DOWNSTREAM
    5656    VisiblePosition() : m_affinity(VP_DEFAULT_AFFINITY) { }
    57     VisiblePosition(Node*, int offset, EAffinity);
    5857    VisiblePosition(const Position&, EAffinity = VP_DEFAULT_AFFINITY);
    5958
  • trunk/Source/WebCore/editing/htmlediting.cpp

    r77062 r77980  
    427427        if (isSpecialElement(n)) {
    428428            VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
    429             VisiblePosition firstInElement = VisiblePosition(n, 0, DOWNSTREAM);
     429            VisiblePosition firstInElement = VisiblePosition(firstPositionInOrBeforeNode(n), DOWNSTREAM);
    430430            if (isTableElement(n) && vPos == firstInElement.next())
    431431                return n;
     
    443443        if (isSpecialElement(n)) {
    444444            VisiblePosition vPos = VisiblePosition(pos, DOWNSTREAM);
    445             VisiblePosition lastInElement = VisiblePosition(n, n->childNodeCount(), DOWNSTREAM);
     445            VisiblePosition lastInElement = VisiblePosition(Position(n, n->childNodeCount(), Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    446446            if (isTableElement(n) && vPos == lastInElement.previous())
    447447                return n;
     
    520520    ASSERT(node);
    521521    if (node->childNodeCount())
    522         return VisiblePosition(node, 0, DOWNSTREAM);
     522        return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    523523    ASSERT(node->parentNode());
    524524    return positionInParentBeforeNode(node);
     
    530530    ASSERT(node);
    531531    if (node->childNodeCount())
    532         return VisiblePosition(node, node->childNodeCount(), DOWNSTREAM);
     532        return VisiblePosition(lastPositionInOrAfterNode(node), DOWNSTREAM);
    533533    ASSERT(node->parentNode());
    534534    return positionInParentAfterNode(node);
  • trunk/Source/WebCore/editing/visible_units.cpp

    r77521 r77980  
    378378    }
    379379   
    380     int startOffset = 0;
    381     if (startBox->isInlineTextBox()) {
    382         InlineTextBox *startTextBox = static_cast<InlineTextBox *>(startBox);
    383         startOffset = startTextBox->start();
    384     }
    385  
    386     VisiblePosition visPos = VisiblePosition(startNode, startOffset, DOWNSTREAM);
     380    VisiblePosition visPos = startBox->isInlineTextBox() ? VisiblePosition(Position(startNode, static_cast<InlineTextBox *>(startBox)->start(), Position::PositionIsOffsetInAnchor), DOWNSTREAM)
     381                                                         : VisiblePosition(positionBeforeNode(startNode), DOWNSTREAM);
    387382    return positionAvoidingFirstPositionInTable(visPos);
    388383}
     
    430425    }
    431426   
    432     int endOffset = 1;
     427    Position pos;
    433428    if (endNode->hasTagName(brTag)) {
    434         endOffset = 0;
     429        pos = positionBeforeNode(endNode);
    435430    } else if (endBox->isInlineTextBox()) {
    436431        InlineTextBox *endTextBox = static_cast<InlineTextBox *>(endBox);
    437         endOffset = endTextBox->start();
     432        int endOffset = endTextBox->start();
    438433        if (!endTextBox->isLineBreak())
    439434            endOffset += endTextBox->len();
    440     }
    441    
    442     return VisiblePosition(endNode, endOffset, VP_UPSTREAM_IF_POSSIBLE);
     435        pos = Position(endNode, endOffset, Position::PositionIsOffsetInAnchor);
     436    } else
     437        pos = positionAfterNode(endNode);
     438   
     439    return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
    443440}
    444441
     
    576573    // to the start of the line we're on.
    577574    Element* rootElement = node->isContentEditable() ? node->rootEditableElement() : node->document()->documentElement();
    578     return VisiblePosition(rootElement, 0, DOWNSTREAM);
     575    return VisiblePosition(firstPositionInNode(rootElement), DOWNSTREAM);
    579576}
    580577
     
    681678    // to the end of the line we're on.
    682679    Element* rootElement = node->isContentEditable() ? node->rootEditableElement() : node->document()->documentElement();
    683     return VisiblePosition(rootElement, rootElement ? rootElement->childNodeCount() : 0, DOWNSTREAM);
     680    return VisiblePosition(lastPositionInNode(rootElement), DOWNSTREAM);
    684681}
    685682
     
    753750    Node *node = startNode;
    754751    int offset = p.deprecatedEditingOffset();
     752    Position::AnchorType type = p.anchorType();
    755753
    756754    Node *n = startNode;
     
    773771
    774772        if (r->isText() && r->caretMaxRenderedOffset() > 0) {
     773            type = Position::PositionIsOffsetInAnchor;
    775774            if (style->preserveNewline()) {
    776775                const UChar* chars = toRenderText(r)->characters();
     
    781780                while (--i >= 0)
    782781                    if (chars[i] == '\n')
    783                         return VisiblePosition(n, i + 1, DOWNSTREAM);
     782                        return VisiblePosition(Position(n, i + 1, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    784783            }
    785784            node = n;
     
    788787        } else if (editingIgnoresContent(n) || isTableElement(n)) {
    789788            node = n;
    790             offset = 0;
     789            type = Position::PositionIsBeforeAnchor;
    791790            n = n->previousSibling() ? n->previousSibling() : n->traversePreviousNodePostOrder(startBlock);
    792791        } else
     
    794793    }
    795794
    796     return VisiblePosition(node, offset, DOWNSTREAM);
     795    if (type == Position::PositionIsOffsetInAnchor)
     796        return VisiblePosition(Position(node, offset, type), DOWNSTREAM);
     797   
     798    return VisiblePosition(Position(node, type), DOWNSTREAM);
    797799}
    798800
     
    813815    Node *node = startNode;
    814816    int offset = p.deprecatedEditingOffset();
     817    Position::AnchorType type = p.anchorType();
    815818
    816819    Node *n = startNode;
     
    835838        if (r->isText() && r->caretMaxRenderedOffset() > 0) {
    836839            int length = toRenderText(r)->textLength();
     840            type = Position::PositionIsOffsetInAnchor;
    837841            if (style->preserveNewline()) {
    838842                const UChar* chars = toRenderText(r)->characters();
     
    840844                for (int i = o; i < length; ++i)
    841845                    if (chars[i] == '\n')
    842                         return VisiblePosition(n, i, DOWNSTREAM);
     846                        return VisiblePosition(Position(n, i, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    843847            }
    844848            node = n;
     
    847851        } else if (editingIgnoresContent(n) || isTableElement(n)) {
    848852            node = n;
    849             offset = lastOffsetForEditing(n);
     853            type = Position::PositionIsAfterAnchor;
    850854            n = n->traverseNextSibling(stayInsideBlock);
    851855        } else
     
    853857    }
    854858
    855     return VisiblePosition(node, offset, DOWNSTREAM);
     859    if (type == Position::PositionIsOffsetInAnchor)
     860        return VisiblePosition(Position(node, offset, type), DOWNSTREAM);
     861
     862    return VisiblePosition(Position(node, type), DOWNSTREAM);
    856863}
    857864
     
    927934    Node *startBlock = startNode->enclosingBlockFlowElement();
    928935   
    929     return VisiblePosition(startBlock, startBlock->childNodeCount(), VP_DEFAULT_AFFINITY);   
     936    return VisiblePosition(lastPositionInNode(startBlock), VP_DEFAULT_AFFINITY);   
    930937}
    931938
     
    952959        return VisiblePosition();
    953960   
    954     return VisiblePosition(node->document()->documentElement(), 0, DOWNSTREAM);
     961    return VisiblePosition(firstPositionInNode(node->document()->documentElement()), DOWNSTREAM);
    955962}
    956963
     
    966973   
    967974    Element* doc = node->document()->documentElement();
    968     return VisiblePosition(doc, doc->childNodeCount(), DOWNSTREAM);
     975    return VisiblePosition(lastPositionInNode(doc), DOWNSTREAM);
    969976}
    970977
     
    11221129        return VisiblePosition();
    11231130
    1124     int startOffset = logicalStartBox->caretMinOffset();
    1125  
    1126     VisiblePosition visPos = VisiblePosition(logicalStartNode, startOffset, DOWNSTREAM);
     1131    VisiblePosition visPos = logicalStartNode->isTextNode() ? VisiblePosition(Position(logicalStartNode, logicalStartBox->caretMinOffset(), Position::PositionIsOffsetInAnchor), DOWNSTREAM)
     1132                                                            : VisiblePosition(positionBeforeNode(logicalStartNode), DOWNSTREAM);
    11271133    return positionAvoidingFirstPositionInTable(visPos);
    11281134}
     
    11581164        return VisiblePosition();
    11591165   
    1160     int endOffset = 1;
     1166    Position pos;
    11611167    if (logicalEndNode->hasTagName(brTag))
    1162         endOffset = 0;
     1168        pos = positionBeforeNode(logicalEndNode);
    11631169    else if (logicalEndBox->isInlineTextBox()) {
    11641170        InlineTextBox* endTextBox = static_cast<InlineTextBox*>(logicalEndBox);
    1165         endOffset = endTextBox->start();
     1171        int endOffset = endTextBox->start();
    11661172        if (!endTextBox->isLineBreak())
    11671173            endOffset += endTextBox->len();
    1168     }
    1169    
    1170     return VisiblePosition(logicalEndNode, endOffset, VP_UPSTREAM_IF_POSSIBLE);
     1174        pos = Position(logicalEndNode, endOffset, Position::PositionIsOffsetInAnchor);
     1175    } else
     1176        pos = positionAfterNode(logicalEndNode);
     1177   
     1178    return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
    11711179}
    11721180
  • trunk/Source/WebCore/page/DOMSelection.cpp

    r76107 r77980  
    212212        return;
    213213
    214     m_frame->selection()->moveTo(VisiblePosition(node, offset, DOWNSTREAM));
     214    // FIXME: Eliminate legacy editing positions
     215    m_frame->selection()->moveTo(VisiblePosition(Position(node, offset), DOWNSTREAM));
    215216}
    216217
     
    265266        return;
    266267
    267     VisiblePosition visibleBase = VisiblePosition(baseNode, baseOffset, DOWNSTREAM);
    268     VisiblePosition visibleExtent = VisiblePosition(extentNode, extentOffset, DOWNSTREAM);
     268    // FIXME: Eliminate legacy editing positions
     269    VisiblePosition visibleBase = VisiblePosition(Position(baseNode, baseOffset), DOWNSTREAM);
     270    VisiblePosition visibleExtent = VisiblePosition(Position(extentNode, extentOffset), DOWNSTREAM);
    269271
    270272    m_frame->selection()->moveTo(visibleBase, visibleExtent);
     
    283285        return;
    284286
    285     m_frame->selection()->moveTo(VisiblePosition(node, offset, DOWNSTREAM));
     287    // FIXME: Eliminate legacy editing positions
     288    m_frame->selection()->moveTo(VisiblePosition(Position(node, offset), DOWNSTREAM));
    286289}
    287290
     
    354357        return;
    355358
    356     m_frame->selection()->setExtent(VisiblePosition(node, offset, DOWNSTREAM));
     359    // FIXME: Eliminate legacy editing positions
     360    m_frame->selection()->setExtent(VisiblePosition(Position(node, offset), DOWNSTREAM));
    357361}
    358362
  • trunk/Source/WebCore/page/EventHandler.cpp

    r77286 r77980  
    374374    VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(event.localPoint()));
    375375    if (visiblePos.isNull())
    376         visiblePos = VisiblePosition(innerNode, 0, DOWNSTREAM);
     376        visiblePos = VisiblePosition(firstPositionInOrBeforeNode(innerNode), DOWNSTREAM);
    377377    Position pos = visiblePos.deepEquivalent();
    378378   
  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r77286 r77980  
    26552655                return VisiblePosition(candidate, affinity);
    26562656        }
    2657         return VisiblePosition(node, offset, affinity);
     2657        // FIXME: Eliminate legacy editing positions
     2658        return VisiblePosition(Position(node, offset), affinity);
    26582659    }
    26592660
     
    26702671        while ((renderer = renderer->nextInPreOrder(parent))) {
    26712672            if (Node* node = renderer->node())
    2672                 return VisiblePosition(node, 0, DOWNSTREAM);
     2673                return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    26732674        }
    26742675
     
    26792680                break;
    26802681            if (Node* node = renderer->node())
    2681                 return VisiblePosition(lastDeepEditingPositionForNode(node), DOWNSTREAM);
     2682                return VisiblePosition(lastPositionInOrAfterNode(node), DOWNSTREAM);
    26822683        }
    26832684
    26842685        // Use the parent itself unless it too is anonymous.
    26852686        if (Node* node = parent->node())
    2686             return VisiblePosition(node, 0, DOWNSTREAM);
     2687            return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    26872688
    26882689        // Repeat at the next level up.
  • trunk/Source/WebCore/rendering/RenderTextControl.cpp

    r77062 r77980  
    322322{
    323323    if (index <= 0)
    324         return VisiblePosition(m_innerText.get(), 0, DOWNSTREAM);
     324        return VisiblePosition(Position(m_innerText.get(), 0, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    325325    ExceptionCode ec = 0;
    326326    RefPtr<Range> range = Range::create(document());
     
    333333    int endOffset = it.range()->endOffset(ec);
    334334    ASSERT(!ec);
    335     return VisiblePosition(endContainer, endOffset, UPSTREAM);
     335    return VisiblePosition(Position(endContainer, endOffset, Position::PositionIsOffsetInAnchor), UPSTREAM);
    336336}
    337337
  • trunk/Source/WebCore/svg/SVGTextContentElement.cpp

    r77485 r77980  
    146146
    147147    // Find selection start
    148     VisiblePosition start(const_cast<SVGTextContentElement*>(this), 0, SEL_DEFAULT_AFFINITY);
     148    VisiblePosition start(firstPositionInNode(const_cast<SVGTextContentElement*>(this)));
    149149    for (unsigned i = 0; i < charnum; ++i)
    150150        start = start.next();
  • trunk/Source/WebKit/mac/ChangeLog

    r77963 r77980  
     12011-02-08  Levi Weintraub  <leviw@chromium.org>
     2
     3        Reviewed by Ryosuke Niwa.
     4
     5        Stop instantiating legacy editing Positions in VisiblePosition
     6        https://bugs.webkit.org/show_bug.cgi?id=52919
     7
     8        Changing usage of legacy VisiblePosition constructor. Since we were dealing
     9        with positions from DOM Ranges, we're guaranteed a parent-anchored position.
     10
     11        * WebView/WebFrame.mm:
     12        (-[WebFrame _caretRectAtPosition:affinity:]):
     13        * WebView/WebFrameInternal.h:
     14        * WebView/WebTextCompletionController.mm:
     15        (-[WebTextCompletionController doCompletion]):
     16
    1172011-02-08  Adam Barth  <abarth@webkit.org>
    218
  • trunk/Source/WebKit/mac/WebView/WebFrame.mm

    r77257 r77980  
    661661}
    662662
    663 - (NSRect)_caretRectAtNode:(DOMNode *)node offset:(int)offset affinity:(NSSelectionAffinity)affinity
    664 {
    665     VisiblePosition visiblePosition(core(node), offset, static_cast<EAffinity>(affinity));
     663- (NSRect)_caretRectAtPosition:(const Position&)pos affinity:(NSSelectionAffinity)affinity
     664{
     665    VisiblePosition visiblePosition(pos, static_cast<EAffinity>(affinity));
    666666    return visiblePosition.absoluteCaretBounds();
    667667}
  • trunk/Source/WebKit/mac/WebView/WebFrameInternal.h

    r77257 r77980  
    3333#import <WebCore/EditAction.h>
    3434#import <WebCore/FrameLoaderTypes.h>
     35#import <WebCore/Position.h>
    3536#import <WebCore/SelectionController.h>
    3637#import <WebCore/Settings.h>
     
    135136- (NSString *)_markupStringFromRange:(DOMRange *)range nodes:(NSArray **)nodes;
    136137
    137 - (NSRect)_caretRectAtNode:(DOMNode *)node offset:(int)offset affinity:(NSSelectionAffinity)affinity;
     138- (NSRect)_caretRectAtPosition:(const WebCore::Position&)pos affinity:(NSSelectionAffinity)affinity;
    138139- (NSRect)_firstRectForDOMRange:(DOMRange *)range;
    139140- (void)_scrollDOMRangeToVisible:(DOMRange *)range;
  • trunk/Source/WebKit/mac/WebView/WebTextCompletionController.mm

    r74566 r77980  
    2929#import "WebTextCompletionController.h"
    3030
     31#import "DOMNodeInternal.h"
    3132#import "DOMRangeInternal.h"
    3233#import "WebFrameInternal.h"
     
    204205            _originalString = [[frame _stringForRange:selection] retain];
    205206            [self _buildUI];
    206             NSRect wordRect = [frame _caretRectAtNode:[wholeWord startContainer] offset:[wholeWord startOffset] affinity:NSSelectionAffinityDownstream];
     207            NSRect wordRect = [frame _caretRectAtPosition:Position(core([wholeWord startContainer]), [wholeWord startOffset], Position::PositionIsOffsetInAnchor) affinity:NSSelectionAffinityDownstream];
    207208            // +1 to be under the word, not the caret
    208209            // FIXME - 3769652 - Wrong positioning for right to left languages.  We should line up the upper
Note: See TracChangeset for help on using the changeset viewer.