Support child-based node offsets when setting accessible selections

third_party/WebKit/Source/modules/accessibility/AXLayoutObject.cpp

 /*
 * Copyright (C) 2008 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 1799 matching lines @@
 }
 
 
 //
 // Modify or take an action on an object.
 //
 
 // Convert from an accessible object and offset to a VisiblePosition.
 static VisiblePosition toVisiblePosition(AXObject* obj, int offset)
 {
-    // First walk up until we find an accessible object with an associated node.
-    AXObject* runner = obj;
-    Node* node = nullptr;
-    while (runner && !node) {
-        node = runner->getNode();
-        runner = runner->parentObject();
-    }
-
-    if (!node)
+    if (!obj->getNode())
         return VisiblePosition();
 
-    // If it's not a text node, no conversion is necessary, just create a VisiblePosition
-    // with this node and offset.
-    if (!node->isTextNode())
-        return createVisiblePosition(Position(node, offset));
+    Node* node = obj->getNode();
+    if (!node->isTextNode()) {
+        // The offsets are child offsets over the AX tree. Note that we allow
+        // for the offset to equal the number of children as |Range| does.
+        int childCount = obj->children().size();
+        // Figure out what it means when |childCount| is 0.

[dmazzoni, 2016/09/16 18:10:56]

Is this a TODO/FIXME?

Maybe it should just select this node?

It seems silly to me that in order to select a node you have to call
setSelection on its parent, why not just allow selecting a node itself and then
if it has no children, the start and end offsets don't matter?

You don't have to change that, but please update the comment to indicate what it
does now and what you may want to do later

[David Tseng, 2016/09/16 20:50:31]

This isn't a selection but a position.

It's not quite that simple. We have to go to the axobj's *parent* and use the
obj's index in parent to point to the child. That still leaves us with deciding
whether to point to *before* or *after* the obj. I picked before, but have no
strong preference.

In general though, it breaks the contract with the client regarding non-text
nodes having child node offsets. I uploaded the change, but we might want to
reconsider at some point if it causes confusion/problems. For example, I could
do:
setDocumentSelection({anchorObject: divWithNoChildren, focusObject:
divWithNoChildren, anchorOffset: 1000000, focusOffset: 2000000000});

and it would select the div by setting anchor/focus to divWithNoChildren.parent
and offsets to divWithNoChildren.indexInParent (for both anchor and focus). So,
that's an insertion point which makes as much sense as selecting the whole
object I guess.

+        if (childCount == 0 || offset < 0 || offset > childCount)
+            return VisiblePosition();
+
+        // Clamp to between 0 and child count - 1.
+        int clampedOffset =
+            static_cast<unsigned>(offset) > (obj->children().size() - 1) ? offset - 1 : offset;
+        AXObject* childObj = obj->children()[clampedOffset];
+        Node* childNode = childObj->getNode();
+        if (!childNode || !childNode->parentNode())
+            return VisiblePosition();
+
+        // The index in parent.
+        int adjustedOffset = -1;
+        NodeList* childNodes = childNode->parentNode()->childNodes();
+        for (unsigned i = 0; i < childNodes->length(); ++i) {
+            if (childNodes->item(i) == childNode) {
+                adjustedOffset = i;
+                break;
+            }
+        }
+
+        if (adjustedOffset == -1)
+            return VisiblePosition();
+
+        // If we had to clamp the offset above, the client wants to select the
+        // end of the node.
+        if (clampedOffset != offset)
+            adjustedOffset++;
+
+        return createVisiblePosition(Position::editingPositionOf(childNode->parentNode(), adjustedOffset));
+    }
 
     // If it is a text node, we need to call some utility functions that use a TextIterator
     // to walk the characters of the node and figure out the position corresponding to the
     // visible character at position |offset|.
     ContainerNode* parent = node->parentNode();
     if (!parent)
         return VisiblePosition();
 
     VisiblePosition nodePosition = blink::visiblePositionBeforeNode(*node);
     int nodeIndex = blink::indexForVisiblePosition(nodePosition, parent);
     return blink::visiblePositionForIndex(nodeIndex + offset, parent);
 }
 
 void AXLayoutObject::setSelection(const AXRange& selection)
 {
     if (!getLayoutObject() || !selection.isValid())
         return;
 
     AXObject* anchorObject = selection.anchorObject ?
         selection.anchorObject.get() : this;
     AXObject* focusObject = selection.focusObject ?
         selection.focusObject.get() : this;
 
     if (!isValidSelectionBound(anchorObject)
         || !isValidSelectionBound(focusObject)) {
         return;
     }
 
+    // The selection offsets are offsets into the accessible value.
     if (anchorObject == focusObject
         && anchorObject->getLayoutObject()->isTextControl()) {
         HTMLTextFormControlElement* textControl = toLayoutTextControl(
             anchorObject->getLayoutObject())->textFormControlElement();
         if (selection.anchorOffset <= selection.focusOffset) {
             textControl->setSelectionRange(
                 selection.anchorOffset, selection.focusOffset,
                 SelectionHasForwardDirection);
         } else {
             textControl->setSelectionRange(
@@ skipping 498 matching lines @@
 
 bool AXLayoutObject::elementAttributeValue(const QualifiedName& attributeName) const
 {
     if (!m_layoutObject)
         return false;
 
     return equalIgnoringCase(getAttribute(attributeName), "true");
 }
 
 } // namespace blink