Changeset 199817 in webkit


Ignore:
Timestamp:
Apr 21, 2016 9:07:18 AM (8 years ago)
Author:
Chris Dumez
Message:

Drop [UsePointersEvenForNonNullableObjectArguments] from Range
​https://bugs.webkit.org/show_bug.cgi?id=156805

Reviewed by Youenn Fablet.

Source/WebCore:

No new tests, no web-exposed behavior change.

  • accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::rangeForNodeContents):
(WebCore::characterOffsetsInOrder):
(WebCore::setRangeStartOrEndWithCharacterOffset):
(WebCore::AXObjectCache::startOrEndCharacterOffsetForRange):
(WebCore::AXObjectCache::previousBoundary):

  • accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::selectText):

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::documentBasedSelectedTextRange):

  • dom/Node.cpp:

(WebCore::Node::textRects):

  • dom/Range.cpp:

(WebCore::Range::Range):
(WebCore::Range::setDocument):
(WebCore::Range::setStart):
(WebCore::Range::setEnd):
(WebCore::Range::isPointInRange):
(WebCore::Range::comparePoint):
(WebCore::Range::compareNode):
(WebCore::Range::compareBoundaryPoints):
(WebCore::Range::compareBoundaryPointsForBindings):
(WebCore::Range::intersectsNode):
(WebCore::Range::processContents):
(WebCore::Range::insertNode):
(WebCore::Range::checkNodeWOffset):
(WebCore::Range::setStartAfter):
(WebCore::Range::setEndBefore):
(WebCore::Range::setEndAfter):
(WebCore::Range::selectNode):
(WebCore::Range::selectNodeContents):
(WebCore::Range::surroundContents):
(WebCore::Range::setStartBefore):
(WebCore::Range::contains):
(WebCore::rangesOverlap):
(WebCore::rangeOfContents):
(WebCore::boundaryNodeChildrenWillBeRemoved):
(WebCore::boundaryTextNodesMerged):
(WebCore::boundaryTextNodesSplit):
(WebCore::Range::expand):
(WebCore::checkForDifferentRootContainer): Deleted.
(WebCore::highestAncestorUnderCommonRoot): Deleted.
(WebCore::childOfCommonRootBeforeOffset): Deleted.
(WebCore::deleteCharacterData): Deleted.
(WebCore::Range::toString): Deleted.
(WebCore::Range::toHTML): Deleted.
(WebCore::Range::text): Deleted.
(WebCore::Range::cloneRange): Deleted.
(WebCore::Range::absoluteTextRects): Deleted.
(WebCore::Range::absoluteTextQuads): Deleted.
(WebCore::boundaryNodeChildrenChanged): Deleted.
(WebCore::boundaryNodeWillBeRemoved): Deleted.
(WebCore::Range::nodeWillBeRemoved): Deleted.
(WebCore::boundaryTextRemoved): Deleted.
(WebCore::Range::getBoundingClientRect): Deleted.
(WebCore::Range::getBorderAndTextQuads): Deleted.

  • dom/Range.h:
  • dom/Range.idl:
  • dom/RangeBoundaryPoint.h:

(WebCore::RangeBoundaryPoint::set):
(WebCore::RangeBoundaryPoint::setToStartOfNode):
(WebCore::RangeBoundaryPoint::setToEndOfNode):

  • editing/AlternativeTextController.cpp:

(WebCore::AlternativeTextController::applyAlternativeTextToRange):

  • editing/ApplyStyleCommand.cpp:

(WebCore::ApplyStyleCommand::fixRangeAndApplyInlineStyle):

  • editing/Editor.cpp:

(WebCore::Editor::advanceToNextMisspelling):
(WebCore::Editor::rangeOfString):
(WebCore::isFrameInRange):
(WebCore::Editor::countMatchesForText):

  • editing/EditorCommand.cpp:

(WebCore::unionDOMRanges):
(WebCore::executeDeleteToMark):
(WebCore::executeSelectToMark):

  • editing/FormatBlockCommand.cpp:

(WebCore::FormatBlockCommand::formatRange):

  • editing/FrameSelection.cpp:

(WebCore::FrameSelection::respondToNodeModification):

  • editing/InsertListCommand.cpp:

(WebCore::InsertListCommand::doApplyForSingleParagraph):

  • editing/TextCheckingHelper.cpp:

(WebCore::TextCheckingParagraph::offsetTo):

  • editing/TextIterator.cpp:

(WebCore::CharacterIterator::range):
(WebCore::BackwardsCharacterIterator::range):
(WebCore::TextIterator::rangeFromLocationAndLength):
(WebCore::TextIterator::getLocationAndLengthFromRange):
(WebCore::findPlainText):

  • editing/VisiblePosition.cpp:

(WebCore::setStart):
(WebCore::setEnd):

  • editing/VisibleSelection.cpp:

(WebCore::makeSearchRange):

  • editing/VisibleUnits.cpp:

(WebCore::previousBoundary):
(WebCore::nextBoundary):

  • editing/htmlediting.cpp:

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

  • editing/htmlediting.h:
  • editing/mac/EditorMac.mm:

(WebCore::Editor::adjustedSelectionRange):

  • page/ContextMenuController.cpp:

(WebCore::ContextMenuController::contextMenuItemSelected):

  • page/DOMSelection.cpp:

(WebCore::DOMSelection::addRange):

  • page/DragController.cpp:

(WebCore::selectElement):

  • page/EventHandler.cpp:

(WebCore::EventHandler::dispatchMouseEvent):

  • page/Page.cpp:

(WebCore::Page::findStringMatchingRanges):

  • page/TextIndicator.cpp:

(WebCore::hasNonInlineOrReplacedElements):

  • rendering/RenderNamedFlowThread.cpp:

(WebCore::RenderNamedFlowThread::getRanges):

Source/WebKit/mac:

  • WebView/WebFrame.mm:

(-[WebFrame _smartDeleteRangeForProposedRange:]):

Source/WebKit2:

  • WebProcess/InjectedBundle/API/mac/WKDOMRange.mm:

(-[WKDOMRange setStart:offset:]):
(-[WKDOMRange setEnd:offset:]):
(-[WKDOMRange selectNode:]):
(-[WKDOMRange selectNodeContents:]):

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::contentsAsString):

