Changeset 266295 in webkit

Timestamp:

Aug 28, 2020, 2:37:08 PM (6 years ago)

Author:

Darin Adler

Message:

Remove almost all the remaining uses of live ranges
​https://bugs.webkit.org/show_bug.cgi?id=215755

Reviewed by Sam Weinig.

Source/WebCore:

• accessibility/AXObjectCache.cpp:

(WebCore::characterOffsetsInOrder): Use documentOrder.

• accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::misspellingRange const): Ditto.
(WebCore::rangeClosestToRange): Use characterCount. Also removed unnnecessary assertions
and special cases.
(WebCore::AccessibilityObject::rangeOfStringClosestToRangeInDirection const): Use documentOrder.

• accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::documentBasedSelectedTextRange const): Use intersects.
Also use firstRange instead of toNormalizedRange.

• dom/Element.h: Export attachShadow so it can be used in unit tests.

• dom/Node.cpp:

(WebCore::depthInComposedTree): Renamed and changed to use parentInComposedTree
instead of parentOrShadowHostNode to handle cases involving assigned slots correctly.
(WebCore::commonInclusiveAncestorAndChildren): Ditto.
(WebCore::isSiblingSubsequent): Added assertions.
(WebCore::documentOrder): Add logic so shadow roots are ordered before the
other children of their hosts in cases that don't involve assigned slots.
Without this the results would be inconsistent based on the order of the
arguments passed to documentOrder.

• dom/Node.h: Added is_neq, is_lteq, and is_gteq for use with PartialOrdering,

matching the names and behavior from C++20.

• dom/Range.cpp: Removed unused CoordinateSpace.

(WebCore::Range::Range): Updated since RangeBoundaryPoint now uses references.
(WebCore::Range::updateDocument): Renamed from setDocument and changed so that
it maintains the invariants without requiring the caller pass any arguments.
Also updated for RangeBoundaryPoint anme changes.
(WebCore::Range::compareBoundaryPoints): Deleted.
(WebCore::checkForDifferentRootContainer): Deleted.
(WebCore::Range::setStart): Updated for checkNodeOffsetPair name change.
Removed too-complex code for moving between documents. Use documentOrder
instead of checkForDifferentRootContainer to check for start/end that have
incorrect order or no common ancestor. Use updateDocument.
(WebCore::Range::setEnd): Ditto.
(WebCore::Range::isPointInRange): Use isPointInRange that takes a SimpleRange.
Also updated for checkNodeOffsetPair name change.
(WebCore::Range::comparePoint const): Use documentOrder. Ditto.
(WebCore::Range::compareNode const): Use documentOrder.
(WebCore::top): Deleted.
(WebCore::Range::compareBoundaryPoints const): Deleted more overloads.
Kept only the one needed for bindings, and renamed it from
compareBoundaryPointsForBindings. Also fixed the implementatin to be simpler,
use documentOrder, and match the DOM specification more closely (without a
behavior change).
(WebCore::Range::boundaryPointsValid const): Deleted.
(WebCore::Range::intersectsNode const): Use intersects from SimpleRange.
Also don't raise exceptions.
(WebCore::lengthOfContentsInNode): Deleted. This gives the same result as
Node::length, but less efficiently.
(WebCore::Range::processContents): Updated since RangeBoundaryPoint now
uses references.
(WebCore::processContentsBetweenOffsets): Removed obsolete comment.
(WebCore::Range::toString const): Use intersectingNodes and
characterDataOffsetRange.
(WebCore::Range::text const): Deleted.
(WebCore::Range::detach): Moved to the header.
(WebCore::Range::checkNodeOffsetPair const): Rneamed from checkNodeWOffset.
(WebCore::Range::cloneRange): Use m_ownerDocument.
(WebCore::Range::setStartAfter): Tweaked coding style.
(WebCore::Range::setEndBefore): Ditto.
(WebCore::Range::setEndAfter): Ditto.
(WebCore::Range::selectNode): Ditto. Also removed unnecessary code to
call setDocument, since setStart takes care of that.
(WebCore::Range::selectNodeContents): Ditto.
(WebCore::Range::setStartBefore): Ditto.
(WebCore::Range::firstNode const): Deleted.
(WebCore::Range::pastLastNode const): Deleted.
(WebCore::Range::contains const): Deleted.
(WebCore::areRangesEqual): Deleted.
(WebCore::rangesOverlap): Deleted.
(WebCore::boundaryNodeChildrenChanged): Tweaked coding style and updated
since RangeBoundaryPoint uses a reference.
(WebCore::Range::nodeChildrenChanged): Use m_ownerDocument.
(WebCore::boundaryNodeChildrenWillBeRemoved): Removed unneeded code
to handle case where one of the children is the childBefore but the
node is not inside the container -- that case doesn't exist. Use
Node::contains.
(WebCore::Range::nodeChildrenWillBeRemoved): Use m_ownerDocument.
(WebCore::boundaryNodeWillBeRemoved): Simplify logic using
Range::contains.
(WebCore::Range::nodeWillBeRemoved): Use m_ownerDocument.
(WebCore::Range::parentlessNodeMovedToNewDocumentAffectsRange):
Updated since RangeBoundaryPoint uses a reference.
(WebCore::boundaryTextInserted): Ditto.
(WebCore::boundaryTextRemoved): Ditto.
(WebCore::boundaryTextNodesMerged): Ditto.
(WebCore::boundaryTextNodesSplit): Ditto.
(showTree): Removed call to boundaryPointsValid. That's checking something
the class already treats as an invariant, so it's obsolete code left from
long ago when we didn't have that implemented correctly.

• dom/Range.h: Reorganized the header to match the IDL file.

Removed ownerDocument, compareBoundaryPoints overloads other than the one
used from bindings, firstNode, pastLastNode, text, contains, areRangesEqual,
and rangesOverlap. Also updated since RangeBoundaryPoint::container is now
a reference. Moved detach function here to the header as an empty inline.

• dom/Range.idl: Changed start/endOffset to unsigned. Stopped using the

name compareBoundaryPointersForBindings. Updated intersectsNode to not
throw exceptions as called for in the DOM specification. Tweaked comments.

• dom/RangeBoundaryPoint.h: Changed constructor argument to a reference.

Renamed setToBeforeChild, setToAfterChild, setToStartOfNode, and setToEndOfNode
to setToBeforeNode, setToAfterNode, setToBeforeContents, setToAfterContents.
Merged ensureOffsetIsValid into the offset function. Changed m_containerNode
into a Ref<> and renamed it m_container. Removed clear.

• dom/SimpleRange.cpp:

(WebCore::isOffsetBeforeChild): Add logic so shadow roots are ordered after offset
0 but before offset 1 in their hosts in cases that don't involve assigned slots.
This is an arbitrary choice, but is consistent with how we order shadow roots before
other child nodes.
(WebCore::documentOrder): Use parentInComposedTree instead of parentOrShadowHostNode
to handle cases involving assigned slots correctly.
(WebCore::isPointInRange): Added.
(WebCore::documentOrder): Added.
(WebCore::contains): Added.
(WebCore::intersects): Added.
(WebCore::unionRange): Added.

• dom/SimpleRange.h: Updated for above.

• editing/Editing.cpp:

(WebCore::comparePositions): Use documentOrder.
(WebCore::isNodeVisiblyContainedWithin): Use contains.

• editing/Editor.cpp:

(WebCore::isFrameInRange): Use intersects.
(WebCore::Editor::scanSelectionForTelephoneNumbers): Use intersects.

• editing/EditorCommand.cpp:

(WebCore::unionRanges): Moved to SimpleRange.cpp, where it's now
implemented using documentOrder.
(WebCore::executeDeleteToMark): Updated name to unionRange.
(WebCore::executeSelectToMark): Ditto.

• editing/FrameSelection.cpp:

(WebCore::FrameSelection::respondToNodeModification): Use intersects.

• editing/mac/DictionaryLookupLegacy.mm:

(WebCore::selectionContainsPosition): Use isPointInRange.

• page/DOMSelection.cpp:

(WebCore::DOMSelection::extend): Use makeRefPtr and Node::length
to streamline the implementation.
(WebCore::DOMSelection::getRangeAt): Use makeBoundaryPointBeforeNode
and remove unneeded null check that's already covered above.
(WebCore::DOMSelection::addRange): Use intersects and unionRange.
(WebCore::DOMSelection::containsNode const): Use intersects and contains.
(WebCore::DOMSelection::isValidForPosition const): Use boolean logic.

• page/DragController.cpp:

(WebCore::DragController::draggableElement const): Use contains.
(WebCore::DragController::insertDroppedImagePlaceholdersAtCaret): Use intersects.

• page/EventHandler.cpp:

(WebCore::EventHandler::dispatchMouseEvent): Use contains.

• page/Page.cpp:

(WebCore::Page::findTextMatches): Use documentOrder.

• page/mac/ServicesOverlayController.mm:

(WebCore::ServicesOverlayController::findTelephoneNumberHighlightContainingSelectionHighlight):
Use contains.

• testing/Internals.cpp:

(WebCore::Internals::rangeAsText): Use plainText.
(WebCore::join): Added.
(WebCore::Internals::rangeAsTextUsingBackwardsTextIterator): Use a vector
that we reverse and join rather than inserting at the start of a string.
(WebCore::Internals::subrange): Added a call to updateLayout since text iterator
functions depend on the state of the render tree. Realized this was theoretically
needed because of Internals::rangeAsText.
(WebCore::Internals::rangeOfStringNearLocation): Ditto.

Source/WebKit:

• WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMRange.cpp:

(webkit_dom_range_compare_boundary_points): Update for rename of
compareBoundaryPointsForBindings.
(webkit_dom_range_intersects_node): Removed exception handling.
(webkit_dom_range_get_text): Use plainText.

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

(-[WKDOMRange initWithDocument:]): Tightened up into a one-liner.
(-[WKDOMRange text]): Use plainText.
(-[WKDOMRange textRects]): Stopped using Range::ownerDocument.

• WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp:

(WebKit::InjectedBundleRangeHandle::document): Stopped using
Range::ownerDocument.
(WebKit::InjectedBundleRangeHandle::boundingRectInWindowCoordinates const):
Ditto.
(WebKit::InjectedBundleRangeHandle::renderedImage): Ditto.
(WebKit::InjectedBundleRangeHandle::text const): Use plainText.

• WebProcess/WebPage/glib/WebPageGLib.cpp:

(WebKit::WebPage::getPlatformEditorState const): Use contains.

• WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::requestDocumentEditingContext): Use intersects.

Source/WebKitLegacy/mac:

• DOM/DOMRange.mm:

(-[DOMRange text]): Use plainText.
(-[DOMRange compareBoundaryPoints:sourceRange:]): Update for rename of
compareBoundaryPointsForBindings.
(-[DOMRange intersectsNode:]): Removed raiseOnDOMError.

• DOM/DOMUIKitExtensions.mm:

(firstNodeAfter): Moved Range::firstNode here since it's the only remaining caller;
might need to keep legacy behavior depending on how this is used by UIKit.
(-[DOMRange firstNode]): Call firstNodeAfter.

• DOM/WebDOMOperations.mm:

(-[DOMRange markupString]): Stop using Range::ownerDocument.

Tools:

• TestWebKitAPI/Tests/WebCore/DocumentOrder.cpp:

(TestWebKitAPI::TEST): Added test cases for node ordering involving non-user-agent
shadow tree. Added test case that showed the old "use node order if offsets are equal"
rule for boundary point ordering was wrong. Added tests for isPointInRange,
intersects, and contains functions.

Location:

trunk

Files:

• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/accessibility/AXObjectCache.cpp (modified) (3 diffs)
• Source/WebCore/accessibility/AccessibilityObject.cpp (modified) (3 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.cpp (modified) (4 diffs)
• Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp (modified) (1 diff)
• Source/WebCore/dom/Document.h (modified) (1 diff)
• Source/WebCore/dom/DocumentMarkerController.cpp (modified) (2 diffs)
• Source/WebCore/dom/Element.h (modified) (1 diff)
• Source/WebCore/dom/Node.cpp (modified) (8 diffs)
• Source/WebCore/dom/Node.h (modified) (2 diffs)
• Source/WebCore/dom/Range.cpp (modified) (29 diffs)
• Source/WebCore/dom/Range.h (modified) (4 diffs)
• Source/WebCore/dom/Range.idl (modified) (4 diffs)
• Source/WebCore/dom/RangeBoundaryPoint.h (modified) (7 diffs)
• Source/WebCore/dom/SimpleRange.cpp (modified) (4 diffs)
• Source/WebCore/dom/SimpleRange.h (modified) (1 diff)
• Source/WebCore/editing/Editing.cpp (modified) (2 diffs)
• Source/WebCore/editing/Editor.cpp (modified) (2 diffs)
• Source/WebCore/editing/EditorCommand.cpp (modified) (3 diffs)
• Source/WebCore/editing/FrameSelection.cpp (modified) (2 diffs)
• Source/WebCore/editing/ReplaceRangeWithTextCommand.cpp (modified) (1 diff)
• Source/WebCore/editing/SpellingCorrectionCommand.cpp (modified) (1 diff)
• Source/WebCore/editing/TextCheckingHelper.cpp (modified) (1 diff)
• Source/WebCore/editing/mac/DictionaryLookupLegacy.mm (modified) (1 diff)
• Source/WebCore/editing/markup.cpp (modified) (1 diff)
• Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp (modified) (1 diff)
• Source/WebCore/page/DOMSelection.cpp (modified) (5 diffs)
• Source/WebCore/page/DragController.cpp (modified) (3 diffs)
• Source/WebCore/page/EventHandler.cpp (modified) (1 diff)
• Source/WebCore/page/Page.cpp (modified) (3 diffs)
• Source/WebCore/page/mac/ServicesOverlayController.mm (modified) (1 diff)
• Source/WebCore/rendering/RenderObject.cpp (modified) (1 diff)
• Source/WebCore/testing/Internals.cpp (modified) (1 diff)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMRange.cpp (modified) (4 diffs)
• Source/WebKit/WebProcess/InjectedBundle/API/mac/WKDOMRange.mm (modified) (4 diffs)
• Source/WebKit/WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp (modified) (5 diffs)
• Source/WebKit/WebProcess/WebPage/FindController.cpp (modified) (2 diffs)
• Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm (modified) (3 diffs)
• Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm (modified) (1 diff)
• Source/WebKitLegacy/mac/ChangeLog (modified) (1 diff)
• Source/WebKitLegacy/mac/DOM/DOM.mm (modified) (3 diffs)
• Source/WebKitLegacy/mac/DOM/DOMRange.mm (modified) (4 diffs)
• Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm (modified) (2 diffs)
• Source/WebKitLegacy/mac/DOM/WebDOMOperations.mm (modified) (1 diff)
• Source/WebKitLegacy/mac/WebView/WebPDFView.mm (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WebCore/DocumentOrder.cpp (modified) (8 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-08-28  Darin Adler  <darin@apple.com>
+
+        Remove almost all the remaining uses of live ranges
+        https://bugs.webkit.org/show_bug.cgi?id=215755
+
+        Reviewed by Sam Weinig.
+
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::characterOffsetsInOrder): Use documentOrder.
+        * accessibility/AccessibilityObject.cpp:
+        (WebCore::AccessibilityObject::misspellingRange const): Ditto.
+        (WebCore::rangeClosestToRange): Use characterCount. Also removed unnnecessary assertions
+        and special cases.
+        (WebCore::AccessibilityObject::rangeOfStringClosestToRangeInDirection const): Use documentOrder.
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::documentBasedSelectedTextRange const): Use intersects.
+        Also use firstRange instead of toNormalizedRange.
+
+        * dom/Element.h: Export attachShadow so it can be used in unit tests.
+
+        * dom/Node.cpp:
+        (WebCore::depthInComposedTree): Renamed and changed to use parentInComposedTree
+        instead of parentOrShadowHostNode to handle cases involving assigned slots correctly.
+        (WebCore::commonInclusiveAncestorAndChildren): Ditto.
+        (WebCore::isSiblingSubsequent): Added assertions.
+        (WebCore::documentOrder): Add logic so shadow roots are ordered before the
+        other children of their hosts in cases that don't involve assigned slots.
+        Without this the results would be inconsistent based on the order of the
+        arguments passed to documentOrder.
+
+        * dom/Node.h: Added is_neq, is_lteq, and is_gteq for use with PartialOrdering,
+        matching the names and behavior from C++20.
+
+        * dom/Range.cpp: Removed unused CoordinateSpace.
+        (WebCore::Range::Range): Updated since RangeBoundaryPoint now uses references.
+        (WebCore::Range::updateDocument): Renamed from setDocument and changed so that
+        it maintains the invariants without requiring the caller pass any arguments.
+        Also updated for RangeBoundaryPoint anme changes.
+        (WebCore::Range::compareBoundaryPoints): Deleted.
+        (WebCore::checkForDifferentRootContainer): Deleted.
+        (WebCore::Range::setStart): Updated for checkNodeOffsetPair name change.
+        Removed too-complex code for moving between documents. Use documentOrder
+        instead of checkForDifferentRootContainer to check for start/end that have
+        incorrect order or no common ancestor. Use updateDocument.
+        (WebCore::Range::setEnd): Ditto.
+        (WebCore::Range::isPointInRange): Use isPointInRange that takes a SimpleRange.
+        Also updated for checkNodeOffsetPair name change.
+        (WebCore::Range::comparePoint const): Use documentOrder. Ditto.
+        (WebCore::Range::compareNode const): Use documentOrder.
+        (WebCore::top): Deleted.
+        (WebCore::Range::compareBoundaryPoints const): Deleted more overloads.
+        Kept only the one needed for bindings, and renamed it from
+        compareBoundaryPointsForBindings. Also fixed the implementatin to be simpler,
+        use documentOrder, and match the DOM specification more closely (without a
+        behavior change).
+        (WebCore::Range::boundaryPointsValid const): Deleted.
+        (WebCore::Range::intersectsNode const): Use intersects from SimpleRange.
+        Also don't raise exceptions.
+        (WebCore::lengthOfContentsInNode): Deleted. This gives the same result as
+        Node::length, but less efficiently.
+        (WebCore::Range::processContents): Updated since RangeBoundaryPoint now
+        uses references.
+        (WebCore::processContentsBetweenOffsets): Removed obsolete comment.
+        (WebCore::Range::toString const): Use intersectingNodes and
+        characterDataOffsetRange.
+        (WebCore::Range::text const): Deleted.
+        (WebCore::Range::detach): Moved to the header.
+        (WebCore::Range::checkNodeOffsetPair const): Rneamed from checkNodeWOffset.
+        (WebCore::Range::cloneRange): Use m_ownerDocument.
+        (WebCore::Range::setStartAfter): Tweaked coding style.
+        (WebCore::Range::setEndBefore): Ditto.
+        (WebCore::Range::setEndAfter): Ditto.
+        (WebCore::Range::selectNode): Ditto. Also removed unnecessary code to
+        call setDocument, since setStart takes care of that.
+        (WebCore::Range::selectNodeContents): Ditto.
+        (WebCore::Range::setStartBefore): Ditto.
+        (WebCore::Range::firstNode const): Deleted.
+        (WebCore::Range::pastLastNode const): Deleted.
+        (WebCore::Range::contains const): Deleted.
+        (WebCore::areRangesEqual): Deleted.
+        (WebCore::rangesOverlap): Deleted.
+        (WebCore::boundaryNodeChildrenChanged): Tweaked coding style and updated
+        since RangeBoundaryPoint uses a reference.
+        (WebCore::Range::nodeChildrenChanged): Use m_ownerDocument.
+        (WebCore::boundaryNodeChildrenWillBeRemoved): Removed unneeded code
+        to handle case where one of the children is the childBefore but the
+        node is not inside the container -- that case doesn't exist. Use
+        Node::contains.
+        (WebCore::Range::nodeChildrenWillBeRemoved): Use m_ownerDocument.
+        (WebCore::boundaryNodeWillBeRemoved): Simplify logic using
+        Range::contains.
+        (WebCore::Range::nodeWillBeRemoved): Use m_ownerDocument.
+        (WebCore::Range::parentlessNodeMovedToNewDocumentAffectsRange):
+        Updated since RangeBoundaryPoint uses a reference.
+        (WebCore::boundaryTextInserted): Ditto.
+        (WebCore::boundaryTextRemoved): Ditto.
+        (WebCore::boundaryTextNodesMerged): Ditto.
+        (WebCore::boundaryTextNodesSplit): Ditto.
+        (showTree): Removed call to boundaryPointsValid. That's checking something
+        the class already treats as an invariant, so it's obsolete code left from
+        long ago when we didn't have that implemented correctly.
+
+        * dom/Range.h: Reorganized the header to match the IDL file.
+        Removed ownerDocument, compareBoundaryPoints overloads other than the one
+        used from bindings, firstNode, pastLastNode, text, contains, areRangesEqual,
+        and rangesOverlap. Also updated since RangeBoundaryPoint::container is now
+        a reference. Moved detach function here to the header as an empty inline.
+
+        * dom/Range.idl: Changed start/endOffset to unsigned. Stopped using the
+        name compareBoundaryPointersForBindings. Updated intersectsNode to not
+        throw exceptions as called for in the DOM specification. Tweaked comments.
+
+        * dom/RangeBoundaryPoint.h: Changed constructor argument to a reference.
+        Renamed setToBeforeChild, setToAfterChild, setToStartOfNode, and setToEndOfNode
+        to setToBeforeNode, setToAfterNode, setToBeforeContents, setToAfterContents.
+        Merged ensureOffsetIsValid into the offset function. Changed m_containerNode
+        into a Ref<> and renamed it m_container. Removed clear.
+
+        * dom/SimpleRange.cpp:
+        (WebCore::isOffsetBeforeChild): Add logic so shadow roots are ordered after offset
+        0 but before offset 1 in their hosts in cases that don't involve assigned slots.
+        This is an arbitrary choice, but is consistent with how we order shadow roots before
+        other child nodes.
+        (WebCore::documentOrder): Use parentInComposedTree instead of parentOrShadowHostNode
+        to handle cases involving assigned slots correctly.
+        (WebCore::isPointInRange): Added.
+        (WebCore::documentOrder): Added.
+        (WebCore::contains): Added.
+        (WebCore::intersects): Added.
+        (WebCore::unionRange): Added.
+        * dom/SimpleRange.h: Updated for above.
+
+        * editing/Editing.cpp:
+        (WebCore::comparePositions): Use documentOrder.
+        (WebCore::isNodeVisiblyContainedWithin): Use contains.
+        * editing/Editor.cpp:
+        (WebCore::isFrameInRange): Use intersects.
+        (WebCore::Editor::scanSelectionForTelephoneNumbers): Use intersects.
+
+        * editing/EditorCommand.cpp:
+        (WebCore::unionRanges): Moved to SimpleRange.cpp, where it's now
+        implemented using documentOrder.
+        (WebCore::executeDeleteToMark): Updated name to unionRange.
+        (WebCore::executeSelectToMark): Ditto.
+
+        * editing/FrameSelection.cpp:
+        (WebCore::FrameSelection::respondToNodeModification): Use intersects.
+
+        * editing/mac/DictionaryLookupLegacy.mm:
+        (WebCore::selectionContainsPosition): Use isPointInRange.
+
+        * page/DOMSelection.cpp:
+        (WebCore::DOMSelection::extend): Use makeRefPtr and Node::length
+        to streamline the implementation.
+        (WebCore::DOMSelection::getRangeAt): Use makeBoundaryPointBeforeNode
+        and remove unneeded null check that's already covered above.
+        (WebCore::DOMSelection::addRange): Use intersects and unionRange.
+        (WebCore::DOMSelection::containsNode const): Use intersects and contains.
+        (WebCore::DOMSelection::isValidForPosition const): Use boolean logic.
+
+        * page/DragController.cpp:
+        (WebCore::DragController::draggableElement const): Use contains.
+        (WebCore::DragController::insertDroppedImagePlaceholdersAtCaret): Use intersects.
+
+        * page/EventHandler.cpp:
+        (WebCore::EventHandler::dispatchMouseEvent): Use contains.
+
+        * page/Page.cpp:
+        (WebCore::Page::findTextMatches): Use documentOrder.
+
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::findTelephoneNumberHighlightContainingSelectionHighlight):
+        Use contains.
+
+        * testing/Internals.cpp:
+        (WebCore::Internals::rangeAsText): Use plainText.
+        (WebCore::join): Added.
+        (WebCore::Internals::rangeAsTextUsingBackwardsTextIterator): Use a vector
+        that we reverse and join rather than inserting at the start of a string.
+        (WebCore::Internals::subrange): Added a call to updateLayout since text iterator
+        functions depend on the state of the render tree. Realized this was theoretically
+        needed because of Internals::rangeAsText.
+        (WebCore::Internals::rangeOfStringNearLocation): Ditto.
+
 2020-08-28  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebCore/accessibility/AXObjectCache.cpp

