Changeset 80059 in webkit


Ignore:
Timestamp:
Mar 1, 2011 4:06:11 PM (13 years ago)
Author:
leviw@chromium.org
Message:

2011-03-01 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-03-01 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::document): Added this inline function to avoid the necessity of calling anchorNode to assure a document from a Position. (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:
27 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r80055 r80059  
     12011-03-01  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::document): Added this inline function to avoid the necessity
     26        of calling anchorNode to assure a document from a Position.
     27        (WebCore::Position::upstream): Fixed to correctly respect PositionIsAfterAnchor
     28        (WebCore::Position::downstream): ditto
     29        * dom/Range.cpp:
     30        (WebCore::Range::editingStartPosition):
     31        * editing/Editor.cpp:
     32        (WebCore::Editor::canDeleteRange):
     33        * editing/ReplaceSelectionCommand.cpp:
     34        (WebCore::ReplaceSelectionCommand::doApply):
     35        * editing/SelectionController.cpp:
     36        (WebCore::SelectionController::selectFrameElementInParentIfFullySelected):
     37        (WebCore::SelectionController::setSelectedRange):
     38        * editing/TextIterator.cpp:
     39        (WebCore::TextIterator::shouldRepresentNodeOffsetZero):
     40        * editing/TypingCommand.cpp:
     41        (WebCore::TypingCommand::deleteKeyPressed):
     42        * editing/VisiblePosition.cpp:
     43        (WebCore::VisiblePosition::leftVisuallyDistinctCandidate):
     44        (WebCore::VisiblePosition::rightVisuallyDistinctCandidate):
     45        (WebCore::VisiblePosition::canonicalPosition):
     46        (WebCore::VisiblePosition::characterAfter):
     47        (WebCore::VisiblePosition::localCaretRect):
     48        (WebCore::makeRange):
     49        (WebCore::startVisiblePosition):
     50        (WebCore::endVisiblePosition):
     51        (WebCore::setStart):
     52        (WebCore::setEnd):
     53        (WebCore::isFirstVisiblePositionInNode):
     54        (WebCore::isLastVisiblePositionInNode):
     55        * editing/VisiblePosition.h:
     56        (WebCore::VisiblePosition::VisiblePosition):
     57        * editing/htmlediting.cpp:
     58        (WebCore::firstInSpecialElement):
     59        (WebCore::lastInSpecialElement):
     60        (WebCore::visiblePositionBeforeNode):
     61        (WebCore::visiblePositionAfterNode):
     62        * editing/visible_units.cpp:
     63        (WebCore::startPositionForLine):
     64        (WebCore::endPositionForLine):
     65        (WebCore::previousLinePosition):
     66        (WebCore::nextLinePosition):
     67        (WebCore::startOfParagraph):
     68        (WebCore::endOfParagraph):
     69        (WebCore::endOfBlock):
     70        (WebCore::startOfDocument):
     71        (WebCore::endOfDocument):
     72        (WebCore::logicalStartPositionForLine):
     73        (WebCore::logicalEndPositionForLine):
     74        * page/DOMSelection.cpp:
     75        (WebCore::DOMSelection::collapse):
     76        (WebCore::DOMSelection::setBaseAndExtent):
     77        (WebCore::DOMSelection::setPosition):
     78        (WebCore::DOMSelection::extend):
     79        * page/EventHandler.cpp:
     80        (WebCore::EventHandler::handleMousePressEventSingleClick):
     81        * rendering/RenderObject.cpp:
     82        (WebCore::RenderObject::createVisiblePosition):
     83        * rendering/RenderTextControl.cpp:
     84        (WebCore::RenderTextControl::visiblePositionForIndex):
     85        * svg/SVGTextContentElement.cpp:
     86        (WebCore::SVGTextContentElement::selectSubString):
     87
    1882011-03-01  Jeremy Orlow  <jorlow@chromium.org>
    289
  • trunk/Source/WebCore/WebCore.exp.in

    r80014 r80059  
    410410__ZN7WebCore15StringTruncator14centerTruncateERKN3WTF6StringEfRKNS_4FontE
    411411__ZN7WebCore15StringTruncator5widthERKN3WTF6StringERKNS_4FontE
    412 __ZN7WebCore15VisiblePositionC1EPNS_4NodeEiNS_9EAffinityE
    413412__ZN7WebCore15VisiblePositionC1ERKNS_8PositionENS_9EAffinityE
    414413__ZN7WebCore15defaultLanguageEv
     
    806805__ZN7WebCore8IntPointC1ERK8_NSPoint
    807806__ZN7WebCore8PositionC1EN3WTF10PassRefPtrINS_4NodeEEEi
     807__ZN7WebCore8PositionC1EN3WTF10PassRefPtrINS_4NodeEEEiNS0_10AnchorTypeE
    808808__ZN7WebCore8Settings14setJavaEnabledEb
    809809__ZN7WebCore8Settings15setWebGLEnabledEb
  • trunk/Source/WebCore/accessibility/AXObjectCache.cpp

    r79196 r80059  
    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

    r79196 r80059  
    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

    r79953 r80059  
    24622462   
    24632463    if (index <= 0)
    2464         return VisiblePosition(node, 0, DOWNSTREAM);
     2464        return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    24652465   
    24662466    ExceptionCode ec = 0;
     
    24692469    CharacterIterator it(range.get());
    24702470    it.advance(index - 1);
    2471     return VisiblePosition(it.range()->endContainer(ec), it.range()->endOffset(ec), UPSTREAM);
     2471    return VisiblePosition(Position(it.range()->endContainer(ec), it.range()->endOffset(ec), Position::PositionIsOffsetInAnchor), UPSTREAM);
    24722472}
    24732473   
  • trunk/Source/WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp

    r79920 r80059  
    25382538    Node* node = realObject->node();
    25392539    if (node) {
    2540         VisiblePosition startPosition = VisiblePosition(node, 0, DOWNSTREAM);
     2540        VisiblePosition startPosition = VisiblePosition(positionBeforeNode(node), DOWNSTREAM);
    25412541        VisiblePosition endPosition = realObject->selection().visibleEnd();
    25422542
  • trunk/Source/WebCore/dom/Position.cpp

    r79196 r80059  
    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/Position.h

    r79196 r80059  
    108108    Node* deprecatedNode() const { return m_anchorNode.get(); }
    109109
     110    Document* document() const { return m_anchorNode ? m_anchorNode->document() : 0; }
     111
    110112    // These should only be used for PositionIsOffsetInAnchor positions, unless
    111113    // the position is a legacy editing position.
  • trunk/Source/WebCore/dom/Range.cpp

    r79854 r80059  
    15691569    // with a spurious "mixed" style.
    15701570   
    1571     VisiblePosition visiblePosition(m_start.container(), m_start.offset(), VP_DEFAULT_AFFINITY);
     1571    VisiblePosition visiblePosition = Position(m_start.container(), m_start.offset(), Position::PositionIsOffsetInAnchor);
    15721572    if (visiblePosition.isNull())
    15731573        return Position();
  • trunk/Source/WebCore/editing/Editor.cpp

    r80023 r80059  
    307307   
    308308    if (range->collapsed(ec)) {
    309         VisiblePosition start(startContainer, range->startOffset(ec), DOWNSTREAM);
     309        VisiblePosition start(Position(startContainer, range->startOffset(ec), Position::PositionIsOffsetInAnchor), DOWNSTREAM);
    310310        VisiblePosition previous = start.previous();
    311311        // 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

    r79398 r80059  
    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.deprecatedNode());
  • trunk/Source/WebCore/editing/SelectionController.cpp

    r79953 r80059  
    13591359    // Create compute positions before and after the element.
    13601360    unsigned ownerElementNodeIndex = ownerElement->nodeIndex();
    1361     VisiblePosition beforeOwnerElement(VisiblePosition(ownerElementParent, ownerElementNodeIndex, SEL_DEFAULT_AFFINITY));
    1362     VisiblePosition afterOwnerElement(VisiblePosition(ownerElementParent, ownerElementNodeIndex + 1, VP_UPSTREAM_IF_POSSIBLE));
     1361    VisiblePosition beforeOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex, Position::PositionIsOffsetInAnchor)));
     1362    VisiblePosition afterOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1, Position::PositionIsOffsetInAnchor), VP_UPSTREAM_IF_POSSIBLE));
    13631363
    13641364    // Focus on the parent frame, and then select from before this element to after.
     
    14311431   
    14321432    // FIXME: Can we provide extentAffinity?
    1433     VisiblePosition visibleStart(startContainer, startOffset, collapsed ? affinity : DOWNSTREAM);
    1434     VisiblePosition visibleEnd(endContainer, endOffset, SEL_DEFAULT_AFFINITY);
     1433    VisiblePosition visibleStart(Position(startContainer, startOffset, Position::PositionIsOffsetInAnchor), collapsed ? affinity : DOWNSTREAM);
     1434    VisiblePosition visibleEnd(Position(endContainer, endOffset, Position::PositionIsOffsetInAnchor), SEL_DEFAULT_AFFINITY);
    14351435    SetSelectionOptions options = ClearTypingStyle;
    14361436    if (closeTyping)
  • trunk/Source/WebCore/editing/TextIterator.cpp

    r79429 r80059  
    861861    // The currPos.isNotNull() check is needed because positions in non-HTML content
    862862    // (like SVG) do not have visible positions, and we don't want to emit for them either.
    863     VisiblePosition startPos = VisiblePosition(m_startContainer, m_startOffset, DOWNSTREAM);
    864     VisiblePosition currPos = VisiblePosition(m_node, 0, DOWNSTREAM);
     863    VisiblePosition startPos = VisiblePosition(Position(m_startContainer, m_startOffset, Position::PositionIsOffsetInAnchor), DOWNSTREAM);
     864    VisiblePosition currPos = VisiblePosition(positionBeforeNode(m_node), DOWNSTREAM);
    865865    return startPos.isNotNull() && currPos.isNotNull() && !inSameLine(startPos, currPos);
    866866}
  • trunk/Source/WebCore/editing/TypingCommand.cpp

    r80023 r80059  
    502502        // If the caret is just after a table, select the table and don't delete anything.
    503503        } else if (Node* table = isFirstPositionAfterTable(visibleStart)) {
    504             setEndingSelection(VisibleSelection(positionAfterNode(table), endingSelection().start(), DOWNSTREAM));
     504            setEndingSelection(VisibleSelection(positionBeforeNode(table), endingSelection().start(), DOWNSTREAM));
    505505            typingAddedToOpenCommand(DeleteKey);
    506506            return;
  • trunk/Source/WebCore/editing/VisiblePosition.cpp

    r79196 r80059  
    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.deprecatedNode())
     103    if (p.isNull())
    110104        return Position();
    111105
     
    243237{
    244238    Position p = m_deepPosition;
    245     if (!p.deprecatedNode())
     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.deprecatedNode();
    455     if (!node)
     448    if (position.isNull())
    456449        return Position();
    457450
    458     ASSERT(node->document());
    459     node->document()->updateLayoutIgnorePendingStylesheets();
     451    Node* node = position.containerNode();
     452
     453    ASSERT(position.document());
     454    position.document()->updateLayoutIgnorePendingStylesheets();
    460455
    461456    Position candidate = position.upstream();
     
    475470    // The new position must be in the same editable element. Enforce that first.
    476471    // Unless the descent is from a non-editable html element to an editable body.
    477     if (node->hasTagName(htmlTag) && !node->isContentEditable() && node->document()->body() && node->document()->body()->isContentEditable())
     472    if (node && node->hasTagName(htmlTag) && !node->isContentEditable() && node->document()->body() && node->document()->body()->isContentEditable())
    478473        return next.isNotNull() ? next : prev;
    479474
     
    497492
    498493    // The new position should be in the same block flow element. Favor that.
    499     Node *originalBlock = node->enclosingBlockFlowElement();
     494    Node* originalBlock = node ? node->enclosingBlockFlowElement() : 0;
    500495    bool nextIsOutsideOriginalBlock = !nextNode->isDescendantOf(originalBlock) && nextNode != originalBlock;
    501496    bool prevIsOutsideOriginalBlock = !prevNode->isDescendantOf(originalBlock) && prevNode != originalBlock;
     
    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.deprecatedNode();
    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.deprecatedNode());
    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.deprecatedNode();
    531     if (!node) {
     526    if (m_deepPosition.isNull()) {
    532527        renderer = 0;
    533528        return IntRect();
    534529    }
     530    Node* node = m_deepPosition.anchorNode();
    535531   
    536532    renderer = node->renderer();
     
    602598    Position s = start.deepEquivalent().parentAnchoredEquivalent();
    603599    Position e = end.deepEquivalent().parentAnchoredEquivalent();
    604     return Range::create(s.anchorNode()->document(), s.deprecatedNode(), s.deprecatedEditingOffset(), e.deprecatedNode(), e.deprecatedEditingOffset());
     600    return Range::create(s.containerNode()->document(), s.containerNode(), s.offsetInContainerNode(), e.containerNode(), e.offsetInContainerNode());
    605601}
    606602
     
    608604{
    609605    int exception = 0;
    610     return VisiblePosition(r->startContainer(exception), r->startOffset(exception), affinity);
     606    return VisiblePosition(Position(r->startContainer(exception), r->startOffset(exception), Position::PositionIsOffsetInAnchor), affinity);
    611607}
    612608
     
    614610{
    615611    int exception = 0;
    616     return VisiblePosition(r->endContainer(exception), r->endOffset(exception), affinity);
     612    return VisiblePosition(Position(r->endContainer(exception), r->endOffset(exception), Position::PositionIsOffsetInAnchor), affinity);
    617613}
    618614
     
    623619    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    624620    int code = 0;
    625     r->setStart(p.deprecatedNode(), p.deprecatedEditingOffset(), code);
     621    r->setStart(p.containerNode(), p.offsetInContainerNode(), code);
    626622    return code == 0;
    627623}
     
    633629    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    634630    int code = 0;
    635     r->setEnd(p.deprecatedNode(), p.deprecatedEditingOffset(), code);
     631    r->setEnd(p.containerNode(), p.offsetInContainerNode(), code);
    636632    return code == 0;
    637633}
     
    649645    if (visiblePosition.isNull())
    650646        return false;
    651    
    652     if (!visiblePosition.deepEquivalent().deprecatedNode()->isDescendantOf(node))
     647
     648    if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
    653649        return false;
    654        
     650
    655651    VisiblePosition previous = visiblePosition.previous();
    656652    return previous.isNull() || !previous.deepEquivalent().deprecatedNode()->isDescendantOf(node);
     
    661657    if (visiblePosition.isNull())
    662658        return false;
    663    
    664     if (!visiblePosition.deepEquivalent().deprecatedNode()->isDescendantOf(node))
     659
     660    if (!visiblePosition.deepEquivalent().containerNode()->isDescendantOf(node))
    665661        return false;
    666                
     662
    667663    VisiblePosition next = visiblePosition.next();
    668664    return next.isNull() || !next.deepEquivalent().deprecatedNode()->isDescendantOf(node);
  • trunk/Source/WebCore/editing/VisiblePosition.h

    r79196 r80059  
    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

    r79196 r80059  
    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

    r79429 r80059  
    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

    r79196 r80059  
    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

    r79875 r80059  
    4646#include "FrameTree.h"
    4747#include "FrameView.h"
     48#include "htmlediting.h"
    4849#include "HTMLFrameElementBase.h"
    4950#include "HTMLFrameSetElement.h"
     
    373374    VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(event.localPoint()));
    374375    if (visiblePos.isNull())
    375         visiblePos = VisiblePosition(innerNode, 0, DOWNSTREAM);
     376        visiblePos = VisiblePosition(firstPositionInOrBeforeNode(innerNode), DOWNSTREAM);
    376377    Position pos = visiblePos.deepEquivalent();
    377378   
  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r79920 r80059  
    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

    r79196 r80059  
    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

    r78345 r80059  
    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

    r80014 r80059  
     12011-03-01  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-03-01  Sam Weinig  <sam@webkit.org>
    218
  • trunk/Source/WebKit/mac/WebView/WebFrame.mm

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

    r77997 r80059  
    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

    r79615 r80059  
    2929#import "WebTextCompletionController.h"
    3030
     31#import "DOMNodeInternal.h"
    3132#import "DOMRangeInternal.h"
    3233#import "WebFrameInternal.h"
     
    205206            _originalString = [[frame _stringForRange:selection] retain];
    206207            [self _buildUI];
    207             NSRect wordRect = [frame _caretRectAtNode:[wholeWord startContainer] offset:[wholeWord startOffset] affinity:NSSelectionAffinityDownstream];
     208            NSRect wordRect = [frame _caretRectAtPosition:Position(core([wholeWord startContainer]), [wholeWord startOffset], Position::PositionIsOffsetInAnchor) affinity:NSSelectionAffinityDownstream];
    208209            // +1 to be under the word, not the caret
    209210            // 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.