Location:
trunk/Source
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r199816 r199817  
     12016-04-21  Chris Dumez  <cdumez@apple.com>
     2
     3        Drop [UsePointersEvenForNonNullableObjectArguments] from Range
     4        https://bugs.webkit.org/show_bug.cgi?id=156805
     5
     6        Reviewed by Youenn Fablet.
     7
     8        No new tests, no web-exposed behavior change.
     9
     10        * accessibility/AXObjectCache.cpp:
     11        (WebCore::AXObjectCache::rangeForNodeContents):
     12        (WebCore::characterOffsetsInOrder):
     13        (WebCore::setRangeStartOrEndWithCharacterOffset):
     14        (WebCore::AXObjectCache::startOrEndCharacterOffsetForRange):
     15        (WebCore::AXObjectCache::previousBoundary):
     16        * accessibility/AccessibilityObject.cpp:
     17        (WebCore::AccessibilityObject::selectText):
     18        * accessibility/AccessibilityRenderObject.cpp:
     19        (WebCore::AccessibilityRenderObject::documentBasedSelectedTextRange):
     20        * dom/Node.cpp:
     21        (WebCore::Node::textRects):
     22        * dom/Range.cpp:
     23        (WebCore::Range::Range):
     24        (WebCore::Range::setDocument):
     25        (WebCore::Range::setStart):
     26        (WebCore::Range::setEnd):
     27        (WebCore::Range::isPointInRange):
     28        (WebCore::Range::comparePoint):
     29        (WebCore::Range::compareNode):
     30        (WebCore::Range::compareBoundaryPoints):
     31        (WebCore::Range::compareBoundaryPointsForBindings):
     32        (WebCore::Range::intersectsNode):
     33        (WebCore::Range::processContents):
     34        (WebCore::Range::insertNode):
     35        (WebCore::Range::checkNodeWOffset):
     36        (WebCore::Range::setStartAfter):
     37        (WebCore::Range::setEndBefore):
     38        (WebCore::Range::setEndAfter):
     39        (WebCore::Range::selectNode):
     40        (WebCore::Range::selectNodeContents):
     41        (WebCore::Range::surroundContents):
     42        (WebCore::Range::setStartBefore):
     43        (WebCore::Range::contains):
     44        (WebCore::rangesOverlap):
     45        (WebCore::rangeOfContents):
     46        (WebCore::boundaryNodeChildrenWillBeRemoved):
     47        (WebCore::boundaryTextNodesMerged):
     48        (WebCore::boundaryTextNodesSplit):
     49        (WebCore::Range::expand):
     50        (WebCore::checkForDifferentRootContainer): Deleted.
     51        (WebCore::highestAncestorUnderCommonRoot): Deleted.
     52        (WebCore::childOfCommonRootBeforeOffset): Deleted.
     53        (WebCore::deleteCharacterData): Deleted.
     54        (WebCore::Range::toString): Deleted.
     55        (WebCore::Range::toHTML): Deleted.
     56        (WebCore::Range::text): Deleted.
     57        (WebCore::Range::cloneRange): Deleted.
     58        (WebCore::Range::absoluteTextRects): Deleted.
     59        (WebCore::Range::absoluteTextQuads): Deleted.
     60        (WebCore::boundaryNodeChildrenChanged): Deleted.
     61        (WebCore::boundaryNodeWillBeRemoved): Deleted.
     62        (WebCore::Range::nodeWillBeRemoved): Deleted.
     63        (WebCore::boundaryTextRemoved): Deleted.
     64        (WebCore::Range::getBoundingClientRect): Deleted.
     65        (WebCore::Range::getBorderAndTextQuads): Deleted.
     66        * dom/Range.h:
     67        * dom/Range.idl:
     68        * dom/RangeBoundaryPoint.h:
     69        (WebCore::RangeBoundaryPoint::set):
     70        (WebCore::RangeBoundaryPoint::setToStartOfNode):
     71        (WebCore::RangeBoundaryPoint::setToEndOfNode):
     72        * editing/AlternativeTextController.cpp:
     73        (WebCore::AlternativeTextController::applyAlternativeTextToRange):
     74        * editing/ApplyStyleCommand.cpp:
     75        (WebCore::ApplyStyleCommand::fixRangeAndApplyInlineStyle):
     76        * editing/Editor.cpp:
     77        (WebCore::Editor::advanceToNextMisspelling):
     78        (WebCore::Editor::rangeOfString):
     79        (WebCore::isFrameInRange):
     80        (WebCore::Editor::countMatchesForText):
     81        * editing/EditorCommand.cpp:
     82        (WebCore::unionDOMRanges):
     83        (WebCore::executeDeleteToMark):
     84        (WebCore::executeSelectToMark):
     85        * editing/FormatBlockCommand.cpp:
     86        (WebCore::FormatBlockCommand::formatRange):
     87        * editing/FrameSelection.cpp:
     88        (WebCore::FrameSelection::respondToNodeModification):
     89        * editing/InsertListCommand.cpp:
     90        (WebCore::InsertListCommand::doApplyForSingleParagraph):
     91        * editing/TextCheckingHelper.cpp:
     92        (WebCore::TextCheckingParagraph::offsetTo):
     93        * editing/TextIterator.cpp:
     94        (WebCore::CharacterIterator::range):
     95        (WebCore::BackwardsCharacterIterator::range):
     96        (WebCore::TextIterator::rangeFromLocationAndLength):
     97        (WebCore::TextIterator::getLocationAndLengthFromRange):
     98        (WebCore::findPlainText):
     99        * editing/VisiblePosition.cpp:
     100        (WebCore::setStart):
     101        (WebCore::setEnd):
     102        * editing/VisibleSelection.cpp:
     103        (WebCore::makeSearchRange):
     104        * editing/VisibleUnits.cpp:
     105        (WebCore::previousBoundary):
     106        (WebCore::nextBoundary):
     107        * editing/htmlediting.cpp:
     108        (WebCore::visiblePositionForIndexUsingCharacterIterator):
     109        (WebCore::isNodeVisiblyContainedWithin):
     110        * editing/htmlediting.h:
     111        * editing/mac/EditorMac.mm:
     112        (WebCore::Editor::adjustedSelectionRange):
     113        * page/ContextMenuController.cpp:
     114        (WebCore::ContextMenuController::contextMenuItemSelected):
     115        * page/DOMSelection.cpp:
     116        (WebCore::DOMSelection::addRange):
     117        * page/DragController.cpp:
     118        (WebCore::selectElement):
     119        * page/EventHandler.cpp:
     120        (WebCore::EventHandler::dispatchMouseEvent):
     121        * page/Page.cpp:
     122        (WebCore::Page::findStringMatchingRanges):
     123        * page/TextIndicator.cpp:
     124        (WebCore::hasNonInlineOrReplacedElements):
     125        * rendering/RenderNamedFlowThread.cpp:
     126        (WebCore::RenderNamedFlowThread::getRanges):
     127
    11282016-04-21  Chris Dumez  <cdumez@apple.com>
    2129

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

    r199809 r199817  
    16071607    RefPtr<Range> range = Range::create(*document);
    16081608    ExceptionCode ec = 0;
    1609     range->selectNodeContents(node, ec);
     1609    range->selectNodeContents(*node, ec);
    16101610    return ec ? nullptr : range;
    16111611}
    … …  
    16361636    RefPtr<Range> range1 = AXObjectCache::rangeForNodeContents(node1);
    16371637    RefPtr<Range> range2 = AXObjectCache::rangeForNodeContents(node2);
    1638     return range1->compareBoundaryPoints(Range::START_TO_START, range2.get(), IGNORE_EXCEPTION) <= 0;
     1638
     1639    return !range2 || range1->compareBoundaryPoints(Range::START_TO_START, *range2, IGNORE_EXCEPTION) <= 0;
    16391640}
    16401641
    … …  
    16641665    int offset = characterOffset.startIndex + characterOffset.offset;
    16651666    Node* node = characterOffset.node;
     1667    ASSERT(node);
    16661668   
    16671669    bool replacedNodeOrBR = isReplacedNodeOrBR(node);
    … …  
    16741676        node = resetNodeAndOffsetForReplacedNode(node, offset, characterCount);
    16751677   
     1678    if (!node) {
     1679        ec = TypeError;
     1680        return;
     1681    }
     1682
    16761683    if (isStart)
    1677         range->setStart(node, offset, ec);
     1684        range->setStart(*node, offset, ec);
    16781685    else
    1679         range->setEnd(node, offset, ec);
     1686        range->setEnd(*node, offset, ec);
    16801687}
    16811688
    … …  
    17441751    bool stayWithinRange = !isStart;
    17451752   
    1746     RefPtr<Range> copyRange = range;
     1753    Ref<Range> copyRange = *range;
    17471754    // Change the start of the range, so the character offset starts from node beginning.
    17481755    int offset = 0;
    1749     Node* node = &copyRange->startContainer();
    1750     if (node->offsetInCharacters()) {
     1756    Node& node = copyRange->startContainer();
     1757    if (node.offsetInCharacters()) {
    17511758        copyRange = Range::create(range->ownerDocument(), &range->startContainer(), range->startOffset(), &range->endContainer(), range->endOffset());
    1752         CharacterOffset nodeStartOffset = traverseToOffsetInRange(rangeForNodeContents(node), 0);
     1759        CharacterOffset nodeStartOffset = traverseToOffsetInRange(rangeForNodeContents(&node), 0);
    17531760        offset = std::max(copyRange->startOffset() - nodeStartOffset.startIndex, 0);
    17541761        copyRange->setStart(node, nodeStartOffset.startIndex);
    17551762    }
    17561763   
    1757     return traverseToOffsetInRange(copyRange, offset, isStart ? TraverseOptionDefault : TraverseOptionToNodeEnd, stayWithinRange);
     1764    return traverseToOffsetInRange(WTFMove(copyRange), offset, isStart ? TraverseOptionDefault : TraverseOptionToNodeEnd, stayWithinRange);
    17581765}
    17591766
    … …  
    22142221    if (requiresContextForWordBoundary(characterBefore(characterOffset))) {
    22152222        RefPtr<Range> forwardsScanRange(boundary->document().createRange());
    2216         forwardsScanRange->setEndAfter(boundary, ec);
     2223        forwardsScanRange->setEndAfter(*boundary, ec);
    22172224        setRangeStartOrEndWithCharacterOffset(forwardsScanRange, characterOffset, true, ec);
    22182225        suffixLength = suffixLengthForRange(forwardsScanRange, string);

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

    r199260 r199817  
    738738    RefPtr<Range> selectedStringRange = selectionRange();
    739739    // When starting our search again, make this a zero length range so that search forwards will find this selected range if its appropriate.
    740     selectedStringRange->setEnd(&selectedStringRange->startContainer(), selectedStringRange->startOffset());
     740    selectedStringRange->setEnd(selectedStringRange->startContainer(), selectedStringRange->startOffset());
    741741   
    742742    RefPtr<Range> closestAfterStringRange = nullptr;

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

    r199295 r199817  
    14351435    VisibleSelection visibleSelection = selection();
    14361436    RefPtr<Range> currentSelectionRange = visibleSelection.toNormalizedRange();
    1437     if (!currentSelectionRange || !currentSelectionRange->intersectsNode(node, IGNORE_EXCEPTION))
     1437    if (!currentSelectionRange || !currentSelectionRange->intersectsNode(*node, IGNORE_EXCEPTION))
    14381438        return PlainTextRange();
    14391439   
    … …  
    15141514        textControl.setSelectionRange(range.start, range.start + range.length);
    15151515    } else {
    1516         VisiblePosition start = visiblePositionForIndexUsingCharacterIterator(node(), range.start);
    1517         VisiblePosition end = visiblePositionForIndexUsingCharacterIterator(node(), range.start + range.length);
     1516        ASSERT(node());
     1517        VisiblePosition start = visiblePositionForIndexUsingCharacterIterator(*node(), range.start);
     1518        VisiblePosition end = visiblePositionForIndexUsingCharacterIterator(*node(), range.start + range.length);
    15181519        m_renderer->frame().selection().setSelection(VisibleSelection(start, end), FrameSelection::defaultSetSelectionOptions(UserTriggered));
    15191520    }
    … …  
    18771878        return VisiblePosition();
    18781879
    1879     return visiblePositionForIndexUsingCharacterIterator(node, index);
     1880    return visiblePositionForIndexUsingCharacterIterator(*node, index);
    18801881}
    18811882   

  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp

    r189182 r199817  
    162162    Node* node = coreObject->node();
    163163    Node* lastDescendant = node->lastDescendant();
    164     return (range->intersectsNode(node, IGNORE_EXCEPTION)
     164    return (range->intersectsNode(*node, IGNORE_EXCEPTION)
    165165        && (&range->endContainer() != node || range->endOffset())
    166166        && (&range->startContainer() != lastDescendant || range->startOffset() != lastOffsetInNode(lastDescendant)));

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

    r199260 r199817  
    21322132   
    21332133    ExceptionCode ec;
    2134     testRange->setEnd(&range->endContainer(), range->endOffset(), ec);
     2134    testRange->setEnd(range->endContainer(), range->endOffset(), ec);
    21352135    ASSERT(&testRange->startContainer() == scope);
    21362136    int endPosition = TextIterator::rangeLength(testRange.get());

  • trunk/Source/WebCore/bindings/objc/DOMUIKitExtensions.mm

    r188187 r199817  
    114114    Position start = frameSelection.selection().start().parentAnchoredEquivalent();
    115115    Position end = frameSelection.selection().end().parentAnchoredEquivalent();
    116     range->setStart(start.containerNode(), start.offsetInContainerNode(), ignored);
    117     range->setEnd(end.containerNode(), end.offsetInContainerNode(), ignored);
     116    if (start.containerNode())
     117        range->setStart(*start.containerNode(), start.offsetInContainerNode(), ignored);
     118    if (end.containerNode())
     119        range->setEnd(*end.containerNode(), end.offsetInContainerNode(), ignored);
    118120}
    119121
    … …  
    130132    Position start = frameSelection.selection().start().parentAnchoredEquivalent();
    131133    Position end = frameSelection.selection().end().parentAnchoredEquivalent();
    132     range->setStart(start.containerNode(), start.offsetInContainerNode(), ignored);
    133     range->setEnd(end.containerNode(), end.offsetInContainerNode(), ignored);
     134    if (start.containerNode())
     135        range->setStart(*start.containerNode(), start.offsetInContainerNode(), ignored);
     136    if (end.containerNode())
     137        range->setEnd(*end.containerNode(), end.offsetInContainerNode(), ignored);
    134138}
    135139

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

    r199003 r199817  
    23152315{
    23162316    RefPtr<Range> range = Range::create(document());
    2317     range->selectNodeContents(const_cast<Node*>(this), IGNORE_EXCEPTION);
     2317    range->selectNodeContents(const_cast<Node&>(*this), IGNORE_EXCEPTION);
    23182318    range->absoluteTextRects(rects);
    23192319}

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

    r198583 r199817  
    8181}
    8282
     83// FIXME: startContainer and endContainer should probably be Ref<Node>&&.
    8384inline Range::Range(Document& ownerDocument, PassRefPtr<Node> startContainer, int startOffset, PassRefPtr<Node> endContainer, int endOffset)
    8485    : m_ownerDocument(ownerDocument)
    … …  
    9495    // Simply setting the containers and offsets directly would not do any of the checking
    9596    // that setStart and setEnd do, so we call those functions.
    96     setStart(startContainer, startOffset);
    97     setEnd(endContainer, endOffset);
     97    if (startContainer)
     98        setStart(*startContainer, startOffset);
     99    if (endContainer)
     100        setEnd(*endContainer, endOffset);
    98101}
    99102
    … …  
    130133    m_ownerDocument->detachRange(this);
    131134    m_ownerDocument = document;
    132     m_start.setToStartOfNode(&document);
    133     m_end.setToStartOfNode(&document);
     135    m_start.setToStartOfNode(document);
     136    m_end.setToStartOfNode(document);
    134137    m_ownerDocument->attachRange(this);
    135138}
    … …  
    158161}
    159162
    160 void Range::setStart(PassRefPtr<Node> refNode, int offset, ExceptionCode& ec)
    161 {
    162     if (!refNode) {
    163         ec = TypeError;
    164         return;
    165     }
    166 
     163void Range::setStart(Ref<Node>&& refNode, int offset, ExceptionCode& ec)
     164{
    167165    bool didMoveDocument = false;
    168166    if (&refNode->document() != &ownerDocument()) {
    … …  
    172170
    173171    ec = 0;
    174     Node* childNode = checkNodeWOffset(refNode.get(), offset, ec);
     172    Node* childNode = checkNodeWOffset(refNode, offset, ec);
    175173    if (ec)
    176174        return;
    177175
    178     m_start.set(refNode, offset, childNode);
     176    m_start.set(WTFMove(refNode), offset, childNode);
    179177
    180178    if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
    … …  
    182180}
    183181
    184 void Range::setEnd(PassRefPtr<Node> refNode, int offset, ExceptionCode& ec)
    185 {
    186     if (!refNode) {
    187         ec = TypeError;
    188         return;
    189     }
    190 
     182void Range::setEnd(Ref<Node>&& refNode, int offset, ExceptionCode& ec)
     183{
    191184    bool didMoveDocument = false;
    192185    if (&refNode->document() != &ownerDocument()) {
    … …  
    196189
    197190    ec = 0;
    198     Node* childNode = checkNodeWOffset(refNode.get(), offset, ec);
     191    Node* childNode = checkNodeWOffset(refNode, offset, ec);
    199192    if (ec)
    200193        return;
    201194
    202     m_end.set(refNode, offset, childNode);
     195    m_end.set(WTFMove(refNode), offset, childNode);
    203196
    204197    if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
    … …  
    209202{
    210203    Position parentAnchored = start.parentAnchoredEquivalent();
    211     setStart(parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), ec);
     204    if (!parentAnchored.containerNode()) {
     205        ec = TypeError;
     206        return;
     207    }
     208    setStart(*parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), ec);
    212209}
    213210
    … …  
    215212{
    216213    Position parentAnchored = end.parentAnchoredEquivalent();
    217     setEnd(parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), ec);
     214    if (!parentAnchored.containerNode()) {
     215        ec = TypeError;
     216        return;
     217    }
     218    setEnd(*parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), ec);
    218219}
    219220
    … …  
    226227}
    227228
    228 bool Range::isPointInRange(Node* refNode, int offset, ExceptionCode& ec)
    229 {
    230     if (!refNode) {
    231         ec = TypeError;
    232         return false;
    233     }
    234 
    235     if (&refNode->document() != &ownerDocument()) {
     229bool Range::isPointInRange(Node& refNode, int offset, ExceptionCode& ec)
     230{
     231    if (&refNode.document() != &ownerDocument()) {
    236232        return false;
    237233    }
    … …  
    242238        // DOM4 spec requires us to check whether refNode and start container have the same root first
    243239        // but we do it in the reverse order to avoid O(n) operation here in common case.
    244         if (!commonAncestorContainer(refNode, &startContainer()))
     240        if (!commonAncestorContainer(&refNode, &startContainer()))
    245241            ec = 0;
    246242        return false;
    247243    }
    248244
    249     bool result = compareBoundaryPoints(refNode, offset, &startContainer(), m_start.offset(), ec) >= 0 && !ec
    250         && compareBoundaryPoints(refNode, offset, &endContainer(), m_end.offset(), ec) <= 0 && !ec;
     245    bool result = compareBoundaryPoints(&refNode, offset, &startContainer(), m_start.offset(), ec) >= 0 && !ec
     246        && compareBoundaryPoints(&refNode, offset, &endContainer(), m_end.offset(), ec) <= 0 && !ec;
    251247    ASSERT(!ec || ec == WRONG_DOCUMENT_ERR);
    252248    ec = 0;
    … …  
    254250}
    255251
    256 short Range::comparePoint(Node* refNode, int offset, ExceptionCode& ec) const
     252short Range::comparePoint(Node& refNode, int offset, ExceptionCode& ec) const
    257253{
    258254    // http://developer.mozilla.org/en/docs/DOM:range.comparePoint
    259255    // This method returns -1, 0 or 1 depending on if the point described by the
    260256    // refNode node and an offset within the node is before, same as, or after the range respectively.
    261 
    262     if (!refNode) {
    263         ec = TypeError;
    264         return 0;
    265     }
    266 
    267     if (&refNode->document() != &ownerDocument()) {
     257    if (&refNode.document() != &ownerDocument()) {
    268258        ec = WRONG_DOCUMENT_ERR;
    269259        return 0;
    … …  
    275265        // DOM4 spec requires us to check whether refNode and start container have the same root first
    276266        // but we do it in the reverse order to avoid O(n) operation here in common case.
    277         if (!refNode->inDocument() && !commonAncestorContainer(refNode, &startContainer()))
     267        if (!refNode.inDocument() && !commonAncestorContainer(&refNode, &startContainer()))
    278268            ec = WRONG_DOCUMENT_ERR;
    279269        return 0;
    … …  
    281271
    282272    // compare to start, and point comes before
    283     if (compareBoundaryPoints(refNode, offset, &startContainer(), m_start.offset(), ec) < 0)
     273    if (compareBoundaryPoints(&refNode, offset, &startContainer(), m_start.offset(), ec) < 0)
    284274        return -1;
    285275
    … …  
    288278
    289279    // compare to end, and point comes after
    290     if (compareBoundaryPoints(refNode, offset, &endContainer(), m_end.offset(), ec) > 0 && !ec)
     280    if (compareBoundaryPoints(&refNode, offset, &endContainer(), m_end.offset(), ec) > 0 && !ec)
    291281        return 1;
    292282
    … …  
    295285}
    296286
    297 Range::CompareResults Range::compareNode(Node* refNode, ExceptionCode& ec) const
     287Range::CompareResults Range::compareNode(Node& refNode, ExceptionCode& ec) const
    298288{
    299289    // http://developer.mozilla.org/en/docs/DOM:range.compareNode
    … …  
    301291    // before and after(surrounds), or inside the range, respectively
    302292
    303     if (!refNode) {
    304         ec = TypeError;
    305         return NODE_BEFORE;
    306     }
    307 
    308     if (!refNode->inDocument()) {
     293    if (!refNode.inDocument()) {
    309294        // Firefox doesn't throw an exception for this case; it returns 0.
    310295        return NODE_BEFORE;
    311296    }
    312297
    313     if (&refNode->document() != &ownerDocument()) {
     298    if (&refNode.document() != &ownerDocument()) {
    314299        // Firefox doesn't throw an exception for this case; it returns 0.
    315300        return NODE_BEFORE;
    316301    }
    317302
    318     ContainerNode* parentNode = refNode->parentNode();
    319     unsigned nodeIndex = refNode->computeNodeIndex();
     303    ContainerNode* parentNode = refNode.parentNode();
     304    unsigned nodeIndex = refNode.computeNodeIndex();
    320305   
    321306    if (!parentNode) {
    … …  
    326311    }
    327312
    328     if (comparePoint(parentNode, nodeIndex, ec) < 0) { // starts before
    329         if (comparePoint(parentNode, nodeIndex + 1, ec) > 0) // ends after the range
     313    // starts before
     314    if (comparePoint(*parentNode, nodeIndex, ec) < 0) {
     315        if (comparePoint(*parentNode, nodeIndex + 1, ec) > 0) // ends after the range
    330316            return NODE_BEFORE_AND_AFTER;
    331317        return NODE_BEFORE; // ends before or in the range
    332     } else { // starts at or after the range start
    333         if (comparePoint(parentNode, nodeIndex + 1, ec) > 0) // ends after the range
    334             return NODE_AFTER;
    335         return NODE_INSIDE; // ends inside the range
    336     }
    337 }
    338 
    339 short Range::compareBoundaryPoints(CompareHow how, const Range* sourceRange, ExceptionCode& ec) const
    340 {
    341     if (!sourceRange) {
    342         ec = TypeError;
    343         return 0;
    344     }
    345 
     318    }
     319    // starts at or after the range start
     320    if (comparePoint(*parentNode, nodeIndex + 1, ec) > 0) // ends after the range
     321        return NODE_AFTER;
     322    return NODE_INSIDE; // ends inside the range
     323}
     324
     325short Range::compareBoundaryPoints(CompareHow how, const Range& sourceRange, ExceptionCode& ec) const
     326{
    346327    Node* thisCont = commonAncestorContainer();
    347     Node* sourceCont = sourceRange->commonAncestorContainer();
     328    Node* sourceCont = sourceRange.commonAncestorContainer();
    348329
    349330    if (&thisCont->document() != &sourceCont->document()) {
    … …  
    365346    switch (how) {
    366347        case START_TO_START:
    367             return compareBoundaryPoints(m_start, sourceRange->m_start, ec);
     348            return compareBoundaryPoints(m_start, sourceRange.m_start, ec);
    368349        case START_TO_END:
    369             return compareBoundaryPoints(m_end, sourceRange->m_start, ec);
     350            return compareBoundaryPoints(m_end, sourceRange.m_start, ec);
    370351        case END_TO_END:
    371             return compareBoundaryPoints(m_end, sourceRange->m_end, ec);
     352            return compareBoundaryPoints(m_end, sourceRange.m_end, ec);
    372353        case END_TO_START:
    373             return compareBoundaryPoints(m_start, sourceRange->m_end, ec);
     354            return compareBoundaryPoints(m_start, sourceRange.m_end, ec);
    374355    }
    375356
    … …  
    378359}
    379360
    380 short Range::compareBoundaryPointsForBindings(unsigned short compareHow, const Range* sourceRange, ExceptionCode& ec) const
     361short Range::compareBoundaryPointsForBindings(unsigned short compareHow, const Range& sourceRange, ExceptionCode& ec) const
    381362{
    382363    if (compareHow > END_TO_START) {
    … …  
    496477}
    497478
    498 bool Range::intersectsNode(Node* refNode, ExceptionCode& ec) const
    499 {
    500     if (!refNode) {
    501         ec = TypeError;
     479bool Range::intersectsNode(Node& refNode, ExceptionCode& ec) const
     480{
     481    if (!refNode.inDocument() || &refNode.document() != &ownerDocument())
    502482        return false;
    503     }
    504 
    505     if (!refNode->inDocument() || &refNode->document() != &ownerDocument())
    506         return false;
    507 
    508     ContainerNode* parentNode = refNode->parentNode();
     483
     484    ContainerNode* parentNode = refNode.parentNode();
    509485    if (!parentNode)
    510486        return true;
    511487
    512     unsigned nodeIndex = refNode->computeNodeIndex();
     488    unsigned nodeIndex = refNode.computeNodeIndex();
    513489
    514490    // If (parent, offset) is before end and (parent, offset + 1) is after start, return true.
    515491    // Otherwise, return false.
    516     short compareFirst = comparePoint(parentNode, nodeIndex, ec);
    517     short compareSecond = comparePoint(parentNode, nodeIndex + 1, ec);
     492    short compareFirst = comparePoint(*parentNode, nodeIndex, ec);
     493    short compareSecond = comparePoint(*parentNode, nodeIndex + 1, ec);
    518494
    519495    bool isFirstBeforeEnd = m_start == m_end ? compareFirst < 0 : compareFirst <= 0;
    … …  
    646622    if (action == Extract || action == Delete) {
    647623        if (partialStart && commonRoot->contains(partialStart.get()))
    648             setStart(partialStart->parentNode(), partialStart->computeNodeIndex() + 1, ec);
     624            setStart(*partialStart->parentNode(), partialStart->computeNodeIndex() + 1, ec);
    649625        else if (partialEnd && commonRoot->contains(partialEnd.get()))
    650             setStart(partialEnd->parentNode(), partialEnd->computeNodeIndex(), ec);
     626            setStart(*partialEnd->parentNode(), partialEnd->computeNodeIndex(), ec);
    651627        if (ec)
    652628            return nullptr;
    … …  
    837813}
    838814
    839 void Range::insertNode(RefPtr<Node>&& node, ExceptionCode& ec)
    840 {
    841     if (!node) {
    842         ec = TypeError;
    843         return;
    844     }
    845 
     815void Range::insertNode(Ref<Node>&& node, ExceptionCode& ec)
     816{
    846817    bool startIsCharacterData = is<CharacterData>(startContainer());
    847818    if (startIsCharacterData && !startContainer().parentNode()) {
    … …  
    860831
    861832    ec = 0;
    862     if (!parent->ensurePreInsertionValidity(*node, referenceNode.get(), ec))
     833    if (!parent->ensurePreInsertionValidity(node, referenceNode.get(), ec))
    863834        return;
    864835
    … …  
    870841    }
    871842
    872     if (referenceNode == node)
     843    if (referenceNode == node.ptr())
    873844        referenceNode = referenceNode->nextSibling();
    874845
    … …  
    878849
    879850    unsigned newOffset = referenceNode ? referenceNode->computeNodeIndex() : parent->countChildNodes();
    880     if (is<DocumentFragment>(*node))
    881         newOffset += downcast<DocumentFragment>(*node).countChildNodes();
     851    if (is<DocumentFragment>(node.get()))
     852        newOffset += downcast<DocumentFragment>(node.get()).countChildNodes();
    882853    else
    883854        ++newOffset;
    884855
    885     parent->insertBefore(node.releaseNonNull(), referenceNode.get(), ec);
     856    parent->insertBefore(WTFMove(node), referenceNode.get(), ec);
    886857    if (ec)
    887858        return;
    888859
    889860    if (collapsed())
    890         setEnd(parent.ptr(), newOffset, ec);
     861        setEnd(WTFMove(parent), newOffset, ec);
    891862}
    892863
    … …  
    951922}
    952923
    953 Node* Range::checkNodeWOffset(Node* n, int offset, ExceptionCode& ec) const
    954 {
    955     switch (n->nodeType()) {
     924Node* Range::checkNodeWOffset(Node& node, int offset, ExceptionCode& ec) const
     925{
     926    switch (node.nodeType()) {
    956927        case Node::DOCUMENT_TYPE_NODE:
    957928            ec = INVALID_NODE_TYPE_ERR;
    … …  
    961932        case Node::TEXT_NODE:
    962933        case Node::PROCESSING_INSTRUCTION_NODE:
    963             if (static_cast<unsigned>(offset) > downcast<CharacterData>(*n).length())
     934            if (static_cast<unsigned>(offset) > downcast<CharacterData>(node).length())
    964935                ec = INDEX_SIZE_ERR;
    965936            return nullptr;
    … …  
    970941            if (!offset)
    971942                return nullptr;
    972             Node* childBefore = n->traverseToChildAt(offset - 1);
     943            Node* childBefore = node.traverseToChildAt(offset - 1);
    973944            if (!childBefore)
    974945                ec = INDEX_SIZE_ERR;
    … …  
    985956}
    986957
    987 void Range::setStartAfter(Node* refNode, ExceptionCode& ec)
    988 {
    989     if (!refNode) {
    990         ec = TypeError;
    991         return;
    992     }
    993 
    994     if (!refNode->parentNode()) {
     958void Range::setStartAfter(Node& refNode, ExceptionCode& ec)
     959{
     960    if (!refNode.parentNode()) {
    995961        ec = INVALID_NODE_TYPE_ERR;
    996962        return;
    997963    }
    998964
    999     setStart(refNode->parentNode(), refNode->computeNodeIndex() + 1, ec);
    1000 }
    1001 
    1002 void Range::setEndBefore(Node* refNode, ExceptionCode& ec)
    1003 {
    1004     if (!refNode) {
    1005         ec = TypeError;
    1006         return;
    1007     }
    1008 
    1009     if (!refNode->parentNode()) {
     965    setStart(*refNode.parentNode(), refNode.computeNodeIndex() + 1, ec);
     966}
     967
     968void Range::setEndBefore(Node& refNode, ExceptionCode& ec)
     969{
     970    if (!refNode.parentNode()) {
    1010971        ec = INVALID_NODE_TYPE_ERR;
    1011972        return;
    1012973    }
    1013974
    1014     setEnd(refNode->parentNode(), refNode->computeNodeIndex(), ec);
    1015 }
    1016 
    1017 void Range::setEndAfter(Node* refNode, ExceptionCode& ec)
    1018 {
    1019     if (!refNode) {
    1020         ec = TypeError;
    1021         return;
    1022     }
    1023 
    1024     if (!refNode->parentNode()) {
     975    setEnd(*refNode.parentNode(), refNode.computeNodeIndex(), ec);
     976}
     977
     978void Range::setEndAfter(Node& refNode, ExceptionCode& ec)
     979{
     980    if (!refNode.parentNode()) {
    1025981        ec = INVALID_NODE_TYPE_ERR;
    1026982        return;
    1027983    }
    1028984
    1029     setEnd(refNode->parentNode(), refNode->computeNodeIndex() + 1, ec);
    1030 }
    1031 
    1032 void Range::selectNode(Node* refNode, ExceptionCode& ec)
    1033 {
    1034     if (!refNode) {
    1035         ec = TypeError;
    1036         return;
    1037     }
    1038 
    1039     if (!refNode->parentNode()) {
     985    setEnd(*refNode.parentNode(), refNode.computeNodeIndex() + 1, ec);
     986}
     987
     988void Range::selectNode(Node& refNode, ExceptionCode& ec)
     989{
     990    if (!refNode.parentNode()) {
    1040991        ec = INVALID_NODE_TYPE_ERR;
    1041992        return;
    1042993    }
    1043994
    1044     if (&ownerDocument() != &refNode->document())
    1045         setDocument(refNode->document());
    1046 
    1047     unsigned index = refNode->computeNodeIndex();
     995    if (&ownerDocument() != &refNode.document())
     996        setDocument(refNode.document());
     997
     998    unsigned index = refNode.computeNodeIndex();
    1048999    ec = 0;
    1049     setStart(refNode->parentNode(), index, ec);
     1000    setStart(*refNode.parentNode(), index, ec);
    10501001    if (ec)
    10511002        return;
    1052     setEnd(refNode->parentNode(), index + 1, ec);
    1053 }
    1054 
    1055 void Range::selectNodeContents(Node* refNode, ExceptionCode& ec)
    1056 {
    1057     if (!refNode) {
    1058         ec = TypeError;
    1059         return;
    1060     }
    1061 
    1062     if (refNode->isDocumentTypeNode()) {
     1003    setEnd(*refNode.parentNode(), index + 1, ec);
     1004}
     1005
     1006void Range::selectNodeContents(Node& refNode, ExceptionCode& ec)
     1007{
     1008    if (refNode.isDocumentTypeNode()) {
    10631009        ec = INVALID_NODE_TYPE_ERR;
    10641010        return;
    10651011    }
    10661012
    1067     if (&ownerDocument() != &refNode->document())
    1068         setDocument(refNode->document());
     1013    if (&ownerDocument() != &refNode.document())
     1014        setDocument(refNode.document());
    10691015
    10701016    m_start.setToStartOfNode(refNode);
    … …  
    10721018}
    10731019
    1074 void Range::surroundContents(PassRefPtr<Node> passNewParent, ExceptionCode& ec)
    1075 {
    1076     RefPtr<Node> newParent = passNewParent;
    1077 
    1078     if (!newParent) {
    1079         ec = TypeError;
    1080         return;
    1081     }
     1020void Range::surroundContents(Node& passNewParent, ExceptionCode& ec)
     1021{
     1022    Ref<Node> newParent = passNewParent;
    10821023
    10831024    // INVALID_STATE_ERR: Raised if the Range partially selects a non-Text node.
    … …  
    11341075    ec = 0;
    11351076    while (Node* n = newParent->firstChild()) {
    1136         downcast<ContainerNode>(*newParent).removeChild(*n, ec);
     1077        downcast<ContainerNode>(newParent.get()).removeChild(*n, ec);
    11371078        if (ec)
    11381079            return;
    … …  
    11471088    if (ec)
    11481089        return;
    1149     selectNode(newParent.get(), ec);
    1150 }
    1151 
    1152 void Range::setStartBefore(Node* refNode, ExceptionCode& ec)
    1153 {
    1154     if (!refNode) {
    1155         ec = TypeError;
    1156         return;
    1157     }
    1158 
    1159     if (!refNode->parentNode()) {
     1090    selectNode(newParent, ec);
     1091}
     1092
     1093void Range::setStartBefore(Node& refNode, ExceptionCode& ec)
     1094{
     1095    if (!refNode.parentNode()) {
    11601096        ec = INVALID_NODE_TYPE_ERR;
    11611097        return;
    11621098    }
    11631099
    1164     setStart(refNode->parentNode(), refNode->computeNodeIndex(), ec);
     1100    setStart(*refNode.parentNode(), refNode.computeNodeIndex(), ec);
    11651101}
    11661102
    … …  
    15401476        return false;
    15411477
    1542     short startToStart = compareBoundaryPoints(Range::START_TO_START, &other, ASSERT_NO_EXCEPTION);
     1478    short startToStart = compareBoundaryPoints(Range::START_TO_START, other, ASSERT_NO_EXCEPTION);
    15431479    if (startToStart > 0)
    15441480        return false;
    15451481
    1546     short endToEnd = compareBoundaryPoints(Range::END_TO_END, &other, ASSERT_NO_EXCEPTION);
     1482    short endToEnd = compareBoundaryPoints(Range::END_TO_END, other, ASSERT_NO_EXCEPTION);
    15471483    return endToEnd >= 0;
    15481484}
    … …  
    15761512        return false;
    15771513
    1578     short startToStart = a->compareBoundaryPoints(Range::START_TO_START, b, ASSERT_NO_EXCEPTION);
    1579     short endToEnd = a->compareBoundaryPoints(Range::END_TO_END, b, ASSERT_NO_EXCEPTION);
     1514    short startToStart = a->compareBoundaryPoints(Range::START_TO_START, *b, ASSERT_NO_EXCEPTION);
     1515    short endToEnd = a->compareBoundaryPoints(Range::END_TO_END, *b, ASSERT_NO_EXCEPTION);
    15801516
    15811517    // First range contains the second range.
    … …  
    15841520
    15851521    // End of first range is inside second range.
    1586     if (a->compareBoundaryPoints(Range::START_TO_END, b, ASSERT_NO_EXCEPTION) >= 0 && endToEnd <= 0)
     1522    if (a->compareBoundaryPoints(Range::START_TO_END, *b, ASSERT_NO_EXCEPTION) >= 0 && endToEnd <= 0)
    15871523        return true;
    15881524
    15891525    // Start of first range is inside second range.
    1590     if (startToStart >= 0 && a->compareBoundaryPoints(Range::END_TO_START, b, ASSERT_NO_EXCEPTION) <= 0)
     1526    if (startToStart >= 0 && a->compareBoundaryPoints(Range::END_TO_START, *b, ASSERT_NO_EXCEPTION) <= 0)
    15911527        return true;
    15921528
    … …  
    15981534    Ref<Range> range = Range::create(node.document());
    15991535    int exception = 0;
    1600     range->selectNodeContents(&node, exception);
     1536    range->selectNodeContents(node, exception);
    16011537    return range;
    16021538}
    … …  
    16221558    for (Node* nodeToBeRemoved = container.firstChild(); nodeToBeRemoved; nodeToBeRemoved = nodeToBeRemoved->nextSibling()) {
    16231559        if (boundary.childBefore() == nodeToBeRemoved) {
    1624             boundary.setToStartOfNode(&container);
     1560            boundary.setToStartOfNode(container);
    16251561            return;
    16261562        }
    … …  
    16281564        for (Node* n = boundary.container(); n; n = n->parentNode()) {
    16291565            if (n == nodeToBeRemoved) {
    1630                 boundary.setToStartOfNode(&container);
     1566                boundary.setToStartOfNode(container);
    16311567                return;
    16321568            }
    … …  
    17081644{
    17091645    if (boundary.container() == oldNode.node())
    1710         boundary.set(oldNode.node()->previousSibling(), boundary.offset() + offset, 0);
     1646        boundary.set(*oldNode.node()->previousSibling(), boundary.offset() + offset, 0);
    17111647    else if (boundary.container() == oldNode.node()->parentNode() && boundary.offset() == oldNode.index())
    1712         boundary.set(oldNode.node()->previousSibling(), offset, 0);
     1648        boundary.set(*oldNode.node()->previousSibling(), offset, 0);
    17131649}
    17141650
    … …  
    17311667        unsigned boundaryOffset = boundary.offset();
    17321668        if (boundaryOffset > splitOffset)
    1733             boundary.set(oldNode->nextSibling(), boundaryOffset - splitOffset, 0);
     1669            boundary.set(*oldNode->nextSibling(), boundaryOffset - splitOffset, 0);
    17341670        return;
    17351671    }
    … …  
    17721708    } else
    17731709        return;
    1774     setStart(start.deepEquivalent().containerNode(), start.deepEquivalent().computeOffsetInContainerNode(), ec);
    1775     setEnd(end.deepEquivalent().containerNode(), end.deepEquivalent().computeOffsetInContainerNode(), ec);
     1710
     1711    if (!start.deepEquivalent().containerNode()) {
     1712        ec = TypeError;
     1713        return;
     1714    }
     1715    setStart(*start.deepEquivalent().containerNode(), start.deepEquivalent().computeOffsetInContainerNode(), ec);
     1716    if (!end.deepEquivalent().containerNode()) {
     1717        ec = TypeError;
     1718        return;
     1719    }
     1720    setEnd(*end.deepEquivalent().containerNode(), end.deepEquivalent().computeOffsetInContainerNode(), ec);
    17761721}
    17771722

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

    r198997 r199817  
    6767    Node* commonAncestorContainer() const { return commonAncestorContainer(&startContainer(), &endContainer()); }
    6868    WEBCORE_EXPORT static Node* commonAncestorContainer(Node* containerA, Node* containerB);
    69     WEBCORE_EXPORT void setStart(PassRefPtr<Node> container, int offset, ExceptionCode& = ASSERT_NO_EXCEPTION);
    70     WEBCORE_EXPORT void setEnd(PassRefPtr<Node> container, int offset, ExceptionCode& = ASSERT_NO_EXCEPTION);
     69    WEBCORE_EXPORT void setStart(Ref<Node>&& container, int offset, ExceptionCode& = ASSERT_NO_EXCEPTION);
     70    WEBCORE_EXPORT void setEnd(Ref<Node>&& container, int offset, ExceptionCode& = ASSERT_NO_EXCEPTION);
    7171    WEBCORE_EXPORT void collapse(bool toStart);
    72     WEBCORE_EXPORT bool isPointInRange(Node* refNode, int offset, ExceptionCode&);
    73     short comparePoint(Node* refNode, int offset, ExceptionCode&) const;
     72    WEBCORE_EXPORT bool isPointInRange(Node& refNode, int offset, ExceptionCode&);
     73    short comparePoint(Node& refNode, int offset, ExceptionCode&) const;
    7474    enum CompareResults { NODE_BEFORE, NODE_AFTER, NODE_BEFORE_AND_AFTER, NODE_INSIDE };
    75     CompareResults compareNode(Node* refNode, ExceptionCode&) const;
     75    CompareResults compareNode(Node& refNode, ExceptionCode&) const;
    7676    enum CompareHow { START_TO_START, START_TO_END, END_TO_END, END_TO_START };
    77     WEBCORE_EXPORT short compareBoundaryPoints(CompareHow, const Range* sourceRange, ExceptionCode&) const;
    78     short compareBoundaryPointsForBindings(unsigned short compareHow, const Range* sourceRange, ExceptionCode&) const;
     77    WEBCORE_EXPORT short compareBoundaryPoints(CompareHow, const Range& sourceRange, ExceptionCode&) const;
     78    short compareBoundaryPointsForBindings(unsigned short compareHow, const Range& sourceRange, ExceptionCode&) const;
    7979    static short compareBoundaryPoints(Node* containerA, int offsetA, Node* containerB, int offsetB, ExceptionCode&);
    8080    static short compareBoundaryPoints(const RangeBoundaryPoint& boundaryA, const RangeBoundaryPoint& boundaryB, ExceptionCode&);
    8181    WEBCORE_EXPORT bool boundaryPointsValid() const;
    82     bool intersectsNode(Node* refNode, ExceptionCode&) const;
     82    bool intersectsNode(Node& refNode, ExceptionCode&) const;
    8383    void deleteContents(ExceptionCode&);
    8484    RefPtr<DocumentFragment> extractContents(ExceptionCode&);
    8585    RefPtr<DocumentFragment> cloneContents(ExceptionCode&);
    86     void insertNode(RefPtr<Node>&&, ExceptionCode&);
     86    void insertNode(Ref<Node>&&, ExceptionCode&);
    8787    String toString() const;
    8888
    … …  
    9595    WEBCORE_EXPORT Ref<Range> cloneRange() const;
    9696
    97     WEBCORE_EXPORT void setStartAfter(Node*, ExceptionCode& = ASSERT_NO_EXCEPTION);
    98     WEBCORE_EXPORT void setEndBefore(Node*, ExceptionCode& = ASSERT_NO_EXCEPTION);
    99     WEBCORE_EXPORT void setEndAfter(Node*, ExceptionCode& = ASSERT_NO_EXCEPTION);
    100     WEBCORE_EXPORT void selectNode(Node*, ExceptionCode& = ASSERT_NO_EXCEPTION);
    101     WEBCORE_EXPORT void selectNodeContents(Node*, ExceptionCode&);
    102     void surroundContents(PassRefPtr<Node>, ExceptionCode&);
    103     WEBCORE_EXPORT void setStartBefore(Node*, ExceptionCode&);
     97    WEBCORE_EXPORT void setStartAfter(Node&, ExceptionCode& = ASSERT_NO_EXCEPTION);
     98    WEBCORE_EXPORT void setEndBefore(Node&, ExceptionCode& = ASSERT_NO_EXCEPTION);
     99    WEBCORE_EXPORT void setEndAfter(Node&, ExceptionCode& = ASSERT_NO_EXCEPTION);
     100    WEBCORE_EXPORT void selectNode(Node&, ExceptionCode& = ASSERT_NO_EXCEPTION);
     101    WEBCORE_EXPORT void selectNodeContents(Node&, ExceptionCode&);
     102    void surroundContents(Node&, ExceptionCode&);
     103    WEBCORE_EXPORT void setStartBefore(Node&, ExceptionCode&);
    104104
    105105    const Position startPosition() const { return m_start.toPosition(); }
    … …  
    160160    void setDocument(Document&);
    161161
    162     Node* checkNodeWOffset(Node*, int offset, ExceptionCode&) const;
     162    Node* checkNodeWOffset(Node&, int offset, ExceptionCode&) const;
    163163
    164164    enum ActionType { Delete, Extract, Clone };

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

    r199264 r199817  
    2323    Constructor,
    2424    ConstructorCallWith=Document,
    25     UsePointersEvenForNonNullableObjectArguments,
    2625    ImplementationLacksVTable,
    2726    ExportMacro=WEBCORE_EXPORT,

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

    r195927 r199817  
    4646    void clear();
    4747
    48     void set(PassRefPtr<Node> container, int offset, Node* childBefore);
     48    void set(Ref<Node>&& container, int offset, Node* childBefore);
    4949    void setOffset(int offset);
    5050
    5151    void setToBeforeChild(Node&);
    5252    void setToAfterChild(Node&);
    53     void setToStartOfNode(PassRefPtr<Node>);
    54     void setToEndOfNode(PassRefPtr<Node>);
     53    void setToStartOfNode(Ref<Node>&&);
     54    void setToEndOfNode(Ref<Node>&&);
    5555
    5656    void childBeforeWillBeRemoved();
    … …  
    117117}
    118118
    119 inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node* childBefore)
    120 {
    121     ASSERT(container);
     119inline void RangeBoundaryPoint::set(Ref<Node>&& container, int offset, Node* childBefore)
     120{
    122121    ASSERT(offset >= 0);
    123122    ASSERT(childBefore == (offset ? container->traverseToChildAt(offset - 1) : 0));
    124     m_containerNode = container;
     123    m_containerNode = WTFMove(container);
    125124    m_offsetInContainer = offset;
    126125    m_childBeforeBoundary = childBefore;
    … …  
    152151}
    153152
    154 inline void RangeBoundaryPoint::setToStartOfNode(PassRefPtr<Node> container)
    155 {
    156     ASSERT(container);
    157     m_containerNode = container;
     153inline void RangeBoundaryPoint::setToStartOfNode(Ref<Node>&& container)
     154{
     155    m_containerNode = WTFMove(container);
    158156    m_offsetInContainer = 0;
    159157    m_childBeforeBoundary = nullptr;
    160158}
    161159
    162 inline void RangeBoundaryPoint::setToEndOfNode(PassRefPtr<Node> container)
    163 {
    164     ASSERT(container);
    165     m_containerNode = container;
     160inline void RangeBoundaryPoint::setToEndOfNode(Ref<Node>&& container)
     161{
     162    m_containerNode = WTFMove(container);
    166163    if (m_containerNode->offsetInCharacters()) {
    167164        m_offsetInContainer = m_containerNode->maxCharacterOffset();

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

    r199807 r199817  
    259259    Position startPositionOfRangeWithAlternative = range->startPosition();
    260260    ExceptionCode ec = 0;
    261     correctionStartOffsetInParagraphAsRange->setEnd(startPositionOfRangeWithAlternative.containerNode(), startPositionOfRangeWithAlternative.computeOffsetInContainerNode(), ec);
     261    if (!startPositionOfRangeWithAlternative.containerNode())
     262        return;
     263    correctionStartOffsetInParagraphAsRange->setEnd(*startPositionOfRangeWithAlternative.containerNode(), startPositionOfRangeWithAlternative.computeOffsetInContainerNode(), ec);
    262264    if (ec)
    263265        return;

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

    r194819 r199817  
    723723    Element* editableRoot = startNode->rootEditableElement();
    724724    if (startNode != editableRoot) {
    725         while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(startNode->parentNode(), range.get()))
     725        while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(*startNode->parentNode(), range.get()))
    726726            startNode = startNode->parentNode();
    727727    }

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

    r199030 r199817  
    420420    ExceptionCode ec;   
    421421    RefPtr<Range> context = document().createRange();
    422     context->selectNodeContents(&element, ec);
     422    context->selectNodeContents(element, ec);
    423423
    424424    StringBuilder dictationPhrasesBuilder;
    … …  
    628628           
    629629        RefPtr<Range> context = document().createRange();
    630         context->selectNodeContents(elem, ec);
     630        context->selectNodeContents(*elem, ec);
    631631        Ref<DocumentFragment> fragment = createFragmentFromText(*context.get(), text);
    632632        elem->appendChild(WTFMove(fragment), ec);
    … …  
    19511951       
    19521952        Position rangeCompliantPosition = position.parentAnchoredEquivalent();
    1953         spellingSearchRange->setStart(rangeCompliantPosition.deprecatedNode(), rangeCompliantPosition.deprecatedEditingOffset(), IGNORE_EXCEPTION);
     1953        if (rangeCompliantPosition.deprecatedNode())
     1954            spellingSearchRange->setStart(*rangeCompliantPosition.deprecatedNode(), rangeCompliantPosition.deprecatedEditingOffset(), IGNORE_EXCEPTION);
    19541955        startedWithSelection = false; // won't need to wrap
    19551956    }
    … …  
    19581959    Node* topNode = highestEditableRoot(position);
    19591960    // FIXME: lastOffsetForEditing() is wrong here if editingIgnoresContent(highestEditableRoot()) returns true (e.g. a <table>)
    1960     spellingSearchRange->setEnd(topNode, lastOffsetForEditing(topNode), IGNORE_EXCEPTION);
     1961    if (topNode)
     1962        spellingSearchRange->setEnd(*topNode, lastOffsetForEditing(topNode), IGNORE_EXCEPTION);
    19611963
    19621964    // If spellingSearchRange starts in the middle of a word, advance to the next word so we start checking
    … …  
    20122014            CharacterIterator chars(*grammarSearchRange);
    20132015            chars.advance(misspellingOffset);
    2014             grammarSearchRange->setEnd(&chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION);
     2016            grammarSearchRange->setEnd(chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION);
    20152017        }
    20162018   
    … …  
    20232025    // block rather than at a selection).
    20242026    if (startedWithSelection && !misspelledWord && !badGrammarPhrase) {
    2025         spellingSearchRange->setStart(topNode, 0, IGNORE_EXCEPTION);
     2027        if (topNode)
     2028            spellingSearchRange->setStart(*topNode, 0, IGNORE_EXCEPTION);
    20262029        // going until the end of the very first chunk we tested is far enough
    2027         spellingSearchRange->setEnd(&searchEndNodeAfterWrap, searchEndOffsetAfterWrap, IGNORE_EXCEPTION);
     2030        spellingSearchRange->setEnd(searchEndNodeAfterWrap, searchEndOffsetAfterWrap, IGNORE_EXCEPTION);
    20282031       
    20292032        if (unifiedTextCheckerEnabled()) {
    … …  
    20462049                CharacterIterator chars(*grammarSearchRange);
    20472050                chars.advance(misspellingOffset);
    2048                 grammarSearchRange->setEnd(&chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION);
     2051                grammarSearchRange->setEnd(chars.range()->startContainer(), chars.range()->startOffset(), IGNORE_EXCEPTION);
    20492052            }
    20502053
    … …  
    31693172    if (shadowTreeRoot) {
    31703173        if (forward)
    3171             searchRange->setEnd(shadowTreeRoot.get(), shadowTreeRoot->countChildNodes());
     3174            searchRange->setEnd(*shadowTreeRoot, shadowTreeRoot->countChildNodes());
    31723175        else
    3173             searchRange->setStart(shadowTreeRoot.get(), 0);
     3176            searchRange->setStart(*shadowTreeRoot, 0);
    31743177    }
    31753178
    … …  
    31873190        if (shadowTreeRoot) {
    31883191            if (forward)
    3189                 searchRange->setEnd(shadowTreeRoot.get(), shadowTreeRoot->countChildNodes());
     3192                searchRange->setEnd(*shadowTreeRoot, shadowTreeRoot->countChildNodes());
    31903193            else
    3191                 searchRange->setStart(shadowTreeRoot.get(), 0);
     3194                searchRange->setStart(*shadowTreeRoot, 0);
    31923195        }
    31933196
    … …  
    31983201    if (resultRange->collapsed() && shadowTreeRoot) {
    31993202        searchRange = rangeOfContents(document());
    3200         if (forward)
    3201             searchRange->setStartAfter(shadowTreeRoot->shadowHost());
    3202         else
    3203             searchRange->setEndBefore(shadowTreeRoot->shadowHost());
     3203        if (shadowTreeRoot->shadowHost()) {
     3204            if (forward)
     3205                searchRange->setStartAfter(*shadowTreeRoot->shadowHost());
     3206            else
     3207                searchRange->setEndBefore(*shadowTreeRoot->shadowHost());
     3208        }
    32043209
    32053210        resultRange = findPlainText(*searchRange, target, options);
    … …  
    32243229    for (HTMLFrameOwnerElement* ownerElement = frame->ownerElement(); ownerElement; ownerElement = ownerElement->document().ownerElement()) {
    32253230        if (&ownerElement->document() == &range->ownerDocument()) {
    3226             inRange = range->intersectsNode(ownerElement, IGNORE_EXCEPTION);
     3231            inRange = range->intersectsNode(*ownerElement, IGNORE_EXCEPTION);
    32273232            break;
    32283233        }
    … …  
    32563261                break;
    32573262
    3258             searchRange->setStartAfter(resultRange->startContainer().shadowHost(), IGNORE_EXCEPTION);
    3259             searchRange->setEnd(&originalEndContainer, originalEndOffset, IGNORE_EXCEPTION);
     3263            searchRange->setStartAfter(*resultRange->startContainer().shadowHost(), IGNORE_EXCEPTION);
     3264            searchRange->setEnd(originalEndContainer, originalEndOffset, IGNORE_EXCEPTION);
    32603265            continue;
    32613266        }
    … …  
    32763281        // since findPlainText will use a TextIterator to go over the visible
    32773282        // text nodes.
    3278         searchRange->setStart(&resultRange->endContainer(), resultRange->endOffset(), IGNORE_EXCEPTION);
     3283        searchRange->setStart(resultRange->endContainer(), resultRange->endOffset(), IGNORE_EXCEPTION);
    32793284
    32803285        Node* shadowTreeRoot = searchRange->shadowRoot();
    32813286        if (searchRange->collapsed() && shadowTreeRoot)
    3282             searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->countChildNodes(), IGNORE_EXCEPTION);
     3287            searchRange->setEnd(*shadowTreeRoot, shadowTreeRoot->countChildNodes(), IGNORE_EXCEPTION);
    32833288    } while (true);
    32843289

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

    r198354 r199817  
    229229}
    230230
    231 static RefPtr<Range> unionDOMRanges(Range* a, Range* b)
    232 {
    233     Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ASSERT_NO_EXCEPTION) <= 0 ? a : b;
    234     Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ASSERT_NO_EXCEPTION) <= 0 ? b : a;
    235 
    236     return Range::create(a->ownerDocument(), &start->startContainer(), start->startOffset(), &end->endContainer(), end->endOffset());
     231static RefPtr<Range> unionDOMRanges(Range& a, Range& b)
     232{
     233    Range& start = a.compareBoundaryPoints(Range::START_TO_START, b, ASSERT_NO_EXCEPTION) <= 0 ? a : b;
     234    Range& end = a.compareBoundaryPoints(Range::END_TO_END, b, ASSERT_NO_EXCEPTION) <= 0 ? b : a;
     235    return Range::create(a.ownerDocument(), &start.startContainer(), start.startOffset(), &end.endContainer(), end.endOffset());
    237236}
    238237
    … …  
    357356    RefPtr<Range> mark = frame.editor().mark().toNormalizedRange();
    358357    FrameSelection& selection = frame.selection();
    359     if (mark) {
    360         bool selected = selection.setSelectedRange(unionDOMRanges(mark.get(), frame.editor().selectedRange().get()).get(), DOWNSTREAM, true);
     358    if (mark && frame.editor().selectedRange()) {
     359        bool selected = selection.setSelectedRange(unionDOMRanges(*mark, *frame.editor().selectedRange()).get(), DOWNSTREAM, true);
    361360        ASSERT(selected);
    362361        if (!selected)
    … …  
    10111010        return false;
    10121011    }
    1013     frame.selection().setSelectedRange(unionDOMRanges(mark.get(), selection.get()).get(), DOWNSTREAM, true);
     1012    frame.selection().setSelectedRange(unionDOMRanges(*mark, *selection).get(), DOWNSTREAM, true);
    10141013    return true;
    10151014}

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

    r189182 r199817  
    7474        return;
    7575    if (isElementForFormatBlock(refNode->tagQName()) && start == startOfBlock(start)
    76         && (end == endOfBlock(end) || isNodeVisiblyContainedWithin(refNode, range.get()))
     76        && (end == endOfBlock(end) || isNodeVisiblyContainedWithin(*refNode, range.get()))
    7777        && refNode != root && !root->isDescendantOf(refNode)) {
    7878        // Already in a block element that only contains the current paragraph

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

    r199334 r199817  
    475475    } else if (RefPtr<Range> range = m_selection.firstRange()) {
    476476        ExceptionCode ec = 0;
    477         Range::CompareResults compareResult = range->compareNode(&node, ec);
     477        Range::CompareResults compareResult = range->compareNode(node, ec);
    478478        if (!ec && (compareResult == Range::NODE_BEFORE_AND_AFTER || compareResult == Range::NODE_INSIDE)) {
    479479            // If we did nothing here, when this node's renderer was destroyed, the rect that it
    … …  
    26062606}
    26072607
    2608 void FrameSelection::selectRangeOnElement(unsigned location, unsigned length, Node* node)
     2608void FrameSelection::selectRangeOnElement(unsigned location, unsigned length, Node& node)
    26092609{
    26102610    RefPtr<Range> resultRange = m_frame->document()->createRange();

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

    r198177 r199817  
    231231    WEBCORE_EXPORT PassRefPtr<Range> rangeByMovingCurrentSelection(int amount) const;
    232232    WEBCORE_EXPORT PassRefPtr<Range> rangeByExtendingCurrentSelection(int amount) const;
    233     WEBCORE_EXPORT void selectRangeOnElement(unsigned location, unsigned length, Node*);
     233    WEBCORE_EXPORT void selectRangeOnElement(unsigned location, unsigned length, Node&);
    234234    WEBCORE_EXPORT void clearCurrentSelection();
    235235    void setCaretBlinks(bool caretBlinks = true);

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

    r191605 r199817  
    221221
    222222        // If the entire list is selected, then convert the whole list.
    223         if (switchListType && isNodeVisiblyContainedWithin(listNode.get(), currentSelection)) {
     223        if (switchListType && isNodeVisiblyContainedWithin(*listNode, currentSelection)) {
    224224            bool rangeStartIsInList = visiblePositionBeforeNode(listNode.get()) == currentSelection->startPosition();
    225225            bool rangeEndIsInList = visiblePositionAfterNode(listNode.get()) == currentSelection->endPosition();
    … …  
    244244            // because moveParagraphWithClones could have removed them.
    245245            if (rangeStartIsInList && newList)
    246                 currentSelection->setStart(newList, 0, IGNORE_EXCEPTION);
     246                currentSelection->setStart(*newList, 0, IGNORE_EXCEPTION);
    247247            if (rangeEndIsInList && newList)
    248                 currentSelection->setEnd(newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION);
     248                currentSelection->setEnd(*newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION);
    249249
    250250            setEndingSelection(VisiblePosition(firstPositionInNode(newList.get())));

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

    r198306 r199817  
    175175{
    176176    ASSERT(m_checkingRange);
     177    if (!position.containerNode()) {
     178        ec = TypeError;
     179        return 0;
     180    }
     181
    177182    Ref<Range> range = offsetAsRange()->cloneRange();
    178     range->setEnd(position.containerNode(), position.computeOffsetInContainerNode(), ec);
     183    range->setEnd(*position.containerNode(), position.computeOffsetInContainerNode(), ec);
    179184    if (ec)
    180185        return 0;

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

    r195452 r199817  
    14801480            ASSERT(&node == &range->endContainer());
    14811481            int offset = range->startOffset() + m_runOffset;
    1482             range->setStart(&node, offset);
    1483             range->setEnd(&node, offset + 1);
     1482            range->setStart(node, offset);
     1483            range->setEnd(node, offset + 1);
    14841484        }
    14851485    }
    … …  
    15701570            ASSERT(&node == &r->endContainer());
    15711571            int offset = r->endOffset() - m_runOffset;
    1572             r->setStart(&node, offset - 1);
    1573             r->setEnd(&node, offset);
     1572            r->setStart(node, offset - 1);
     1573            r->setEnd(node, offset);
    15741574        }
    15751575    }
    … …  
    24802480    // FIXME: the atEnd() check shouldn't be necessary, workaround for <http://bugs.webkit.org/show_bug.cgi?id=6289>.
    24812481    if (!rangeLocation && !rangeLength && it.atEnd()) {
    2482         resultRange->setStart(&textRunRange->startContainer(), 0);
    2483         resultRange->setEnd(&textRunRange->startContainer(), 0);
     2482        resultRange->setStart(textRunRange->startContainer(), 0);
     2483        resultRange->setEnd(textRunRange->startContainer(), 0);
    24842484        return WTFMove(resultRange);
    24852485    }
    … …  
    24992499                if (!it.atEnd()) {
    25002500                    Ref<Range> range = it.range();
    2501                     textRunRange->setEnd(&range->startContainer(), range->startOffset());
     2501                    textRunRange->setEnd(range->startContainer(), range->startOffset());
    25022502                } else {
    25032503                    Position runStart = textRunRange->startPosition();
    25042504                    Position runEnd = VisiblePosition(runStart).next().deepEquivalent();
    25052505                    if (runEnd.isNotNull())
    2506                         textRunRange->setEnd(runEnd.containerNode(), runEnd.computeOffsetInContainerNode());
     2506                        textRunRange->setEnd(*runEnd.containerNode(), runEnd.computeOffsetInContainerNode());
    25072507                }
    25082508            }
    … …  
    25132513            if (textRunRange->startContainer().isTextNode()) {
    25142514                int offset = rangeLocation - docTextPosition;
    2515                 resultRange->setStart(&textRunRange->startContainer(), offset + textRunRange->startOffset());
     2515                resultRange->setStart(textRunRange->startContainer(), offset + textRunRange->startOffset());
    25162516            } else {
    25172517                if (rangeLocation == docTextPosition)
    2518                     resultRange->setStart(&textRunRange->startContainer(), textRunRange->startOffset());
     2518                    resultRange->setStart(textRunRange->startContainer(), textRunRange->startOffset());
    25192519                else
    2520                     resultRange->setStart(&textRunRange->endContainer(), textRunRange->endOffset());
     2520                    resultRange->setStart(textRunRange->endContainer(), textRunRange->endOffset());
    25212521            }
    25222522        }
    … …  
    25252525            if (textRunRange->startContainer().isTextNode()) {
    25262526                int offset = rangeEnd - docTextPosition;
    2527                 resultRange->setEnd(&textRunRange->startContainer(), offset + textRunRange->startOffset());
     2527                resultRange->setEnd(textRunRange->startContainer(), offset + textRunRange->startOffset());
    25282528            } else {
    25292529                if (rangeEnd == docTextPosition)
    2530                     resultRange->setEnd(&textRunRange->startContainer(), textRunRange->startOffset());
     2530                    resultRange->setEnd(textRunRange->startContainer(), textRunRange->startOffset());
    25312531                else
    2532                     resultRange->setEnd(&textRunRange->endContainer(), textRunRange->endOffset());
     2532                    resultRange->setEnd(textRunRange->endContainer(), textRunRange->endOffset());
    25332533            }
    25342534            docTextPosition += length;
    … …  
    25432543   
    25442544    if (rangeLength && rangeEnd > docTextPosition) // rangeEnd is out of bounds
    2545         resultRange->setEnd(&textRunRange->endContainer(), textRunRange->endOffset());
     2545        resultRange->setEnd(textRunRange->endContainer(), textRunRange->endOffset());
    25462546   
    25472547    return WTFMove(resultRange);
    … …  
    25672567    location = TextIterator::rangeLength(testRange.ptr());
    25682568
    2569     testRange->setEnd(&range->endContainer(), range->endOffset(), IGNORE_EXCEPTION);
     2569    testRange->setEnd(range->endContainer(), range->endOffset(), IGNORE_EXCEPTION);
    25702570    ASSERT(&testRange->startContainer() == scope);
    25712571    length = TextIterator::rangeLength(testRange.ptr()) - location;
    … …  
    26242624    if (buffer.needsMoreContext()) {
    26252625        Ref<Range> beforeStartRange = range.ownerDocument().createRange();
    2626         beforeStartRange->setEnd(&range.startContainer(), range.startOffset());
     2626        beforeStartRange->setEnd(range.startContainer(), range.startOffset());
    26272627        for (SimplifiedBackwardsTextIterator backwardsIterator(beforeStartRange.get()); !backwardsIterator.atEnd(); backwardsIterator.advance()) {
    26282628            buffer.prependContext(backwardsIterator.text());

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

    r198177 r199817  
    731731}
    732732
    733 bool setStart(Range *r, const VisiblePosition &visiblePosition)
    734 {
    735     if (!r)
     733bool setStart(Range* range, const VisiblePosition& visiblePosition)
     734{
     735    if (!range)
    736736        return false;
     737
    737738    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    738     int code = 0;
    739     r->setStart(p.containerNode(), p.offsetInContainerNode(), code);
    740     return code == 0;
    741 }
    742 
    743 bool setEnd(Range *r, const VisiblePosition &visiblePosition)
    744 {
    745     if (!r)
     739    if (!p.containerNode())
    746740        return false;
     741
     742    int ec = 0;
     743    range->setStart(*p.containerNode(), p.offsetInContainerNode(), ec);
     744    return !ec;
     745}
     746
     747bool setEnd(Range* range, const VisiblePosition& visiblePosition)
     748{
     749    if (!range)
     750        return false;
     751
    747752    Position p = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
    748     int code = 0;
    749     r->setEnd(p.containerNode(), p.offsetInContainerNode(), code);
    750     return code == 0;
     753    if (!p.containerNode())
     754        return false;
     755
     756    int ec = 0;
     757    range->setEnd(*p.containerNode(), p.offsetInContainerNode(), ec);
     758    return !ec;
    751759}
    752760

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

    r198587 r199817  
    214214
    215215    Position start(pos.parentAnchoredEquivalent());
    216     searchRange->selectNodeContents(boundary, ec);
    217     searchRange->setStart(start.containerNode(), start.offsetInContainerNode(), ec);
     216    searchRange->selectNodeContents(*boundary, ec);
     217    searchRange->setStart(*start.containerNode(), start.offsetInContainerNode(), ec);
    218218
    219219    ASSERT(!ec);

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

    r198177 r199817  
    570570    Position start = createLegacyEditingPosition(boundary, 0).parentAnchoredEquivalent();
    571571    Position end = pos.parentAnchoredEquivalent();
    572     RefPtr<Range> searchRange = Range::create(boundaryDocument);
     572
     573    if (start.isNull() || end.isNull())
     574        return VisiblePosition();
     575
     576    Ref<Range> searchRange = Range::create(boundaryDocument);
    573577   
    574578    Vector<UChar, 1024> string;
    … …  
    578582    if (requiresContextForWordBoundary(c.characterBefore())) {
    579583        RefPtr<Range> forwardsScanRange(boundaryDocument.createRange());
    580         forwardsScanRange->setEndAfter(boundary, ec);
    581         forwardsScanRange->setStart(end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
     584        forwardsScanRange->setEndAfter(*boundary, ec);
     585        forwardsScanRange->setStart(*end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
    582586        suffixLength = suffixLengthForRange(forwardsScanRange, string);
    583587    }
    584588
    585     searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
    586     searchRange->setEnd(end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
     589    searchRange->setStart(*start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
     590    searchRange->setEnd(*end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
    587591
    588592    ASSERT(!ec);
    … …  
    590594        return VisiblePosition();
    591595
    592     SimplifiedBackwardsTextIterator it(*searchRange);
     596    SimplifiedBackwardsTextIterator it(searchRange);
    593597    unsigned next = backwardSearchForBoundaryWithTextIterator(it, string, suffixLength, searchFunction);
    594598
    … …  
    603607
    604608    // Use the character iterator to translate the next value into a DOM position.
    605     BackwardsCharacterIterator charIt(*searchRange);
     609    BackwardsCharacterIterator charIt(searchRange);
    606610    charIt.advance(string.size() - suffixLength - next);
    607611    // FIXME: charIt can get out of shadow host.
    … …  
    617621
    618622    Document& boundaryDocument = boundary->document();
    619     RefPtr<Range> searchRange(boundaryDocument.createRange());
     623    Ref<Range> searchRange = boundaryDocument.createRange();
    620624    Position start(pos.parentAnchoredEquivalent());
    621625
    … …  
    625629    if (requiresContextForWordBoundary(c.characterAfter())) {
    626630        RefPtr<Range> backwardsScanRange(boundaryDocument.createRange());
    627         backwardsScanRange->setEnd(start.deprecatedNode(), start.deprecatedEditingOffset(), IGNORE_EXCEPTION);
     631        if (start.deprecatedNode())
     632            backwardsScanRange->setEnd(*start.deprecatedNode(), start.deprecatedEditingOffset(), IGNORE_EXCEPTION);
    628633        prefixLength = prefixLengthForRange(backwardsScanRange, string);
    629634    }
    630635
    631     searchRange->selectNodeContents(boundary, IGNORE_EXCEPTION);
    632     searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), IGNORE_EXCEPTION);
    633     TextIterator it(searchRange.get(), TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     636    searchRange->selectNodeContents(*boundary, IGNORE_EXCEPTION);
     637    if (start.deprecatedNode())
     638        searchRange->setStart(*start.deprecatedNode(), start.deprecatedEditingOffset(), IGNORE_EXCEPTION);
     639    TextIterator it(searchRange.ptr(), TextIteratorEmitsCharactersBetweenAllVisiblePositions);
    634640    unsigned next = forwardSearchForBoundaryWithTextIterator(it, string, prefixLength, searchFunction);
    635641   
    … …  
    638644    else if (next > prefixLength) {
    639645        // Use the character iterator to translate the next value into a DOM position.
    640         CharacterIterator charIt(*searchRange, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     646        CharacterIterator charIt(searchRange, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
    641647        charIt.advance(next - prefixLength - 1);
    642648        RefPtr<Range> characterRange = charIt.range();

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

    r198583 r199817  
    11651165}
    11661166
    1167 VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node* node, int index)
    1168 {
    1169     ASSERT(node);
     1167VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node& node, int index)
     1168{
    11701169    if (index <= 0)
    1171         return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
    1172 
    1173     RefPtr<Range> range = Range::create(node->document());
     1170        return VisiblePosition(firstPositionInOrBeforeNode(&node), DOWNSTREAM);
     1171
     1172    RefPtr<Range> range = Range::create(node.document());
    11741173    range->selectNodeContents(node, IGNORE_EXCEPTION);
    11751174    CharacterIterator it(*range);
    … …  
    11871186// Determines whether a node is inside a range or visibly starts and ends at the boundaries of the range.
    11881187// Call this function to determine whether a node is visibly fit inside selectedRange
    1189 bool isNodeVisiblyContainedWithin(Node* node, const Range* selectedRange)
    1190 {
    1191     ASSERT(node);
     1188bool isNodeVisiblyContainedWithin(Node& node, const Range* selectedRange)
     1189{
    11921190    ASSERT(selectedRange);
    11931191    // If the node is inside the range, then it surely is contained within
    … …  
    11951193        return true;
    11961194
    1197     bool startIsVisuallySame = visiblePositionBeforeNode(node) == selectedRange->startPosition();
    1198     if (startIsVisuallySame && comparePositions(positionInParentAfterNode(node), selectedRange->endPosition()) < 0)
     1195    bool startIsVisuallySame = visiblePositionBeforeNode(&node) == selectedRange->startPosition();
     1196    if (startIsVisuallySame && comparePositions(positionInParentAfterNode(&node), selectedRange->endPosition()) < 0)
    11991197        return true;
    12001198
    1201     bool endIsVisuallySame = visiblePositionAfterNode(node) == selectedRange->endPosition();
    1202     if (endIsVisuallySame && comparePositions(selectedRange->startPosition(), positionInParentBeforeNode(node)) < 0)
     1199    bool endIsVisuallySame = visiblePositionAfterNode(&node) == selectedRange->endPosition();
     1200    if (endIsVisuallySame && comparePositions(selectedRange->startPosition(), positionInParentBeforeNode(&node)) < 0)
    12031201        return true;
    12041202

  • trunk/Source/WebCore/editing/htmlediting.h

    r198583 r199817  
    118118bool isListItem(const Node*);
    119119bool isNodeRendered(const Node*);
    120 bool isNodeVisiblyContainedWithin(Node*, const Range*);
     120bool isNodeVisiblyContainedWithin(Node&, const Range*);
    121121bool isRenderedAsNonInlineTableImageOrHR(const Node*);
    122122bool areIdenticalElements(const Node*, const Node*);
    … …  
    199199int indexForVisiblePosition(Node*, const VisiblePosition&, bool forSelectionPreservation);
    200200VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
    201 VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node*, int index); // FIXME: Why do we need this version?
     201VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node&, int index); // FIXME: Why do we need this version?
    202202
    203203// -------------------------------------------------------------------------

  • trunk/Source/WebCore/editing/mac/EditorMac.mm

    r198177 r199817  
    319319    auto* enclosingAnchor = enclosingElementWithTag(firstPositionInNode(commonAncestor), HTMLNames::aTag);
    320320    if (enclosingAnchor && comparePositions(firstPositionInOrBeforeNode(range->startPosition().anchorNode()), range->startPosition()) >= 0)
    321         range->setStart(enclosingAnchor, 0, IGNORE_EXCEPTION);
     321        range->setStart(*enclosingAnchor, 0, IGNORE_EXCEPTION);
    322322    return range;
    323323}

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

    r198900 r199817  
    414414            Document& document = m_context.hitTestResult().innerNonSharedNode()->document();
    415415            selectedRange = document.createRange();
    416             selectedRange->selectNode(document.documentElement(), IGNORE_EXCEPTION);
     416            if (document.documentElement())
     417                selectedRange->selectNode(*document.documentElement(), IGNORE_EXCEPTION);
    417418        }
    418419        m_client.speak(plainText(selectedRange.get()));

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

    r199585 r199817  
    394394
    395395    RefPtr<Range> range = selection.selection().toNormalizedRange();
    396     if (r->compareBoundaryPoints(Range::START_TO_START, range.get(), IGNORE_EXCEPTION) == -1) {
     396    if (!range)
     397        return;
     398
     399    if (r->compareBoundaryPoints(Range::START_TO_START, *range, IGNORE_EXCEPTION) == -1) {
    397400        // We don't support discontiguous selection. We don't do anything if r and range don't intersect.
    398         if (r->compareBoundaryPoints(Range::START_TO_END, range.get(), IGNORE_EXCEPTION) > -1) {
    399             if (r->compareBoundaryPoints(Range::END_TO_END, range.get(), IGNORE_EXCEPTION) == -1) {
     401        if (r->compareBoundaryPoints(Range::START_TO_END, *range, IGNORE_EXCEPTION) > -1) {
     402            if (r->compareBoundaryPoints(Range::END_TO_END, *range, IGNORE_EXCEPTION) == -1) {
    400403                // The original range and r intersect.
    401404                selection.moveTo(r->startPosition(), range->endPosition(), DOWNSTREAM);
    … …  
    408411        // We don't support discontiguous selection. We don't do anything if r and range don't intersect.
    409412        ExceptionCode ec = 0;
    410         if (r->compareBoundaryPoints(Range::END_TO_START, range.get(), ec) < 1 && !ec) {
    411             if (r->compareBoundaryPoints(Range::END_TO_END, range.get(), IGNORE_EXCEPTION) == -1) {
     413        if (r->compareBoundaryPoints(Range::END_TO_START, *range, ec) < 1 && !ec) {
     414            if (r->compareBoundaryPoints(Range::END_TO_END, *range, IGNORE_EXCEPTION) == -1) {
    412415                // The original range contains r.
    413416                selection.moveTo(range.get());

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

    r198243 r199817  
    713713{
    714714    RefPtr<Range> range = element.document().createRange();
    715     range->selectNode(&element);
     715    range->selectNode(element);
    716716    element.document().frame()->selection().setSelection(VisibleSelection(*range, DOWNSTREAM));
    717717}

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

    r199331 r199817  
    25082508                // will set a selection inside it, which will call setFocuseNodeIfNeeded.
    25092509                if (m_frame.selection().isRange()
    2510                     && m_frame.selection().toNormalizedRange()->compareNode(element, IGNORE_EXCEPTION) == Range::NODE_INSIDE
     2510                    && m_frame.selection().toNormalizedRange()->compareNode(*element, IGNORE_EXCEPTION) == Range::NODE_INSIDE
    25112511                    && element->isDescendantOf(m_frame.document()->focusedElement()))
    25122512                    return true;

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

    r199286 r199817  
    633633        if (options & Backwards) {
    634634            for (size_t i = matchRanges.size(); i > 0; --i) {
    635                 if (selectedRange->compareBoundaryPoints(Range::END_TO_START, matchRanges[i - 1].get(), IGNORE_EXCEPTION) > 0) {
     635                if (selectedRange->compareBoundaryPoints(Range::END_TO_START, *matchRanges[i - 1], IGNORE_EXCEPTION) > 0) {
    636636                    indexForSelection = i - 1;
    637637                    break;
    … …  
    640640        } else {
    641641            for (size_t i = 0, size = matchRanges.size(); i < size; ++i) {
    642                 if (selectedRange->compareBoundaryPoints(Range::START_TO_END, matchRanges[i].get(), IGNORE_EXCEPTION) < 0) {
     642                if (selectedRange->compareBoundaryPoints(Range::START_TO_END, *matchRanges[i], IGNORE_EXCEPTION) < 0) {
    643643                    indexForSelection = i;
    644644                    break;

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

    r198578 r199817  
    126126        if (!renderer)
    127127            continue;
    128         if ((!renderer->isInline() || renderer->isReplaced()) && range.intersectsNode(node, ASSERT_NO_EXCEPTION))
     128        if ((!renderer->isInline() || renderer->isReplaced()) && range.intersectsNode(*node, ASSERT_NO_EXCEPTION))
    129129            return true;
    130130    }

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

    r198992 r199817  
    695695                if (foundStartPosition) {
    696696                    if (!startsAboveRegion) {
    697                         if (range->intersectsNode(node, IGNORE_EXCEPTION))
    698                             range->setEndBefore(node, IGNORE_EXCEPTION);
     697                        if (range->intersectsNode(*node, IGNORE_EXCEPTION))
     698                            range->setEndBefore(*node, IGNORE_EXCEPTION);
    699699                        rangeObjects.append(range->cloneRange());
    700700                        range = Range::create(contentElement->document());
    … …  
    704704                }
    705705                if (skipOverOutsideNodes)
    706                     range->setStartAfter(node, IGNORE_EXCEPTION);
     706                    range->setStartAfter(*node, IGNORE_EXCEPTION);
    707707                foundStartPosition = false;
    708708                continue;
    … …  
    734734                if (startsAboveRegion) {
    735735                    startsAboveRegion = false;
    736                     range->setStartBefore(node, IGNORE_EXCEPTION);
     736                    range->setStartBefore(*node, IGNORE_EXCEPTION);
    737737                }
    738738            }
    … …  
    771771                // allow this end position to be changed only by other elements that are not descendants of the current end node
    772772                if (endsBelowRegion || (!endsBelowRegion && !node->isDescendantOf(lastEndNode))) {
    773                     range->setEndAfter(node, IGNORE_EXCEPTION);
     773                    range->setEndAfter(*node, IGNORE_EXCEPTION);
    774774                    endsBelowRegion = false;
    775775                    lastEndNode = node;

  • trunk/Source/WebKit/mac/ChangeLog

    r199779 r199817  
     12016-04-21  Chris Dumez  <cdumez@apple.com>
     2
     3        Drop [UsePointersEvenForNonNullableObjectArguments] from Range
     4        https://bugs.webkit.org/show_bug.cgi?id=156805
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * WebView/WebFrame.mm:
     9        (-[WebFrame _smartDeleteRangeForProposedRange:]):
     10
    1112016-04-20  Brady Eidson  <beidson@apple.com>
    212

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

    r199619 r199817  
    874874    newEnd = newEnd.parentAnchoredEquivalent();
    875875
    876     RefPtr<Range> range = _private->coreFrame->document()->createRange();
    877     int exception = 0;
    878     range->setStart(newStart.containerNode(), newStart.offsetInContainerNode(), exception);
    879     range->setEnd(newStart.containerNode(), newStart.offsetInContainerNode(), exception);
    880     return kit(range.get());
     876    Ref<Range> range = _private->coreFrame->document()->createRange();
     877    if (newStart.containerNode()) {
     878        int exception = 0;
     879        range->setStart(*newStart.containerNode(), newStart.offsetInContainerNode(), exception);
     880        range->setEnd(*newStart.containerNode(), newStart.offsetInContainerNode(), exception);
     881    }
     882    return kit(range.ptr());
    881883}
    882884
    … …  
    16291631        return;
    16301632
    1631     Node *node = core(element);
     1633    Node* node = core(element);
    16321634    if (!node->inDocument())
    16331635        return;
    16341636       
    1635     frame->selection().selectRangeOnElement(range.location, range.length, node);
     1637    frame->selection().selectRangeOnElement(range.location, range.length, *node);
    16361638}
    16371639

  • trunk/Source/WebKit/win/WebView.cpp

    r199619 r199817  
    61156115        ExceptionCode ec = 0;
    61166116        RefPtr<Range> tempRange = range->cloneRange();
    6117         tempRange->setStart(&tempRange->startContainer(), tempRange->startOffset() + charPos->dwCharPos, ec);
     6117        tempRange->setStart(tempRange->startContainer(), tempRange->startOffset() + charPos->dwCharPos, ec);
    61186118        caret = targetFrame->editor().firstRectForRange(tempRange.get());
    61196119    }

  • trunk/Source/WebKit2/ChangeLog

    r199811 r199817  
     12016-04-21  Chris Dumez  <cdumez@apple.com>
     2
     3        Drop [UsePointersEvenForNonNullableObjectArguments] from Range
     4        https://bugs.webkit.org/show_bug.cgi?id=156805
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * WebProcess/InjectedBundle/API/mac/WKDOMRange.mm:
     9        (-[WKDOMRange setStart:offset:]):
     10        (-[WKDOMRange setEnd:offset:]):
     11        (-[WKDOMRange selectNode:]):
     12        (-[WKDOMRange selectNodeContents:]):
     13        * WebProcess/WebPage/WebFrame.cpp:
     14        (WebKit::WebFrame::contentsAsString):
     15
    1162016-04-21  Carlos Garcia Campos  <cgarcia@igalia.com>
    217

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/API/mac/WKDOMRange.mm

    r189182 r199817  
    6666- (void)setStart:(WKDOMNode *)node offset:(int)offset
    6767{
     68    if (!node)
     69        return;
    6870    // FIXME: Do something about the exception.
    6971    WebCore::ExceptionCode ec = 0;
    70     _impl->setStart(WebKit::toWebCoreNode(node), offset, ec);
     72    _impl->setStart(*WebKit::toWebCoreNode(node), offset, ec);
    7173}
    7274
    7375- (void)setEnd:(WKDOMNode *)node offset:(int)offset
    7476{
     77    if (!node)
     78        return;
    7579    // FIXME: Do something about the exception.
    7680    WebCore::ExceptionCode ec = 0;
    77     _impl->setEnd(WebKit::toWebCoreNode(node), offset, ec);
     81    _impl->setEnd(*WebKit::toWebCoreNode(node), offset, ec);
    7882}
    7983
    … …  
    8589- (void)selectNode:(WKDOMNode *)node
    8690{
     91    if (!node)
     92        return;
    8793    // FIXME: Do something about the exception.
    8894    WebCore::ExceptionCode ec = 0;
    89     _impl->selectNode(WebKit::toWebCoreNode(node), ec);
     95    _impl->selectNode(*WebKit::toWebCoreNode(node), ec);
    9096}
    9197
    9298- (void)selectNodeContents:(WKDOMNode *)node
    9399{
     100    if (!node)
     101        return;
    94102    // FIXME: Do something about the exception.
    95103    WebCore::ExceptionCode ec = 0;
    96     _impl->selectNodeContents(WebKit::toWebCoreNode(node), ec);
     104    _impl->selectNodeContents(*WebKit::toWebCoreNode(node), ec);
    97105}
    98106

  • trunk/Source/WebKit2/WebProcess/WebPage/WebFrame.cpp

    r198893 r199817  
    331331
    332332    ExceptionCode ec = 0;
    333     range->selectNode(documentElement.get(), ec);
     333    range->selectNode(*documentElement, ec);
    334334    if (ec)
    335335        return String();

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

    r199399 r199817  
    941941    flags = IsBlockSelection;
    942942    range = Range::create(bestChoice->document());
    943     range->selectNodeContents(bestChoice, ASSERT_NO_EXCEPTION);
     943    range->selectNodeContents(*bestChoice, ASSERT_NO_EXCEPTION);
    944944    return range->collapsed() ? nullptr : range;
    945945}
    … …  
    965965
    966966    range = Range::create(currentNode->document());
    967     range->selectNodeContents(currentNode, ASSERT_NO_EXCEPTION);
     967    range->selectNodeContents(*currentNode, ASSERT_NO_EXCEPTION);
    968968    return range;
    969969}
    … …  
    12211221        return false;
    12221222    return (first->commonAncestorContainer()->ownerDocument() == second->commonAncestorContainer()->ownerDocument()
    1223         && first->compareBoundaryPoints(Range::START_TO_START, second, ASSERT_NO_EXCEPTION) <= 0
    1224         && first->compareBoundaryPoints(Range::END_TO_END, second, ASSERT_NO_EXCEPTION) >= 0);
     1223        && first->compareBoundaryPoints(Range::START_TO_START, *second, ASSERT_NO_EXCEPTION) <= 0
     1224        && first->compareBoundaryPoints(Range::END_TO_END, *second, ASSERT_NO_EXCEPTION) >= 0);
    12251225}
    12261226
    … …  
    12321232        return rangeB;
    12331233
    1234     Range* start = rangeA->compareBoundaryPoints(Range::START_TO_START, rangeB, ASSERT_NO_EXCEPTION) <= 0 ? rangeA : rangeB;
    1235     Range* end = rangeA->compareBoundaryPoints(Range::END_TO_END, rangeB, ASSERT_NO_EXCEPTION) <= 0 ? rangeB : rangeA;
     1234    Range* start = rangeA->compareBoundaryPoints(Range::START_TO_START, *rangeB, ASSERT_NO_EXCEPTION) <= 0 ? rangeA : rangeB;
     1235    Range* end = rangeA->compareBoundaryPoints(Range::END_TO_END, *rangeB, ASSERT_NO_EXCEPTION) <= 0 ? rangeB : rangeA;
    12361236
    12371237    return Range::create(rangeA->ownerDocument(), &start->startContainer(), start->startOffset(), &end->endContainer(), end->endOffset());
    … …  
    22332233                        if (DataDetection::requiresExtendedContext(*element)) {
    22342234                            RefPtr<Range> linkRange = Range::create(element->document());
    2235                             linkRange->selectNodeContents(element, ASSERT_NO_EXCEPTION);
     2235                            linkRange->selectNodeContents(*element, ASSERT_NO_EXCEPTION);
    22362236                            info.textBefore = plainTextReplacingNoBreakSpace(rangeExpandedByCharactersInDirectionAtWordBoundary(linkRange->startPosition(), dataDetectionExtendedContextLength, DirectionBackward).get(), TextIteratorDefaultBehavior, true);
    22372237                            info.textAfter = plainTextReplacingNoBreakSpace(rangeExpandedByCharactersInDirectionAtWordBoundary(linkRange->endPosition(), dataDetectionExtendedContextLength, DirectionForward).get(), TextIteratorDefaultBehavior, true);
Note: See TracChangeset for help on using the changeset viewer.