@@ -2037 +2037 @@
 static bool characterOffsetsInOrder(const CharacterOffset& characterOffset1, const CharacterOffset& characterOffset2)
 {
+    // FIXME: Should just be able to call documentOrder without accessibility-specific logic. Not clear why we need CharacterOffset instead of Position or BoundaryPoint.
+
     if (characterOffset1.isNull() || characterOffset2.isNull())
         return false;
@@ -2049 +2051 @@
     if (!node2->isCharacterDataNode() && !isReplacedNodeOrBR(node2) && node2->hasChildNodes())
         node2 = node2->traverseToChildAt(characterOffset2.offset);
-    
     if (!node1 || !node2)
         return false;
@@ -2055 +2056 @@
     auto range1 = AXObjectCache::rangeForNodeContents(*node1);
     auto range2 = AXObjectCache::rangeForNodeContents(*node2);
-    auto result = createLiveRange(range1)->compareBoundaryPoints(Range::START_TO_START, createLiveRange(range2));
-    if (result.hasException())
-        return true;
-    return result.releaseReturnValue() <= 0;
+    return is_lteq(documentOrder(range1.start, range2.start));
 }
 

trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

@@ -298 +298 @@
     checkTextOfParagraph(*textChecker, stringValue(), TextCheckingType::Spelling, misspellings, frame->selection().selection());
 
-    // The returned misspellings are assumed to be ordered in the document
-    // logical order, which should be matched by Range::compareBoundaryPoints.
-    // So iterate forward or backwards depending on the desired search
-    // direction to find the closest misspelling in that direction.
+    // Find the first misspelling past the start.
     if (direction == AccessibilitySearchDirection::Next) {
-        for (const auto& misspelling : misspellings) {
+        for (auto& misspelling : misspellings) {
             auto misspellingRange = editor.rangeForTextCheckingResult(misspelling);
-            if (!misspellingRange)
-                continue;
-
-            if (createLiveRange(*misspellingRange)->compareBoundaryPoints(Range::END_TO_END, createLiveRange(start)).releaseReturnValue() > 0)
+            if (misspellingRange && is_gt(documentOrder(misspellingRange->end, start.end)))
                 return *misspellingRange;
         }
-    } else if (direction == AccessibilitySearchDirection::Previous) {
-        for (auto rit = misspellings.rbegin(); rit != misspellings.rend(); ++rit) {
-            auto misspellingRange = editor.rangeForTextCheckingResult(*rit);
-            if (!misspellingRange)
-                continue;
-
-            if (createLiveRange(*misspellingRange)->compareBoundaryPoints(Range::START_TO_START, createLiveRange(start)).releaseReturnValue() < 0)
+    } else {
+        for (auto& misspelling : makeReversedRange(misspellings)) {
+            auto misspellingRange = editor.rangeForTextCheckingResult(misspelling);
+            if (misspellingRange && is_lt(documentOrder(misspellingRange->start, start.start)))
                 return *misspellingRange;
         }
@@ -566 +557 @@
 static Optional<SimpleRange> rangeClosestToRange(const SimpleRange& referenceRange, Optional<SimpleRange>&& afterRange, Optional<SimpleRange>&& beforeRange)
 {
-    // The treeScope for shadow nodes may not be the same scope as another element in a document.
-    // Comparisons may fail in that case, which are expected behavior and should not assert.
-
-    if (afterRange && (afterRange->start.container->compareDocumentPosition(referenceRange.end.container) & Node::DOCUMENT_POSITION_DISCONNECTED))
-        return WTF::nullopt;
-    ASSERT(!afterRange || createLiveRange(afterRange)->compareBoundaryPoints(Range::START_TO_START, createLiveRange(referenceRange)).releaseReturnValue() >= 0);
-
-    if (beforeRange && (beforeRange->end.container->compareDocumentPosition(referenceRange.start.container) & Node::DOCUMENT_POSITION_DISCONNECTED))
-        return WTF::nullopt;
-    ASSERT(!beforeRange || createLiveRange(beforeRange)->compareBoundaryPoints(Range::START_TO_START, createLiveRange(referenceRange)).releaseReturnValue() <= 0);
-
-    if (!afterRange && !beforeRange)
-        return WTF::nullopt;
     if (!beforeRange)
         return WTFMove(afterRange);
     if (!afterRange)
         return WTFMove(beforeRange);
-
-    auto positionsToAfterRange = Position::positionCountBetweenPositions(createLegacyEditingPosition(afterRange->start), createLegacyEditingPosition(referenceRange.end));
-    auto positionsToBeforeRange = Position::positionCountBetweenPositions(createLegacyEditingPosition(beforeRange->end), createLegacyEditingPosition(referenceRange.start));
-
-    return WTFMove(positionsToAfterRange < positionsToBeforeRange ? afterRange : beforeRange);
+    auto distanceBefore = characterCount({ beforeRange->end, referenceRange.start });
+    auto distanceAfter = characterCount({ afterRange->start, referenceRange.end });
+    return WTFMove(distanceBefore <= distanceAfter ? beforeRange : afterRange);
 }
 
@@ -604 +580 @@
     for (auto& searchString : searchStrings) {
         if (auto foundStringRange = frame->editor().rangeOfString(searchString, referenceRange, findOptions)) {
+            bool foundStringIsCloser;
             if (!closestStringRange)
+                foundStringIsCloser = true;
+            else {
+                foundStringIsCloser = isBackwardSearch
+                    ? is_gt(documentOrder(foundStringRange->end, closestStringRange->end))
+                    : is_lt(documentOrder(foundStringRange->start, closestStringRange->start));
+            }
+            if (foundStringIsCloser)
                 closestStringRange = *foundStringRange;
-            else {
-                // If searching backward, use the trailing range edges to correctly determine which
-                // range is closest. Similarly, if searching forward, use the leading range edges.
-                auto& closestStringPosition = isBackwardSearch ? closestStringRange->end : closestStringRange->start;
-                auto& foundStringPosition = isBackwardSearch ? foundStringRange->end : foundStringRange->start;
-                
-                auto closestPositionOffset = closestStringPosition.offset;
-                auto searchPositionOffset = foundStringPosition.offset;
-                auto closestContainerNode = closestStringPosition.container.ptr();
-                auto searchContainerNode = foundStringPosition.container.ptr();
-                
-                auto result = Range::compareBoundaryPoints(closestContainerNode, closestPositionOffset, searchContainerNode, searchPositionOffset).releaseReturnValue();
-                if ((!isBackwardSearch && result > 0) || (isBackwardSearch && result < 0))
-                    closestStringRange = *foundStringRange;
-            }
         }
     }

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -916 +916 @@
         auto start = VisiblePosition { createLegacyEditingPosition(range->start) };
         auto end = nextVisiblePosition(start);
-        if (!end.isNull() && createLiveRange(range)->contains(end))
+        if (isPointInRange(*range, makeBoundaryPoint(end)))
             return { boundsForRange(*makeSimpleRange(start, end)).center() };
     }
@@ -1562 +1562 @@
         return PlainTextRange();
 
-    VisibleSelection visibleSelection = selection();
-    auto selectionRange = visibleSelection.toNormalizedRange();
-    if (!selectionRange)
-        return PlainTextRange();
-
-    // FIXME: The reason this does the correct thing when the selection is in the
-    // shadow tree of an input element is that we get an exception below, and we
-    // choose to interpret all exceptions as "does not intersect". Seems likely
-    // that does not handle all cases correctly.
-    auto intersectsResult = createLiveRange(*selectionRange)->intersectsNode(*node);
-    if (!intersectsResult.hasException() && !intersectsResult.releaseReturnValue())
+    auto visibleSelection = selection();
+    auto selectionRange = visibleSelection.firstRange();
+    if (!selectionRange || !intersects(*selectionRange, *node))
         return PlainTextRange();
 
@@ -1657 +1649 @@
         auto elementRange = this->elementRange();
         auto start = visiblePositionForIndexUsingCharacterIterator(node, range.start);
-        if (!createLiveRange(elementRange)->contains(start))
+        if (!isPointInRange(*elementRange, makeBoundaryPoint(start)))
             start = createLegacyEditingPosition(elementRange->start);
         auto end = visiblePositionForIndexUsingCharacterIterator(node, range.start + range.length);
-        if (!createLiveRange(elementRange)->contains(end))
+        if (!isPointInRange(*elementRange, makeBoundaryPoint(end)))
             end = createLegacyEditingPosition(elementRange->start);
         m_renderer->frame().selection().setSelection(VisibleSelection(start, end), FrameSelection::defaultSetSelectionOptions(UserTriggered));
@@ -2217 +2209 @@
         auto start = range.start;
         if (auto elementRange = this->elementRange()) {
-            if (!createLiveRange(elementRange)->contains(start))
+            if (!isPointInRange(*elementRange, makeBoundaryPoint(start)))
                 start = createLegacyEditingPosition(elementRange->start);
         }

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

@@ -156 +156 @@
         return false;
 
-    if (selection.isNone())
-        return false;
-
-    auto range = selection.toNormalizedRange();
-    if (!range)
-        return false;
-
-    // We want to check that both the selection intersects the node
-    // AND that the selection is not just "touching" one of the
-    // boundaries for the selected node. We want to check whether the
-    // node is actually inside the region, at least partially.
-    auto& node = *coreObject->node();
-    auto* lastDescendant = node.lastDescendant();
-    unsigned lastOffset = lastDescendant->length();
-    auto intersectsResult = createLiveRange(*range)->intersectsNode(node);
-    return !intersectsResult.hasException()
-        && intersectsResult.releaseReturnValue()
-        && (range->end.container.ptr() != &node || range->end.offset)
-        && (range->start.container.ptr() != lastDescendant || range->start.offset != lastOffset);
+    auto range = selection.firstRange();
+    return range && intersects(*range, *coreObject->node());
 }
 

trunk/Source/WebCore/dom/Document.h

@@ -906 +906 @@
     // Returns the owning element in the parent document.
     // Returns nullptr if this is the top level document.
-    HTMLFrameOwnerElement* ownerElement() const;
+    WEBCORE_EXPORT HTMLFrameOwnerElement* ownerElement() const;
 
     // Used by DOM bindings; no direction known.

trunk/Source/WebCore/dom/DocumentMarkerController.cpp

@@ -650 +650 @@
 void addMarker(const SimpleRange& range, DocumentMarker::MarkerType type, const DocumentMarker::Data& data)
 {
-    range.start.container->document().markers().addMarker(range, type, data);
+    range.start.document().markers().addMarker(range, type, data);
 }
 
@@ -660 +660 @@
 void removeMarkers(const SimpleRange& range, OptionSet<DocumentMarker::MarkerType> types, RemovePartiallyOverlappingMarker policy)
 {
-    range.start.container->document().markers().removeMarkers(range, types, policy);
+    range.start.document().markers().removeMarkers(range, types, policy);
 }
 

trunk/Source/WebCore/dom/Element.h

@@ -298 +298 @@
         bool delegatesFocus { false };
     };
-    ExceptionOr<ShadowRoot&> attachShadow(const ShadowRootInit&);
+    WEBCORE_EXPORT ExceptionOr<ShadowRoot&> attachShadow(const ShadowRootInit&);
 
     RefPtr<ShadowRoot> userAgentShadowRoot() const;

trunk/Source/WebCore/dom/Node.cpp

@@ -1629 +1629 @@
 }
 
-// FIXME: Refactor this so it calls documentOrdering, except for any exotic inefficient things that are needed only here.
+// FIXME: Refactor this so it calls documentOrder, except for any exotic inefficient things that are needed only here.
 unsigned short Node::compareDocumentPosition(Node& otherNode)
 {
@@ -2628 +2628 @@
 }
 
-static size_t depth(const Node& node)
+static size_t depthInComposedTree(const Node& node)
 {
     size_t depth = 0;
     auto ancestor = &node;
-    while ((ancestor = ancestor->parentOrShadowHostNode()))
+    while ((ancestor = ancestor->parentInComposedTree()))
         ++depth;
     return depth;
@@ -2642 +2642 @@
     const Node* distinctAncestorB;
 };
+
+// FIXME: This function's name is not explicit about the fact that it's the common inclusive ancestor in the composed tree.
 static AncestorAndChildren commonInclusiveAncestorAndChildren(const Node& a, const Node& b)
 {
-    // This first check isn't needed for correctness, but it is cheap and likely to be
+    // This check isn't needed for correctness, but it is cheap and likely to be
     // common enough to be worth optimizing so we don't have to walk to the root.
     if (&a == &b)
         return { &a, nullptr, nullptr };
-    auto [depthA, depthB] = std::make_tuple(depth(a), depth(b));
+    // FIXME: Could optimize cases where nodes are both in the same shadow tree.
+    // FIXME: Could optimize cases where nodes are in different documents to quickly return false.
+    // FIXME: Could optimize cases where one node is connected and the other is not to quickly return false.
+    auto [depthA, depthB] = std::make_tuple(depthInComposedTree(a), depthInComposedTree(b));
     auto [x, y, difference] = depthA >= depthB
         ? std::make_tuple(&a, &b, depthA - depthB)
@@ -2655 +2660 @@
     for (decltype(difference) i = 0; i < difference; ++i) {
         distinctAncestorA = x;
-        x = x->parentOrShadowHostNode();
+        x = x->parentInComposedTree();
     }
     decltype(y) distinctAncestorB = nullptr;
@@ -2661 +2666 @@
         distinctAncestorA = x;
         distinctAncestorB = y;
-        x = x->parentOrShadowHostNode();
-        y = y->parentOrShadowHostNode();
+        x = x->parentInComposedTree();
+        y = y->parentInComposedTree();
     }
     if (depthA < depthB)
@@ -2669 +2674 @@
 }
 
+// FIXME: This function's name is not explicit about the fact that it's the common inclusive ancestor in the composed tree.
 RefPtr<Node> commonInclusiveAncestor(Node& a, Node& b)
 {
@@ -2676 +2682 @@
 static bool isSiblingSubsequent(const Node& siblingA, const Node& siblingB)
 {
+    ASSERT(siblingA.parentNode());
+    ASSERT(siblingA.parentNode() == siblingB.parentNode());
     ASSERT(&siblingA != &siblingB);
     for (auto sibling = &siblingA; sibling; sibling = sibling->nextSibling()) {
@@ -2695 +2703 @@
     if (!result.distinctAncestorB)
         return PartialOrdering::greater;
+    bool isShadowRootA = result.distinctAncestorA->isShadowRoot();
+    bool isShadowRootB = result.distinctAncestorB->isShadowRoot();
+    if (isShadowRootA || isShadowRootB) {
+        if (!isShadowRootB)
+            return PartialOrdering::less;
+        if (!isShadowRootA)
+            return PartialOrdering::greater;
+        ASSERT_NOT_REACHED();
+        return PartialOrdering::unordered;
+    }
     return isSiblingSubsequent(*result.distinctAncestorA, *result.distinctAncestorB) ? PartialOrdering::less : PartialOrdering::greater;
 }

trunk/Source/WebCore/dom/Node.h

@@ -694 +694 @@
     Type m_type;
 };
+constexpr bool is_eq(PartialOrdering);
+constexpr bool is_lt(PartialOrdering);
+constexpr bool is_gt(PartialOrdering);
+constexpr bool is_neq(PartialOrdering);
+constexpr bool is_lteq(PartialOrdering);
+constexpr bool is_gteq(PartialOrdering);
 
 WEBCORE_EXPORT PartialOrdering documentOrder(const Node&, const Node&);
@@ -830 +836 @@
 }
 
