<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[195240] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/195240">195240</a></dd>
<dt>Author</dt> <dd>n_wang@apple.com</dd>
<dt>Date</dt> <dd>2016-01-18 16:56:13 -0800 (Mon, 18 Jan 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>AX: [Mac] Implement next/previous text marker functions using TextIterator
https://bugs.webkit.org/show_bug.cgi?id=152728
Reviewed by Chris Fleizach.
Source/WebCore:
The existing AXTextMarker based calls are implemented using visible position, and that introduced
some bugs which make VoiceOver working incorrectly on Mac sometimes. Since TextIterator uses rendering
position, we tried to use it to refactor those AXTextMarker based calls.
In this patch, I implemented functions to navigate to previous/next text marker using Range and TextIterator.
Also added a conversion between visible position and character offset to make sure unconverted text marker
related functions are still working correctly.
Tests: accessibility/mac/previous-next-text-marker.html
accessibility/mac/text-marker-with-user-select-none.html
* accessibility/AXObjectCache.cpp:
(WebCore::AXObjectCache::visiblePositionForTextMarkerData):
(WebCore::AXObjectCache::traverseToOffsetInRange):
(WebCore::AXObjectCache::lengthForRange):
(WebCore::AXObjectCache::rangeForNodeContents):
(WebCore::characterOffsetsInOrder):
(WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets):
(WebCore::AXObjectCache::setTextMarkerDataWithCharacterOffset):
(WebCore::AXObjectCache::startOrEndTextMarkerDataForRange):
(WebCore::AXObjectCache::textMarkerDataForCharacterOffset):
(WebCore::AXObjectCache::nextNode):
(WebCore::AXObjectCache::previousNode):
(WebCore::AXObjectCache::visiblePositionFromCharacterOffset):
(WebCore::AXObjectCache::characterOffsetFromVisiblePosition):
(WebCore::AXObjectCache::accessibilityObjectForTextMarkerData):
(WebCore::AXObjectCache::textMarkerDataForVisiblePosition):
* accessibility/AXObjectCache.h:
(WebCore::CharacterOffset::CharacterOffset):
(WebCore::CharacterOffset::remaining):
(WebCore::CharacterOffset::isNull):
(WebCore::AXObjectCache::setNodeInUse):
(WebCore::AXObjectCache::removeNodeForUse):
(WebCore::AXObjectCache::isNodeInUse):
* accessibility/AccessibilityObject.cpp:
(WebCore::AccessibilityObject::selectionRange):
(WebCore::AccessibilityObject::elementRange):
(WebCore::AccessibilityObject::selectText):
(WebCore::AccessibilityObject::lineRangeForPosition):
(WebCore::AccessibilityObject::replacedNodeNeedsCharacter):
(WebCore::renderListItemContainerForNode):
(WebCore::listMarkerTextForNode):
(WebCore::AccessibilityObject::listMarkerTextForNodeAndPosition):
(WebCore::AccessibilityObject::stringForRange):
(WebCore::AccessibilityObject::stringForVisiblePositionRange):
(WebCore::replacedNodeNeedsCharacter): Deleted.
* accessibility/AccessibilityObject.h:
(WebCore::AccessibilityObject::visiblePositionRange):
(WebCore::AccessibilityObject::visiblePositionRangeForLine):
(WebCore::AccessibilityObject::boundsForVisiblePositionRange):
(WebCore::AccessibilityObject::setSelectedVisiblePositionRange):
* accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
(isTextMarkerIgnored):
(-[WebAccessibilityObjectWrapper accessibilityObjectForTextMarker:]):
(accessibilityObjectForTextMarker):
(-[WebAccessibilityObjectWrapper textMarkerRangeFromRange:]):
(textMarkerRangeFromRange):
(-[WebAccessibilityObjectWrapper startOrEndTextMarkerForRange:isStart:]):
(startOrEndTextmarkerForRange):
(-[WebAccessibilityObjectWrapper nextTextMarkerForNode:offset:]):
(-[WebAccessibilityObjectWrapper previousTextMarkerForNode:offset:]):
(-[WebAccessibilityObjectWrapper textMarkerForNode:offset:]):
(textMarkerForCharacterOffset):
(-[WebAccessibilityObjectWrapper rangeForTextMarkerRange:]):
(-[WebAccessibilityObjectWrapper characterOffsetForTextMarker:]):
(textMarkerForVisiblePosition):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
Tools:
* WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm:
(WTR::AccessibilityUIElement::accessibilityElementForTextMarker):
LayoutTests:
* accessibility/mac/previous-next-text-marker-expected.txt: Added.
* accessibility/mac/previous-next-text-marker.html: Added.
* accessibility/mac/text-marker-with-user-select-none-expected.txt: Added.
* accessibility/mac/text-marker-with-user-select-none.html: Added.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreaccessibilityAXObjectCachecpp">trunk/Source/WebCore/accessibility/AXObjectCache.cpp</a></li>
<li><a href="#trunkSourceWebCoreaccessibilityAXObjectCacheh">trunk/Source/WebCore/accessibility/AXObjectCache.h</a></li>
<li><a href="#trunkSourceWebCoreaccessibilityAccessibilityObjectcpp">trunk/Source/WebCore/accessibility/AccessibilityObject.cpp</a></li>
<li><a href="#trunkSourceWebCoreaccessibilityAccessibilityObjecth">trunk/Source/WebCore/accessibility/AccessibilityObject.h</a></li>
<li><a href="#trunkSourceWebCoreaccessibilitymacWebAccessibilityObjectWrapperMacmm">trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm</a></li>
<li><a href="#trunkToolsChangeLog">trunk/Tools/ChangeLog</a></li>
<li><a href="#trunkToolsWebKitTestRunnerInjectedBundlemacAccessibilityUIElementMacmm">trunk/Tools/WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsaccessibilitymacpreviousnexttextmarkerexpectedtxt">trunk/LayoutTests/accessibility/mac/previous-next-text-marker-expected.txt</a></li>
<li><a href="#trunkLayoutTestsaccessibilitymacpreviousnexttextmarkerhtml">trunk/LayoutTests/accessibility/mac/previous-next-text-marker.html</a></li>
<li><a href="#trunkLayoutTestsaccessibilitymactextmarkerwithuserselectnoneexpectedtxt">trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none-expected.txt</a></li>
<li><a href="#trunkLayoutTestsaccessibilitymactextmarkerwithuserselectnonehtml">trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none.html</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/LayoutTests/ChangeLog 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -1,3 +1,15 @@
</span><ins>+2016-01-18 Nan Wang <n_wang@apple.com>
+
+ AX: [Mac] Implement next/previous text marker functions using TextIterator
+ https://bugs.webkit.org/show_bug.cgi?id=152728
+
+ Reviewed by Chris Fleizach.
+
+ * accessibility/mac/previous-next-text-marker-expected.txt: Added.
+ * accessibility/mac/previous-next-text-marker.html: Added.
+ * accessibility/mac/text-marker-with-user-select-none-expected.txt: Added.
+ * accessibility/mac/text-marker-with-user-select-none.html: Added.
+
</ins><span class="cx"> 2016-01-17 Simon Fraser <simon.fraser@apple.com>
</span><span class="cx">
</span><span class="cx"> More displaylist tests, and minor cleanup
</span></span></pre></div>
<a id="trunkLayoutTestsaccessibilitymacpreviousnexttextmarkerexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/accessibility/mac/previous-next-text-marker-expected.txt (0 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/accessibility/mac/previous-next-text-marker-expected.txt (rev 0)
+++ trunk/LayoutTests/accessibility/mac/previous-next-text-marker-expected.txt 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -0,0 +1,37 @@
</span><ins>+text
+
+text1
+c d
+
+can't select
+This tests the next/previous text marker functions are implemented correctly.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS text.textMarkerRangeLength(textMarkerRange) is 4
+PASS text.accessibilityElementForTextMarker(startMarker).isEqual(text) is true
+PASS text.accessibilityElementForTextMarker(endMarker).isEqual(text) is true
+PASS element.stringValue is 'AXValue: '
+PASS element.stringValue is 'AXValue: text1'
+PASS element.stringValue is 'AXValue: '
+PASS element.stringValue is 'AXValue: text'
+PASS text2.textMarkerRangeLength(textMarkerRange2) is 5
+Object string for range: c [ATTACHMENT] d
+AXValue: c
+AXValue: c
+AXValue:
+AXValue: d
+AXValue:
+AXValue: c
+AXValue: c
+AXValue: text1
+PASS text3.stringForTextMarkerRange(markerRange) is 'ect'
+PASS text3.stringForTextMarkerRange(markerRange) is 'sel'
+PASS !psw.accessibilityElementForTextMarker(start) is true
+PASS text2.accessibilityElementForTextMarker(currentMarker).isEqual(text3) is true
+PASS text2.accessibilityElementForTextMarker(currentMarker).isEqual(text2.childAtIndex(2)) is true
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
</ins></span></pre></div>
<a id="trunkLayoutTestsaccessibilitymacpreviousnexttextmarkerhtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/accessibility/mac/previous-next-text-marker.html (0 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/accessibility/mac/previous-next-text-marker.html (rev 0)
+++ trunk/LayoutTests/accessibility/mac/previous-next-text-marker.html 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -0,0 +1,136 @@
</span><ins>+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+<head>
+<script src="../../resources/js-test-pre.js"></script>
+</head>
+<style>
+.userselect { user-select: none; -webkit-user-select: none; }
+</style>
+<body id="body">
+
+<div id="text" tabindex="0">text</div>
+<br>
+text1
+
+<div id="text2">
+c <img src="#" aria-label="blah" style="background-color: #aaaaaa; width: 100px; height: 100px;"> d
+</div>
+
+<input type="password" id="psw">
+
+<div class="userselect" id="text3">can't select</div>
+
+<p id="description"></p>
+<div id="console"></div>
+
+<script>
+
+ description("This tests the next/previous text marker functions are implemented correctly.");
+
+ if (window.accessibilityController) {
+
+ var text = accessibilityController.accessibleElementById("text");
+ // Get the actual text node.
+ text = text.childAtIndex(0);
+
+ // Check that we can get the start/end marker for this range.
+ var textMarkerRange = text.textMarkerRangeForElement(text);
+ shouldBe("text.textMarkerRangeLength(textMarkerRange)", "4");
+
+ var startMarker = text.startTextMarkerForTextMarkerRange(textMarkerRange);
+ var endMarker = text.endTextMarkerForTextMarkerRange(textMarkerRange);
+ shouldBeTrue("text.accessibilityElementForTextMarker(startMarker).isEqual(text)");
+ shouldBeTrue("text.accessibilityElementForTextMarker(endMarker).isEqual(text)");
+
+ // Check next text marker. (Advance 5 characters, it will land at <br>.)
+ var currentMarker = startMarker;
+ for (var i = 0; i < 5; i++) {
+ currentMarker = text.nextTextMarker(currentMarker);
+ }
+ var element = text.accessibilityElementForTextMarker(currentMarker);
+ shouldBe("element.stringValue", "'AXValue: '");
+
+ // Advance one more character, it will lande at "t" in "text1".
+ currentMarker = text.nextTextMarker(currentMarker);
+ element = text.accessibilityElementForTextMarker(currentMarker);
+ shouldBe("element.stringValue", "'AXValue: text1'");
+
+ // Check previous text marker. (Traverse backwards one character, it will land at <br>.)
+ currentMarker = text.previousTextMarker(currentMarker);
+ element = text.accessibilityElementForTextMarker(currentMarker);
+ shouldBe("element.stringValue", "'AXValue: '");
+
+ // Traverse backwards one more character, it will land at the last character of "text".
+ currentMarker = text.previousTextMarker(currentMarker);
+ element = text.accessibilityElementForTextMarker(currentMarker);
+ shouldBe("element.stringValue", "'AXValue: text'");
+
+ // Check the case with replaced node
+ var text2 = accessibilityController.accessibleElementById("text2");
+ var textMarkerRange2 = text2.textMarkerRangeForElement(text2);
+ shouldBe("text2.textMarkerRangeLength(textMarkerRange2)", "5");
+ var str = text2.stringForTextMarkerRange(textMarkerRange2).replace(String.fromCharCode(65532), "[ATTACHMENT]");
+ debug("Object string for range: " + str);
+
+ currentMarker = text2.startTextMarkerForTextMarkerRange(textMarkerRange2);
+ // Advance 4 characters, it will land at first character of " d".
+ for (var i = 0; i < 4; i++) {
+ currentMarker = text2.nextTextMarker(currentMarker);
+ element = text2.accessibilityElementForTextMarker(currentMarker);
+ debug(element.stringValue);
+ }
+
+ // Traverse backwards 4 characters, it will land at the last character of "text1".
+ for (var i = 0; i < 4; i++) {
+ currentMarker = text2.previousTextMarker(currentMarker);
+ element = text2.accessibilityElementForTextMarker(currentMarker);
+ debug(element.stringValue);
+ }
+
+ // Check the case with user-select:none, nextTextMarker/previousTextMarker should still work.
+ var text3 = accessibilityController.accessibleElementById("text3");
+ text3 = text3.childAtIndex(0);
+ // Advance to land at user-select:none node.
+ var marker1, marker2;
+ for (var i = 0; i < 17; i++) {
+ currentMarker = text3.nextTextMarker(currentMarker);
+ // i == 13, it should land on "e", and i == 16, it should land on "t"
+ if (i == 13) {
+ marker1 = currentMarker;
+ }
+ }
+ marker2 = currentMarker;
+ var markerRange = text3.textMarkerRangeForMarkers(marker1, marker2);
+ shouldBe("text3.stringForTextMarkerRange(markerRange)", "'ect'");
+ // Iterate backwards the second marker for 6 characters, the range should be "sel"
+ for (var i = 0; i < 6; i++) {
+ currentMarker = text3.previousTextMarker(currentMarker);
+ }
+ marker2 = currentMarker;
+ markerRange = text3.textMarkerRangeForMarkers(marker1, marker2);
+ shouldBe("text3.stringForTextMarkerRange(markerRange)", "'sel'");
+
+ // Check the case with password field.
+ var psw = accessibilityController.accessibleElementById("psw");
+ var textMarkerRange3 = psw.textMarkerRangeForElement(psw);
+ var start = psw.startTextMarkerForTextMarkerRange(textMarkerRange3);
+ shouldBeTrue("!psw.accessibilityElementForTextMarker(start)");
+
+ // Check next/previous text marker call will skip password field
+ // We start from text2 and advance 6 characters, it should skip the password field and land on text3.
+ currentMarker = text2.startTextMarkerForTextMarkerRange(textMarkerRange2);
+ for (var i = 0; i < 6; i++) {
+ currentMarker = text2.nextTextMarker(currentMarker);
+ }
+ shouldBeTrue("text2.accessibilityElementForTextMarker(currentMarker).isEqual(text3)");
+ // Check previous text marker, it should land on " d" node.
+ currentMarker = text2.previousTextMarker(currentMarker);
+ shouldBeTrue("text2.accessibilityElementForTextMarker(currentMarker).isEqual(text2.childAtIndex(2))");
+
+ }
+
+</script>
+
+<script src="../../resources/js-test-post.js"></script>
+</body>
+</html>
</ins><span class="cx">\ No newline at end of file
</span></span></pre></div>
<a id="trunkLayoutTestsaccessibilitymactextmarkerwithuserselectnoneexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none-expected.txt (0 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none-expected.txt (rev 0)
+++ trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none-expected.txt 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -0,0 +1,16 @@
</span><ins>+hello test world test hello
+link to here
+test
+This tests that accessibility text markers still work even when user-select:none is set.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS textElement.textMarkerRangeLength(textMarkerRange) is 45
+PASS text is "hello test world test hello\nlink to here\ntest"
+PASS text is 'h'
+PASS element.isEqual(textElement.childAtIndex(0)) is true
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
</ins></span></pre></div>
<a id="trunkLayoutTestsaccessibilitymactextmarkerwithuserselectnonehtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none.html (0 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none.html (rev 0)
+++ trunk/LayoutTests/accessibility/mac/text-marker-with-user-select-none.html 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -0,0 +1,49 @@
</span><ins>+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+<head>
+<script src="../../resources/js-test-pre.js"></script>
+</head>
+<body id="body">
+
+<div id="text" style="-webkit-user-select:none">
+
+hello test <b>world</b> test hello<br>
+<a href="#">link</a> to <a href="#">here</a><br>
+test
+
+</div>
+
+
+
+<p id="description"></p>
+<div id="console"></div>
+
+<script>
+
+ description("This tests that accessibility text markers still work even when user-select:none is set.");
+
+ if (window.accessibilityController) {
+
+ var textElement = accessibilityController.accessibleElementById("text");
+ var textMarkerRange = textElement.textMarkerRangeForElement(textElement);
+ shouldBe("textElement.textMarkerRangeLength(textMarkerRange)", "45");
+
+ var startMarker = textElement.startTextMarkerForTextMarkerRange(textMarkerRange);
+ var endMarker = textElement.endTextMarkerForTextMarkerRange(textMarkerRange);
+ textMarkerRange = textElement.textMarkerRangeForMarkers(startMarker, endMarker);
+ var text = textElement.stringForTextMarkerRange(textMarkerRange);
+ shouldBeEqualToString("text", "hello test world test hello\nlink to here\ntest");
+
+ var nextMarker = textElement.nextTextMarker(startMarker);
+ textMarkerRange = textElement.textMarkerRangeForMarkers(startMarker, nextMarker);
+ text = textElement.stringForTextMarkerRange(textMarkerRange);
+ shouldBe("text", "'h'");
+ var element = textElement.accessibilityElementForTextMarker(nextMarker);
+ shouldBeTrue("element.isEqual(textElement.childAtIndex(0))");
+ }
+
+</script>
+
+<script src="../../resources/js-test-post.js"></script>
+</body>
+</html>
</ins><span class="cx">\ No newline at end of file
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/ChangeLog 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -1,3 +1,77 @@
</span><ins>+2016-01-18 Nan Wang <n_wang@apple.com>
+
+ AX: [Mac] Implement next/previous text marker functions using TextIterator
+ https://bugs.webkit.org/show_bug.cgi?id=152728
+
+ Reviewed by Chris Fleizach.
+
+ The existing AXTextMarker based calls are implemented using visible position, and that introduced
+ some bugs which make VoiceOver working incorrectly on Mac sometimes. Since TextIterator uses rendering
+ position, we tried to use it to refactor those AXTextMarker based calls.
+ In this patch, I implemented functions to navigate to previous/next text marker using Range and TextIterator.
+ Also added a conversion between visible position and character offset to make sure unconverted text marker
+ related functions are still working correctly.
+
+ Tests: accessibility/mac/previous-next-text-marker.html
+ accessibility/mac/text-marker-with-user-select-none.html
+
+ * accessibility/AXObjectCache.cpp:
+ (WebCore::AXObjectCache::visiblePositionForTextMarkerData):
+ (WebCore::AXObjectCache::traverseToOffsetInRange):
+ (WebCore::AXObjectCache::lengthForRange):
+ (WebCore::AXObjectCache::rangeForNodeContents):
+ (WebCore::characterOffsetsInOrder):
+ (WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets):
+ (WebCore::AXObjectCache::setTextMarkerDataWithCharacterOffset):
+ (WebCore::AXObjectCache::startOrEndTextMarkerDataForRange):
+ (WebCore::AXObjectCache::textMarkerDataForCharacterOffset):
+ (WebCore::AXObjectCache::nextNode):
+ (WebCore::AXObjectCache::previousNode):
+ (WebCore::AXObjectCache::visiblePositionFromCharacterOffset):
+ (WebCore::AXObjectCache::characterOffsetFromVisiblePosition):
+ (WebCore::AXObjectCache::accessibilityObjectForTextMarkerData):
+ (WebCore::AXObjectCache::textMarkerDataForVisiblePosition):
+ * accessibility/AXObjectCache.h:
+ (WebCore::CharacterOffset::CharacterOffset):
+ (WebCore::CharacterOffset::remaining):
+ (WebCore::CharacterOffset::isNull):
+ (WebCore::AXObjectCache::setNodeInUse):
+ (WebCore::AXObjectCache::removeNodeForUse):
+ (WebCore::AXObjectCache::isNodeInUse):
+ * accessibility/AccessibilityObject.cpp:
+ (WebCore::AccessibilityObject::selectionRange):
+ (WebCore::AccessibilityObject::elementRange):
+ (WebCore::AccessibilityObject::selectText):
+ (WebCore::AccessibilityObject::lineRangeForPosition):
+ (WebCore::AccessibilityObject::replacedNodeNeedsCharacter):
+ (WebCore::renderListItemContainerForNode):
+ (WebCore::listMarkerTextForNode):
+ (WebCore::AccessibilityObject::listMarkerTextForNodeAndPosition):
+ (WebCore::AccessibilityObject::stringForRange):
+ (WebCore::AccessibilityObject::stringForVisiblePositionRange):
+ (WebCore::replacedNodeNeedsCharacter): Deleted.
+ * accessibility/AccessibilityObject.h:
+ (WebCore::AccessibilityObject::visiblePositionRange):
+ (WebCore::AccessibilityObject::visiblePositionRangeForLine):
+ (WebCore::AccessibilityObject::boundsForVisiblePositionRange):
+ (WebCore::AccessibilityObject::setSelectedVisiblePositionRange):
+ * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
+ (isTextMarkerIgnored):
+ (-[WebAccessibilityObjectWrapper accessibilityObjectForTextMarker:]):
+ (accessibilityObjectForTextMarker):
+ (-[WebAccessibilityObjectWrapper textMarkerRangeFromRange:]):
+ (textMarkerRangeFromRange):
+ (-[WebAccessibilityObjectWrapper startOrEndTextMarkerForRange:isStart:]):
+ (startOrEndTextmarkerForRange):
+ (-[WebAccessibilityObjectWrapper nextTextMarkerForNode:offset:]):
+ (-[WebAccessibilityObjectWrapper previousTextMarkerForNode:offset:]):
+ (-[WebAccessibilityObjectWrapper textMarkerForNode:offset:]):
+ (textMarkerForCharacterOffset):
+ (-[WebAccessibilityObjectWrapper rangeForTextMarkerRange:]):
+ (-[WebAccessibilityObjectWrapper characterOffsetForTextMarker:]):
+ (textMarkerForVisiblePosition):
+ (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
+
</ins><span class="cx"> 2016-01-18 Olivier Blin <olivier.blin@softathome.com>
</span><span class="cx">
</span><span class="cx"> [Mac] Remove unused playerToPrivateMap()
</span></span></pre></div>
<a id="trunkSourceWebCoreaccessibilityAXObjectCachecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/accessibility/AXObjectCache.cpp (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/accessibility/AXObjectCache.cpp 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/accessibility/AXObjectCache.cpp 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -81,6 +81,7 @@
</span><span class="cx"> #include "RenderTableRow.h"
</span><span class="cx"> #include "RenderView.h"
</span><span class="cx"> #include "ScrollView.h"
</span><ins>+#include "TextIterator.h"
</ins><span class="cx"> #include <wtf/DataLog.h>
</span><span class="cx">
</span><span class="cx"> #if ENABLE(VIDEO)
</span><span class="lines">@@ -1418,6 +1419,332 @@
</span><span class="cx"> return visiblePos;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+CharacterOffset AXObjectCache::traverseToOffsetInRange(RefPtr<Range>range, int offset, bool toNodeEnd, bool stayWithinRange)
+{
+ if (!range)
+ return CharacterOffset();
+
+ int offsetInCharacter = 0;
+ int offsetSoFar = 0;
+ int remaining = 0;
+ int lastLength = 0;
+ Node* currentNode = nullptr;
+ bool finished = false;
+ int lastStartOffset = 0;
+
+ TextIterator iterator(range.get());
+
+ // 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();
+ if (offset > 0 || toNodeEnd) {
+ if (AccessibilityObject::replacedNodeNeedsCharacter(currentNode) || (currentNode->renderer() && currentNode->renderer()->isBR()))
+ offsetSoFar++;
+ lastLength = offsetSoFar;
+
+ // When going backwards, stayWithinRange is false.
+ // 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, toNodeEnd);
+ return CharacterOffset();
+ }
+ }
+ }
+
+ for (; !iterator.atEnd(); iterator.advance()) {
+ int currentLength = iterator.text().length();
+
+ Node& node = iterator.range()->startContainer();
+ currentNode = &node;
+ // When currentLength == 0, we check if there's any replaced node.
+ // If not, we skip the node with no length.
+ if (!currentLength) {
+ int subOffset = iterator.range()->startOffset();
+ Node* childNode = node.traverseToChildAt(subOffset);
+ if (AccessibilityObject::replacedNodeNeedsCharacter(childNode)) {
+ offsetSoFar++;
+ currentLength++;
+ currentNode = childNode;
+ } else
+ continue;
+ } else {
+ // Ignore space, new line, tag node.
+ if (currentLength == 1 && isSpaceOrNewline(iterator.text()[0]))
+ continue;
+ offsetSoFar += currentLength;
+ }
+
+ lastLength = currentLength;
+ lastStartOffset = iterator.range()->startOffset();
+
+ // Break early if we have advanced enough characters.
+ if (!toNodeEnd && offsetSoFar >= offset) {
+ offsetInCharacter = offset - (offsetSoFar - currentLength);
+ finished = true;
+ break;
+ }
+ }
+
+ if (!finished) {
+ offsetInCharacter = lastLength;
+ if (!toNodeEnd)
+ remaining = offset - offsetSoFar;
+ }
+
+ return CharacterOffset(currentNode, lastStartOffset, offsetInCharacter, remaining);
+}
+
+int AXObjectCache::lengthForRange(Range* range)
+{
+ if (!range)
+ return -1;
+
+ int length = 0;
+ for (TextIterator it(range); !it.atEnd(); it.advance()) {
+ // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX)
+ if (it.text().length())
+ length += it.text().length();
+ else {
+ // locate the node and starting offset for this replaced range
+ Node& node = it.range()->startContainer();
+ int offset = it.range()->startOffset();
+ if (AccessibilityObject::replacedNodeNeedsCharacter(node.traverseToChildAt(offset)))
+ ++length;
+ }
+ }
+
+ return length;
+}
+
+RefPtr<Range> AXObjectCache::rangeForNodeContents(Node* node)
+{
+ if (!node)
+ return nullptr;
+
+ Document* document = &node->document();
+ if (!document)
+ return nullptr;
+ RefPtr<Range> range = Range::create(*document);
+ ExceptionCode ec = 0;
+ range->selectNodeContents(node, ec);
+ return ec ? nullptr : range;
+}
+
+static bool characterOffsetsInOrder(const CharacterOffset& characterOffset1, const CharacterOffset& characterOffset2)
+{
+ if (characterOffset1.isNull() || characterOffset2.isNull())
+ return false;
+
+ if (characterOffset1.node == characterOffset2.node)
+ return characterOffset1.offset <= characterOffset2.offset;
+
+ RefPtr<Range> range1 = AXObjectCache::rangeForNodeContents(characterOffset1.node);
+ RefPtr<Range> range2 = AXObjectCache::rangeForNodeContents(characterOffset2.node);
+ return range1->compareBoundaryPoints(Range::START_TO_START, range2.get(), IGNORE_EXCEPTION) <= 0;
+}
+
+RefPtr<Range> 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;
+
+ int endOffset = endCharacterOffset.offset;
+
+ // endOffset can be out of bounds sometimes if the node is a replaced node or has brTag.
+ if (startCharacterOffset.node == endCharacterOffset.node) {
+ RefPtr<Range> nodeRange = AXObjectCache::rangeForNodeContents(startCharacterOffset.node);
+ int nodeLength = TextIterator::rangeLength(nodeRange.get());
+ if (endOffset > nodeLength)
+ endOffset = nodeLength;
+ }
+
+ int startOffset = startCharacterOffset.startIndex + startCharacterOffset.offset;
+ endOffset = endCharacterOffset.startIndex + endOffset;
+
+ // If start node is a replaced node and it has children, we want to include the replaced node itself in the range.
+ Node* startNode = startCharacterOffset.node;
+ if (AccessibilityObject::replacedNodeNeedsCharacter(startNode) && (startNode->hasChildNodes() || startNode != endCharacterOffset.node)) {
+ startOffset = startNode->computeNodeIndex();
+ startNode = startNode->parentNode();
+ }
+
+ RefPtr<Range> result = Range::create(m_document);
+ ExceptionCode ecStart = 0, ecEnd = 0;
+ result->setStart(startNode, startOffset, ecStart);
+ result->setEnd(endCharacterOffset.node, endOffset, ecEnd);
+ if (ecStart || ecEnd)
+ return nullptr;
+
+ return result;
+}
+
+void AXObjectCache::setTextMarkerDataWithCharacterOffset(TextMarkerData& textMarkerData, const CharacterOffset& characterOffset)
+{
+ if (characterOffset.isNull())
+ return;
+
+ Node* domNode = characterOffset.node;
+ if (is<HTMLInputElement>(*domNode) && downcast<HTMLInputElement>(*domNode).isPasswordField()) {
+ textMarkerData.ignored = true;
+ return;
+ }
+
+ RefPtr<AccessibilityObject> obj = this->getOrCreate(domNode);
+
+ // Convert to visible position.
+ VisiblePosition visiblePosition = visiblePositionFromCharacterOffset(obj.get(), characterOffset);
+ int vpOffset = 0;
+ if (!visiblePosition.isNull()) {
+ Position deepPos = visiblePosition.deepEquivalent();
+ vpOffset = deepPos.deprecatedEditingOffset();
+ }
+
+ textMarkerData.axID = obj.get()->axObjectID();
+ textMarkerData.node = domNode;
+ textMarkerData.characterOffset = characterOffset.offset;
+ textMarkerData.characterStartIndex = characterOffset.startIndex;
+ textMarkerData.offset = vpOffset;
+ textMarkerData.affinity = visiblePosition.affinity();
+
+ this->setNodeInUse(domNode);
+}
+
+void AXObjectCache::startOrEndTextMarkerDataForRange(TextMarkerData& textMarkerData, RefPtr<Range> range, bool isStart)
+{
+ memset(&textMarkerData, 0, sizeof(TextMarkerData));
+
+ if (!range)
+ return;
+
+ // If it's end text marker, we want to go to the end of the range, and stay within the range.
+ bool stayWithinRange = !isStart;
+
+ // Change the start of the range, so the character offset starts from node beginning.
+ int offset = 0;
+ Node* node = &range->startContainer();
+ if (node->offsetInCharacters()) {
+ CharacterOffset nodeStartOffset = traverseToOffsetInRange(rangeForNodeContents(node), 0, false);
+ offset = std::max(range->startOffset() - nodeStartOffset.startIndex, 0);
+ range->setStart(node, nodeStartOffset.startIndex);
+ }
+
+ CharacterOffset characterOffset = traverseToOffsetInRange(range, offset, !isStart, stayWithinRange);
+ setTextMarkerDataWithCharacterOffset(textMarkerData, characterOffset);
+}
+
+void AXObjectCache::textMarkerDataForCharacterOffset(TextMarkerData& textMarkerData, Node& node, int offset, bool toNodeEnd)
+{
+ memset(&textMarkerData, 0, sizeof(TextMarkerData));
+
+ Node* domNode = &node;
+ if (!domNode)
+ return;
+
+ // If offset <= 0, means we want to go to the previous node.
+ if (offset <= 0 && !toNodeEnd) {
+ // Set the offset to the amount of characters we need to go backwards.
+ offset = - offset + 1;
+ while (offset > 0 && textMarkerData.characterOffset <= offset) {
+ offset -= textMarkerData.characterOffset;
+ domNode = previousNode(domNode);
+ if (domNode) {
+ textMarkerDataForCharacterOffset(textMarkerData, *domNode, 0, true);
+ offset--;
+ } else
+ return;
+ }
+ if (offset > 0)
+ textMarkerDataForCharacterOffset(textMarkerData, *domNode, offset, false);
+ return;
+ }
+
+ RefPtr<Range> 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.
+ CharacterOffset characterOffset = traverseToOffsetInRange(range, offset, toNodeEnd);
+ while (!characterOffset.isNull() && characterOffset.remaining() && !toNodeEnd) {
+ domNode = nextNode(domNode);
+ if (!domNode)
+ return;
+ range = rangeForNodeContents(domNode);
+ characterOffset = traverseToOffsetInRange(range, characterOffset.remaining(), toNodeEnd);
+ }
+
+ setTextMarkerDataWithCharacterOffset(textMarkerData, characterOffset);
+}
+
+Node* AXObjectCache::nextNode(Node* node) const
+{
+ if (!node)
+ return nullptr;
+
+ return NodeTraversal::nextSkippingChildren(*node);
+}
+
+Node* AXObjectCache::previousNode(Node* node) const
+{
+ if (!node)
+ return nullptr;
+
+ // First child of body shouldn't have previous node.
+ if (node->parentNode() && node->parentNode()->renderer() && node->parentNode()->renderer()->isBody() && !node->previousSibling())
+ return nullptr;
+
+ return NodeTraversal::previousSkippingChildren(*node);
+}
+
+VisiblePosition AXObjectCache::visiblePositionFromCharacterOffset(AccessibilityObject* obj, const CharacterOffset& characterOffset)
+{
+ if (!obj)
+ return VisiblePosition();
+
+ // nextVisiblePosition means advancing one character. Use this to calculate the character offset.
+ VisiblePositionRange vpRange = obj->visiblePositionRange();
+ VisiblePosition start = vpRange.start;
+ VisiblePosition result = start;
+ for (int i = 0; i < characterOffset.offset; i++)
+ result = obj->nextVisiblePosition(result);
+
+ return result;
+}
+
+CharacterOffset AXObjectCache::characterOffsetFromVisiblePosition(AccessibilityObject* obj, const VisiblePosition& visiblePos)
+{
+ if (!obj)
+ return 0;
+
+ // Use nextVisiblePosition to calculate how many characters we need to traverse to the current position.
+ Position deepPos = visiblePos.deepEquivalent();
+ VisiblePositionRange vpRange = obj->visiblePositionRange();
+ VisiblePosition vp = vpRange.start;
+ int characterOffset = 0;
+ Position vpDeepPos = vp.deepEquivalent();
+
+ while (!vpDeepPos.isNull() && !deepPos.equals(vpDeepPos)) {
+ vp = obj->nextVisiblePosition(vp);
+ vpDeepPos = vp.deepEquivalent();
+ characterOffset++;
+ }
+
+ return traverseToOffsetInRange(rangeForNodeContents(obj->node()), characterOffset, false);
+}
+
+AccessibilityObject* AXObjectCache::accessibilityObjectForTextMarkerData(TextMarkerData& textMarkerData)
+{
+ if (!isNodeInUse(textMarkerData.node))
+ return nullptr;
+
+ Node* domNode = textMarkerData.node;
+ return this->getOrCreate(domNode);
+}
+
</ins><span class="cx"> void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos)
</span><span class="cx"> {
</span><span class="cx"> // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence.
</span><span class="lines">@@ -1443,8 +1770,13 @@
</span><span class="cx"> textMarkerData.axID = obj.get()->axObjectID();
</span><span class="cx"> textMarkerData.node = domNode;
</span><span class="cx"> textMarkerData.offset = deepPos.deprecatedEditingOffset();
</span><del>- textMarkerData.affinity = visiblePos.affinity();
</del><ins>+ textMarkerData.affinity = visiblePos.affinity();
</ins><span class="cx">
</span><ins>+ // convert to character offset
+ CharacterOffset characterOffset = characterOffsetFromVisiblePosition(obj.get(), visiblePos);
+ textMarkerData.characterOffset = characterOffset.offset;
+ textMarkerData.characterStartIndex = characterOffset.startIndex;
+
</ins><span class="cx"> cache->setNodeInUse(domNode);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCoreaccessibilityAXObjectCacheh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/accessibility/AXObjectCache.h (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/accessibility/AXObjectCache.h 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/accessibility/AXObjectCache.h 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -51,9 +51,29 @@
</span><span class="cx"> AXID axID;
</span><span class="cx"> Node* node;
</span><span class="cx"> int offset;
</span><ins>+ int characterStartIndex;
+ int characterOffset;
+ bool ignored;
</ins><span class="cx"> EAffinity affinity;
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+struct CharacterOffset {
+ Node* node;
+ int startIndex;
+ int offset;
+ int remainingOffset;
+
+ CharacterOffset(Node* n = nullptr, int startIndex = 0, int offset = 0, int remaining = 0)
+ : node(n)
+ , startIndex(startIndex)
+ , offset(offset)
+ , remainingOffset(remaining)
+ { }
+
+ int remaining() const { return remainingOffset; }
+ bool isNull() const { return !node; }
+};
+
</ins><span class="cx"> class AXComputedObjectAttributeCache {
</span><span class="cx"> public:
</span><span class="cx"> AccessibilityObjectInclusion getIgnored(AXID) const;
</span><span class="lines">@@ -164,6 +184,12 @@
</span><span class="cx"> // Text marker utilities.
</span><span class="cx"> void textMarkerDataForVisiblePosition(TextMarkerData&, const VisiblePosition&);
</span><span class="cx"> VisiblePosition visiblePositionForTextMarkerData(TextMarkerData&);
</span><ins>+ void textMarkerDataForCharacterOffset(TextMarkerData&, Node&, int, bool toNodeEnd = false);
+ void startOrEndTextMarkerDataForRange(TextMarkerData&, RefPtr<Range>, bool);
+ AccessibilityObject* accessibilityObjectForTextMarkerData(TextMarkerData&);
+ RefPtr<Range> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
+ static RefPtr<Range> rangeForNodeContents(Node*);
+ static int lengthForRange(Range*);
</ins><span class="cx">
</span><span class="cx"> enum AXNotification {
</span><span class="cx"> AXActiveDescendantChanged,
</span><span class="lines">@@ -254,6 +280,13 @@
</span><span class="cx"> void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
</span><span class="cx"> void removeNodeForUse(Node* n) { m_textMarkerNodes.remove(n); }
</span><span class="cx"> bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
</span><ins>+
+ Node* nextNode(Node*) const;
+ Node* previousNode(Node*) const;
+ CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, bool, bool stayWithinRange = false);
+ VisiblePosition visiblePositionFromCharacterOffset(AccessibilityObject*, const CharacterOffset&);
+ CharacterOffset characterOffsetFromVisiblePosition(AccessibilityObject*, const VisiblePosition&);
+ void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> AccessibilityObject* rootWebArea();
</span></span></pre></div>
<a id="trunkSourceWebCoreaccessibilityAccessibilityObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/accessibility/AccessibilityObject.cpp (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/accessibility/AccessibilityObject.cpp 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/accessibility/AccessibilityObject.cpp 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -715,6 +715,11 @@
</span><span class="cx"> return Range::create(*frame->document());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+RefPtr<Range> AccessibilityObject::elementRange() const
+{
+ return AXObjectCache::rangeForNodeContents(node());
+}
+
</ins><span class="cx"> String AccessibilityObject::selectText(AccessibilitySelectTextCriteria* criteria)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(criteria);
</span><span class="lines">@@ -1203,7 +1208,7 @@
</span><span class="cx"> return VisiblePositionRange(startPosition, endPosition);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool replacedNodeNeedsCharacter(Node* replacedNode)
</del><ins>+bool AccessibilityObject::replacedNodeNeedsCharacter(Node* replacedNode)
</ins><span class="cx"> {
</span><span class="cx"> // we should always be given a rendered node and a replaced node, but be safe
</span><span class="cx"> // replaced nodes are either attachments (widgets) or images
</span><span class="lines">@@ -1228,7 +1233,19 @@
</span><span class="cx"> }
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><ins>+
+static String listMarkerTextForNode(Node* node)
+{
+ RenderListItem* listItem = renderListItemContainerForNode(node);
+ if (!listItem)
+ return String();
</ins><span class="cx">
</span><ins>+ // If this is in a list item, we need to manually add the text for the list marker
+ // because a RenderListMarker does not have a Node equivalent and thus does not appear
+ // when iterating text.
+ return listItem->markerTextWithSuffix();
+}
+
</ins><span class="cx"> // Returns the text associated with a list marker if this node is contained within a list item.
</span><span class="cx"> String AccessibilityObject::listMarkerTextForNodeAndPosition(Node* node, const VisiblePosition& visiblePositionStart) const
</span><span class="cx"> {
</span><span class="lines">@@ -1236,14 +1253,36 @@
</span><span class="cx"> if (!isStartOfLine(visiblePositionStart))
</span><span class="cx"> return String();
</span><span class="cx">
</span><del>- RenderListItem* listItem = renderListItemContainerForNode(node);
- if (!listItem)
</del><ins>+ return listMarkerTextForNode(node);
+}
+
+String AccessibilityObject::stringForRange(RefPtr<Range> range) const
+{
+ if (!range)
</ins><span class="cx"> return String();
</span><del>-
- // If this is in a list item, we need to manually add the text for the list marker
- // because a RenderListMarker does not have a Node equivalent and thus does not appear
- // when iterating text.
- return listItem->markerTextWithSuffix();
</del><ins>+
+ TextIterator it(range.get());
+ if (it.atEnd())
+ return String();
+
+ StringBuilder builder;
+ for (; !it.atEnd(); it.advance()) {
+ // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX)
+ if (it.text().length()) {
+ // Add a textual representation for list marker text.
+ builder.append(listMarkerTextForNode(it.node()));
+ it.appendTextToStringBuilder(builder);
+ } else {
+ // locate the node and starting offset for this replaced range
+ Node& node = it.range()->startContainer();
+ ASSERT(&node == &it.range()->endContainer());
+ int offset = it.range()->startOffset();
+ if (replacedNodeNeedsCharacter(node.traverseToChildAt(offset)))
+ builder.append(objectReplacementCharacter);
+ }
+ }
+
+ return builder.toString();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> String AccessibilityObject::stringForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) const
</span></span></pre></div>
<a id="trunkSourceWebCoreaccessibilityAccessibilityObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/accessibility/AccessibilityObject.h (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/accessibility/AccessibilityObject.h 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/accessibility/AccessibilityObject.h 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -817,6 +817,9 @@
</span><span class="cx"> virtual VisiblePositionRange visiblePositionRange() const { return VisiblePositionRange(); }
</span><span class="cx"> virtual VisiblePositionRange visiblePositionRangeForLine(unsigned) const { return VisiblePositionRange(); }
</span><span class="cx">
</span><ins>+ RefPtr<Range> elementRange() const;
+ static bool replacedNodeNeedsCharacter(Node* replacedNode);
+
</ins><span class="cx"> VisiblePositionRange visiblePositionRangeForUnorderedPositions(const VisiblePosition&, const VisiblePosition&) const;
</span><span class="cx"> VisiblePositionRange positionOfLeftWord(const VisiblePosition&) const;
</span><span class="cx"> VisiblePositionRange positionOfRightWord(const VisiblePosition&) const;
</span><span class="lines">@@ -829,6 +832,7 @@
</span><span class="cx"> VisiblePositionRange lineRangeForPosition(const VisiblePosition&) const;
</span><span class="cx">
</span><span class="cx"> String stringForVisiblePositionRange(const VisiblePositionRange&) const;
</span><ins>+ String stringForRange(RefPtr<Range>) const;
</ins><span class="cx"> virtual IntRect boundsForVisiblePositionRange(const VisiblePositionRange&) const { return IntRect(); }
</span><span class="cx"> int lengthForVisiblePositionRange(const VisiblePositionRange&) const;
</span><span class="cx"> virtual void setSelectedVisiblePositionRange(const VisiblePositionRange&) const { }
</span></span></pre></div>
<a id="trunkSourceWebCoreaccessibilitymacWebAccessibilityObjectWrapperMacmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -782,6 +782,136 @@
</span><span class="cx">
</span><span class="cx"> #pragma mark Text Marker helpers
</span><span class="cx">
</span><ins>+static bool isTextMarkerIgnored(id textMarker)
+{
+ if (!textMarker)
+ return false;
+
+ TextMarkerData textMarkerData;
+ if (!wkGetBytesFromAXTextMarker(textMarker, &textMarkerData, sizeof(textMarkerData)))
+ return false;
+
+ return textMarkerData.ignored;
+}
+
+- (AccessibilityObject*)accessibilityObjectForTextMarker:(id)textMarker
+{
+ return accessibilityObjectForTextMarker(m_object->axObjectCache(), textMarker);
+}
+
+static AccessibilityObject* accessibilityObjectForTextMarker(AXObjectCache* cache, id textMarker)
+{
+ if (!textMarker || !cache || isTextMarkerIgnored(textMarker))
+ return nullptr;
+
+ TextMarkerData textMarkerData;
+ if (!wkGetBytesFromAXTextMarker(textMarker, &textMarkerData, sizeof(textMarkerData)))
+ return nullptr;
+ return cache->accessibilityObjectForTextMarkerData(textMarkerData);
+}
+
+- (id)textMarkerRangeFromRange:(const RefPtr<Range>)range
+{
+ return textMarkerRangeFromRange(m_object->axObjectCache(), range);
+}
+
+static id textMarkerRangeFromRange(AXObjectCache *cache, const RefPtr<Range> range)
+{
+ id startTextMarker = startOrEndTextmarkerForRange(cache, range, true);
+ id endTextMarker = startOrEndTextmarkerForRange(cache, range, false);
+ return textMarkerRangeFromMarkers(startTextMarker, endTextMarker);
+}
+
+- (id)startOrEndTextMarkerForRange:(const RefPtr<Range>)range isStart:(BOOL)isStart
+{
+ return startOrEndTextmarkerForRange(m_object->axObjectCache(), range, isStart);
+}
+
+static id startOrEndTextmarkerForRange(AXObjectCache* cache, RefPtr<Range> range, bool isStart)
+{
+ if (!cache)
+ return nil;
+
+ TextMarkerData textMarkerData;
+ cache->startOrEndTextMarkerDataForRange(textMarkerData, range, isStart);
+ if (!textMarkerData.axID)
+ return nil;
+
+ return CFBridgingRelease(wkCreateAXTextMarker(&textMarkerData, sizeof(textMarkerData)));
+}
+
+- (id)nextTextMarkerForNode:(Node&)node offset:(int)offset
+{
+ int nextOffset = offset + 1;
+ id textMarker = [self textMarkerForNode:node offset:nextOffset];
+ if (isTextMarkerIgnored(textMarker))
+ textMarker = [self nextTextMarkerForNode:node offset:nextOffset];
+ return textMarker;
+}
+
+- (id)previousTextMarkerForNode:(Node&)node offset:(int)offset
+{
+ int previousOffset = offset - 1;
+ id textMarker = [self textMarkerForNode:node offset:previousOffset];
+ if (isTextMarkerIgnored(textMarker))
+ textMarker = [self previousTextMarkerForNode:node offset:previousOffset];
+ return textMarker;
+}
+
+- (id)textMarkerForNode:(Node&)node offset:(int)offset
+{
+ return textMarkerForCharacterOffset(m_object->axObjectCache(), node, offset);
+}
+
+static id textMarkerForCharacterOffset(AXObjectCache* cache, Node& node, int offset, bool toNodeEnd = false)
+{
+ if (!cache)
+ return nil;
+
+ Node* domNode = &node;
+ if (!domNode)
+ return nil;
+
+ TextMarkerData textMarkerData;
+ cache->textMarkerDataForCharacterOffset(textMarkerData, node, offset, toNodeEnd);
+ if (!textMarkerData.axID && !textMarkerData.ignored)
+ return nil;
+
+ return CFBridgingRelease(wkCreateAXTextMarker(&textMarkerData, sizeof(textMarkerData)));
+}
+
+- (RefPtr<Range>)rangeForTextMarkerRange:(id)textMarkerRange
+{
+ if (!textMarkerRange)
+ return nullptr;
+
+ id startTextMarker = AXTextMarkerRangeStart(textMarkerRange);
+ id endTextMarker = AXTextMarkerRangeEnd(textMarkerRange);
+
+ if (!startTextMarker || !endTextMarker)
+ return nullptr;
+
+ AXObjectCache* cache = m_object->axObjectCache();
+ if (!cache)
+ return nullptr;
+
+ CharacterOffset startCharacterOffset = [self characterOffsetForTextMarker:startTextMarker];
+ CharacterOffset endCharacterOffset = [self characterOffsetForTextMarker:endTextMarker];
+ return cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset);
+}
+
+- (CharacterOffset)characterOffsetForTextMarker:(id)textMarker
+{
+ if (!textMarker || isTextMarkerIgnored(textMarker))
+ return CharacterOffset();
+
+ TextMarkerData textMarkerData;
+ if (!wkGetBytesFromAXTextMarker(textMarker, &textMarkerData, sizeof(textMarkerData)))
+ return CharacterOffset();
+
+ return CharacterOffset(textMarkerData.node, textMarkerData.characterStartIndex, textMarkerData.characterOffset);
+}
+
</ins><span class="cx"> static id textMarkerForVisiblePosition(AXObjectCache* cache, const VisiblePosition& visiblePos)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(cache);
</span><span class="lines">@@ -3828,16 +3958,15 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXUIElementForTextMarker"]) {
</span><del>- VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
- AccessibilityObject* axObject = m_object->accessibilityObjectForPosition(visiblePos);
</del><ins>+ AccessibilityObject* axObject = [self accessibilityObjectForTextMarker:textMarker];
</ins><span class="cx"> if (!axObject)
</span><span class="cx"> return nil;
</span><span class="cx"> return axObject->wrapper();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXTextMarkerRangeForUIElement"]) {
</span><del>- VisiblePositionRange vpRange = uiElement.get()->visiblePositionRange();
- return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
</del><ins>+ RefPtr<Range> range = uiElement.get()->elementRange();
+ return [self textMarkerRangeFromRange:range];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXLineForTextMarker"]) {
</span><span class="lines">@@ -3851,8 +3980,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXStringForTextMarkerRange"]) {
</span><del>- VisiblePositionRange visiblePosRange = [self visiblePositionRangeForTextMarkerRange:textMarkerRange];
- return m_object->stringForVisiblePositionRange(visiblePosRange);
</del><ins>+ RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
+ return m_object->stringForRange(range);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXTextMarkerForPosition"]) {
</span><span class="lines">@@ -3895,20 +4024,23 @@
</span><span class="cx"> if (!AXObjectIsTextMarker(textMarker1) || !AXObjectIsTextMarker(textMarker2))
</span><span class="cx"> return nil;
</span><span class="cx">
</span><del>- VisiblePosition visiblePos1 = [self visiblePositionForTextMarker:(textMarker1)];
- VisiblePosition visiblePos2 = [self visiblePositionForTextMarker:(textMarker2)];
- VisiblePositionRange vpRange = m_object->visiblePositionRangeForUnorderedPositions(visiblePos1, visiblePos2);
- return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
</del><ins>+ AXObjectCache* cache = m_object->axObjectCache();
+ if (!cache)
+ return nil;
+ CharacterOffset characterOffset1 = [self characterOffsetForTextMarker:textMarker1];
+ CharacterOffset characterOffset2 = [self characterOffsetForTextMarker:textMarker2];
+ RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(characterOffset1, characterOffset2);
+ return [self textMarkerRangeFromRange:range];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXNextTextMarkerForTextMarker"]) {
</span><del>- VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
- return [self textMarkerForVisiblePosition:m_object->nextVisiblePosition(visiblePos)];
</del><ins>+ CharacterOffset characterOffset = [self characterOffsetForTextMarker:textMarker];
+ return [self nextTextMarkerForNode:*characterOffset.node offset:characterOffset.offset];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXPreviousTextMarkerForTextMarker"]) {
</span><del>- VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
- return [self textMarkerForVisiblePosition:m_object->previousVisiblePosition(visiblePos)];
</del><ins>+ CharacterOffset characterOffset = [self characterOffsetForTextMarker:textMarker];
+ return [self previousTextMarkerForNode:*characterOffset.node offset:characterOffset.offset];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"]) {
</span><span class="lines">@@ -3994,8 +4126,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXLengthForTextMarkerRange"]) {
</span><del>- VisiblePositionRange visiblePosRange = [self visiblePositionRangeForTextMarkerRange:textMarkerRange];
- int length = m_object->lengthForVisiblePositionRange(visiblePosRange);
</del><ins>+ RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
+ int length = AXObjectCache::lengthForRange(range.get());
</ins><span class="cx"> if (length < 0)
</span><span class="cx"> return nil;
</span><span class="cx"> return [NSNumber numberWithInt:length];
</span><span class="lines">@@ -4003,13 +4135,13 @@
</span><span class="cx">
</span><span class="cx"> // Used only by DumpRenderTree (so far).
</span><span class="cx"> if ([attribute isEqualToString:@"AXStartTextMarkerForTextMarkerRange"]) {
</span><del>- VisiblePositionRange visiblePosRange = [self visiblePositionRangeForTextMarkerRange:textMarkerRange];
- return [self textMarkerForVisiblePosition:visiblePosRange.start];
</del><ins>+ RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
+ return [self startOrEndTextMarkerForRange:range isStart:YES];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if ([attribute isEqualToString:@"AXEndTextMarkerForTextMarkerRange"]) {
</span><del>- VisiblePositionRange visiblePosRange = [self visiblePositionRangeForTextMarkerRange:textMarkerRange];
- return [self textMarkerForVisiblePosition:visiblePosRange.end];
</del><ins>+ RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
+ return [self startOrEndTextMarkerForRange:range isStart:NO];
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(TREE_DEBUGGING)
</span></span></pre></div>
<a id="trunkToolsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Tools/ChangeLog (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/ChangeLog 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Tools/ChangeLog 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -1,3 +1,13 @@
</span><ins>+2016-01-18 Nan Wang <n_wang@apple.com>
+
+ AX: [Mac] Implement next/previous text marker functions using TextIterator
+ https://bugs.webkit.org/show_bug.cgi?id=152728
+
+ Reviewed by Chris Fleizach.
+
+ * WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm:
+ (WTR::AccessibilityUIElement::accessibilityElementForTextMarker):
+
</ins><span class="cx"> 2016-01-18 Csaba Osztrogonác <ossy@webkit.org>
</span><span class="cx">
</span><span class="cx"> [cmake] Add testair to the build system
</span></span></pre></div>
<a id="trunkToolsWebKitTestRunnerInjectedBundlemacAccessibilityUIElementMacmm"></a>
<div class="modfile"><h4>Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm (195239 => 195240)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm 2016-01-19 00:06:46 UTC (rev 195239)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/mac/AccessibilityUIElementMac.mm 2016-01-19 00:56:13 UTC (rev 195240)
</span><span class="lines">@@ -1801,7 +1801,8 @@
</span><span class="cx"> {
</span><span class="cx"> BEGIN_AX_OBJC_EXCEPTIONS
</span><span class="cx"> id uiElement = [m_element accessibilityAttributeValue:@"AXUIElementForTextMarker" forParameter:(id)marker->platformTextMarker()];
</span><del>- return AccessibilityUIElement::create(uiElement);
</del><ins>+ if (uiElement)
+ return AccessibilityUIElement::create(uiElement);
</ins><span class="cx"> END_AX_OBJC_EXCEPTIONS
</span><span class="cx">
</span><span class="cx"> return nullptr;
</span></span></pre>
</div>
</div>
</body>
</html>