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()) {

[dmazzoni, 2016/09/15 16:32:36]

It's possible to call AXObject::setSelection on an object that doesn't even have
a node, right? How about if (!node || !node->isTextNode()) to handle that case
too?

+        // 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.
+        if (offset < 0 || static_cast<unsigned>(offset) > obj->children().size())
+            return VisiblePosition();
+
+        // Clamp to between 0 and child count - 1.
+        int clampedOffset =
+            static_cast<unsigned>(offset) > (obj->children().size() - 1) ? offset - 1 : offset;

[dmazzoni, 2016/09/15 16:32:36]

Clearer using std::min?

+        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));

[dmazzoni, 2016/09/15 16:32:36]

Instead of computing the index in parent in the DOM tree, could you just call
Position::beforeNode(childNode)?

+    }
 
     // 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