Log Message
Remove use of live ranges from AXObject.h https://bugs.webkit.org/show_bug.cgi?id=214053
Reviewed by Sam Weinig. * accessibility/AXObjectCache.cpp: (WebCore::AXObjectCache::traverseToOffsetInRange): Take SimpleRange. (WebCore::AXObjectCache::lengthForRange): Take Optional<SimpleRange>. (WebCore::AXObjectCache::rangeForNodeContents): Return SimpleRange, take reference rather than pointer. (WebCore::characterOffsetsInOrder): Use SimpleRange. (WebCore::resetNodeAndOffsetForReplacedNode): Take a reference to the node rather than a pointer. (WebCore::boundaryPoint): Added. Could be used to replace calls to setRangeStartOrEndWithCharacterOffset. (WebCore::setRangeStartOrEndWithCharacterOffset): Take SimpleRange. Also use the new boundaryPoint function above. (WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets): Return Optional<SimpleRange>. (WebCore::AXObjectCache::startOrEndCharacterOffsetForRange): Take SimpleRange. (WebCore::AXObjectCache::startOrEndTextMarkerDataForRange): Take SimpleRange. (WebCore::AXObjectCache::characterOffsetForNodeAndOffset): Use SimpleRange. (WebCore::AXObjectCache::textMarkerDataForNextCharacterOffset): Ditto. (WebCore::AXObjectCache::textMarkerDataForPreviousCharacterOffset): Ditto. (WebCore::AXObjectCache::visiblePositionFromCharacterOffset): (WebCore::AXObjectCache::characterOffsetFromVisiblePosition): (WebCore::AXObjectCache::leftWordRange): Return Optional<SimpleRange>. (WebCore::AXObjectCache::rightWordRange): Ditto. (WebCore::AXObjectCache::nextBoundary): Ditto. (WebCore::AXObjectCache::previousBoundary): Ditto. (WebCore::AXObjectCache::startCharacterOffsetOfParagraph): Use SimpleRange. (WebCore::AXObjectCache::endCharacterOffsetOfParagraph): Ditto. (WebCore::AXObjectCache::paragraphForCharacterOffset): Ditto. (WebCore::AXObjectCache::sentenceForCharacterOffset): Ditto. (WebCore::AXObjectCache::localCaretRectForCharacterOffset): Ditto. (WebCore::AXObjectCache::characterOffsetForPoint): Ditto. (WebCore::AXObjectCache::characterOffsetForIndex): Ditto. (WebCore::AXObjectCache::indexForCharacterOffset): Ditto. * accessibility/AXObjectCache.h: Remove uses of Range and include of "Range.h". * accessibility/AccessibilityObject.cpp: (WebCore::AccessibilityObject::elementRange const): Call createLiveRange. (WebCore::AccessibilityObject::rangeForPlainTextRange const): Ditto. * accessibility/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::boundsForRange const): Pass SimpleRange. * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm: (+[WebAccessibilityTextMarker startOrEndTextMarkerForRange:isStart:cache:]): Pass SimpleRange. (-[WebAccessibilityObjectWrapper positionForTextMarker:]): Call createLiveRange. (-[WebAccessibilityObjectWrapper textMarkerRangeForSelection]): Pass SimpleRange. (-[WebAccessibilityObjectWrapper textMarkerForPosition:]): Ditto. (-[WebAccessibilityObjectWrapper rangeForTextMarkers:]): Call createLiveRange. (-[WebAccessibilityObjectWrapper lengthForTextMarkers:]): Pass SimpleRange. * accessibility/mac/WebAccessibilityObjectWrapperMac.mm: (startOrEndTextmarkerForRange): (-[WebAccessibilityObjectWrapper rangeForTextMarkerRange:]): Pass SimpleRange. (-[WebAccessibilityObjectWrapper _indexForTextMarker:]): Call createLiveRange. (-[WebAccessibilityObjectWrapper textMarkerRangeAtTextMarker:forUnit:]): Ditto. (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]): Ditto. * dom/BoundaryPoint.h: Added makeBoundaryPointBefore/AfterNode. * dom/SimpleRange.cpp: (WebCore::makeBoundaryPointBeforeNode): Added. (WebCore::makeBoundaryPointAfterNode): Ditto.
Modified Paths
- trunk/Source/WebCore/ChangeLog
- trunk/Source/WebCore/accessibility/AXObjectCache.cpp
- trunk/Source/WebCore/accessibility/AXObjectCache.h
- trunk/Source/WebCore/accessibility/AccessibilityObject.cpp
- trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp
- trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm
- trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm
- trunk/Source/WebCore/dom/BoundaryPoint.h
- trunk/Source/WebCore/dom/SimpleRange.cpp
Diff
Modified: trunk/Source/WebCore/ChangeLog (264117 => 264118)
--- trunk/Source/WebCore/ChangeLog 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/ChangeLog 2020-07-08 18:03:21 UTC (rev 264118)
@@ -1,3 +1,73 @@
+2020-07-08 Darin Adler <da...@apple.com>
+
+ Remove use of live ranges from AXObject.h
+ https://bugs.webkit.org/show_bug.cgi?id=214053
+
+ Reviewed by Sam Weinig.
+
+ * accessibility/AXObjectCache.cpp:
+ (WebCore::AXObjectCache::traverseToOffsetInRange): Take SimpleRange.
+ (WebCore::AXObjectCache::lengthForRange): Take Optional<SimpleRange>.
+ (WebCore::AXObjectCache::rangeForNodeContents): Return SimpleRange, take reference
+ rather than pointer.
+ (WebCore::characterOffsetsInOrder): Use SimpleRange.
+ (WebCore::resetNodeAndOffsetForReplacedNode): Take a reference to the node rather than
+ a pointer.
+ (WebCore::boundaryPoint): Added. Could be used to replace calls to
+ setRangeStartOrEndWithCharacterOffset.
+ (WebCore::setRangeStartOrEndWithCharacterOffset): Take SimpleRange. Also use the
+ new boundaryPoint function above.
+ (WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets): Return Optional<SimpleRange>.
+ (WebCore::AXObjectCache::startOrEndCharacterOffsetForRange): Take SimpleRange.
+ (WebCore::AXObjectCache::startOrEndTextMarkerDataForRange): Take SimpleRange.
+ (WebCore::AXObjectCache::characterOffsetForNodeAndOffset): Use SimpleRange.
+ (WebCore::AXObjectCache::textMarkerDataForNextCharacterOffset): Ditto.
+ (WebCore::AXObjectCache::textMarkerDataForPreviousCharacterOffset): Ditto.
+ (WebCore::AXObjectCache::visiblePositionFromCharacterOffset):
+ (WebCore::AXObjectCache::characterOffsetFromVisiblePosition):
+ (WebCore::AXObjectCache::leftWordRange): Return Optional<SimpleRange>.
+ (WebCore::AXObjectCache::rightWordRange): Ditto.
+ (WebCore::AXObjectCache::nextBoundary): Ditto.
+ (WebCore::AXObjectCache::previousBoundary): Ditto.
+ (WebCore::AXObjectCache::startCharacterOffsetOfParagraph): Use SimpleRange.
+ (WebCore::AXObjectCache::endCharacterOffsetOfParagraph): Ditto.
+ (WebCore::AXObjectCache::paragraphForCharacterOffset): Ditto.
+ (WebCore::AXObjectCache::sentenceForCharacterOffset): Ditto.
+ (WebCore::AXObjectCache::localCaretRectForCharacterOffset): Ditto.
+ (WebCore::AXObjectCache::characterOffsetForPoint): Ditto.
+ (WebCore::AXObjectCache::characterOffsetForIndex): Ditto.
+ (WebCore::AXObjectCache::indexForCharacterOffset): Ditto.
+
+ * accessibility/AXObjectCache.h: Remove uses of Range and include of "Range.h".
+
+ * accessibility/AccessibilityObject.cpp:
+ (WebCore::AccessibilityObject::elementRange const): Call createLiveRange.
+ (WebCore::AccessibilityObject::rangeForPlainTextRange const): Ditto.
+
+ * accessibility/AccessibilityRenderObject.cpp:
+ (WebCore::AccessibilityRenderObject::boundsForRange const): Pass SimpleRange.
+
+ * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
+ (+[WebAccessibilityTextMarker startOrEndTextMarkerForRange:isStart:cache:]): Pass SimpleRange.
+ (-[WebAccessibilityObjectWrapper positionForTextMarker:]): Call createLiveRange.
+ (-[WebAccessibilityObjectWrapper textMarkerRangeForSelection]): Pass SimpleRange.
+ (-[WebAccessibilityObjectWrapper textMarkerForPosition:]): Ditto.
+ (-[WebAccessibilityObjectWrapper rangeForTextMarkers:]): Call createLiveRange.
+ (-[WebAccessibilityObjectWrapper lengthForTextMarkers:]): Pass SimpleRange.
+
+ * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
+ (startOrEndTextmarkerForRange):
+ (-[WebAccessibilityObjectWrapper rangeForTextMarkerRange:]): Pass SimpleRange.
+ (-[WebAccessibilityObjectWrapper _indexForTextMarker:]): Call createLiveRange.
+ (-[WebAccessibilityObjectWrapper textMarkerRangeAtTextMarker:forUnit:]): Ditto.
+ (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]): Ditto.
+
+ * dom/BoundaryPoint.h: Added makeBoundaryPointBefore/AfterNode.
+
+ * dom/SimpleRange.cpp:
+ (WebCore::makeBoundaryPointBeforeNode): Added.
+ (WebCore::makeBoundaryPointAfterNode): Ditto.
+
2020-07-08 Zalan Bujtas <za...@apple.com>
[LFC][IFC] Do not use the initial strut baseline values when the text content is inside an inline container
Modified: trunk/Source/WebCore/accessibility/AXObjectCache.cpp (264117 => 264118)
--- trunk/Source/WebCore/accessibility/AXObjectCache.cpp 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/AXObjectCache.cpp 2020-07-08 18:03:21 UTC (rev 264118)
@@ -1812,11 +1812,8 @@
return result;
}
-CharacterOffset AXObjectCache::traverseToOffsetInRange(RefPtr<Range>range, int offset, TraverseOption option, bool stayWithinRange)
+CharacterOffset AXObjectCache::traverseToOffsetInRange(const SimpleRange& range, int offset, TraverseOption option, bool stayWithinRange)
{
- if (!range)
- return CharacterOffset();
-
bool toNodeEnd = option & TraverseOptionToNodeEnd;
bool validateOffset = option & TraverseOptionValidateOffset;
bool doNotEnterTextControls = option & TraverseOptionDoNotEnterTextControls;
@@ -1829,12 +1826,12 @@
bool finished = false;
int lastStartOffset = 0;
- TextIterator iterator(*range, doNotEnterTextControls ? TextIteratorDefaultBehavior : TextIteratorEntersTextControls);
+ TextIterator iterator(range, doNotEnterTextControls ? TextIteratorDefaultBehavior : TextIteratorEntersTextControls);
// When the range has zero length, there might be replaced node or brTag that we need to increment the characterOffset.
if (iterator.atEnd()) {
- currentNode = &range->startContainer();
- lastStartOffset = range->startOffset();
+ currentNode = range.start.container.ptr();
+ lastStartOffset = range.start.offset;
if (offset > 0 || toNodeEnd) {
if (AccessibilityObject::replacedNodeNeedsCharacter(currentNode) || (currentNode->renderer() && currentNode->renderer()->isBR()))
cumulativeOffset++;
@@ -1844,7 +1841,7 @@
// Here when we don't have any character to move and we are going backwards, we traverse to the previous node.
if (!lastLength && toNodeEnd && !stayWithinRange) {
if (Node* preNode = previousNode(currentNode))
- return traverseToOffsetInRange(rangeForNodeContents(preNode), offset, option);
+ return traverseToOffsetInRange(rangeForNodeContents(*preNode), offset, option);
return CharacterOffset();
}
}
@@ -1929,13 +1926,13 @@
// Sometimes when we are getting the end CharacterOffset of a line range, the TextIterator will emit an extra space at the end
// and make the character count greater than the Range's end offset.
- if (toNodeEnd && currentNode->isTextNode() && currentNode == &range->endContainer() && static_cast<int>(range->endOffset()) < lastStartOffset + offsetInCharacter)
- offsetInCharacter = range->endOffset() - lastStartOffset;
+ if (toNodeEnd && currentNode->isTextNode() && currentNode == range.end.container.ptr() && static_cast<int>(range.end.offset) < lastStartOffset + offsetInCharacter)
+ offsetInCharacter = range.end.offset - lastStartOffset;
return CharacterOffset(currentNode, lastStartOffset, offsetInCharacter, remaining);
}
-int AXObjectCache::lengthForRange(Range* range)
+int AXObjectCache::lengthForRange(const Optional<SimpleRange>& range)
{
if (!range)
return -1;
@@ -1953,23 +1950,14 @@
return length;
}
-RefPtr<Range> AXObjectCache::rangeForNodeContents(Node* node)
+SimpleRange AXObjectCache::rangeForNodeContents(Node& node)
{
- if (!node)
- return nullptr;
- Document* document = &node->document();
- if (!document)
- return nullptr;
- auto range = Range::create(*document);
- if (AccessibilityObject::replacedNodeNeedsCharacter(node)) {
+ if (AccessibilityObject::replacedNodeNeedsCharacter(&node)) {
// For replaced nodes without children, the node itself is included in the range.
- if (range->selectNode(*node).hasException())
- return nullptr;
- } else {
- if (range->selectNodeContents(*node).hasException())
- return nullptr;
+ if (auto range = makeRangeSelectingNode(node))
+ return *range;
}
- return range;
+ return makeRangeSelectingNodeContents(node);
}
Optional<SimpleRange> AXObjectCache::rangeMatchesTextNearRange(const SimpleRange& originalRange, const String& matchText)
@@ -2014,77 +2002,67 @@
if (!node1 || !node2)
return false;
- RefPtr<Range> range1 = AXObjectCache::rangeForNodeContents(node1);
- RefPtr<Range> range2 = AXObjectCache::rangeForNodeContents(node2);
-
- if (!range2)
- return true;
- if (!range1)
- return false;
- auto result = range1->compareBoundaryPoints(Range::START_TO_START, *range2);
+ 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;
}
-static Node* resetNodeAndOffsetForReplacedNode(Node* replacedNode, int& offset, int characterCount)
+static Node* resetNodeAndOffsetForReplacedNode(Node& replacedNode, int& offset, int characterCount)
{
// Use this function to include the replaced node itself in the range we are creating.
auto nodeRange = AXObjectCache::rangeForNodeContents(replacedNode);
- if (!nodeRange)
- return nullptr;
- bool isInNode = static_cast<unsigned>(characterCount) <= WebCore::characterCount(*nodeRange);
- offset = replacedNode->computeNodeIndex() + (isInNode ? 0 : 1);
- return replacedNode->parentNode();
+ bool isInNode = static_cast<unsigned>(characterCount) <= WebCore::characterCount(nodeRange);
+ offset = replacedNode.computeNodeIndex() + (isInNode ? 0 : 1);
+ return replacedNode.parentNode();
}
-static bool setRangeStartOrEndWithCharacterOffset(Range& range, const CharacterOffset& characterOffset, bool isStart)
+static Optional<BoundaryPoint> boundaryPoint(const CharacterOffset& characterOffset, bool isStart)
{
if (characterOffset.isNull())
- return false;
-
+ return WTF::nullopt;
+
int offset = characterOffset.startIndex + characterOffset.offset;
Node* node = characterOffset.node;
ASSERT(node);
-
+
bool replacedNodeOrBR = isReplacedNodeOrBR(node);
// For the non text node that has no children, we should create the range with its parent, otherwise the range would be collapsed.
// Example: <div contenteditable="true"></div>, we want the range to include the div element.
bool noChildren = !replacedNodeOrBR && !node->isTextNode() && !node->hasChildNodes();
int characterCount = noChildren ? (isStart ? 0 : 1) : characterOffset.offset;
-
+
if (replacedNodeOrBR || noChildren)
- node = resetNodeAndOffsetForReplacedNode(node, offset, characterCount);
-
+ node = resetNodeAndOffsetForReplacedNode(*node, offset, characterCount);
+
if (!node)
- return false;
+ return WTF::nullopt;
- if (isStart) {
- if (range.setStart(*node, offset).hasException())
- return false;
- } else {
- if (range.setEnd(*node, offset).hasException())
- return false;
- }
+ return { { *node, static_cast<unsigned>(offset) } };
+}
+static bool setRangeStartOrEndWithCharacterOffset(SimpleRange& range, const CharacterOffset& characterOffset, bool isStart)
+{
+ auto point = boundaryPoint(characterOffset, isStart);
+ if (!point)
+ return false;
+ if (isStart)
+ range.start = *point;
+ else
+ range.end = *point;
return true;
}
-RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset& characterOffset1, const CharacterOffset& characterOffset2)
+Optional<SimpleRange> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset& characterOffset1, const CharacterOffset& characterOffset2)
{
- if (characterOffset1.isNull() || characterOffset2.isNull())
- return nullptr;
-
bool alreadyInOrder = characterOffsetsInOrder(characterOffset1, characterOffset2);
- CharacterOffset startCharacterOffset = alreadyInOrder ? characterOffset1 : characterOffset2;
- CharacterOffset endCharacterOffset = alreadyInOrder ? characterOffset2 : characterOffset1;
-
- auto result = Range::create(m_document);
- if (!setRangeStartOrEndWithCharacterOffset(result, startCharacterOffset, true))
- return nullptr;
- if (!setRangeStartOrEndWithCharacterOffset(result, endCharacterOffset, false))
- return nullptr;
- return result;
+ auto start = boundaryPoint(alreadyInOrder ? characterOffset1 : characterOffset2, true);
+ auto end = boundaryPoint(alreadyInOrder ? characterOffset2 : characterOffset1, false);
+ if (!start || !end)
+ return WTF::nullopt;
+ return { { *start, * end } };
}
void AXObjectCache::setTextMarkerDataWithCharacterOffset(TextMarkerData& textMarkerData, const CharacterOffset& characterOffset)
@@ -2120,41 +2098,38 @@
this->setNodeInUse(domNode);
}
-CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(RefPtr<Range> range, bool isStart, bool enterTextControls)
+CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(const SimpleRange& range, bool isStart, bool enterTextControls)
{
- if (!range)
- return CharacterOffset();
-
// When getting the end CharacterOffset at node boundary, we don't want to collapse to the previous node.
- if (!isStart && !range->endOffset())
- return characterOffsetForNodeAndOffset(range->endContainer(), 0, TraverseOptionIncludeStart);
+ if (!isStart && !range.end.offset)
+ return characterOffsetForNodeAndOffset(range.end.container, 0, TraverseOptionIncludeStart);
// If it's end text marker, we want to go to the end of the range, and stay within the range.
bool stayWithinRange = !isStart;
- Node& endNode = range->endContainer();
+ Node& endNode = range.end.container;
if (endNode.isCharacterDataNode() && !isStart)
- return traverseToOffsetInRange(rangeForNodeContents(&endNode), range->endOffset(), TraverseOptionValidateOffset);
+ return traverseToOffsetInRange(rangeForNodeContents(endNode), range.end.offset, TraverseOptionValidateOffset);
- Ref<Range> copyRange = *range;
+ auto copyRange = range;
// Change the start of the range, so the character offset starts from node beginning.
int offset = 0;
- Node& node = copyRange->startContainer();
+ auto& node = copyRange.start.container.get();
if (node.isCharacterDataNode()) {
- CharacterOffset nodeStartOffset = traverseToOffsetInRange(rangeForNodeContents(&node), range->startOffset(), TraverseOptionValidateOffset);
+ auto nodeStartOffset = traverseToOffsetInRange(rangeForNodeContents(node), range.start.offset, TraverseOptionValidateOffset);
if (isStart)
return nodeStartOffset;
- copyRange = Range::create(range->ownerDocument(), &range->startContainer(), 0, &range->endContainer(), range->endOffset());
+ copyRange.start.offset = 0;
offset += nodeStartOffset.offset;
}
-
- TraverseOption options = isStart ? TraverseOptionDefault : TraverseOptionToNodeEnd;
+
+ auto options = isStart ? TraverseOptionDefault : TraverseOptionToNodeEnd;
if (!enterTextControls)
options = static_cast<TraverseOption>(options | TraverseOptionDoNotEnterTextControls);
- return traverseToOffsetInRange(WTFMove(copyRange), offset, options, stayWithinRange);
+ return traverseToOffsetInRange(copyRange, offset, options, stayWithinRange);
}
-void AXObjectCache::startOrEndTextMarkerDataForRange(TextMarkerData& textMarkerData, RefPtr<Range> range, bool isStart)
+void AXObjectCache::startOrEndTextMarkerDataForRange(TextMarkerData& textMarkerData, const SimpleRange& range, bool isStart)
{
// This memory must be zero'd so instances of TextMarkerData can be tested for byte-equivalence.
// Warning: This is risky and bad because TextMarkerData is a nontrivial type.
@@ -2197,7 +2172,7 @@
return charOffset;
}
- RefPtr<Range> range = rangeForNodeContents(domNode);
+ auto range = rangeForNodeContents(*domNode);
// Traverse the offset amount of characters forward and see if there's remaining offsets.
// Keep traversing to the next node when there's remaining offsets.
@@ -2206,7 +2181,7 @@
domNode = nextNode(domNode);
if (!domNode)
return CharacterOffset();
- range = rangeForNodeContents(domNode);
+ range = rangeForNodeContents(*domNode);
characterOffset = traverseToOffsetInRange(range, characterOffset.remaining(), option);
}
@@ -2253,8 +2228,8 @@
next = nextCharacterOffset(next, false);
textMarkerDataForCharacterOffset(textMarkerData, next);
- // We should skip next CharactetOffset if it's visually the same.
- if (!lengthForRange(rangeForUnorderedCharacterOffsets(previous, next).get()))
+ // We should skip next CharacterOffset if it's visually the same.
+ if (!lengthForRange(rangeForUnorderedCharacterOffsets(previous, next)))
shouldContinue = true;
previous = next;
} while (textMarkerData.ignored || shouldContinue);
@@ -2270,8 +2245,8 @@
previous = previousCharacterOffset(previous, false);
textMarkerDataForCharacterOffset(textMarkerData, previous);
- // We should skip previous CharactetOffset if it's visually the same.
- if (!lengthForRange(rangeForUnorderedCharacterOffsets(previous, next).get()))
+ // We should skip previous CharacterOffset if it's visually the same.
+ if (!lengthForRange(rangeForUnorderedCharacterOffsets(previous, next)))
shouldContinue = true;
next = previous;
} while (textMarkerData.ignored || shouldContinue);
@@ -2305,7 +2280,9 @@
// Create a collapsed range and use that to form a VisiblePosition, so that the case with
// composed characters will be covered.
auto range = rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
- return range ? VisiblePosition(range->startPosition()) : VisiblePosition();
+ if (!range)
+ return { };
+ return createLegacyEditingPosition(range->start);
}
CharacterOffset AXObjectCache::characterOffsetFromVisiblePosition(const VisiblePosition& visiblePos)
@@ -2318,7 +2295,7 @@
ASSERT(domNode);
if (domNode->isCharacterDataNode())
- return traverseToOffsetInRange(rangeForNodeContents(domNode), deepPos.deprecatedEditingOffset(), TraverseOptionValidateOffset);
+ return traverseToOffsetInRange(rangeForNodeContents(*domNode), deepPos.deprecatedEditingOffset(), TraverseOptionValidateOffset);
RefPtr<AccessibilityObject> obj = this->getOrCreate(domNode);
if (!obj)
@@ -2355,7 +2332,7 @@
}
// Sometimes when the node is a replaced node and is ignored in accessibility, we get a wrong CharacterOffset from it.
- CharacterOffset result = traverseToOffsetInRange(rangeForNodeContents(obj->node()), characterOffset);
+ CharacterOffset result = traverseToOffsetInRange(rangeForNodeContents(*obj->node()), characterOffset);
if (result.remainingOffset > 0 && !result.isNull() && isRendererReplacedElement(result.node->renderer()))
result.offset += result.remainingOffset;
return result;
@@ -2548,7 +2525,7 @@
return endCharacterOffsetOfWord(nextOffset, LeftWordIfOnBoundary);
}
-RefPtr<Range> AXObjectCache::leftWordRange(const CharacterOffset& characterOffset)
+Optional<SimpleRange> AXObjectCache::leftWordRange(const CharacterOffset& characterOffset)
{
CharacterOffset start = startCharacterOffsetOfWord(characterOffset, LeftWordIfOnBoundary);
CharacterOffset end = endCharacterOffsetOfWord(start);
@@ -2555,7 +2532,7 @@
return rangeForUnorderedCharacterOffsets(start, end);
}
-RefPtr<Range> AXObjectCache::rightWordRange(const CharacterOffset& characterOffset)
+Optional<SimpleRange> AXObjectCache::rightWordRange(const CharacterOffset& characterOffset)
{
CharacterOffset start = startCharacterOffsetOfWord(characterOffset, RightWordIfOnBoundary);
CharacterOffset end = endCharacterOffsetOfWord(start);
@@ -2621,25 +2598,23 @@
if (!boundary)
return { };
- RefPtr<Range> searchRange = rangeForNodeContents(boundary);
- if (!searchRange)
- return { };
+ auto searchRange = rangeForNodeContents(*boundary);
Vector<UChar, 1024> string;
unsigned prefixLength = 0;
if (requiresContextForWordBoundary(characterAfter(characterOffset))) {
- auto backwardsScanRange = boundary->document().createRange();
+ auto backwardsScanRange = makeRangeSelectingNodeContents(boundary->document());
if (!setRangeStartOrEndWithCharacterOffset(backwardsScanRange, characterOffset, false))
return { };
- prefixLength = prefixLengthForRange(backwardsScanRange, string);
+ prefixLength = prefixLengthForRange(createLiveRange(backwardsScanRange), string);
}
- if (!setRangeStartOrEndWithCharacterOffset(*searchRange, characterOffset, true))
+ if (!setRangeStartOrEndWithCharacterOffset(searchRange, characterOffset, true))
return { };
CharacterOffset end = startOrEndCharacterOffsetForRange(searchRange, false);
- TextIterator it(*searchRange, TextIteratorEmitsObjectReplacementCharacters);
+ TextIterator it(searchRange, TextIteratorEmitsObjectReplacementCharacters);
unsigned next = forwardSearchForBoundaryWithTextIterator(it, string, prefixLength, searchFunction);
if (it.atEnd() && next == string.size())
@@ -2669,12 +2644,12 @@
if (!boundary)
return CharacterOffset();
- RefPtr<Range> searchRange = rangeForNodeContents(boundary);
+ auto searchRange = rangeForNodeContents(*boundary);
Vector<UChar, 1024> string;
unsigned suffixLength = 0;
if (needsContextAtParagraphStart == NeedsContextAtParagraphStart::Yes && startCharacterOffsetOfParagraph(characterOffset).isEqual(characterOffset)) {
- auto forwardsScanRange = boundary->document().createRange();
+ auto forwardsScanRange = makeRangeSelectingNodeContents(boundary->document());
auto endOfCurrentParagraph = endCharacterOffsetOfParagraph(characterOffset);
if (!setRangeStartOrEndWithCharacterOffset(forwardsScanRange, characterOffset, true))
return { };
@@ -2684,25 +2659,27 @@
append(string, forwardsIterator.text());
suffixLength = string.size();
} else if (requiresContextForWordBoundary(characterBefore(characterOffset))) {
- auto forwardsScanRange = boundary->document().createRange();
- if (forwardsScanRange->setEndAfter(*boundary).hasException())
+ auto forwardsScanRange = makeRangeSelectingNodeContents(boundary->document());
+ auto afterBoundary = makeBoundaryPointAfterNode(*boundary);
+ if (!afterBoundary)
return { };
+ forwardsScanRange.start = *afterBoundary;
if (!setRangeStartOrEndWithCharacterOffset(forwardsScanRange, characterOffset, true))
return { };
- suffixLength = suffixLengthForRange(forwardsScanRange, string);
+ suffixLength = suffixLengthForRange(createLiveRange(forwardsScanRange), string);
}
- if (!setRangeStartOrEndWithCharacterOffset(*searchRange, characterOffset, false))
+ if (!setRangeStartOrEndWithCharacterOffset(searchRange, characterOffset, false))
return { };
CharacterOffset start = startOrEndCharacterOffsetForRange(searchRange, true);
- SimplifiedBackwardsTextIterator it(*searchRange);
+ SimplifiedBackwardsTextIterator it(searchRange);
unsigned next = backwardSearchForBoundaryWithTextIterator(it, string, suffixLength, searchFunction);
if (!next)
return it.atEnd() ? start : characterOffset;
- auto& node = it.atEnd() ? searchRange->startContainer() : it.range().start.container.get();
+ auto& node = (it.atEnd() ? searchRange : it.range()).start.container.get();
// SimplifiedBackwardsTextIterator ignores replaced elements.
if (AccessibilityObject::replacedNodeNeedsCharacter(characterOffset.node))
@@ -2709,12 +2686,12 @@
return characterOffsetForNodeAndOffset(*characterOffset.node, 0);
Node* nextSibling = node.nextSibling();
if (&node != characterOffset.node && AccessibilityObject::replacedNodeNeedsCharacter(nextSibling))
- return startOrEndCharacterOffsetForRange(rangeForNodeContents(nextSibling), false);
+ return startOrEndCharacterOffsetForRange(rangeForNodeContents(*nextSibling), false);
if ((!suffixLength && node.isTextNode() && next <= node.length()) || (node.renderer() && node.renderer()->isBR() && !next)) {
// The next variable contains a usable index into a text node
if (node.isTextNode())
- return traverseToOffsetInRange(rangeForNodeContents(&node), next, TraverseOptionValidateOffset);
+ return traverseToOffsetInRange(rangeForNodeContents(node), next, TraverseOptionValidateOffset);
return characterOffsetForNodeAndOffset(node, next, TraverseOptionIncludeStart);
}
@@ -2732,20 +2709,20 @@
if (characterOffset.isNull())
return CharacterOffset();
- auto* startNode = characterOffset.node;
+ auto& startNode = *characterOffset.node;
- if (isRenderedAsNonInlineTableImageOrHR(startNode))
+ if (isRenderedAsNonInlineTableImageOrHR(&startNode))
return startOrEndCharacterOffsetForRange(rangeForNodeContents(startNode), true);
- auto* startBlock = enclosingBlock(startNode);
+ auto* startBlock = enclosingBlock(&startNode);
int offset = characterOffset.startIndex + characterOffset.offset;
- auto* highestRoot = highestEditableRoot(firstPositionInOrBeforeNode(startNode));
+ auto* highestRoot = highestEditableRoot(firstPositionInOrBeforeNode(&startNode));
Position::AnchorType type = Position::PositionIsOffsetInAnchor;
- auto* node = findStartOfParagraph(startNode, highestRoot, startBlock, offset, type, boundaryCrossingRule);
+ auto& node = *findStartOfParagraph(&startNode, highestRoot, startBlock, offset, type, boundaryCrossingRule);
if (type == Position::PositionIsOffsetInAnchor)
- return characterOffsetForNodeAndOffset(*node, offset, TraverseOptionIncludeStart);
+ return characterOffsetForNodeAndOffset(node, offset, TraverseOptionIncludeStart);
return startOrEndCharacterOffsetForRange(rangeForNodeContents(node), true);
}
@@ -2757,7 +2734,7 @@
Node* startNode = characterOffset.node;
if (isRenderedAsNonInlineTableImageOrHR(startNode))
- return startOrEndCharacterOffsetForRange(rangeForNodeContents(startNode), false);
+ return startOrEndCharacterOffsetForRange(rangeForNodeContents(*startNode), false);
Node* stayInsideBlock = enclosingBlock(startNode);
int offset = characterOffset.startIndex + characterOffset.offset;
@@ -2764,23 +2741,22 @@
Node* highestRoot = highestEditableRoot(firstPositionInOrBeforeNode(startNode));
Position::AnchorType type = Position::PositionIsOffsetInAnchor;
- Node* node = findEndOfParagraph(startNode, highestRoot, stayInsideBlock, offset, type, boundaryCrossingRule);
+ auto& node = *findEndOfParagraph(startNode, highestRoot, stayInsideBlock, offset, type, boundaryCrossingRule);
if (type == Position::PositionIsOffsetInAnchor) {
- if (node->isTextNode()) {
+ if (node.isTextNode()) {
CharacterOffset startOffset = startOrEndCharacterOffsetForRange(rangeForNodeContents(node), true);
offset -= startOffset.startIndex;
}
- return characterOffsetForNodeAndOffset(*node, offset, TraverseOptionIncludeStart);
+ return characterOffsetForNodeAndOffset(node, offset, TraverseOptionIncludeStart);
}
return startOrEndCharacterOffsetForRange(rangeForNodeContents(node), false);
}
-RefPtr<Range> AXObjectCache::paragraphForCharacterOffset(const CharacterOffset& characterOffset)
+Optional<SimpleRange> AXObjectCache::paragraphForCharacterOffset(const CharacterOffset& characterOffset)
{
CharacterOffset start = startCharacterOffsetOfParagraph(characterOffset);
CharacterOffset end = endCharacterOffsetOfParagraph(start);
-
return rangeForUnorderedCharacterOffsets(start, end);
}
@@ -2818,7 +2794,7 @@
return nextBoundary(characterOffset, endSentenceBoundary);
}
-RefPtr<Range> AXObjectCache::sentenceForCharacterOffset(const CharacterOffset& characterOffset)
+Optional<SimpleRange> AXObjectCache::sentenceForCharacterOffset(const CharacterOffset& characterOffset)
{
CharacterOffset start = startCharacterOffsetOfSentence(characterOffset);
CharacterOffset end = endCharacterOffsetOfSentence(start);
@@ -2859,12 +2835,11 @@
InlineBox* inlineBox = nullptr;
int caretOffset;
// Use a collapsed range to get the position.
- RefPtr<Range> range = rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
+ auto range = rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
if (!range)
return IntRect();
- Position startPosition = range->startPosition();
- startPosition.getInlineBoxAndOffset(DOWNSTREAM, inlineBox, caretOffset);
+ createLegacyEditingPosition(range->start).getInlineBoxAndOffset(DOWNSTREAM, inlineBox, caretOffset);
if (inlineBox)
renderer = &inlineBox->renderer();
@@ -2892,15 +2867,16 @@
if (!obj)
return CharacterOffset();
- VisiblePosition vp = obj->visiblePositionForPoint(point);
- RefPtr<Range> range = makeRange(vp, vp);
- return startOrEndCharacterOffsetForRange(range, true);
+ auto boundary = makeBoundaryPoint(obj->visiblePositionForPoint(point));
+ if (!boundary)
+ return { };
+
+ return startOrEndCharacterOffsetForRange({ *boundary, *boundary }, true);
}
CharacterOffset AXObjectCache::characterOffsetForPoint(const IntPoint &point)
{
- RefPtr<Range> caretRange = m_document.caretRangeFromPoint(LayoutPoint(point));
- return startOrEndCharacterOffsetForRange(caretRange, true);
+ return startOrEndCharacterOffsetForRange(*m_document.caretRangeFromPoint(LayoutPoint(point)), true);
}
CharacterOffset AXObjectCache::characterOffsetForBounds(const IntRect& rect, bool first)
@@ -2964,8 +2940,12 @@
// BR node, while CharacterOffset will do the opposite.
if (obj->isTextControl() && characterOffsetNodeIsBR(validate))
validate.offset = 1;
-
- RefPtr<Range> range = obj->elementRange();
+
+ auto liveRange = obj->elementRange();
+ if (!liveRange)
+ return { };
+
+ auto range = SimpleRange { *liveRange };
CharacterOffset start = startOrEndCharacterOffsetForRange(range, true, true);
CharacterOffset end = startOrEndCharacterOffsetForRange(range, false, true);
CharacterOffset result = start;
@@ -2990,11 +2970,10 @@
int AXObjectCache::indexForCharacterOffset(const CharacterOffset& characterOffset, AccessibilityObject* obj)
{
// Create a collapsed range so that we can get the VisiblePosition from it.
- RefPtr<Range> range = rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
+ auto range = rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
if (!range)
return 0;
- VisiblePosition vp = range->startPosition();
- return obj->indexForVisiblePosition(vp);
+ return obj->indexForVisiblePosition(createLegacyEditingPosition(range->start));
}
const Element* AXObjectCache::rootAXEditableElement(const Node* node)
Modified: trunk/Source/WebCore/accessibility/AXObjectCache.h (264117 => 264118)
--- trunk/Source/WebCore/accessibility/AXObjectCache.h 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/AXObjectCache.h 2020-07-08 18:03:21 UTC (rev 264118)
@@ -28,15 +28,13 @@
#include "AXIsolatedTree.h"
#include "AXTextStateChangeIntent.h"
#include "AccessibilityObject.h"
-#include "Range.h"
+#include "SimpleRange.h"
#include "Timer.h"
#include "VisibleUnits.h"
#include <limits.h>
-#include <wtf/Forward.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
-#include <wtf/RefPtr.h>
#if USE(ATK)
#include <wtf/glib/GRefPtr.h>
@@ -236,26 +234,26 @@
// Use ignoreNextNodeStart/ignorePreviousNodeEnd to determine the behavior when we are at node boundary.
CharacterOffset nextCharacterOffset(const CharacterOffset&, bool ignoreNextNodeStart = true);
CharacterOffset previousCharacterOffset(const CharacterOffset&, bool ignorePreviousNodeEnd = true);
- void startOrEndTextMarkerDataForRange(TextMarkerData&, RefPtr<Range>, bool);
- CharacterOffset startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool enterTextControls = false);
+ void startOrEndTextMarkerDataForRange(TextMarkerData&, const SimpleRange&, bool);
+ CharacterOffset startOrEndCharacterOffsetForRange(const SimpleRange&, bool, bool enterTextControls = false);
AccessibilityObject* accessibilityObjectForTextMarkerData(TextMarkerData&);
- RefPtr<Range> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
- static RefPtr<Range> rangeForNodeContents(Node*);
- static int lengthForRange(Range*);
+ Optional<SimpleRange> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
+ static SimpleRange rangeForNodeContents(Node&);
+ static int lengthForRange(const Optional<SimpleRange>&);
// Word boundary
CharacterOffset nextWordEndCharacterOffset(const CharacterOffset&);
CharacterOffset previousWordStartCharacterOffset(const CharacterOffset&);
- RefPtr<Range> leftWordRange(const CharacterOffset&);
- RefPtr<Range> rightWordRange(const CharacterOffset&);
+ Optional<SimpleRange> leftWordRange(const CharacterOffset&);
+ Optional<SimpleRange> rightWordRange(const CharacterOffset&);
// Paragraph
- RefPtr<Range> paragraphForCharacterOffset(const CharacterOffset&);
+ Optional<SimpleRange> paragraphForCharacterOffset(const CharacterOffset&);
CharacterOffset nextParagraphEndCharacterOffset(const CharacterOffset&);
CharacterOffset previousParagraphStartCharacterOffset(const CharacterOffset&);
// Sentence
- RefPtr<Range> sentenceForCharacterOffset(const CharacterOffset&);
+ Optional<SimpleRange> sentenceForCharacterOffset(const CharacterOffset&);
CharacterOffset nextSentenceEndCharacterOffset(const CharacterOffset&);
CharacterOffset previousSentenceStartCharacterOffset(const CharacterOffset&);
@@ -405,7 +403,7 @@
enum TraverseOption { TraverseOptionDefault = 1 << 0, TraverseOptionToNodeEnd = 1 << 1, TraverseOptionIncludeStart = 1 << 2, TraverseOptionValidateOffset = 1 << 3, TraverseOptionDoNotEnterTextControls = 1 << 4 };
Node* nextNode(Node*) const;
Node* previousNode(Node*) const;
- CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
+ CharacterOffset traverseToOffsetInRange(const SimpleRange&, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
VisiblePosition visiblePositionFromCharacterOffset(const CharacterOffset&);
CharacterOffset characterOffsetFromVisiblePosition(const VisiblePosition&);
void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
@@ -603,7 +601,7 @@
inline void AXObjectCache::textChanged(AccessibilityObject*) { }
inline void AXObjectCache::textChanged(Node*) { }
inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
-inline RefPtr<Range> AXObjectCache::rangeForNodeContents(Node*) { return nullptr; }
+inline SimpleRange AXObjectCache::rangeForNodeContents(Node& node) { return makeRangeSelectingNodeContents(node); }
inline void AXObjectCache::remove(AXID) { }
inline void AXObjectCache::remove(RenderObject*) { }
inline void AXObjectCache::remove(Node&) { }
@@ -612,10 +610,10 @@
inline void AXObjectCache::selectedChildrenChanged(Node*) { }
inline void AXObjectCache::setIsSynchronizingSelection(bool) { }
inline void AXObjectCache::setTextSelectionIntent(const AXTextStateChangeIntent&) { }
-inline RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&) { return nullptr; }
+inline Optional<SimpleRange> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&) { return WTF::nullopt; }
inline IntRect AXObjectCache::absoluteCaretBoundsForCharacterOffset(const CharacterOffset&) { return IntRect(); }
inline CharacterOffset AXObjectCache::characterOffsetForIndex(int, const AXCoreObject*) { return CharacterOffset(); }
-inline CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool) { return CharacterOffset(); }
+inline CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(const SimpleRange&, bool, bool) { return CharacterOffset(); }
inline CharacterOffset AXObjectCache::endCharacterOffsetOfLine(const CharacterOffset&) { return CharacterOffset(); }
inline CharacterOffset AXObjectCache::nextCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
inline CharacterOffset AXObjectCache::previousCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
Modified: trunk/Source/WebCore/accessibility/AccessibilityObject.cpp (264117 => 264118)
--- trunk/Source/WebCore/accessibility/AccessibilityObject.cpp 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/AccessibilityObject.cpp 2020-07-08 18:03:21 UTC (rev 264118)
@@ -645,8 +645,11 @@
}
RefPtr<Range> AccessibilityObject::elementRange() const
-{
- return AXObjectCache::rangeForNodeContents(node());
+{
+ auto node = this->node();
+ if (!node)
+ return { };
+ return createLiveRange(AXObjectCache::rangeForNodeContents(*node));
}
RefPtr<Range> AccessibilityObject::findTextRange(Vector<String> const& searchStrings, RefPtr<Range> const& start, AccessibilitySearchTextDirection direction) const
@@ -1189,7 +1192,7 @@
if (AXObjectCache* cache = axObjectCache()) {
CharacterOffset start = cache->characterOffsetForIndex(range.start, this);
CharacterOffset end = cache->characterOffsetForIndex(range.start + range.length, this);
- return cache->rangeForUnorderedCharacterOffsets(start, end);
+ return createLiveRange(cache->rangeForUnorderedCharacterOffsets(start, end));
}
return nullptr;
}
Modified: trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp (264117 => 264118)
--- trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp 2020-07-08 18:03:21 UTC (rev 264118)
@@ -2176,8 +2176,8 @@
if (!cache)
return IntRect();
- CharacterOffset start = cache->startOrEndCharacterOffsetForRange(range, true);
- CharacterOffset end = cache->startOrEndCharacterOffsetForRange(range, false);
+ CharacterOffset start = cache->startOrEndCharacterOffsetForRange(*range, true);
+ CharacterOffset end = cache->startOrEndCharacterOffsetForRange(*range, false);
LayoutRect rect1 = cache->absoluteCaretBoundsForCharacterOffset(start);
LayoutRect rect2 = cache->absoluteCaretBoundsForCharacterOffset(end);
Modified: trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm (264117 => 264118)
--- trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm 2020-07-08 18:03:21 UTC (rev 264118)
@@ -212,9 +212,10 @@
{
if (!cache)
return nil;
-
+ if (!range)
+ return nil;
TextMarkerData textMarkerData;
- cache->startOrEndTextMarkerDataForRange(textMarkerData, range, isStart);
+ cache->startOrEndTextMarkerDataForRange(textMarkerData, *range, isStart);
if (!textMarkerData.axID)
return nil;
return [[[WebAccessibilityTextMarker alloc] initWithTextMarker:&textMarkerData cache:cache] autorelease];
@@ -2369,9 +2370,8 @@
if (AXObjectCache* cache = self.axBackingObject->axObjectCache()) {
CharacterOffset characterOffset = [marker characterOffset];
// Create a collapsed range from the CharacterOffset object.
- RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
- NSRange nsRange = [self _convertToNSRange:range.get()];
- return nsRange.location;
+ auto range = cache->rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
+ return [self _convertToNSRange:createLiveRange(range).get()].location;
}
return NSNotFound;
}
@@ -2432,12 +2432,12 @@
if (!cache)
return nil;
- auto range = createLiveRange(selection.toNormalizedRange());
+ auto range = selection.toNormalizedRange();
if (!range)
return nil;
- CharacterOffset start = cache->startOrEndCharacterOffsetForRange(range, true);
- CharacterOffset end = cache->startOrEndCharacterOffsetForRange(range, false);
+ CharacterOffset start = cache->startOrEndCharacterOffsetForRange(*range, true);
+ CharacterOffset end = cache->startOrEndCharacterOffsetForRange(*range, false);
WebAccessibilityTextMarker* startMarker = [WebAccessibilityTextMarker textMarkerWithCharacterOffset:start cache:cache];
WebAccessibilityTextMarker* endMarker = [WebAccessibilityTextMarker textMarkerWithCharacterOffset:end cache:cache];
@@ -2460,7 +2460,7 @@
if (!cache)
return nil;
- CharacterOffset characterOffset = cache->startOrEndCharacterOffsetForRange(range, true);
+ CharacterOffset characterOffset = cache->startOrEndCharacterOffsetForRange(*range, true);
return [WebAccessibilityTextMarker textMarkerWithCharacterOffset:characterOffset cache:cache];
}
@@ -2797,7 +2797,7 @@
CharacterOffset startCharacterOffset = [startMarker characterOffset];
CharacterOffset endCharacterOffset = [endMarker characterOffset];
- return cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset);
+ return createLiveRange(cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset));
}
- (NSInteger)lengthForTextMarkers:(NSArray *)textMarkers
@@ -2805,8 +2805,11 @@
if (![self _prepareAccessibilityCall])
return 0;
- RefPtr<Range> range = [self rangeForTextMarkers:textMarkers];
- int length = AXObjectCache::lengthForRange(range.get());
+ auto range = [self rangeForTextMarkers:textMarkers];
+ if (!range)
+ return 0;
+
+ int length = AXObjectCache::lengthForRange(SimpleRange { *range });
return length < 0 ? 0 : length;
}
Modified: trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm (264117 => 264118)
--- trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm 2020-07-08 18:03:21 UTC (rev 264118)
@@ -800,12 +800,15 @@
{
if (!cache)
return nil;
-
+
+ if (!range)
+ return nil;
+
TextMarkerData textMarkerData;
- cache->startOrEndTextMarkerDataForRange(textMarkerData, range, isStart);
+ cache->startOrEndTextMarkerDataForRange(textMarkerData, *range, isStart);
if (!textMarkerData.axID)
return nil;
-
+
return CFBridgingRelease(AXTextMarkerCreate(kCFAllocatorDefault, (const UInt8*)&textMarkerData, sizeof(textMarkerData)));
}
@@ -878,7 +881,7 @@
CharacterOffset startCharacterOffset = [self characterOffsetForTextMarker:startTextMarker];
CharacterOffset endCharacterOffset = [self characterOffsetForTextMarker:endTextMarker];
- return cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset);
+ return createLiveRange(cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset));
}
static CharacterOffset characterOffsetForTextMarker(AXObjectCache* cache, CFTypeRef textMarker)
@@ -3650,8 +3653,8 @@
if (AXObjectCache* cache = self.axBackingObject->axObjectCache()) {
CharacterOffset characterOffset = [self characterOffsetForTextMarker:marker];
// Create a collapsed range from the CharacterOffset object.
- RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
- return [self _convertToNSRange:range.get()].location;
+ auto range = cache->rangeForUnorderedCharacterOffsets(characterOffset, characterOffset);
+ return [self _convertToNSRange:createLiveRange(range).get()].location;
}
return NSNotFound;
}
@@ -3771,7 +3774,7 @@
return nil;
auto characterOffset = characterOffsetForTextMarker(cache, textMarker);
- RefPtr<Range> range;
+ Optional<SimpleRange> range;
switch (textUnit) {
case TextUnit::LeftWord:
range = cache->leftWordRange(characterOffset);
@@ -3790,7 +3793,7 @@
break;
}
- return textMarkerRangeFromRange(cache, range);
+ return textMarkerRangeFromRange(cache, createLiveRange(range));
});
}
@@ -4158,8 +4161,8 @@
if (start.isNull() || end.isNull())
return CGRectZero;
- RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(start, end);
- auto bounds = FloatRect(backingObject->boundsForRange(range));
+ auto range = cache->rangeForUnorderedCharacterOffsets(start, end);
+ auto bounds = FloatRect(backingObject->boundsForRange(createLiveRange(range)));
return [protectedSelf convertRectToSpace:bounds space:AccessibilityConversionSpace::Screen];
});
return [NSValue valueWithRect:rect];
@@ -4185,8 +4188,8 @@
if (start.isNull() || end.isNull())
return String();
- RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(start, end);
- return backingObject->stringForRange(range);
+ auto range = cache->rangeForUnorderedCharacterOffsets(start, end);
+ return backingObject->stringForRange(createLiveRange(range));
});
}
@@ -4230,8 +4233,8 @@
CharacterOffset characterOffset1 = [protectedSelf characterOffsetForTextMarker:textMarker1];
CharacterOffset characterOffset2 = [protectedSelf characterOffsetForTextMarker:textMarker2];
- RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(characterOffset1, characterOffset2);
- return [protectedSelf textMarkerRangeFromRange:range];
+ auto range = cache->rangeForUnorderedCharacterOffsets(characterOffset1, characterOffset2);
+ return [protectedSelf textMarkerRangeFromRange:createLiveRange(range)];
});
}
@@ -4314,7 +4317,9 @@
return 0;
RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
- return AXObjectCache::lengthForRange(range.get());
+ if (!range)
+ return 0;
+ return AXObjectCache::lengthForRange(SimpleRange { *range });
});
if (length < 0)
return nil;
Modified: trunk/Source/WebCore/dom/BoundaryPoint.h (264117 => 264118)
--- trunk/Source/WebCore/dom/BoundaryPoint.h 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/dom/BoundaryPoint.h 2020-07-08 18:03:21 UTC (rev 264118)
@@ -40,6 +40,8 @@
bool operator==(const BoundaryPoint&, const BoundaryPoint&);
+WEBCORE_EXPORT Optional<BoundaryPoint> makeBoundaryPointBeforeNode(Node&);
+WEBCORE_EXPORT Optional<BoundaryPoint> makeBoundaryPointAfterNode(Node&);
BoundaryPoint makeBoundaryPointBeforeNodeContents(Node&);
BoundaryPoint makeBoundaryPointAfterNodeContents(Node&);
Modified: trunk/Source/WebCore/dom/SimpleRange.cpp (264117 => 264118)
--- trunk/Source/WebCore/dom/SimpleRange.cpp 2020-07-08 17:57:56 UTC (rev 264117)
+++ trunk/Source/WebCore/dom/SimpleRange.cpp 2020-07-08 18:03:21 UTC (rev 264118)
@@ -55,6 +55,24 @@
return a.start == b.start && a.end == b.end;
}
+// FIXME: Create BoundaryPoint.cpp and move this there.
+Optional<BoundaryPoint> makeBoundaryPointBeforeNode(Node& node)
+{
+ auto parent = node.parentNode();
+ if (!parent)
+ return WTF::nullopt;
+ return BoundaryPoint { *parent, node.computeNodeIndex() };
+}
+
+// FIXME: Create BoundaryPoint.cpp and move this there.
+Optional<BoundaryPoint> makeBoundaryPointAfterNode(Node& node)
+{
+ auto parent = node.parentNode();
+ if (!parent)
+ return WTF::nullopt;
+ return BoundaryPoint { *parent, node.computeNodeIndex() + 1 };
+}
+
Optional<SimpleRange> makeRangeSelectingNode(Node& node)
{
auto parent = node.parentNode();
_______________________________________________ webkit-changes mailing list webkit-changes@lists.webkit.org https://lists.webkit.org/mailman/listinfo/webkit-changes