+constexpr bool is_neq(PartialOrdering ordering)
+{
+    return is_lt(ordering) || is_gt(ordering);
+}
+
+constexpr bool is_lteq(PartialOrdering ordering)
+{
+    return is_lt(ordering) || is_eq(ordering);
+}
+
+constexpr bool is_gteq(PartialOrdering ordering)
+{
+    return is_gt(ordering) || is_eq(ordering);
+}
+
 WTF::TextStream& operator<<(WTF::TextStream&, const Node&);
 

trunk/Source/WebCore/dom/Range.cpp

@@ -67 +67 @@
 
 enum ContentsProcessDirection { ProcessContentsForward, ProcessContentsBackward };
-enum class CoordinateSpace { Absolute, Client };
 
 static ExceptionOr<void> processNodes(Range::ActionType, Vector<Ref<Node>>&, Node* oldContainer, RefPtr<Node> newContainer);
@@ -75 +74 @@
 inline Range::Range(Document& ownerDocument)
     : m_ownerDocument(ownerDocument)
-    , m_start(&ownerDocument)
-    , m_end(&ownerDocument)
+    , m_start(ownerDocument)
+    , m_end(ownerDocument)
 {
 #ifndef NDEBUG
@@ -99 +98 @@
 }
 
-void Range::setDocument(Document& document)
-{
-    ASSERT(m_ownerDocument.ptr() != &document);
+void Range::updateDocument()
+{
+    auto& document = startContainer().document();
+    if (m_ownerDocument.ptr() == &document)
+        return;
     m_ownerDocument->detachRange(*this);
     m_ownerDocument = document;
-    m_start.setToStartOfNode(document);
-    m_end.setToStartOfNode(document);
     m_ownerDocument->attachRange(*this);
 }
 
-static inline bool checkForDifferentRootContainer(const RangeBoundaryPoint& start, const RangeBoundaryPoint& end)
-{
-    Node* endRootContainer = end.container();
-    while (endRootContainer->parentNode())
-        endRootContainer = endRootContainer->parentNode();
-    Node* startRootContainer = start.container();
-    while (startRootContainer->parentNode())
-        startRootContainer = startRootContainer->parentNode();
-
-    return startRootContainer != endRootContainer || Range::compareBoundaryPoints(start, end).releaseReturnValue() > 0;
-}
-
-ExceptionOr<void> Range::setStart(Ref<Node>&& refNode, unsigned offset)
-{
-    bool didMoveDocument = false;
-    if (&refNode->document() != &ownerDocument()) {
-        setDocument(refNode->document());
-        didMoveDocument = true;
-    }
-
-    auto childNode = checkNodeWOffset(refNode, offset);
+ExceptionOr<void> Range::setStart(Ref<Node>&& container, unsigned offset)
+{
+    auto childNode = checkNodeOffsetPair(container, offset);
     if (childNode.hasException())
         return childNode.releaseException();
 
-    m_start.set(WTFMove(refNode), offset, childNode.releaseReturnValue());
-
-    if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
-        collapse(true);
-
+    m_start.set(WTFMove(container), offset, childNode.releaseReturnValue());
+    if (!is_lteq(documentOrder(makeBoundaryPoint(m_start), makeBoundaryPoint(m_end))))
+        m_end = m_start;
+    updateDocument();
     return { };
 }
 
-ExceptionOr<void> Range::setEnd(Ref<Node>&& refNode, unsigned offset)
-{
-    bool didMoveDocument = false;
-    if (&refNode->document() != &ownerDocument()) {
-        setDocument(refNode->document());
-        didMoveDocument = true;
-    }
-
-    auto childNode = checkNodeWOffset(refNode, offset);
+ExceptionOr<void> Range::setEnd(Ref<Node>&& container, unsigned offset)
+{
+    auto childNode = checkNodeOffsetPair(container, offset);
     if (childNode.hasException())
         return childNode.releaseException();
 
-    m_end.set(WTFMove(refNode), offset, childNode.releaseReturnValue());
-
-    if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
-        collapse(false);
-
+    m_end.set(WTFMove(container), offset, childNode.releaseReturnValue());
+    if (!is_lteq(documentOrder(makeBoundaryPoint(m_start), makeBoundaryPoint(m_end))))
+        m_start = m_end;
+    updateDocument();
     return { };
 }
@@ -169 +142 @@
 }
 
-ExceptionOr<bool> Range::isPointInRange(Node& refNode, unsigned offset)
-{
-    if (&refNode.document() != &ownerDocument())
-        return false;
-
-    auto checkNodeResult = checkNodeWOffset(refNode, offset);
-    if (checkNodeResult.hasException()) {
-        // DOM4 spec requires us to check whether refNode and start container have the same root first
-        // but we do it in the reverse order to avoid O(n) operation here in common case.
-        if (!commonInclusiveAncestor(refNode, startContainer()))
+ExceptionOr<bool> Range::isPointInRange(Node& container, unsigned offset)
+{
+    if (auto checkResult = checkNodeOffsetPair(container, offset); checkResult.hasException()) {
+        // DOM specification requires this check be done first but since there are no side effects,
+        // we can do it in reverse order to avoid an extra root node check in the common case.
+        if (&container.rootNode() != &startContainer().rootNode())
             return false;
-        return checkNodeResult.releaseException();
-    }
-
-    auto startCompareResult = compareBoundaryPoints(&refNode, offset, &startContainer(), m_start.offset());
-    if (!(!startCompareResult.hasException() && startCompareResult.releaseReturnValue() >= 0))
-        return false;
-    auto endCompareResult = compareBoundaryPoints(&refNode, offset, &endContainer(), m_end.offset());
-    return !endCompareResult.hasException() && endCompareResult.releaseReturnValue() <= 0;
-}
-
-ExceptionOr<short> Range::comparePoint(Node& refNode, unsigned offset) const
-{
-    // http://developer.mozilla.org/en/docs/DOM:range.comparePoint
-    // This method returns -1, 0 or 1 depending on if the point described by the 
-    // refNode node and an offset within the node is before, same as, or after the range respectively.
-    if (&refNode.document() != &ownerDocument())
-        return Exception { WrongDocumentError };
-
-    auto checkNodeResult = checkNodeWOffset(refNode, offset);
-    if (checkNodeResult.hasException()) {
-        // DOM4 spec requires us to check whether refNode and start container have the same root first
-        // but we do it in the reverse order to avoid O(n) operation here in common case.
-        if (!refNode.isConnected() && !commonInclusiveAncestor(refNode, startContainer()))
+        return checkResult.releaseException();
+    }
+    return WebCore::isPointInRange(makeSimpleRange(*this), { container, offset });
+}
+
+ExceptionOr<short> Range::comparePoint(Node& container, unsigned offset) const
+{
+    if (auto checkResult = checkNodeOffsetPair(container, offset); checkResult.hasException()) {
+        // DOM specification requires this check be done first but since there are no side effects,
+        // we can do it in reverse order to avoid an extra root node check in the common case.
+        if (&container.rootNode() != &startContainer().rootNode())
             return Exception { WrongDocumentError };
-        return checkNodeResult.releaseException();
-    }
-
-    // compare to start, and point comes before
-    auto startCompareResult = compareBoundaryPoints(&refNode, offset, &startContainer(), m_start.offset());
-    if (startCompareResult.hasException())
-        return startCompareResult.releaseException();
-    if (startCompareResult.releaseReturnValue() < 0)
+        return checkResult.releaseException();
+    }
+    auto ordering = documentOrder({ container, offset }, makeSimpleRange(*this));
+    if (is_lt(ordering))
         return -1;
-
-    // compare to end, and point comes after
-    auto endCompareResult = compareBoundaryPoints(&refNode, offset, &endContainer(), m_end.offset());
-    if (endCompareResult.hasException())
-        return endCompareResult.releaseException();
-    if (endCompareResult.releaseReturnValue() > 0)
+    if (is_eq(ordering))
+        return 0;
+    if (is_gt(ordering))
         return 1;
-
-    // point is in the middle of this range, or on the boundary points
-    return 0;
-}
-
-ExceptionOr<Range::CompareResults> Range::compareNode(Node& refNode) const
-{
+    return Exception { WrongDocumentError };
+}
+
+ExceptionOr<Range::CompareResults> Range::compareNode(Node& node) const
+{
+    // FIXME: This deprecated function should be removed.
+    // We originally added it for interoperability with Firefox.
+    // Recent versions of Firefox have removed it.
+
     // http://developer.mozilla.org/en/docs/DOM:range.compareNode
     // This method returns 0, 1, 2, or 3 based on if the node is before, after,
-    // before and after(surrounds), or inside the range, respectively
-
-    if (!refNode.isConnected()) {
-        // Firefox doesn't throw an exception for this case; it returns 0.
+    // before and after(surrounds), or inside the range, respectively.
+
+    if (!node.isConnected() || &node.document() != m_ownerDocument.ptr()) {
+        // Match historical Firefox behavior.
         return NODE_BEFORE;
     }
 
-    if (&refNode.document() != &ownerDocument()) {
-        // Firefox doesn't throw an exception for this case; it returns 0.
+    auto nodeRange = makeRangeSelectingNode(node);
+    if (!nodeRange) {
+        // Match historical Firefox behavior.
+        return Exception { NotFoundError };
+    }
+
+    auto startOrdering = documentOrder(nodeRange->start, makeBoundaryPoint(m_start));
+    auto endOrdering = documentOrder(nodeRange->end, makeBoundaryPoint(m_end));
+    if (is_gteq(startOrdering) && is_lteq(endOrdering))
+        return NODE_INSIDE;
+    if (is_lteq(startOrdering) && is_gteq(endOrdering))
+        return NODE_BEFORE_AND_AFTER;
+    if (is_lteq(startOrdering))
         return NODE_BEFORE;
-    }
-
-    auto* parentNode = refNode.parentNode();
-    if (!parentNode) {
-        // If the node is the top of the tree we should return NODE_BEFORE_AND_AFTER,
-        // but we throw to match firefox behavior.
-        return Exception { NotFoundError };
-    }
-    auto nodeIndex = refNode.computeNodeIndex();
-
-    auto nodeStartCompareResult = comparePoint(*parentNode, nodeIndex);
-    if (nodeStartCompareResult.hasException())
-        return nodeStartCompareResult.releaseException();
-    auto nodeEndCompareResult = comparePoint(*parentNode, nodeIndex + 1);
-    if (nodeEndCompareResult.hasException())
-        return nodeEndCompareResult.releaseException();
-
-    bool nodeStartsBeforeRange = nodeStartCompareResult.releaseReturnValue() < 0;
-    bool nodeEndsAfterRange = nodeEndCompareResult.releaseReturnValue() > 0;
-
-    return nodeStartsBeforeRange
-        ? (nodeEndsAfterRange ? NODE_BEFORE_AND_AFTER : NODE_BEFORE)
-        : (nodeEndsAfterRange ? NODE_AFTER : NODE_INSIDE);
-}
-
-static inline Node* top(Node& node)
-{
-    auto* top = &node;
-    while (auto* parent = top->parentNode())
-        top = parent;
-    return top;
-}
-
-ExceptionOr<short> Range::compareBoundaryPoints(CompareHow how, const Range& sourceRange) const
-{
-    auto* thisContainer = commonAncestorContainer();
-    auto* sourceContainer = sourceRange.commonAncestorContainer();
-    if (!thisContainer || !sourceContainer || &thisContainer->document() != &sourceContainer->document() || top(*thisContainer) != top(*sourceContainer))
-        return Exception { WrongDocumentError };
-
+    if (is_gteq(endOrdering))
+        return NODE_AFTER;
+    return Exception { WrongDocumentError };
+}
+
+ExceptionOr<short> Range::compareBoundaryPoints(unsigned short how, const Range& sourceRange) const
+{
+    const RangeBoundaryPoint* thisPoint;
+    const RangeBoundaryPoint* otherPoint;
     switch (how) {
     case START_TO_START:
-        return compareBoundaryPoints(m_start, sourceRange.m_start);
+        thisPoint = &m_start;
+        otherPoint = &sourceRange.m_start;
+        break;
     case START_TO_END:
-        return compareBoundaryPoints(m_end, sourceRange.m_start);
+        thisPoint = &m_end;
+        otherPoint = &sourceRange.m_start;
+        break;
     case END_TO_END:
-        return compareBoundaryPoints(m_end, sourceRange.m_end);
+        thisPoint = &m_end;
+        otherPoint = &sourceRange.m_end;
+        break;
     case END_TO_START:
-        return compareBoundaryPoints(m_start, sourceRange.m_end);
-    }
-
-    return Exception { SyntaxError };
-}
-
-ExceptionOr<short> Range::compareBoundaryPointsForBindings(unsigned short how, const Range& sourceRange) const
-{
-    switch (how) {
-    case START_TO_START:
-    case START_TO_END:
-    case END_TO_END:
-    case END_TO_START:
-        return compareBoundaryPoints(static_cast<CompareHow>(how), sourceRange);
-    }
-    return Exception { NotSupportedError };
-}
-
-ExceptionOr<short> Range::compareBoundaryPoints(Node* containerA, unsigned offsetA, Node* containerB, unsigned offsetB)
-{
-    ASSERT(containerA);
-    ASSERT(containerB);
-
-    if (!containerA)
+        thisPoint = &m_start;
+        otherPoint = &sourceRange.m_end;
+        break;
+    default:
+        return Exception { NotSupportedError };
+    }
+    auto ordering = documentOrder(makeBoundaryPoint(*thisPoint), makeBoundaryPoint(*otherPoint));
+    if (is_lt(ordering))
         return -1;
-    if (!containerB)
+    if (is_eq(ordering))
+        return 0;
+    if (is_gt(ordering))
         return 1;
-
-    // see DOM2 traversal & range section 2.5
-
-    // case 1: both points have the same container
-    if (containerA == containerB) {
-        if (offsetA == offsetB)
-            return 0; // A is equal to B
-        if (offsetA < offsetB)
-            return -1; // A is before B
-        return 1; // A is after B
-    }
-
-    // case 2: node C (container B or an ancestor) is a child node of A
-    Node* c = containerB;
-    while (c && c->parentNode() != containerA)
-        c = c->parentNode();
-    if (c) {
-        unsigned offsetC = 0;
-        Node* n = containerA->firstChild();
-        while (n != c && offsetC < offsetA) {
-            offsetC++;
-            n = n->nextSibling();
-        }
-        if (offsetA <= offsetC)
-            return -1; // A is before B
-        return 1; // A is after B
-    }
-
-    // case 3: node C (container A or an ancestor) is a child node of B
-    c = containerA;
-    while (c && c->parentNode() != containerB)
-        c = c->parentNode();
-    if (c) {
-        unsigned offsetC = 0;
-        Node* n = containerB->firstChild();
-        while (n != c && offsetC < offsetB) {
-            offsetC++;
-            n = n->nextSibling();
-        }
-        if (offsetC < offsetB)
-            return -1; // A is before B
-        return 1; // A is after B
-    }
-
-    // case 4: containers A & B are siblings, or children of siblings
-    // ### we need to do a traversal here instead
-    auto commonAncestor = commonInclusiveAncestor(*containerA, *containerB);
-    if (!commonAncestor)
-        return Exception { WrongDocumentError };
-    Node* childA = containerA;
-    while (childA && childA->parentNode() != commonAncestor)
-        childA = childA->parentNode();
-    if (!childA)
-        childA = commonAncestor.get();
-    Node* childB = containerB;
-    while (childB && childB->parentNode() != commonAncestor)
-        childB = childB->parentNode();
-    if (!childB)
-        childB = commonAncestor.get();
-
-    if (childA == childB)
-        return 0; // A is equal to B
-
-    Node* n = commonAncestor->firstChild();
-    while (n) {
-        if (n == childA)
-            return -1; // A is before B
-        if (n == childB)
-            return 1; // A is after B
-        n = n->nextSibling();
-    }
-
-    // Should never reach this point.
-    ASSERT_NOT_REACHED();
-    return 0;
-}
-
-ExceptionOr<short> Range::compareBoundaryPoints(const RangeBoundaryPoint& boundaryA, const RangeBoundaryPoint& boundaryB)
-{
-    return compareBoundaryPoints(boundaryA.container(), boundaryA.offset(), boundaryB.container(), boundaryB.offset());
-}
-
-bool Range::boundaryPointsValid() const
-{
-    auto result = compareBoundaryPoints(m_start, m_end);
-    return !result.hasException() && result.releaseReturnValue() <= 0;
+    return Exception { WrongDocumentError };
 }
 
@@ -410 +249 @@
 }
 
-ExceptionOr<bool> Range::intersectsNode(Node& refNode) const
-{
-    if (!refNode.isConnected() || &refNode.document() != &ownerDocument())
-        return false;
-
-    auto* parentNode = refNode.parentNode();
-    if (!parentNode)
-        return true;
-
-    unsigned nodeIndex = refNode.computeNodeIndex();
-
-    // If (parentNode, nodeIndex) is before end and (parentNode, nodeIndex + 1) is after start, return true.
-    // Otherwise, return false.
-    auto compareEndResult = compareBoundaryPoints(parentNode, nodeIndex, m_end.container(), m_end.offset());
-    if (compareEndResult.hasException())
-        return compareEndResult.releaseException();
-    auto compareStartResult = compareBoundaryPoints(parentNode, nodeIndex + 1, m_start.container(), m_start.offset());
-    if (compareStartResult.hasException())
-        return compareStartResult.releaseException();
-    return compareEndResult.returnValue() == -1 && compareStartResult.returnValue() == 1;
+bool Range::intersectsNode(Node& node) const
+{
+    return intersects(makeSimpleRange(*this), node);
 }
 
@@ -465 +287 @@
 }
 
-static inline unsigned lengthOfContentsInNode(Node& node)
-{
-    // This switch statement must be consistent with that of Range::processContentsBetweenOffsets.
-    switch (node.nodeType()) {
-    case Node::DOCUMENT_TYPE_NODE:
-    case Node::ATTRIBUTE_NODE:
-        return 0;
-    case Node::TEXT_NODE:
-    case Node::CDATA_SECTION_NODE:
-    case Node::COMMENT_NODE:
-    case Node::PROCESSING_INSTRUCTION_NODE:
-        return downcast<CharacterData>(node).length();
-    case Node::ELEMENT_NODE:
-    case Node::DOCUMENT_NODE:
-    case Node::DOCUMENT_FRAGMENT_NODE:
-        return downcast<ContainerNode>(node).countChildNodes();
-    }
-    ASSERT_NOT_REACHED();
-    return 0;
-}
-
 ExceptionOr<RefPtr<DocumentFragment>> Range::processContents(ActionType action)
 {
     RefPtr<DocumentFragment> fragment;
     if (action == Extract || action == Clone)
-        fragment = DocumentFragment::create(ownerDocument());
+        fragment = DocumentFragment::create(m_ownerDocument);
 
     if (collapsed())
@@ -510 +311 @@
 
     // what is the highest node that partially selects the start / end of the range?
-    RefPtr<Node> partialStart = highestAncestorUnderCommonRoot(originalStart.container(), commonRoot.get());
-    RefPtr<Node> partialEnd = highestAncestorUnderCommonRoot(originalEnd.container(), commonRoot.get());
+    RefPtr<Node> partialStart = highestAncestorUnderCommonRoot(&originalStart.container(), commonRoot.get());
+    RefPtr<Node> partialEnd = highestAncestorUnderCommonRoot(&originalEnd.container(), commonRoot.get());
 
     // Start and end containers are different.
@@ -534 +335 @@
 
     RefPtr<Node> leftContents;
-    if (originalStart.container() != commonRoot && commonRoot->contains(originalStart.container())) {
-        auto firstResult = processContentsBetweenOffsets(action, nullptr, originalStart.container(), originalStart.offset(), lengthOfContentsInNode(*originalStart.container()));
-        auto secondResult = processAncestorsAndTheirSiblings(action, originalStart.container(), ProcessContentsForward, WTFMove(firstResult), commonRoot.get());
+    if (&originalStart.container() != commonRoot && commonRoot->contains(&originalStart.container())) {
+        auto firstResult = processContentsBetweenOffsets(action, nullptr, &originalStart.container(), originalStart.offset(), originalStart.container().length());
+        auto secondResult = processAncestorsAndTheirSiblings(action, &originalStart.container(), ProcessContentsForward, WTFMove(firstResult), commonRoot.get());
         // FIXME: A bit peculiar that we silently ignore the exception here, but we do have at least some regression tests that rely on this behavior.
         if (!secondResult.hasException())
@@ -543 +344 @@
 
     RefPtr<Node> rightContents;
-    if (&endContainer() != commonRoot && commonRoot->contains(originalEnd.container())) {
-        auto firstResult = processContentsBetweenOffsets(action, nullptr, originalEnd.container(), 0, originalEnd.offset());
-        auto secondResult = processAncestorsAndTheirSiblings(action, originalEnd.container(), ProcessContentsBackward, WTFMove(firstResult), commonRoot.get());
+    if (&endContainer() != commonRoot && commonRoot->contains(&originalEnd.container())) {
+        auto firstResult = processContentsBetweenOffsets(action, nullptr, &originalEnd.container(), 0, originalEnd.offset());
+        auto secondResult = processAncestorsAndTheirSiblings(action, &originalEnd.container(), ProcessContentsBackward, WTFMove(firstResult), commonRoot.get());
         // FIXME: A bit peculiar that we silently ignore the exception here, but we do have at least some regression tests that rely on this behavior.
         if (!secondResult.hasException())
@@ -552 +353 @@
 
     // delete all children of commonRoot between the start and end container
-    RefPtr<Node> processStart = childOfCommonRootBeforeOffset(originalStart.container(), originalStart.offset(), commonRoot.get());
-    if (processStart && originalStart.container() != commonRoot) // processStart contains nodes before m_start.
+    RefPtr<Node> processStart = childOfCommonRootBeforeOffset(&originalStart.container(), originalStart.offset(), commonRoot.get());
+    if (processStart && &originalStart.container() != commonRoot) // processStart contains nodes before m_start.
         processStart = processStart->nextSibling();
-    RefPtr<Node> processEnd = childOfCommonRootBeforeOffset(originalEnd.container(), originalEnd.offset(), commonRoot.get());
+    RefPtr<Node> processEnd = childOfCommonRootBeforeOffset(&originalEnd.container(), originalEnd.offset(), commonRoot.get());
 
     // Collapse the range, making sure that the result is not within a node that was partially selected.
@@ -620 +421 @@
     RefPtr<Node> result;
 
-    // This switch statement must be consistent with that of lengthOfContentsInNode.
     switch (container->nodeType()) {
     case Node::TEXT_NODE:
@@ -869 +669 @@
 String Range::toString() const
 {
+    auto range = makeSimpleRange(*this);
     StringBuilder builder;
-
-    Node* pastLast = pastLastNode();
-    for (Node* node = firstNode(); node != pastLast; node = NodeTraversal::next(*node)) {
-        auto type = node->nodeType();
-        if (type == Node::TEXT_NODE || type == Node::CDATA_SECTION_NODE) {
-            unsigned start = node == &startContainer() ? m_start.offset() : 0U;
-            unsigned end = node == &endContainer() ? std::max(start, m_end.offset()) : std::numeric_limits<unsigned>::max();
-            builder.appendSubstring(downcast<CharacterData>(*node).data(), start, end - start);
-        }
-    }
-
+    for (auto& node : intersectingNodes(range)) {
+        if (is<Text>(node)) {
+            auto offsetRange = characterDataOffsetRange(range, node);
+            builder.appendSubstring(downcast<Text>(node).data(), offsetRange.start, offsetRange.end - offsetRange.start);
+        }
+    }
     return builder.toString();
-}
-
-String Range::text() const
-{
-    // We need to update layout, since plainText uses line boxes in the render tree.
-    // FIXME: As with innerText, we'd like this to work even if there are no render objects.
-    startContainer().document().updateLayout();
-
-    return plainText(makeSimpleRange(*this));
 }
 
@@ -909 +696 @@
 }
 
-void Range::detach()
-{
-    // This is now a no-op as per the DOM specification.
-}
-
-ExceptionOr<Node*> Range::checkNodeWOffset(Node& node, unsigned offset) const
+ExceptionOr<Node*> Range::checkNodeOffsetPair(Node& node, unsigned offset) const
 {
     switch (node.nodeType()) {
@@ -944 +726 @@
 Ref<Range> Range::cloneRange() const
 {
-    auto result = create(ownerDocument());
+    auto result = create(m_ownerDocument);
     result->setStart(startContainer(), m_start.offset());
     result->setEnd(endContainer(), m_end.offset());
@@ -950 +732 @@
 }
 
-ExceptionOr<void> Range::setStartAfter(Node& refNode)
-{
-    if (!refNode.parentNode())
+ExceptionOr<void> Range::setStartAfter(Node& node)
+{
+    auto parent = node.parentNode();
+    if (!parent)
         return Exception { InvalidNodeTypeError };
-    return setStart(*refNode.parentNode(), refNode.computeNodeIndex() + 1);
-}
-
-ExceptionOr<void> Range::setEndBefore(Node& refNode)
-{
-    if (!refNode.parentNode())
+    return setStart(*parent, node.computeNodeIndex() + 1);
+}
+
+ExceptionOr<void> Range::setEndBefore(Node& node)
+{
+    auto parent = node.parentNode();
+    if (!parent)
         return Exception { InvalidNodeTypeError };
-    return setEnd(*refNode.parentNode(), refNode.computeNodeIndex());
-}
-
-ExceptionOr<void> Range::setEndAfter(Node& refNode)
-{
-    if (!refNode.parentNode())
+    return setEnd(*parent, node.computeNodeIndex());
+}
+
+ExceptionOr<void> Range::setEndAfter(Node& node)
+{
+    auto parent = node.parentNode();
+    if (!parent)
         return Exception { InvalidNodeTypeError };
-    return setEnd(*refNode.parentNode(), refNode.computeNodeIndex() + 1);
-}
-
-ExceptionOr<void> Range::selectNode(Node& refNode)
-{
-    if (!refNode.parentNode())
+    return setEnd(*parent, node.computeNodeIndex() + 1);
+}
+
+ExceptionOr<void> Range::selectNode(Node& node)
+{
+    auto parent = node.parentNode();
+    if (!parent)
         return Exception { InvalidNodeTypeError };
-
-    if (&ownerDocument() != &refNode.document())
-        setDocument(refNode.document());
-
-    unsigned index = refNode.computeNodeIndex();
-    auto result = setStart(*refNode.parentNode(), index);
+    unsigned index = node.computeNodeIndex();
+    auto result = setStart(*parent, index);
     if (result.hasException())
         return result.releaseException();
-    return setEnd(*refNode.parentNode(), index + 1);
-}
-
-ExceptionOr<void> Range::selectNodeContents(Node& refNode)
-{
-    if (refNode.isDocumentTypeNode())
+    return setEnd(*parent, index + 1);
+}
+
+ExceptionOr<void> Range::selectNodeContents(Node& node)
+{
+    if (node.isDocumentTypeNode())
         return Exception { InvalidNodeTypeError };
 
-    if (&ownerDocument() != &refNode.document())
-        setDocument(refNode.document());
-
-    m_start.setToStartOfNode(refNode);
-    m_end.setToEndOfNode(refNode);
-
+    m_start.setToBeforeContents(node);
+    m_end.setToAfterContents(node);
     return { };
 }
@@ -1053 +831 @@
 }
 
-ExceptionOr<void> Range::setStartBefore(Node& refNode)
-{
-    if (!refNode.parentNode())
+ExceptionOr<void> Range::setStartBefore(Node& node)
+{
+    auto parent = node.parentNode();
+    if (!parent)
         return Exception { InvalidNodeTypeError };
-    return setStart(*refNode.parentNode(), refNode.computeNodeIndex());
-}
-
-Node* Range::firstNode() const
-{
-    if (startContainer().isCharacterDataNode())
-        return &startContainer();
-    if (Node* child = startContainer().traverseToChildAt(m_start.offset()))
-        return child;
-    if (!m_start.offset())
-        return &startContainer();
-    return NodeTraversal::nextSkippingChildren(startContainer());
-}
-
-Node* Range::pastLastNode() const
-{
-    if (endContainer().isCharacterDataNode())
-        return NodeTraversal::nextSkippingChildren(endContainer());
-    if (Node* child = endContainer().traverseToChildAt(m_end.offset()))
-        return child;
-    return NodeTraversal::nextSkippingChildren(endContainer());
+    return setStart(*parent, node.computeNodeIndex());
 }
 
@@ -1102 +861 @@
 #endif
 
-bool Range::contains(const Range& other) const
-{
-    if (commonAncestorContainer()->document() != other.commonAncestorContainer()->document())
-        return false;
-
-    auto startToStart = compareBoundaryPoints(Range::START_TO_START, other);
-    if (startToStart.hasException() || startToStart.releaseReturnValue() > 0)
-        return false;
-
-    auto endToEnd = compareBoundaryPoints(Range::END_TO_END, other);
-    return !endToEnd.hasException() && endToEnd.releaseReturnValue() >= 0;
-}
-
-bool Range::contains(const VisiblePosition& position) const
-{
-    auto positionRange = makeSimpleRange(position);
-    if (!positionRange)
-        return false;
-    return contains(createLiveRange(*positionRange));
-}
-
-bool areRangesEqual(const Range* a, const Range* b)
-{
-    if (a == b)
-        return true;
-    if (!a || !b)
-        return false;
-    return &a->startContainer() == &b->startContainer() && a->startOffset() == b->startOffset() && &a->endContainer() == &b->endContainer() && a->endOffset() == b->endOffset();
-}
-
-bool rangesOverlap(const Range* a, const Range* b)
-{
-    if (!a || !b)
-        return false;
-
-    if (a == b)
-        return true;
-
-    if (!connectedInSameTreeScope(a->commonAncestorContainer(), b->commonAncestorContainer()))
-        return false;
-
-    short startToStart = a->compareBoundaryPoints(Range::START_TO_START, *b).releaseReturnValue();
-    short endToEnd = a->compareBoundaryPoints(Range::END_TO_END, *b).releaseReturnValue();
-
-    // First range contains the second range.
-    if (startToStart <= 0 && endToEnd >= 0)
-        return true;
-
-    // End of first range is inside second range.
-    if (a->compareBoundaryPoints(Range::START_TO_END, *b).releaseReturnValue() >= 0 && endToEnd <= 0)
-        return true;
-
-    // Start of first range is inside second range.
-    if (startToStart >= 0 && a->compareBoundaryPoints(Range::END_TO_START, *b).releaseReturnValue() <= 0)
-        return true;
-
-    return false;
-}
-
 static inline void boundaryNodeChildrenChanged(RangeBoundaryPoint& boundary, ContainerNode& container)
 {
-    if (!boundary.childBefore())
-        return;
-    if (boundary.container() != &container)
-        return;
-    boundary.invalidateOffset();
+    if (boundary.childBefore() && &boundary.container() == &container)
+        boundary.invalidateOffset();
 }
 
 void Range::nodeChildrenChanged(ContainerNode& container)
 {
-    ASSERT(&container.document() == &ownerDocument());
+    ASSERT(&container.document() == m_ownerDocument.ptr());
     boundaryNodeChildrenChanged(m_start, container);
     boundaryNodeChildrenChanged(m_end, container);
 }
 
-static inline void boundaryNodeChildrenWillBeRemoved(RangeBoundaryPoint& boundary, ContainerNode& container)
-{
-    for (Node* nodeToBeRemoved = container.firstChild(); nodeToBeRemoved; nodeToBeRemoved = nodeToBeRemoved->nextSibling()) {
-        if (boundary.childBefore() == nodeToBeRemoved) {
-            boundary.setToStartOfNode(container);
-            return;
-        }
-
-        for (Node* n = boundary.container(); n; n = n->parentNode()) {
-            if (n == nodeToBeRemoved) {
-                boundary.setToStartOfNode(container);
-                return;
-            }
-        }
-    }
+static inline void boundaryNodeChildrenWillBeRemoved(RangeBoundaryPoint& boundary, ContainerNode& containerOfNodesToBeRemoved)
+{
+    if (containerOfNodesToBeRemoved.contains(&boundary.container()))
+        boundary.setToBeforeContents(containerOfNodesToBeRemoved);
 }
 
 void Range::nodeChildrenWillBeRemoved(ContainerNode& container)
 {
-    ASSERT(&container.document() == &ownerDocument());
+    ASSERT(&container.document() == m_ownerDocument.ptr());
     boundaryNodeChildrenWillBeRemoved(m_start, container);
     boundaryNodeChildrenWillBeRemoved(m_end, container);
@@ -1203 +889 @@
 static inline void boundaryNodeWillBeRemoved(RangeBoundaryPoint& boundary, Node& nodeToBeRemoved)
 {
-    if (boundary.childBefore() == &nodeToBeRemoved) {
+    if (boundary.childBefore() == &nodeToBeRemoved)
         boundary.childBeforeWillBeRemoved();
-        return;
-    }
-
-    for (Node* n = boundary.container(); n; n = n->parentNode()) {
-        if (n == &nodeToBeRemoved) {
-            boundary.setToBeforeChild(nodeToBeRemoved);
-            return;
-        }
-    }
+    else if (nodeToBeRemoved.contains(&boundary.container()))
+        boundary.setToBeforeNode(nodeToBeRemoved);
 }
 
 void Range::nodeWillBeRemoved(Node& node)
 {
-    ASSERT(&node.document() == &ownerDocument());
-    ASSERT(&node != &ownerDocument());
+    ASSERT(&node.document() == m_ownerDocument.ptr());
+    ASSERT(&node != m_ownerDocument.ptr());
     ASSERT(node.parentNode());
     boundaryNodeWillBeRemoved(m_start, node);
@@ -1227 +906 @@
 bool Range::parentlessNodeMovedToNewDocumentAffectsRange(Node& node)
 {
-    return node.containsIncludingShadowDOM(m_start.container());
+    return node.containsIncludingShadowDOM(&m_start.container());
 }
 
@@ -1239 +918 @@
 static inline void boundaryTextInserted(RangeBoundaryPoint& boundary, Node& text, unsigned offset, unsigned length)
 {
-    if (boundary.container() != &text)
+    if (&boundary.container() != &text)
         return;
     unsigned boundaryOffset = boundary.offset();
@@ -1249 +928 @@
 void Range::textInserted(Node& text, unsigned offset, unsigned length)
 {
-    ASSERT(&text.document() == &ownerDocument());
+    ASSERT(&text.document() == m_ownerDocument.ptr());
     boundaryTextInserted(m_start, text, offset, length);
     boundaryTextInserted(m_end, text, offset, length);
@@ -1256 +935 @@
 static inline void boundaryTextRemoved(RangeBoundaryPoint& boundary, Node& text, unsigned offset, unsigned length)
 {
-    if (boundary.container() != &text)
+    if (&boundary.container() != &text)
         return;
     unsigned boundaryOffset = boundary.offset();
@@ -1269 +948 @@
 void Range::textRemoved(Node& text, unsigned offset, unsigned length)
 {
-    ASSERT(&text.document() == &ownerDocument());
+    ASSERT(&text.document() == m_ownerDocument.ptr());
     boundaryTextRemoved(m_start, text, offset, length);
     boundaryTextRemoved(m_end, text, offset, length);
@@ -1276 +955 @@
 static inline void boundaryTextNodesMerged(RangeBoundaryPoint& boundary, NodeWithIndex& oldNode, unsigned offset)
 {
-    if (boundary.container() == oldNode.node())
+    if (&boundary.container() == oldNode.node())
         boundary.set(*oldNode.node()->previousSibling(), boundary.offset() + offset, 0);
-    else if (boundary.container() == oldNode.node()->parentNode() && static_cast<int>(boundary.offset()) == oldNode.index())
+    else if (&boundary.container() == oldNode.node()->parentNode() && boundary.offset() == static_cast<unsigned>(oldNode.index()))
         boundary.set(*oldNode.node()->previousSibling(), offset, 0);
 }
@@ -1285 +964 @@
 {
     ASSERT(oldNode.node());
-    ASSERT(&oldNode.node()->document() == &ownerDocument());
+    ASSERT(&oldNode.node()->document() == m_ownerDocument.ptr());
     ASSERT(oldNode.node()->parentNode());
     ASSERT(oldNode.node()->isTextNode());
@@ -1297 +976 @@
 {
     auto* parent = oldNode.parentNode();
-    if (boundary.container() == &oldNode) {
+    if (&boundary.container() == &oldNode) {
         unsigned splitOffset = oldNode.length();
         unsigned boundaryOffset = boundary.offset();
@@ -1310 +989 @@
     if (!parent)
         return;
-    if (boundary.container() == parent && boundary.childBefore() == &oldNode) {
+    if (&boundary.container() == parent && boundary.childBefore() == &oldNode) {
         auto* newChild = oldNode.nextSibling();
         ASSERT(newChild);
-        boundary.setToAfterChild(*newChild);
+        boundary.setToAfterNode(*newChild);
     }
 }
@@ -1319 +998 @@
 void Range::textNodeSplit(Text& oldNode)
 {
-    ASSERT(&oldNode.document() == &ownerDocument());
+    ASSERT(&oldNode.document() == m_ownerDocument.ptr());
     ASSERT(!oldNode.parentNode() || oldNode.nextSibling());
     ASSERT(!oldNode.parentNode() || oldNode.nextSibling()->isTextNode());
@@ -1414 +1093 @@
 void showTree(const WebCore::Range* range)
 {
-    if (range && range->boundaryPointsValid()) {
+    if (range) {
         range->startContainer().showTreeAndMark(&range->startContainer(), "S", &range->endContainer(), "E");
         fprintf(stderr, "start offset: %d, end offset: %d\n", range->startOffset(), range->endOffset());

trunk/Source/WebCore/dom/Range.h

@@ -34 +34 @@
 class NodeWithIndex;
 class Text;
-class VisiblePosition;
 
 struct SimpleRange;
 
-// FIXME: Rename to LiveRange, while leaving the DOM-exposed name as Range.
 class Range : public RefCounted<Range> {
 public:
@@ -44 +42 @@
     WEBCORE_EXPORT ~Range();
 
-    Document& ownerDocument() const { return m_ownerDocument; }
-
-    Node& startContainer() const { ASSERT(m_start.container()); return *m_start.container(); }
+    Node& startContainer() const { return m_start.container(); }
     unsigned startOffset() const { return m_start.offset(); }
-    Node& endContainer() const { ASSERT(m_end.container()); return *m_end.container(); }
+    Node& endContainer() const { return m_end.container(); }
     unsigned endOffset() const { return m_end.offset(); }
     bool collapsed() const { return m_start == m_end; }
+    Node* commonAncestorContainer() const { return commonInclusiveAncestor(startContainer(), endContainer()).get(); }
 
-    Node* commonAncestorContainer() const { return commonInclusiveAncestor(startContainer(), endContainer()).get(); }
-    WEBCORE_EXPORT ExceptionOr<void> setStart(Ref<Node>&& container, unsigned offset);
-    WEBCORE_EXPORT ExceptionOr<void> setEnd(Ref<Node>&& container, unsigned offset);
+    WEBCORE_EXPORT ExceptionOr<void> setStart(Ref<Node>&&, unsigned offset);
+    WEBCORE_EXPORT ExceptionOr<void> setEnd(Ref<Node>&&, unsigned offset);
+    WEBCORE_EXPORT ExceptionOr<void> setStartBefore(Node&);
+    WEBCORE_EXPORT ExceptionOr<void> setStartAfter(Node&);
+    WEBCORE_EXPORT ExceptionOr<void> setEndBefore(Node&);
+    WEBCORE_EXPORT ExceptionOr<void> setEndAfter(Node&);
     WEBCORE_EXPORT void collapse(bool toStart);
-    WEBCORE_EXPORT ExceptionOr<bool> isPointInRange(Node& refNode, unsigned offset);
-    WEBCORE_EXPORT ExceptionOr<short> comparePoint(Node& refNode, unsigned offset) const;
-    enum CompareResults { NODE_BEFORE, NODE_AFTER, NODE_BEFORE_AND_AFTER, NODE_INSIDE };
-    WEBCORE_EXPORT ExceptionOr<CompareResults> compareNode(Node& refNode) const;
-    enum CompareHow { START_TO_START, START_TO_END, END_TO_END, END_TO_START };
-    WEBCORE_EXPORT ExceptionOr<short> compareBoundaryPoints(CompareHow, const Range& sourceRange) const;
-    WEBCORE_EXPORT ExceptionOr<short> compareBoundaryPointsForBindings(unsigned short compareHow, const Range& sourceRange) const;
-    static ExceptionOr<short> compareBoundaryPoints(Node* containerA, unsigned offsetA, Node* containerB, unsigned offsetB);
-    static ExceptionOr<short> compareBoundaryPoints(const RangeBoundaryPoint& boundaryA, const RangeBoundaryPoint& boundaryB);
-    WEBCORE_EXPORT bool boundaryPointsValid() const;
-    WEBCORE_EXPORT ExceptionOr<bool> intersectsNode(Node& refNode) const;
+    WEBCORE_EXPORT ExceptionOr<void> selectNode(Node&);
+    WEBCORE_EXPORT ExceptionOr<void> selectNodeContents(Node&);
+
+    enum CompareHow : unsigned short { START_TO_START, START_TO_END, END_TO_END, END_TO_START };
+    WEBCORE_EXPORT ExceptionOr<short> compareBoundaryPoints(unsigned short compareHow, const Range& sourceRange) const;
+
     WEBCORE_EXPORT ExceptionOr<void> deleteContents();
     WEBCORE_EXPORT ExceptionOr<Ref<DocumentFragment>> extractContents();
     WEBCORE_EXPORT ExceptionOr<Ref<DocumentFragment>> cloneContents();
     WEBCORE_EXPORT ExceptionOr<void> insertNode(Ref<Node>&&);
+    WEBCORE_EXPORT ExceptionOr<void> surroundContents(Node&);
+
+    WEBCORE_EXPORT Ref<Range> cloneRange() const;
+    static void detach() { }
+
+    WEBCORE_EXPORT ExceptionOr<bool> isPointInRange(Node&, unsigned offset);
+    WEBCORE_EXPORT ExceptionOr<short> comparePoint(Node&, unsigned offset) const;
+    WEBCORE_EXPORT bool intersectsNode(Node&) const;
+
     WEBCORE_EXPORT String toString() const;
 
-    WEBCORE_EXPORT String text() const;
+    Ref<DOMRectList> getClientRects() const;
+    Ref<DOMRect> getBoundingClientRect() const;
 
-    WEBCORE_EXPORT ExceptionOr<Ref<DocumentFragment>> createContextualFragment(const String& html);
+    WEBCORE_EXPORT ExceptionOr<Ref<DocumentFragment>> createContextualFragment(const String& fragment);
 
-    WEBCORE_EXPORT void detach();
-    WEBCORE_EXPORT Ref<Range> cloneRange() const;
+    // Expand range to a unit (word or sentence or block or document) boundary.
+    // Please refer to https://bugs.webkit.org/show_bug.cgi?id=27632 comment #5 for details.
+    WEBCORE_EXPORT ExceptionOr<void> expand(const String&);
 
-    WEBCORE_EXPORT ExceptionOr<void> setStartAfter(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> setEndBefore(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> setEndAfter(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> selectNode(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> selectNodeContents(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> surroundContents(Node&);
-    WEBCORE_EXPORT ExceptionOr<void> setStartBefore(Node&);
-
-    WEBCORE_EXPORT Node* firstNode() const;
+    enum CompareResults : uint8_t { NODE_BEFORE, NODE_AFTER, NODE_BEFORE_AND_AFTER, NODE_INSIDE };
+    WEBCORE_EXPORT ExceptionOr<CompareResults> compareNode(Node&) const;
 
     void nodeChildrenChanged(ContainerNode&);
@@ -101 +100 @@
     void textNodeSplit(Text& oldNode);
 
-    // Expand range to a unit (word or sentence or block or document) boundary.
-    // Please refer to https://bugs.webkit.org/show_bug.cgi?id=27632 comment #5 
-    // for details.
-    WEBCORE_EXPORT ExceptionOr<void> expand(const String&);
-
-    Ref<DOMRectList> getClientRects() const;
-    Ref<DOMRect> getBoundingClientRect() const;
-
 #if ENABLE(TREE_DEBUGGING)
     void formatForDebugger(char* buffer, unsigned length) const;
 #endif
 
-    WEBCORE_EXPORT bool contains(const Range&) const;
-    bool contains(const VisiblePosition&) const;
-
-    enum ActionType { Delete, Extract, Clone };
+    enum ActionType : uint8_t { Delete, Extract, Clone };
 
 private:
     explicit Range(Document&);
 
-    void setDocument(Document&);
-    ExceptionOr<Node*> checkNodeWOffset(Node&, unsigned offset) const;
+    void updateDocument();
+    ExceptionOr<Node*> checkNodeOffsetPair(Node&, unsigned offset) const;
     ExceptionOr<RefPtr<DocumentFragment>> processContents(ActionType);
-
-    Node* pastLastNode() const;
 
     Ref<Document> m_ownerDocument;
@@ -131 +117 @@
     RangeBoundaryPoint m_end;
 };
-
-WEBCORE_EXPORT bool areRangesEqual(const Range*, const Range*);
-WEBCORE_EXPORT bool rangesOverlap(const Range*, const Range*);
 
 WEBCORE_EXPORT SimpleRange makeSimpleRange(const Range&);

trunk/Source/WebCore/dom/Range.idl

@@ -26 +26 @@
 
     readonly attribute Node startContainer;
-    readonly attribute long startOffset; // FIXME: Should be unsigned long.
+    readonly attribute unsigned long startOffset;
     readonly attribute Node endContainer;
-    readonly attribute long endOffset; // FIXME: Should be unsigned long.
+    readonly attribute unsigned long endOffset;
     readonly attribute boolean collapsed;
     readonly attribute Node commonAncestorContainer;
@@ -46 +46 @@
     const unsigned short END_TO_END = 2;
     const unsigned short END_TO_START = 3;
-    [MayThrowException, ImplementedAs=compareBoundaryPointsForBindings] short compareBoundaryPoints(unsigned short how, Range sourceRange);
+    [MayThrowException] short compareBoundaryPoints(unsigned short how, Range sourceRange);
 
     [CEReactions, MayThrowException] void deleteContents();
@@ -60 +60 @@
     [MayThrowException] short comparePoint(Node node, unsigned long offset);
 
-    [MayThrowException] boolean intersectsNode(Node node);
+    boolean intersectsNode(Node node);
 
     stringifier;
@@ -71 +71 @@
     [CEReactions, MayThrowException, NewObject] DocumentFragment createContextualFragment(DOMString fragment);
 
-    // Non standard.
-    [MayThrowException] void expand(optional DOMString unit = "");
+    // Non-standard extension.
+    // FIXME: We should eventually drop this since no other browser supports it.
+    [MayThrowException] void expand(optional DOMString unit);
 
-    // FIXME: We should likely drop this since no other browser supports it.
+    // FIXME: We should likely drop this since we added it for Firefox interoperability, but now no other browser supports it.
     [MayThrowException] short compareNode(Node node);
     const unsigned short NODE_BEFORE = 0;

trunk/Source/WebCore/dom/RangeBoundaryPoint.h

@@ -33 +33 @@
 class RangeBoundaryPoint {
 public:
-    explicit RangeBoundaryPoint(Node* container);
+    explicit RangeBoundaryPoint(Node& container);
 
-    Node* container() const;
+    Node& container() const;
     unsigned offset() const;
     Node* childBefore() const;
-
-    void clear();
 
     void set(Ref<Node>&& container, unsigned offset, Node* childBefore);
     void setOffset(unsigned);
 
-    void setToBeforeChild(Node&);
-    void setToAfterChild(Node&);
-    void setToStartOfNode(Ref<Node>&&);
-    void setToEndOfNode(Ref<Node>&&);
+    void setToBeforeNode(Node&);
+    void setToAfterNode(Node&);
+    void setToBeforeContents(Ref<Node>&&);
+    void setToAfterContents(Ref<Node>&&);
 
     void childBeforeWillBeRemoved();
     void invalidateOffset() const;
-    void ensureOffsetIsValid() const;
 
 private:
-    RefPtr<Node> m_containerNode;
+    Ref<Node> m_container;
     mutable Optional<unsigned> m_offsetInContainer { 0 };
     RefPtr<Node> m_childBeforeBoundary;
@@ -61 +58 @@
 BoundaryPoint makeBoundaryPoint(const RangeBoundaryPoint&);
 
-inline RangeBoundaryPoint::RangeBoundaryPoint(Node* container)
-    : m_containerNode(container)
+inline RangeBoundaryPoint::RangeBoundaryPoint(Node& container)
+    : m_container(container)
 {
-    ASSERT(m_containerNode);
 }
 
-inline Node* RangeBoundaryPoint::container() const
+inline Node& RangeBoundaryPoint::container() const
 {
-    return m_containerNode.get();
+    return m_container;
 }
 
@@ -77 +73 @@
 }
 
-inline void RangeBoundaryPoint::ensureOffsetIsValid() const
-{
-    if (m_offsetInContainer)
-        return;
-
-    ASSERT(m_childBeforeBoundary);
-    m_offsetInContainer = m_childBeforeBoundary->computeNodeIndex() + 1;
-}
-
 inline unsigned RangeBoundaryPoint::offset() const
 {
-    ensureOffsetIsValid();
-    return m_offsetInContainer.value();
-}
-
-inline void RangeBoundaryPoint::clear()
-{
-    m_containerNode = nullptr;
-    m_offsetInContainer = 0;
-    m_childBeforeBoundary = nullptr;
+    if (!m_offsetInContainer) {
+        ASSERT(m_childBeforeBoundary);
+        m_offsetInContainer = m_childBeforeBoundary->computeNodeIndex() + 1;
+    }
+    return *m_offsetInContainer;
 }
 
@@ -102 +85 @@
 {
     ASSERT(childBefore == (offset ? container->traverseToChildAt(offset - 1) : 0));
-    m_containerNode = WTFMove(container);
+    m_container = WTFMove(container);
     m_offsetInContainer = offset;
     m_childBeforeBoundary = childBefore;
@@ -109 +92 @@
 inline void RangeBoundaryPoint::setOffset(unsigned offset)
 {
-    ASSERT(m_containerNode);
-    ASSERT(m_containerNode->isCharacterDataNode());
+    ASSERT(m_container->isCharacterDataNode());
     ASSERT(m_offsetInContainer);
     ASSERT(!m_childBeforeBoundary);
@@ -116 +98 @@
 }
 
-inline void RangeBoundaryPoint::setToBeforeChild(Node& child)
+inline void RangeBoundaryPoint::setToBeforeNode(Node& child)
 {
     ASSERT(child.parentNode());
     m_childBeforeBoundary = child.previousSibling();
-    m_containerNode = child.parentNode();
-    m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : Optional<unsigned>(0);
+    m_container = *child.parentNode();
+    m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : makeOptional(0U);
 }
 
-inline void RangeBoundaryPoint::setToAfterChild(Node& child)
+inline void RangeBoundaryPoint::setToAfterNode(Node& child)
 {
     ASSERT(child.parentNode());
     m_childBeforeBoundary = &child;
-    m_containerNode = child.parentNode();
-    m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : Optional<unsigned>(0);
+    m_container = *child.parentNode();
+    m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : makeOptional(0U);
 }
 
-inline void RangeBoundaryPoint::setToStartOfNode(Ref<Node>&& container)
+inline void RangeBoundaryPoint::setToBeforeContents(Ref<Node>&& container)
 {
-    m_containerNode = WTFMove(container);
+    m_container = WTFMove(container);
     m_offsetInContainer = 0;
     m_childBeforeBoundary = nullptr;
 }
 
-inline void RangeBoundaryPoint::setToEndOfNode(Ref<Node>&& container)
+inline void RangeBoundaryPoint::setToAfterContents(Ref<Node>&& container)
 {
-    m_containerNode = WTFMove(container);
-    if (is<CharacterData>(*m_containerNode)) {
-        m_offsetInContainer = downcast<CharacterData>(*m_containerNode).length();
+    m_container = WTFMove(container);
+    if (is<CharacterData>(m_container)) {
+        m_offsetInContainer = downcast<CharacterData>(m_container.get()).length();
         m_childBeforeBoundary = nullptr;
     } else {
-        m_childBeforeBoundary = m_containerNode->lastChild();
-        m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : Optional<unsigned>(0);
+        m_childBeforeBoundary = m_container->lastChild();
+        m_offsetInContainer = m_childBeforeBoundary ? WTF::nullopt : makeOptional(0U);
     }
 }
@@ -168 +150 @@
 inline bool operator==(const RangeBoundaryPoint& a, const RangeBoundaryPoint& b)
 {
-    if (a.container() != b.container())
+    if (&a.container() != &b.container())
         return false;
-    if (a.childBefore() || b.childBefore()) {
-        if (a.childBefore() != b.childBefore())
-            return false;
-    } else {
-        if (a.offset() != b.offset())
-            return false;
-    }
-    return true;
+    if (a.childBefore() || b.childBefore())
+        return a.childBefore() == b.childBefore();
+    return a.offset() == b.offset();
 }
 
 inline BoundaryPoint makeBoundaryPoint(const RangeBoundaryPoint& point)
 {
-    return { *point.container(), point.offset() };
+    return { point.container(), point.offset() };
 }
 

trunk/Source/WebCore/dom/SimpleRange.cpp

@@ -73 +73 @@
     if (!offset)
         return true;
+    // If the container is not the parent, the child is part of a shadow tree, which we sort between offset 0 and offset 1.
+    if (child.parentNode() != &container)
+        return false;
     unsigned currentOffset = 0;
     for (auto currentChild = container.firstChild(); currentChild && currentChild != &child; currentChild = currentChild->nextSibling()) {
@@ -100 +103 @@
 
     for (auto ancestor = b.container.ptr(); ancestor; ) {
-        auto nextAncestor = ancestor->parentOrShadowHostNode();
+        auto nextAncestor = ancestor->parentInComposedTree();
         if (nextAncestor == a.container.ptr())
             return isOffsetBeforeChild(*nextAncestor, a.offset, *ancestor) ? PartialOrdering::less : PartialOrdering::greater;
@@ -107 +110 @@
 
     for (auto ancestor = a.container.ptr(); ancestor; ) {
-        auto nextAncestor = ancestor->parentOrShadowHostNode();
+        auto nextAncestor = ancestor->parentInComposedTree();
         if (nextAncestor == b.container.ptr())
             return isOffsetBeforeChild(*nextAncestor, b.offset, *ancestor) ? PartialOrdering::greater : PartialOrdering::less;
@@ -206 +209 @@
 }
 
-}
+bool isPointInRange(const SimpleRange& range, const BoundaryPoint& point)
+{
+    return is_lteq(documentOrder(range.start, point)) && is_lteq(documentOrder(point, range.end));
+}
+
+bool isPointInRange(const SimpleRange& range, const Optional<BoundaryPoint>& point)
+{
+    return point && isPointInRange(range, *point);
+}
+
+PartialOrdering documentOrder(const SimpleRange& range, const BoundaryPoint& point)
+{
+    if (auto order = documentOrder(range.start, point); !is_lt(order))
+        return order;
+    if (auto order = documentOrder(range.end, point); !is_gt(order))
+        return order;
+    return PartialOrdering::equivalent;
+}
+
+PartialOrdering documentOrder(const BoundaryPoint& point, const SimpleRange& range)
+{
+    if (auto order = documentOrder(point, range.start); !is_gt(order))
+        return order;
+    if (auto order = documentOrder(point, range.end); !is_lt(order))
+        return order;
+    return PartialOrdering::equivalent;
+}
+
+bool contains(const SimpleRange& outerRange, const SimpleRange& innerRange)
+{
+    return is_lteq(documentOrder(outerRange.start, innerRange.start)) && is_gteq(documentOrder(outerRange.end, innerRange.end));
+}
+
+bool intersects(const SimpleRange& a, const SimpleRange& b)
+{
+    return is_lteq(documentOrder(a.start, b.end)) && is_lteq(documentOrder(b.start, a.end));
+}
+
+SimpleRange unionRange(const SimpleRange& a, const SimpleRange& b)
+{
+    auto& start = is_lteq(documentOrder(a.start, b.start)) ? a : b;
+    auto& end = is_lteq(documentOrder(a.end, b.end)) ? b : a;
+    return { start.start, end.end };
+}
+
+bool contains(const SimpleRange& range, const Node& node)
+{
+    // FIXME: Consider a more efficient algorithm that avoids always computing the node index.
+    // FIXME: Does this const_cast point to a design problem?
+    auto nodeRange = makeRangeSelectingNode(const_cast<Node&>(node));
+    return nodeRange && contains(range, *nodeRange);
+}
+
+bool intersects(const SimpleRange& range, const Node& node)
+{
+    // FIXME: Consider a more efficient algorithm that avoids always computing the node index.
+    // FIXME: Does this const_cast point to a design problem?
+    auto nodeRange = makeRangeSelectingNode(const_cast<Node&>(node));
+    if (!nodeRange)
+        return node.contains(range.start.container.ptr());
+    return is_lt(documentOrder(nodeRange->start, range.end)) && is_lt(documentOrder(range.start, nodeRange->end));
+
+}
+
+}

trunk/Source/WebCore/dom/SimpleRange.h

@@ -65 +65 @@
 
 bool operator==(const SimpleRange&, const SimpleRange&);
+
+WEBCORE_EXPORT bool isPointInRange(const SimpleRange&, const BoundaryPoint&);
+bool isPointInRange(const SimpleRange&, const Optional<BoundaryPoint>&);
+
+WEBCORE_EXPORT bool contains(const SimpleRange& outerRange, const SimpleRange& innerRange);
+WEBCORE_EXPORT bool intersects(const SimpleRange&, const SimpleRange&);
+WEBCORE_EXPORT SimpleRange unionRange(const SimpleRange&, const SimpleRange&);
+
+WEBCORE_EXPORT bool contains(const SimpleRange&, const Node&);
+WEBCORE_EXPORT bool intersects(const SimpleRange&, const Node&);
+
+// Returns equivalent if point is in range.
+WEBCORE_EXPORT PartialOrdering documentOrder(const SimpleRange&, const BoundaryPoint&);
+WEBCORE_EXPORT PartialOrdering documentOrder(const BoundaryPoint&, const SimpleRange&);
 
 class IntersectingNodeRange;

trunk/Source/WebCore/editing/Editing.cpp

@@ -80 +80 @@
 }
 
-// Compare two positions, taking into account the possibility that one or both
-// could be inside a shadow tree. Only works for non-null values.
+// FIXME: Change callers to use documentOrder and delete this.
 int comparePositions(const Position& a, const Position& b)
 {
-    TreeScope* commonScope = commonTreeScope(a.containerNode(), b.containerNode());
-
-    if (!commonScope)
-        return 0;
-
-    Node* nodeA = commonScope->ancestorNodeInThisScope(a.containerNode());
-    ASSERT(nodeA);
-    bool hasDescendentA = nodeA != a.containerNode();
-    int offsetA = hasDescendentA ? 0 : a.computeOffsetInContainerNode();
-
-    Node* nodeB = commonScope->ancestorNodeInThisScope(b.containerNode());
-    ASSERT(nodeB);
-    bool hasDescendentB = nodeB != b.containerNode();
-    int offsetB = hasDescendentB ? 0 : b.computeOffsetInContainerNode();
-
-    int bias = 0;
-    if (nodeA == nodeB) {
-        if (hasDescendentA)
-            bias = -1;
-        else if (hasDescendentB)
-            bias = 1;
-    }
-
-    auto comparisonResult = Range::compareBoundaryPoints(nodeA, offsetA, nodeB, offsetB);
-    if (comparisonResult.hasException())
-        return bias;
-    auto result = comparisonResult.releaseReturnValue();
-    return result ? result : bias;
-}
-
+    auto ordering = documentOrder(a, b);
+    if (is_lt(ordering))
+        return -1;
+    if (is_gt(ordering))
+        return 1;
+    return 0;
+}
+
+// FIXME: Change callers to use documentOrder and delete this.
 int comparePositions(const VisiblePosition& a, const VisiblePosition& b)
 {
@@ -1164 +1142 @@
 bool isNodeVisiblyContainedWithin(Node& node, const SimpleRange& range)
 {
-    // If the node is inside the range, then it surely is contained within.
-    auto comparisonResult = createLiveRange(range)->compareNode(node);
-    if (!comparisonResult.hasException() && comparisonResult.releaseReturnValue() == Range::NODE_INSIDE)
+    if (contains(range, node))
         return true;
 

trunk/Source/WebCore/editing/Editor.cpp

@@ -3551 +3551 @@
 {
     for (auto* ownerElement = frame.ownerElement(); ownerElement; ownerElement = ownerElement->document().ownerElement()) {
-        if (&ownerElement->document() == &range.start.document()) {
-            auto result = createLiveRange(range)->intersectsNode(*ownerElement);
-            return !result.hasException() && result.releaseReturnValue();
-        }
+        if (&ownerElement->document() == &range.start.document())
+            return intersects(range, *ownerElement);
     }
     return false;
@@ -3704 +3702 @@
     auto& selection = m_document.selection();
     if (selection.isRange()) {
-        if (auto selectedRange = selection.selection().firstRange()) {
-            // Extend the range a few characters in each direction to detect incompletely selected phone numbers.
-            constexpr unsigned charactersToExtend = 15;
-            auto selectedLiveRange = createLiveRange(*selectedRange);
-            for (auto& range : scanForTelephoneNumbers(extendSelection(*selectedRange, charactersToExtend))) {
-                // FIXME: Why do we do this unconditionally and the code below this only when it overlaps the selection?
-                addMarker(range, DocumentMarker::TelephoneNumber);
-
-                // Only consider ranges with a detected telephone number if they overlap with the actual selection range.
-                if (rangesOverlap(createLiveRange(range).ptr(), selectedLiveRange.ptr()))
-                    m_detectedTelephoneNumberRanges.append(range);
-            }
+        auto selectedRange = *selection.selection().firstRange();
+        // Extend the range a few characters in each direction to detect incompletely selected phone numbers.
+        constexpr unsigned charactersToExtend = 15;
+        for (auto& range : scanForTelephoneNumbers(extendSelection(selectedRange, charactersToExtend))) {
+            // FIXME: Why do we do this unconditionally instead of when only when it overlaps the selection?
+            addMarker(range, DocumentMarker::TelephoneNumber);
+
+            // Only consider ranges with a detected telephone number if they overlap with the selection.
+            if (intersects(range, selectedRange))
+                m_detectedTelephoneNumberRanges.append(range);
         }
     }

trunk/Source/WebCore/editing/EditorCommand.cpp

@@ -229 +229 @@
 }
 
-static SimpleRange unionRanges(const SimpleRange& a, const SimpleRange& b)
-{
-    auto& start = createLiveRange(a)->compareBoundaryPoints(Range::START_TO_START, createLiveRange(b)).releaseReturnValue() <= 0 ? a : b;
-    auto& end = createLiveRange(a)->compareBoundaryPoints(Range::END_TO_END, createLiveRange(b)).releaseReturnValue() <= 0 ? b : a;
-    return { start.start, end.end };
-}
-
 // Execute command functions
 
@@ -354 +347 @@
 static bool executeDeleteToMark(Frame& frame, Event*, EditorCommandSource, const String&)
 {
-    auto mark = frame.editor().mark().toNormalizedRange();
+    auto& editor = frame.editor();
     auto& selection = frame.selection();
-    if (mark && frame.editor().selectedRange()) {
-        if (!selection.setSelectedRange(unionRanges(*mark, *frame.editor().selectedRange()), DOWNSTREAM, FrameSelection::ShouldCloseTyping::Yes))
+    auto markRange = editor.mark().toNormalizedRange();
+    auto selectionRange = selection.selection().toNormalizedRange();
+    if (markRange && selectionRange) {
+        if (!selection.setSelectedRange(unionRange(*markRange, *selectionRange), DOWNSTREAM, FrameSelection::ShouldCloseTyping::Yes))
             return false;
     }
-    frame.editor().performDelete();
-    frame.editor().setMark(selection.selection());
+    editor.performDelete();
+    editor.setMark(selection.selection());
     return true;
 }
@@ -1051 +1046 @@
 static bool executeSelectToMark(Frame& frame, Event*, EditorCommandSource, const String&)
 {
-    auto mark = frame.editor().mark().toNormalizedRange();
-    auto selection = frame.editor().selectedRange();
-    if (!mark || !selection) {
+    auto& editor = frame.editor();
+    auto& selection = frame.selection();
+    auto markRange = editor.mark().toNormalizedRange();
+    auto selectionRange = selection.selection().toNormalizedRange();
+    if (!markRange || !selectionRange) {
         PAL::systemBeep();
         return false;
     }
-    frame.selection().setSelectedRange(unionRanges(*mark, *selection), DOWNSTREAM, FrameSelection::ShouldCloseTyping::Yes);
+    selection.setSelectedRange(unionRange(*markRange, *selectionRange), DOWNSTREAM, FrameSelection::ShouldCloseTyping::Yes);
     // FIXME: Why do we ignore the return value from setSelectedRange here?
     return true;

trunk/Source/WebCore/editing/FrameSelection.cpp

@@ -555 +555 @@
             m_selection.setWithoutValidation(m_selection.end(), m_selection.start());
     } else if (isRange()) {
-        if (auto range = m_selection.firstRange()) {
-            auto compareNodeResult = createLiveRange(*range)->compareNode(node);
-            if (!compareNodeResult.hasException()) {
-                auto compareResult = compareNodeResult.releaseReturnValue();
-                if (compareResult == Range::NODE_BEFORE_AND_AFTER || compareResult == Range::NODE_INSIDE) {
-                    // If we did nothing here, when this node's renderer was destroyed, the rect that it
-                    // occupied would be invalidated, but, selection gaps that change as a result of
-                    // the removal wouldn't be invalidated.
-                    // FIXME: Don't do so much unnecessary invalidation.
-                    clearRenderTreeSelection = true;
-                }
-            }
+        if (auto range = m_selection.firstRange(); range && intersects(*range, node)) {
+            // If we did nothing here, when this node's renderer was destroyed, the rect that it
+            // occupied would be invalidated, but, selection gaps that change as a result of
+            // the removal wouldn't be invalidated.
+            // FIXME: Don't do so much unnecessary invalidation.
+            clearRenderTreeSelection = true;
         }
     }
@@ -2035 +2029 @@
         return false;
 
-    if (&range->start.container->document() != &range->end.container->document())
+    if (&range->start.document() != &range->end.document())
         return false;
 

trunk/Source/WebCore/editing/ReplaceRangeWithTextCommand.cpp

@@ -42 +42 @@
 
 ReplaceRangeWithTextCommand::ReplaceRangeWithTextCommand(const SimpleRange& rangeToBeReplaced, const String& text)
-    : CompositeEditCommand(rangeToBeReplaced.start.container->document(), EditAction::InsertReplacement)
+    : CompositeEditCommand(rangeToBeReplaced.start.document(), EditAction::InsertReplacement)
     , m_rangeToBeReplaced(rangeToBeReplaced)
     , m_text(text)

trunk/Source/WebCore/editing/SpellingCorrectionCommand.cpp

@@ -85 +85 @@
 
 SpellingCorrectionCommand::SpellingCorrectionCommand(const SimpleRange& rangeToBeCorrected, const String& correction)
-    : CompositeEditCommand(rangeToBeCorrected.start.container->document(), EditAction::InsertReplacement)
+    : CompositeEditCommand(rangeToBeCorrected.start.document(), EditAction::InsertReplacement)
     , m_rangeToBeCorrected(rangeToBeCorrected)
     , m_selectionToBeCorrected(m_rangeToBeCorrected)

trunk/Source/WebCore/editing/TextCheckingHelper.cpp

@@ -338 +338 @@
                     checkingTypes.add(TextCheckingType::Grammar);
                 VisibleSelection currentSelection;
-                if (Frame* frame = paragraphRange.start.container->document().frame())
+                if (Frame* frame = paragraphRange.start.document().frame())
                     currentSelection = frame->selection().selection();
                 checkTextOfParagraph(*m_client.textChecker(), paragraphString, checkingTypes, results, currentSelection);

trunk/Source/WebCore/editing/mac/DictionaryLookupLegacy.mm

@@ -69 +69 @@
         return false;
 
-    auto selectedRange = selection.toNormalizedRange();
-    if (!selectedRange)
-        return false;
-
-    return createLiveRange(*selectedRange)->contains(position);
+    auto selectedRange = selection.firstRange();
+    return selectedRange && isPointInRange(*selectedRange, makeBoundaryPoint(position));
 }
 

trunk/Source/WebCore/editing/markup.cpp

@@ -1121 +1121 @@
 Ref<DocumentFragment> createFragmentFromText(const SimpleRange& context, const String& text)
 {
-    auto& document = context.start.container->document();
+    auto& document = context.start.document();
     auto fragment = document.createDocumentFragment();
     

trunk/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp

@@ -456 +456 @@
 RefPtr<LegacyWebArchive> LegacyWebArchive::create(const SimpleRange& range)
 {
-    auto& document = range.start.container->document();
+    auto& document = range.start.document();
     auto* frame = document.frame();
     if (!frame)

trunk/Source/WebCore/page/DOMSelection.cpp

@@ -28 +28 @@
  */
 
-
 #include "config.h"
 #include "DOMSelection.h"
@@ -285 +284 @@
 ExceptionOr<void> DOMSelection::extend(Node& node, unsigned offset)
 {
-    auto* frame = this->frame();
+    auto frame = makeRefPtr(this->frame());
     if (!frame)
         return { };
-    if (offset > (node.isCharacterDataNode() ? caretMaxOffset(node) : node.countChildNodes()))
+    if (offset > node.length())
         return Exception { IndexSizeError };
     if (!isValidForPosition(&node))
         return { };
-
-    Ref<Frame> protector(*frame);
     frame->selection().setExtent(createLegacyEditingPosition(&node, offset), DOWNSTREAM);
     return { };
@@ -302 +299 @@
     if (index >= rangeCount())
         return Exception { IndexSizeError };
-
-    // If you're hitting this, you've added broken multi-range selection support.
-    ASSERT(rangeCount() == 1);
-
-    auto* frame = this->frame();
-    if (auto* shadowAncestor = selectionShadowAncestor(*frame)) {
-        auto* container = shadowAncestor->parentNodeGuaranteedHostFree();
-        unsigned offset = shadowAncestor->computeNodeIndex();
-        return createLiveRange(makeSimpleRange(BoundaryPoint { *container, offset }));
+    auto& frame = *this->frame();
+    if (auto shadowAncestor = selectionShadowAncestor(frame))
+        return createLiveRange(makeSimpleRange(*makeBoundaryPointBeforeNode(*shadowAncestor)));
+    return createLiveRange(*frame.selection().selection().firstRange());
+}
+
+void DOMSelection::removeAllRanges()
+{
+    auto* frame = this->frame();
+    if (!frame)
+        return;
+    frame->selection().clear();
+}
+
+void DOMSelection::addRange(Range& liveRange)
+{
+    auto frame = makeRefPtr(this->frame());
+    if (!frame)
+        return;
+
+    auto range = makeSimpleRange(liveRange);
+    auto& selection = frame->selection();
+
+    if (auto selectedRange = selection.selection().toNormalizedRange()) {
+        if (!selectedRange->start.container->containingShadowRoot() && intersects(*selectedRange, range))
+            selection.setSelection(unionRange(*selectedRange, range));
+        return;
     }
 
-    auto firstRange = frame->selection().selection().firstRange();
-    ASSERT(firstRange);
-    if (!firstRange)
-        return Exception { IndexSizeError };
-    return createLiveRange(*firstRange);
-}
-
-void DOMSelection::removeAllRanges()
-{
-    auto* frame = this->frame();
-    if (!frame)
-        return;
-    frame->selection().clear();
-}
-
-void DOMSelection::addRange(Range& range)
-{
-    auto* frame = this->frame();
-    if (!frame)
-        return;
-
-    Ref<Frame> protector(*frame);
-
-    auto& selection = frame->selection();
-    auto selectedRange = selection.selection().toNormalizedRange();
-    if (!selectedRange || selectedRange->start.container->containingShadowRoot()) {
-        selection.setSelection(makeSimpleRange(range));
-        return;
-    }
-
-    auto normalizedRange = createLiveRange(selectedRange);
-    auto result = range.compareBoundaryPoints(Range::START_TO_START, *normalizedRange);
-    if (!result.hasException() && result.releaseReturnValue() == -1) {
-        // We don't support discontiguous selection. We don't do anything if the two ranges don't intersect.
-        result = range.compareBoundaryPoints(Range::START_TO_END, *normalizedRange);
-        if (!result.hasException() && result.releaseReturnValue() > -1) {
-            result = range.compareBoundaryPoints(Range::END_TO_END, *normalizedRange);
-            if (!result.hasException() && result.releaseReturnValue() == -1) {
-                // The ranges intersect.
-                selection.moveTo(makeDeprecatedLegacyPosition(&range.startContainer(), range.startOffset()), makeDeprecatedLegacyPosition(&normalizedRange->endContainer(), normalizedRange->endOffset()), DOWNSTREAM);
-            } else {
-                // The new range contains the original range.
-                selection.setSelection(makeSimpleRange(range));
-            }
-        }
-    } else {
-        // We don't support discontiguous selection. We don't do anything if the two ranges don't intersect.
-        result = range.compareBoundaryPoints(Range::END_TO_START, *normalizedRange);
-        if (!result.hasException() && result.releaseReturnValue() < 1) {
-            result = range.compareBoundaryPoints(Range::END_TO_END, *normalizedRange);
-            if (!result.hasException() && result.releaseReturnValue() == -1) {
-                // The original range contains the new range.
-                selection.setSelection(makeSimpleRange(*normalizedRange));
-            } else {
-                // The ranges intersect.
-                selection.moveTo(makeDeprecatedLegacyPosition(&normalizedRange->startContainer(), normalizedRange->startOffset()), makeDeprecatedLegacyPosition(&range.endContainer(), range.endOffset()), DOWNSTREAM);
-            }
-        }
-    }
+    selection.setSelection(range);
 }
 
@@ -393 +350 @@
 bool DOMSelection::containsNode(Node& node, bool allowPartial) const
 {
+    // FIXME: This behavior does not match what the selection API standard specifies.
+    if (node.isTextNode())
+        allowPartial = true;
+
     auto* frame = this->frame();
     if (!frame)
         return false;
 
-    auto& selection = frame->selection();
-    if (frame->document() != &node.document() || selection.isNone())
-        return false;
-
-    Ref<Node> protectedNode(node);
-    auto selectedRange = selection.selection().toNormalizedRange();
+    auto selectedRange = frame->selection().selection().firstRange();
     if (!selectedRange || selectedRange->start.container->containingShadowRoot())
         return false;
 
-    ContainerNode* parentNode = node.parentNode();
-    if (!parentNode || !parentNode->isConnected())
-        return false;
-    unsigned nodeIndex = node.computeNodeIndex();
-
-    auto startsResult = Range::compareBoundaryPoints(parentNode, nodeIndex, &selectedRange->startContainer(), selectedRange->startOffset());
-    if (startsResult.hasException())
-        return false;
-
-    auto endsResult = Range::compareBoundaryPoints(parentNode, nodeIndex + 1, &selectedRange->endContainer(), selectedRange->endOffset());
-    ASSERT(!endsResult.hasException());
-    bool isNodeFullySelected = !startsResult.hasException() && startsResult.releaseReturnValue() >= 0
-        && !endsResult.hasException() && endsResult.releaseReturnValue() <= 0;
-    if (isNodeFullySelected)
-        return true;
-
-    auto startEndResult = Range::compareBoundaryPoints(parentNode, nodeIndex, &selectedRange->endContainer(), selectedRange->endOffset());
-    ASSERT(!startEndResult.hasException());
-    auto endStartResult = Range::compareBoundaryPoints(parentNode, nodeIndex + 1, &selectedRange->startContainer(), selectedRange->startOffset());
-    ASSERT(!endStartResult.hasException());
-    bool isNodeFullyUnselected = (!startEndResult.hasException() && startEndResult.releaseReturnValue() > 0)
-        || (!endStartResult.hasException() && endStartResult.releaseReturnValue() < 0);
-    if (isNodeFullyUnselected)
-        return false;
-
-    return allowPartial || node.isTextNode();
+    return allowPartial ? intersects(*selectedRange, node) : contains(*selectedRange, node);
 }
 
@@ -484 +415 @@
 {
     auto* frame = this->frame();
-    if (!frame)
-        return false;
-    if (!node)
-        return true;
-    return &node->document() == frame->document();
+    return frame && (!node || &node->document() == frame->document());
 }
 

trunk/Source/WebCore/page/DragController.cpp

@@ -155 +155 @@
             String url = dragData.asURL(DragData::DoNotConvertFilenames, &title);
             if (!url.isEmpty()) {
-                auto& document = context.start.container->document();
+                auto& document = context.start.document();
                 auto anchor = HTMLAnchorElement::create(document);
                 anchor->setHref(url);
@@ -775 +775 @@
     if (!startElement)
         return nullptr;
+
 #if ENABLE(ATTACHMENT_ELEMENT)
     if (auto attachment = enclosingAttachmentElement(*startElement)) {
-        auto selection = sourceFrame->selection().selection();
+        auto& selection = sourceFrame->selection().selection();
         bool isSingleAttachmentSelection = selection.start() == Position(attachment.get(), Position::PositionIsBeforeAnchor) && selection.end() == Position(attachment.get(), Position::PositionIsAfterAnchor);
-        bool isAttachmentElementInCurrentSelection = false;
-        if (auto selectedRange = selection.toNormalizedRange()) {
-            auto compareResult = createLiveRange(*selectedRange)->compareNode(*attachment);
-            isAttachmentElementInCurrentSelection = !compareResult.hasException() && compareResult.releaseReturnValue() == Range::NODE_INSIDE;
-        }
-
-        if (!isAttachmentElementInCurrentSelection || isSingleAttachmentSelection) {
+        auto selectedRange = selection.firstRange();
+        if (isSingleAttachmentSelection || !selectedRange || !contains(*selectedRange, *attachment)) {
             state.type = DragSourceAction::Attachment;
             return attachment.get();
@@ -1472 +1468 @@
     Vector<Ref<HTMLImageElement>> placeholders;
     for (auto& placeholder : descendantsOfType<HTMLImageElement>(downcast<ContainerNode>(*container))) {
-        auto intersectsNode = createLiveRange(*insertedContentRange)->intersectsNode(placeholder);
-        if (!intersectsNode.hasException() && intersectsNode.returnValue())
+        if (intersects(*insertedContentRange, placeholder))
             placeholders.append(placeholder);
     }

trunk/Source/WebCore/page/EventHandler.cpp

@@ -2742 +2742 @@
     if (element && m_frame.selection().isRange()) {
         if (auto range = m_frame.selection().selection().toNormalizedRange()) {
-            auto result = createLiveRange(*range)->compareNode(*element);
-            if (!result.hasException() && result.releaseReturnValue() == Range::NODE_INSIDE && element->isDescendantOf(m_frame.document()->focusedElement()))
+            if (contains(*range, *element) && element->isDescendantOf(m_frame.document()->focusedElement()))
                 return true;
         }

trunk/Source/WebCore/page/Page.cpp

@@ -731 +731 @@
     if (frameWithSelection) {
         result.indexForSelection = NoMatchAfterUserSelection;
-        auto selectedRange = frameWithSelection->selection().selection().firstRange();
+        auto selectedRange = *frameWithSelection->selection().selection().firstRange();
         if (options.contains(Backwards)) {
             for (size_t i = result.ranges.size(); i > 0; --i) {
-                auto comparisonResult = createLiveRange(selectedRange)->compareBoundaryPoints(Range::END_TO_START, createLiveRange(result.ranges[i - 1]));
-                if (!comparisonResult.hasException() && comparisonResult.returnValue() > 0) {
+                // FIXME: Seems like this should be is_gteq to correctly handle the same string found twice in a row.
+                if (is_gt(documentOrder(selectedRange.start, result.ranges[i - 1].end))) {
                     result.indexForSelection = i - 1;
                     break;
@@ -742 +742 @@
         } else {
             for (size_t i = 0, size = result.ranges.size(); i < size; ++i) {
-                auto comparisonResult = createLiveRange(selectedRange)->compareBoundaryPoints(Range::START_TO_END, createLiveRange(result.ranges[i]));
-                if (!comparisonResult.hasException() && comparisonResult.returnValue() < 0) {
+                // FIXME: Seems like this should be is_lteq to correctly handle the same string found twice in a row.
+                if (is_lt(documentOrder(selectedRange.end, result.ranges[i].start))) {
                     result.indexForSelection = i;
                     break;
@@ -764 +764 @@
         return WTF::nullopt;
 
-    if (referenceRange && referenceRange->start.container->document().page() != this)
+    if (referenceRange && referenceRange->start.document().page() != this)
         return WTF::nullopt;
 
     CanWrap canWrap = options.contains(WrapAround) ? CanWrap::Yes : CanWrap::No;
-    Frame* frame = referenceRange ? referenceRange->start.container->document().frame() : &mainFrame();
+    Frame* frame = referenceRange ? referenceRange->start.document().frame() : &mainFrame();
     Frame* startFrame = frame;
     do {

trunk/Source/WebCore/page/mac/ServicesOverlayController.mm

@@ -631 +631 @@
 
     for (auto& highlight : m_potentialHighlights) {
-        if (highlight->type() == Highlight::TelephoneNumberType && createLiveRange(highlight->range())->contains(createLiveRange(*selectionRange)))
+        if (highlight->type() == Highlight::TelephoneNumberType && contains(highlight->range(), *selectionRange))
             return highlight.get();
     }

trunk/Source/WebCore/rendering/RenderObject.cpp

@@ -1976 +1976 @@
     Vector<FloatRect> rects;
 
-    range.start.container->document().updateLayoutIgnorePendingStylesheets();
+    range.start.document().updateLayoutIgnorePendingStylesheets();
 
     bool useVisibleBounds = behavior.contains(RenderObject::BoundingRectBehavior::UseVisibleBounds);

trunk/Source/WebCore/testing/Internals.cpp

@@ -2162 +2162 @@
 }
 
-String Internals::rangeAsText(const Range& range)
-{
-    return range.text();
-}
-
-String Internals::rangeAsTextUsingBackwardsTextIterator(const Range& range)
-{
-    String result;
-    for (SimplifiedBackwardsTextIterator backwardsIterator(makeSimpleRange(range)); !backwardsIterator.atEnd(); backwardsIterator.advance())
-        result.insert(backwardsIterator.text().toString(), 0);
-    return result;
-}
-
-Ref<Range> Internals::subrange(Range& range, unsigned rangeLocation, unsigned rangeLength)
-{
-    return createLiveRange(resolveCharacterRange(makeSimpleRange(range), { rangeLocation, rangeLength }));
-}
-
-RefPtr<Range> Internals::rangeOfStringNearLocation(const Range& range, const String& text, unsigned targetOffset)
-{
-    return createLiveRange(findClosestPlainText(makeSimpleRange(range), text, { }, targetOffset));
+String Internals::rangeAsText(const Range& liveRange)
+{
+    auto range = makeSimpleRange(liveRange);
+    range.start.document().updateLayout();
+    return plainText(range);
+}
+
+// FIXME: Move this to StringConcatenate.h.
+static String join(Vector<String>&& strings)
+{
+    StringBuilder result;
+    for (auto& string : strings)
+        result.append(WTFMove(string));
+    return result.toString();
+}
+
+String Internals::rangeAsTextUsingBackwardsTextIterator(const Range& liveRange)
+{
+    auto range = makeSimpleRange(liveRange);
+    range.start.document().updateLayout();
+    Vector<String> strings;
+    for (SimplifiedBackwardsTextIterator backwardsIterator(range); !backwardsIterator.atEnd(); backwardsIterator.advance())
+        strings.append(backwardsIterator.text().toString());
+    strings.reverse();
+    return join(WTFMove(strings));
+}
+
+Ref<Range> Internals::subrange(Range& liveRange, unsigned rangeLocation, unsigned rangeLength)
+{
+    auto range = makeSimpleRange(liveRange);
+    range.start.document().updateLayout();
+    return createLiveRange(resolveCharacterRange(range, { rangeLocation, rangeLength }));
+}
+
+RefPtr<Range> Internals::rangeOfStringNearLocation(const Range& liveRange, const String& text, unsigned targetOffset)
+{
+    auto range = makeSimpleRange(liveRange);
+    range.start.document().updateLayout();
+    return createLiveRange(findClosestPlainText(range, text, { }, targetOffset));
 }
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-08-28  Darin Adler  <darin@apple.com>
+
+        Remove almost all the remaining uses of live ranges
+        https://bugs.webkit.org/show_bug.cgi?id=215755
+
+        Reviewed by Sam Weinig.
+
+        * WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMRange.cpp:
+        (webkit_dom_range_compare_boundary_points): Update for rename of
+        compareBoundaryPointsForBindings.
+        (webkit_dom_range_intersects_node): Removed exception handling.
+        (webkit_dom_range_get_text): Use plainText.
+
+        * WebProcess/InjectedBundle/API/mac/WKDOMRange.mm:
+        (-[WKDOMRange initWithDocument:]): Tightened up into a one-liner.
+        (-[WKDOMRange text]): Use plainText.
+        (-[WKDOMRange textRects]): Stopped using Range::ownerDocument.
+
+        * WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp:
+        (WebKit::InjectedBundleRangeHandle::document): Stopped using
+        Range::ownerDocument.
+        (WebKit::InjectedBundleRangeHandle::boundingRectInWindowCoordinates const):
+        Ditto.
+        (WebKit::InjectedBundleRangeHandle::renderedImage): Ditto.
+        (WebKit::InjectedBundleRangeHandle::text const): Use plainText.
+
+        * WebProcess/WebPage/glib/WebPageGLib.cpp:
+        (WebKit::WebPage::getPlatformEditorState const): Use contains.
+
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::requestDocumentEditingContext): Use intersects.
+
 2020-08-28  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebKit/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMRange.cpp

@@ -26 +26 @@
 #include <WebCore/Document.h>
 #include <WebCore/JSExecState.h>
+#include <WebCore/TextIterator.h>
 #include "WebKitDOMDocumentFragmentPrivate.h"
 #include "WebKitDOMNodePrivate.h"
@@ -356 +357 @@
     g_return_val_if_fail(WEBKIT_DOM_IS_RANGE(sourceRange), 0);
     g_return_val_if_fail(!error || !*error, 0);
-    WebCore::Range* item = WebKit::core(self);
-    WebCore::Range* convertedSourceRange = WebKit::core(sourceRange);
-    auto result = item->compareBoundaryPointsForBindings(how, *convertedSourceRange);
+    auto result = WebKit::core(self)->compareBoundaryPoints(how, *WebKit::core(sourceRange));
     if (result.hasException()) {
         auto description = WebCore::DOMException::description(result.releaseException().code());
@@ -509 +508 @@
     g_return_val_if_fail(WEBKIT_DOM_IS_NODE(refNode), FALSE);
     g_return_val_if_fail(!error || !*error, FALSE);
-    WebCore::Range* item = WebKit::core(self);
-    WebCore::Node* convertedRefNode = WebKit::core(refNode);
-    auto result = item->intersectsNode(*convertedRefNode);
-    if (result.hasException()) {
-        auto description = WebCore::DOMException::description(result.releaseException().code());
-        g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), description.legacyCode, description.name);
-        return false;
-    }
-    return result.releaseReturnValue();
+    return WebKit::core(self)->intersectsNode(*WebKit::core(refNode));
 }
 
@@ -633 +624 @@
     WebCore::JSMainThreadNullState state;
     g_return_val_if_fail(WEBKIT_DOM_IS_RANGE(self), 0);
-    WebCore::Range* item = WebKit::core(self);
-    gchar* result = convertToUTF8String(item->text());
-    return result;
+    auto range = makeSimpleRange(*WebKit::core(self));
+    range.start.document().updateLayout();
+    return convertToUTF8String(plainText(range));
 }
 

trunk/Source/WebKit/WebProcess/InjectedBundle/API/mac/WKDOMRange.mm

@@ -31 +31 @@
 #import "WKDOMInternals.h"
 #import <WebCore/Document.h>
+#import <WebCore/TextIterator.h>
 #import <WebCore/VisibleUnits.h>
 #import <wtf/cocoa/VectorCocoa.h>
@@ -50 +51 @@
 - (id)initWithDocument:(WKDOMDocument *)document
 {
-    auto range = WebCore::Range::create(*WebKit::toWebCoreDocument(document));
-    self = [self _initWithImpl:range.ptr()];
-    if (!self)
-        return nil;
-
-    return self;
+    return [self _initWithImpl:WebCore::Range::create(*WebKit::toWebCoreDocument(document)).ptr()];
 }
 
@@ -119 +115 @@
 - (NSString *)text
 {
-    return _impl->text();
+    auto range = makeSimpleRange(*_impl);
+    range.start.document().updateLayout();
+    return plainText(range);
 }
 
@@ -129 +127 @@
 - (NSArray *)textRects
 {
-    _impl->ownerDocument().updateLayoutIgnorePendingStylesheets();
-    return createNSArray(WebCore::RenderObject::absoluteTextRects(makeSimpleRange(*_impl))).autorelease();
+    auto range = makeSimpleRange(*_impl);
+    range.start.document().updateLayoutIgnorePendingStylesheets();
+    return createNSArray(WebCore::RenderObject::absoluteTextRects(range)).autorelease();
 }
 

trunk/Source/WebKit/WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp

@@ -45 +45 @@
 #include <WebCore/RenderView.h>
 #include <WebCore/SimpleRange.h>
+#include <WebCore/TextIterator.h>
 #include <WebCore/VisibleSelection.h>
 #include <wtf/HashMap.h>
@@ -98 +99 @@
 Ref<InjectedBundleNodeHandle> InjectedBundleRangeHandle::document()
 {
-    return InjectedBundleNodeHandle::getOrCreate(m_range->ownerDocument());
+    return InjectedBundleNodeHandle::getOrCreate(m_range->startContainer().document());
 }
 
 WebCore::IntRect InjectedBundleRangeHandle::boundingRectInWindowCoordinates() const
 {
-    Frame* frame = m_range->ownerDocument().frame();
-    return frame->view()->contentsToWindow(enclosingIntRect(unionRectIgnoringZeroRects(RenderObject::absoluteBorderAndTextRects(makeSimpleRange(m_range)))));
+    auto range = makeSimpleRange(m_range);
+    auto frame = range.start.document().frame();
+    if (!frame)
+        return { };
+    auto view = frame->view();
+    if (!view)
+        return { };
+    return view->contentsToWindow(enclosingIntRect(unionRectIgnoringZeroRects(RenderObject::absoluteBorderAndTextRects(range))));
 }
 
 RefPtr<WebImage> InjectedBundleRangeHandle::renderedImage(SnapshotOptions options)
 {
-    Document& ownerDocument = m_range->ownerDocument();
-    Frame* frame = ownerDocument.frame();
+    auto range = makeSimpleRange(m_range);
+
+    auto document = makeRef(range.start.document());
+
+    auto frame = makeRefPtr(document->frame());
     if (!frame)
         return nullptr;
 
-    FrameView* frameView = frame->view();
+    auto frameView = frame->view();
     if (!frameView)
         return nullptr;
@@ -122 +132 @@
 #endif
 
-    Ref<Frame> protector(*frame);
-
     VisibleSelection oldSelection = frame->selection().selection();
-    frame->selection().setSelection(makeSimpleRange(m_range));
+    frame->selection().setSelection(range);
 
     float scaleFactor = (options & SnapshotOptionsExcludeDeviceScaleFactor) ? 1 : frame->page()->deviceScaleFactor();
-    IntRect paintRect = enclosingIntRect(unionRectIgnoringZeroRects(RenderObject::absoluteBorderAndTextRects(makeSimpleRange(m_range))));
+    IntRect paintRect = enclosingIntRect(unionRectIgnoringZeroRects(RenderObject::absoluteBorderAndTextRects(range)));
     IntSize backingStoreSize = paintRect.size();
     backingStoreSize.scale(scaleFactor);
@@ -156 +164 @@
 
     frameView->setPaintBehavior(paintBehavior);
-    ownerDocument.updateLayout();
+    document->updateLayout();
 
     frameView->paint(*graphicsContext, paintRect);
@@ -168 +176 @@
 String InjectedBundleRangeHandle::text() const
 {
-    return m_range->text();
+    auto range = makeSimpleRange(m_range);
+    range.start.document().updateLayout();
+    return plainText(range);
 }
 

trunk/Source/WebKit/WebProcess/WebPage/FindController.cpp

@@ -306 +306 @@
     if (matchIndex >= m_findMatches.size())
         return;
-    Frame* frame = m_findMatches[matchIndex].start.container->document().frame();
+    Frame* frame = m_findMatches[matchIndex].start.document().frame();
     if (!frame)
         return;
@@ -337 +337 @@
     if (matchIndex >= m_findMatches.size())
         return;
-    Frame* frame = m_findMatches[matchIndex].start.container->document().frame();
+    Frame* frame = m_findMatches[matchIndex].start.document().frame();
     if (!frame)
         return;

trunk/Source/WebKit/WebProcess/WebPage/glib/WebPageGLib.cpp

@@ -110 +110 @@
         auto surroundingRange = makeSimpleRange(surroundingStart, endOfEditableContent(selectionStart));
         auto compositionRange = frame.editor().compositionRange();
-        if (surroundingRange && compositionRange && createLiveRange(surroundingRange)->contains(createLiveRange(*compositionRange).get())) {
+        if (surroundingRange && compositionRange && contains(*surroundingRange, *compositionRange)) {
             auto beforeText = plainText({ surroundingRange->start, compositionRange->start });
             postLayoutData.surroundingContext = beforeText + plainText({ compositionRange->end, surroundingRange->end });

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

@@ -4201 +4201 @@
     auto selectionRange = selection.toNormalizedRange();
     auto rangeOfInterest = *makeSimpleRange(rangeOfInterestStart, rangeOfInterestEnd);
-    if (selectionRange && rangesOverlap(createLiveRange(rangeOfInterest).ptr(), createLiveRange(*selectionRange).ptr())) {
+    if (selectionRange && intersects(rangeOfInterest, *selectionRange)) {
         startOfRangeOfInterestInSelection = std::max(rangeOfInterestStart, selectionStart);
         endOfRangeOfInterestInSelection = std::min(rangeOfInterestEnd, selectionEnd);
@@ -4266 +4266 @@
     context.selectedText = makeString(startOfRangeOfInterestInSelection, endOfRangeOfInterestInSelection);
     context.contextAfter = makeString(endOfRangeOfInterestInSelection, contextAfterEnd);
-    if (compositionRange && rangesOverlap(createLiveRange(rangeOfInterest).ptr(), createLiveRange(*compositionRange).ptr())) {
+    if (compositionRange && intersects(rangeOfInterest, *compositionRange)) {
         VisiblePosition compositionStart(createLegacyEditingPosition(compositionRange->start));
         VisiblePosition compositionEnd(createLegacyEditingPosition(compositionRange->end));
@@ -4282 +4282 @@
             if (!iterator.text().isEmpty()) {
                 auto absoluteBoundingBox = unionRect(RenderObject::absoluteTextRects(iterator.range(), RenderObject::BoundingRectBehavior::IgnoreEmptyTextSelections));
-                rects.append({ iterator.range().start.container->document().view()->contentsToRootView(absoluteBoundingBox), { offsetSoFar++, stride } });
+                rects.append({ iterator.range().start.document().view()->contentsToRootView(absoluteBoundingBox), { offsetSoFar++, stride } });
             }
             iterator.advance(stride);

trunk/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm

@@ -878 +878 @@
             continue;
 
-        auto view = actionContext->range.start.container->document().view();
+        auto view = actionContext->range.start.document().view();
         if (!view)
             continue;

trunk/Source/WebKitLegacy/mac/ChangeLog

@@ +1 @@
+2020-08-28  Darin Adler  <darin@apple.com>
+
+        Remove almost all the remaining uses of live ranges
+        https://bugs.webkit.org/show_bug.cgi?id=215755
+
+        Reviewed by Sam Weinig.
+
+        * DOM/DOMRange.mm:
+        (-[DOMRange text]): Use plainText.
+        (-[DOMRange compareBoundaryPoints:sourceRange:]): Update for rename of
+        compareBoundaryPointsForBindings.
+        (-[DOMRange intersectsNode:]): Removed raiseOnDOMError.
+
+        * DOM/DOMUIKitExtensions.mm:
+        (firstNodeAfter): Moved Range::firstNode here since it's the only remaining caller;
+        might need to keep legacy behavior depending on how this is used by UIKit.
+        (-[DOMRange firstNode]): Call firstNodeAfter.
+
+        * DOM/WebDOMOperations.mm:
+        (-[DOMRange markupString]): Stop using Range::ownerDocument.
+
 2020-08-27  Devin Rousso  <drousso@apple.com>
 

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

@@ -571 +571 @@
 #endif
 {
-    // FIXME: The call to updateLayoutIgnorePendingStylesheets should be moved into WebCore::Range.
-    auto& range = *core(self);
-    range.ownerDocument().updateLayoutIgnorePendingStylesheets();
-    return unionRect(RenderObject::absoluteTextRects(makeSimpleRange(range)));
+    auto range = makeSimpleRange(*core(self));
+    range.start.document().updateLayoutIgnorePendingStylesheets();
+    return unionRect(RenderObject::absoluteTextRects(range));
 }
 
@@ -584 +583 @@
 {
     auto range = makeSimpleRange(*core(self));
-    auto frame = makeRefPtr(range.start.container->document().frame());
+    auto frame = makeRefPtr(range.start.document().frame());
     if (!frame)
         return nil;
@@ -603 +602 @@
 {
     auto range = makeSimpleRange(*core(self));
-    range.start.container->document().updateLayoutIgnorePendingStylesheets();
+    range.start.document().updateLayoutIgnorePendingStylesheets();
     return createNSArray(RenderObject::absoluteTextRects(range)).autorelease();
 }

trunk/Source/WebKitLegacy/mac/DOM/DOMRange.mm

@@ -34 +34 @@
 #import <WebCore/Range.h>
 #import <WebCore/SimpleRange.h>
+#import <WebCore/TextIterator.h>
 #import <WebCore/ThreadCheck.h>
 #import <WebCore/WebCoreObjCExtras.h>
@@ -93 +94 @@
 {
     WebCore::JSMainThreadNullState state;
-    return IMPL->text();
+    auto range = makeSimpleRange(*IMPL);
+    range.start.document().updateLayout();
+    return plainText(range);
 }
 
@@ -171 +174 @@
     if (!sourceRange)
         raiseTypeErrorException();
-    return raiseOnDOMError(IMPL->compareBoundaryPointsForBindings(how, *core(sourceRange)));
+    return raiseOnDOMError(IMPL->compareBoundaryPoints(how, *core(sourceRange)));
 }
 
@@ -245 +248 @@
     if (!refNode)
         raiseTypeErrorException();
-    return raiseOnDOMError(IMPL->intersectsNode(*core(refNode)));
+    return IMPL->intersectsNode(*core(refNode));
 }
 

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

@@ -52 +52 @@
 #import <WebCore/Image.h>
 #import <WebCore/InlineBox.h>
-#import <WebCore/Node.h>
+#import <WebCore/NodeTraversal.h>
 #import <WebCore/Range.h>
 #import <WebCore/RenderBlock.h>
@@ -125 +125 @@
 }
 
+// FIXME: Refactor to share code with intersectingNodesWithDeprecatedZeroOffsetStartQuirk.
+static WebCore::Node* firstNodeAfter(const WebCore::BoundaryPoint& point)
+{
+    if (point.container->isCharacterDataNode())
+        return point.container.ptr();
+    if (auto child = point.container->traverseToChildAt(point.offset))
+        return child;
+    if (!point.offset)
+        return point.container.ptr();
+    return WebCore::NodeTraversal::nextSkippingChildren(point.container);
+}
+
 - (DOMNode *)firstNode
 {
-    return kit(core(self)->firstNode());
+    return kit(firstNodeAfter(makeSimpleRange(*core(self)).start));
 }
 

trunk/Source/WebKitLegacy/mac/DOM/WebDOMOperations.mm

@@ -192 +192 @@
 - (NSString *)markupString
 {
-    auto& range = *core(self);
-    return String { documentTypeString(range.ownerDocument()) + serializePreservingVisualAppearance(makeSimpleRange(range), nullptr, AnnotateForInterchange::Yes) };
+    auto range = makeSimpleRange(*core(self));
+    return String { documentTypeString(range.start.document()) + serializePreservingVisualAppearance(range, nullptr, AnnotateForInterchange::Yes) };
 }
 

trunk/Source/WebKitLegacy/mac/WebView/WebPDFView.mm

@@ -637 +637 @@
 }
 
-static BOOL isFrameInRange(WebFrame *frame, DOMRange *range)
-{
-    BOOL inRange = NO;
-    for (auto* ownerElement = core(frame)->ownerElement(); ownerElement; ownerElement = ownerElement->document().frame()->ownerElement()) {
-        if (&ownerElement->document() == &core(range)->ownerDocument()) {
-            inRange = [range intersectsNode:kit(ownerElement)];
-            break;
-        }
-    }
-    return inRange;
+static bool isFrameInRange(WebCore::Frame& frame, const WebCore::SimpleRange& range)
+{
+    for (auto* ownerElement = frame.ownerElement(); ownerElement; ownerElement = ownerElement->document().ownerElement()) {
+        if (&ownerElement->document() == &range.start.document())
+            return intersects(range, *ownerElement);
+    }
+    return false;
 }
 
 - (NSUInteger)countMatchesForText:(NSString *)string inDOMRange:(DOMRange *)range options:(WebFindOptions)options limit:(NSUInteger)limit markMatches:(BOOL)markMatches
 {
-    if (range && !isFrameInRange([dataSource webFrame], range))
+    if (range && !isFrameInRange(*core([dataSource webFrame]), makeSimpleRange(*core(range))))
         return 0;
 

trunk/Tools/ChangeLog

@@ +1 @@
+2020-08-28  Darin Adler  <darin@apple.com>
+
+        Remove almost all the remaining uses of live ranges
+        https://bugs.webkit.org/show_bug.cgi?id=215755
+
+        Reviewed by Sam Weinig.
+
+        * TestWebKitAPI/Tests/WebCore/DocumentOrder.cpp:
+        (TestWebKitAPI::TEST): Added test cases for node ordering involving non-user-agent
+        shadow tree. Added test case that showed the old "use node order if offsets are equal"
+        rule for boundary point ordering was wrong. Added tests for isPointInRange,
+        intersects, and contains functions.
+
 2020-08-28  Myles C. Maxfield  <mmaxfield@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/WebCore/DocumentOrder.cpp

@@ -26 +26 @@
 #include "config.h"
 
-#include <WebCore/BoundaryPoint.h>
 #include <WebCore/Document.h>
 #include <WebCore/HTMLBodyElement.h>
@@ -33 +32 @@
 #include <WebCore/HTMLTextAreaElement.h>
 #include <WebCore/Position.h>
+#include <WebCore/ShadowRoot.h>
+#include <WebCore/SimpleRange.h>
 #include <WebCore/TextControlInnerElements.h>
 
@@ -39 +40 @@
 #define EXPECT_LESS(a, b) EXPECT_BOTH(a, b, "less", "greater")
 #define EXPECT_UNORDERED(a, b) EXPECT_BOTH(a, b, "unordered", "unordered")
+
+#define EXPECT_CONTAINS_SELF(a) EXPECT_TRUE(contains(a, a))
+#define EXPECT_NESTED(a, b) do { EXPECT_TRUE(contains(a, b)); EXPECT_FALSE(contains(b, a)); } while (0)
+#define EXPECT_NOT_CONTAINED(a, b) do { EXPECT_FALSE(contains(a, b)); EXPECT_FALSE(contains(b, a)); } while (0)
+
+#define EXPECT_INTERSECTS_SELF(a) EXPECT_TRUE(intersects(a, a))
+#define EXPECT_INTERSECTS_BOTH_WAYS(a, b) do { EXPECT_TRUE(intersects(a, b)); EXPECT_TRUE(intersects(b, a)); } while (0)
+#define EXPECT_NOT_INTERSECTING_BOTH_WAYS(a, b) do { EXPECT_FALSE(intersects(a, b)); EXPECT_FALSE(intersects(b, a)); } while (0)
 
 namespace TestWebKitAPI {
@@ -142 +151 @@
     auto& h = *g->innerTextElement();
     EXPECT_LESS(body, h);
+
+    auto& i = a->attachShadow({ ShadowRootMode::Closed }).releaseReturnValue();
+    EXPECT_LESS(body, i);
+    EXPECT_LESS(i, d);
+    EXPECT_LESS(i, b);
+
+    // FIXME: Add tests that cover slots and assignment.
 }
 
@@ -189 +205 @@
     c->appendChild(g);
     EXPECT_LESS(makeBoundaryPoint(body, 0), makeBoundaryPoint(g, 0));
+
+    // FIXME: Add tests that cover shadow trees.
 }
 
@@ -198 +216 @@
     EXPECT_LESS(makeBoundaryPoint(document, 0), makeBoundaryPoint(document, 1));
     EXPECT_LESS(makeBoundaryPoint(body, 0), makeBoundaryPoint(document, 1));
+    EXPECT_LESS(makeBoundaryPoint(body, 1), makeBoundaryPoint(document, 1));
 
     auto a = HTMLDivElement::create(document);
@@ -242 +261 @@
     EXPECT_LESS(makeBoundaryPoint(h, 0), makeBoundaryPoint(c, 1));
     EXPECT_LESS(makeBoundaryPoint(h, 0), makeBoundaryPoint(c, 2));
+
+    // FIXME: Add tests that cover shadow trees.
 }
 
@@ -451 +472 @@
     TEST_ALL_POSITION_TYPES_B(makePositionAfter(document), body, 1, greater);
     TEST_ALL_POSITION_TYPES_B(makePositionAfter(document), h, 0, greater);
+
+    // FIXME: Add tests that cover shadow trees.
+}
+
+TEST(DocumentOrder, IsPointInRange)
+{
+    auto document = createDocument();
+    auto& documentElement = *document->documentElement();
+    auto& body = *document->body();
+
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(document, 0)));
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(document, 1)));
+    EXPECT_FALSE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(document, 2)));
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(body, 0)));
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(body, 1)));
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(body, 2)));
+    EXPECT_FALSE(isPointInRange(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 0)), makeBoundaryPoint(body, 0)));
+    EXPECT_TRUE(isPointInRange(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), makeBoundaryPoint(body, 0)));
+
+    auto a = HTMLDivElement::create(document);
+    EXPECT_FALSE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(a, 0)));
+    EXPECT_FALSE(isPointInRange(makeRangeSelectingNodeContents(body), makeBoundaryPoint(a, 0)));
+
+    body.appendChild(a);
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(document), makeBoundaryPoint(a, 0)));
+    EXPECT_TRUE(isPointInRange(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(a, 0)), makeBoundaryPoint(a, 0)));
+    EXPECT_FALSE(isPointInRange(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), makeBoundaryPoint(a, 0)));
+    EXPECT_TRUE(isPointInRange(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 1)), makeBoundaryPoint(a, 0)));
+    EXPECT_FALSE(isPointInRange(makeSimpleRange(makeBoundaryPoint(body, 1), makeBoundaryPoint(document, 1)), makeBoundaryPoint(a, 0)));
+    EXPECT_TRUE(isPointInRange(makeSimpleRange(makeBoundaryPoint(body, 0), makeBoundaryPoint(document, 1)), makeBoundaryPoint(a, 0)));
+
+    auto b = HTMLDivElement::create(document);
+    body.appendChild(b);
+
+    auto c = HTMLDivElement::create(document);
+    b->appendChild(c);
+
+    auto d = HTMLDivElement::create(document);
+    a->appendChild(d);
+
+    auto e = HTMLDivElement::create(document);
+    auto f = HTMLDivElement::create(document);
+    e->appendChild(f);
+    EXPECT_FALSE(isPointInRange(makeRangeSelectingNodeContents(body), makeBoundaryPoint(f, 0)));
+
+    auto g = HTMLTextAreaElement::create(document);
+    auto& h = *g->innerTextElement();
+    c->appendChild(g);
+    EXPECT_TRUE(isPointInRange(makeRangeSelectingNodeContents(body), makeBoundaryPoint(h, 0)));
+
+    // FIXME: Add tests that cover shadow trees.
+}
+
+TEST(DocumentOrder, RangeContainsRange)
+{
+    auto document = createDocument();
+    auto& documentElement = *document->documentElement();
+    auto& body = *document->body();
+
+    EXPECT_CONTAINS_SELF(makeRangeSelectingNodeContents(document));
+    EXPECT_CONTAINS_SELF(makeRangeSelectingNodeContents(documentElement));
+    EXPECT_CONTAINS_SELF(makeRangeSelectingNodeContents(body));
+
+    EXPECT_NESTED(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(documentElement));
+    EXPECT_NESTED(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(body));
+    EXPECT_NESTED(makeRangeSelectingNodeContents(documentElement), makeRangeSelectingNodeContents(body));
+
+    EXPECT_NESTED(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(documentElement));
+
+    EXPECT_NESTED(makeRangeSelectingNodeContents(documentElement), makeRangeSelectingNodeContents(body));
+
+    EXPECT_NESTED(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 0)));
+    EXPECT_NESTED(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 1)));
+    EXPECT_NOT_CONTAINED(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 2)));
+
+    EXPECT_NESTED(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(document, 2)), makeRangeSelectingNodeContents(document));
+    EXPECT_NOT_CONTAINED(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 1), makeBoundaryPoint(document, 2)));
+
+    EXPECT_NOT_CONTAINED(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 0)), makeRangeSelectingNodeContents(body));
+    EXPECT_NESTED(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), makeSimpleRange(makeBoundaryPoint(body, 0)));
+
+    auto a = HTMLDivElement::create(document);
+    EXPECT_NOT_CONTAINED(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(a));
+
+    body.appendChild(a);
+
+    auto b = HTMLDivElement::create(document);
+    body.appendChild(b);
+
+    auto c = HTMLDivElement::create(document);
+    b->appendChild(c);
+
+    auto d = HTMLDivElement::create(document);
+    a->appendChild(d);
+
+    auto e = HTMLDivElement::create(document);
+    auto f = HTMLDivElement::create(document);
+    e->appendChild(f);
+    EXPECT_NOT_CONTAINED(makeRangeSelectingNodeContents(body), makeRangeSelectingNodeContents(f));
+
+    auto g = HTMLTextAreaElement::create(document);
+    auto& h = *g->innerTextElement();
+    c->appendChild(g);
+    EXPECT_NESTED(makeRangeSelectingNodeContents(body), makeRangeSelectingNodeContents(h));
+
+    // FIXME: Add tests that cover shadow trees.
+}
+
+TEST(DocumentOrder, RangeIntersectsRange)
+{
+    auto document = createDocument();
+    auto& documentElement = *document->documentElement();
+    auto& body = *document->body();
+
+    EXPECT_INTERSECTS_SELF(makeRangeSelectingNodeContents(document));
+    EXPECT_INTERSECTS_SELF(makeRangeSelectingNodeContents(documentElement));
+    EXPECT_INTERSECTS_SELF(makeRangeSelectingNodeContents(body));
+
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(documentElement));
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(body));
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(documentElement), makeRangeSelectingNodeContents(body));
+
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(documentElement));
+
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(documentElement), makeRangeSelectingNodeContents(body));
+
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 0)));
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 1)));
+    EXPECT_NOT_INTERSECTING_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 2)));
+
+    EXPECT_INTERSECTS_BOTH_WAYS(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(document, 2)), makeRangeSelectingNodeContents(document));
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeSimpleRange(makeBoundaryPoint(document, 1), makeBoundaryPoint(document, 2)));
+
+    EXPECT_NOT_INTERSECTING_BOTH_WAYS(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 0)), makeRangeSelectingNodeContents(body));
+    EXPECT_INTERSECTS_BOTH_WAYS(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), makeSimpleRange(makeBoundaryPoint(body, 0)));
+
+    auto a = HTMLDivElement::create(document);
+    EXPECT_NOT_INTERSECTING_BOTH_WAYS(makeRangeSelectingNodeContents(document), makeRangeSelectingNodeContents(a));
+
+    body.appendChild(a);
+
+    auto b = HTMLDivElement::create(document);
+    body.appendChild(b);
+
+    auto c = HTMLDivElement::create(document);
+    b->appendChild(c);
+
+    auto d = HTMLDivElement::create(document);
+    a->appendChild(d);
+
+    auto e = HTMLDivElement::create(document);
+    auto f = HTMLDivElement::create(document);
+    e->appendChild(f);
+    EXPECT_NOT_INTERSECTING_BOTH_WAYS(makeRangeSelectingNodeContents(body), makeRangeSelectingNodeContents(f));
+
+    auto g = HTMLTextAreaElement::create(document);
+    auto& h = *g->innerTextElement();
+    c->appendChild(g);
+    EXPECT_INTERSECTS_BOTH_WAYS(makeRangeSelectingNodeContents(body), makeRangeSelectingNodeContents(h));
+
+    // FIXME: Add tests that cover shadow trees.
+}
+
+TEST(DocumentOrder, RangeContainsNode)
+{
+    auto document = createDocument();
+    auto& documentElement = *document->documentElement();
+    auto& body = *document->body();
+
+    EXPECT_TRUE(contains(makeRangeSelectingNodeContents(document), documentElement));
+    EXPECT_TRUE(contains(makeRangeSelectingNodeContents(document), body));
+    EXPECT_TRUE(contains(makeRangeSelectingNodeContents(documentElement), body));
+
+    EXPECT_FALSE(contains(makeRangeSelectingNodeContents(document), document));
+    EXPECT_FALSE(contains(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(document, 2)), document));
+    EXPECT_FALSE(contains(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 0)), body));
+    EXPECT_FALSE(contains(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), body));
+    EXPECT_FALSE(contains(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 1)), body));
+    EXPECT_TRUE(contains(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 1)), body));
+
+    auto a = HTMLDivElement::create(document);
+    EXPECT_FALSE(contains(makeRangeSelectingNodeContents(document), a));
+
+    body.appendChild(a);
+
+    auto b = HTMLDivElement::create(document);
+    body.appendChild(b);
+
+    auto c = HTMLDivElement::create(document);
+    b->appendChild(c);
+
+    auto d = HTMLDivElement::create(document);
+    a->appendChild(d);
+
+    auto e = HTMLDivElement::create(document);
+    auto f = HTMLDivElement::create(document);
+    e->appendChild(f);
+    EXPECT_FALSE(contains(makeRangeSelectingNodeContents(body), f));
+
+    auto g = HTMLTextAreaElement::create(document);
+    auto& h = *g->innerTextElement();
+    c->appendChild(g);
+    EXPECT_TRUE(contains(makeRangeSelectingNodeContents(body), h));
+
+    // FIXME: Add tests that cover shadow trees.
+}
+
+TEST(DocumentOrder, RangeIntersectsNode)
+{
+    auto document = createDocument();
+    auto& documentElement = *document->documentElement();
+    auto& body = *document->body();
+
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(document), documentElement));
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(document), body));
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(documentElement), body));
+
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(document), document));
+    EXPECT_TRUE(intersects(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(document, 2)), document));
+    EXPECT_FALSE(intersects(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 0)), body));
+    EXPECT_FALSE(intersects(makeSimpleRange(makeBoundaryPoint(documentElement, 1), makeBoundaryPoint(document, 1)), body));
+    EXPECT_TRUE(intersects(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 0)), body));
+    EXPECT_TRUE(intersects(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(body, 1)), body));
+    EXPECT_TRUE(intersects(makeSimpleRange(makeBoundaryPoint(document, 0), makeBoundaryPoint(documentElement, 1)), body));
+
+    auto a = HTMLDivElement::create(document);
+    EXPECT_FALSE(intersects(makeRangeSelectingNodeContents(document), a));
+
+    body.appendChild(a);
+
+    auto b = HTMLDivElement::create(document);
+    body.appendChild(b);
+
+    auto c = HTMLDivElement::create(document);
+    b->appendChild(c);
+
+    auto d = HTMLDivElement::create(document);
+    a->appendChild(d);
+
+    auto e = HTMLDivElement::create(document);
+    auto f = HTMLDivElement::create(document);
+    e->appendChild(f);
+    EXPECT_FALSE(intersects(makeRangeSelectingNodeContents(body), e));
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(f), e));
+    EXPECT_FALSE(intersects(makeRangeSelectingNodeContents(body), f));
+
+    auto g = HTMLTextAreaElement::create(document);
+    auto& h = *g->innerTextElement();
+    c->appendChild(g);
+    EXPECT_TRUE(intersects(makeRangeSelectingNodeContents(body), h));
+
+    // FIXME: Add tests that cover shadow trees.
 }