Implements the ability to get and set the caret position and the current selection from anywhere in…

Source/web/WebAXObject.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 798 matching lines @@
 }
 
 WebAXRole WebAXObject::role() const
 {
     if (isDetached())
         return WebAXRoleUnknown;
 
     return static_cast<WebAXRole>(m_private->roleValue());
 }
 
+void WebAXObject::selection(WebAXObject& anchorObject, int& anchorOffset,
+    WebAXObject& focusObject, int& focusOffset) const
+{
+    if (isDetached()) {
+        anchorObject = WebAXObject();
+        anchorOffset = -1;
+        focusObject = WebAXObject();
+        focusOffset = -1;
+        return;
+    }
+
+    AXObject::AXRange axSelection = m_private->selection();
+    anchorObject = WebAXObject(axSelection.anchorObject);
+    anchorOffset = axSelection.anchorOffset;
+    focusObject = WebAXObject(axSelection.focusObject);
+    focusOffset = axSelection.focusOffset;
+    return;
+}
+
+void WebAXObject::setSelection(const WebAXObject& anchorObject, int anchorOffset,
+    const WebAXObject& focusObject, int focusOffset) const
+{
+    if (isDetached())
+        return;
+
+    AXObject::AXRange axSelection(anchorObject, anchorOffset,
+        focusObject, focusOffset);
+    m_private->setSelection(axSelection);
+    return;
+}
+
 unsigned WebAXObject::selectionEnd() const
 {
     if (isDetached())
         return 0;
 
-    return m_private->selectedTextRange().start + m_private->selectedTextRange().length;
+    AXObject::AXRange axSelection = m_private->selectionUnderObject();

[dmazzoni, 2015/06/24 00:11:01]

It seems like this changes the behavior.

Previously, selectionEnd only returned something for an input or textarea.

Now, it will return the selection whenever there's a document selection or
contenteditable selection within the subtree rooted at this element. That's
going to expose the selection start and end in the accessibility tree and may
cause strange behavior.

It's not entirely clear to me if we really need selectionUnderObject the way you
implemented it. Perhaps what's actually needed is something like
plainTextSelectionRange() which returns the start and end offset of the
selection for an editable text element - that could include a contentEditable
where it collapses all of the text.

+    return axSelection.focusOffset;
 }
 
 unsigned WebAXObject::selectionStart() const
 {
     if (isDetached())
         return 0;
 
-    return m_private->selectedTextRange().start;
+    AXObject::AXRange axSelection = m_private->selectionUnderObject();
+    return axSelection.anchorOffset;
 }
 
 unsigned WebAXObject::selectionEndLineNumber() const
 {
     if (isDetached())
         return 0;
 
     VisiblePosition position = m_private->visiblePositionForIndex(selectionEnd());
     int lineNumber = m_private->lineForPosition(position);
     if (lineNumber < 0)
@@ skipping 17 matching lines @@
 {
     if (!isDetached())
         m_private->setFocused(on);
 }
 
 void WebAXObject::setSelectedTextRange(int selectionStart, int selectionEnd) const
 {
     if (isDetached())
         return;
 
-    m_private->setSelectedTextRange(AXObject::PlainTextRange(selectionStart, selectionEnd - selectionStart));
+    m_private->setSelection(AXObject::AXRange(selectionStart, selectionEnd));
 }
 
 void WebAXObject::setValue(WebString value) const
 {
     if (isDetached())
         return;
 
     m_private->setValue(value);
 }
 
@@ skipping 601 matching lines @@
     for (size_t i = 0; i < vectorSize; i++)
         offsetsWebVector[i] = offsetsVector[i];
     offsets.swap(offsetsWebVector);
 }
 
 void WebAXObject::wordBoundaries(WebVector<int>& starts, WebVector<int>& ends) const
 {
     if (isDetached())
         return;
 
-    Vector<AXObject::PlainTextRange> words;
-    m_private->wordBoundaries(words);
+    Vector<AXObject::AXRange> wordBoundaries;
+    m_private->wordBoundaries(wordBoundaries);
 
-    WebVector<int> startsWebVector(words.size());
-    WebVector<int> endsWebVector(words.size());
-    for (size_t i = 0; i < words.size(); i++) {
-        startsWebVector[i] = words[i].start;
-        endsWebVector[i] = words[i].start + words[i].length;
+    WebVector<int> wordStartOffsets(wordBoundaries.size());
+    WebVector<int> wordEndOffsets(wordBoundaries.size());
+    for (size_t i = 0; i < wordBoundaries.size(); ++i) {
+        wordStartOffsets[i] = wordBoundaries[i].anchorOffset;

[dmazzoni, 2015/06/24 00:11:01]

How about: ASSERT(wordBoundaries[i].isSimple());

+        wordEndOffsets[i] = wordBoundaries[i].focusOffset;
     }
-    starts.swap(startsWebVector);
-    ends.swap(endsWebVector);
+
+    starts.swap(wordStartOffsets);
+    ends.swap(wordEndOffsets);
 }
 
 bool WebAXObject::isScrollableContainer() const
 {
     if (isDetached())
         return false;
 
     return m_private->isScrollableContainer();
 }
 
@@ skipping 57 matching lines @@
     m_private = object;
     return *this;
 }
 
 WebAXObject::operator WTF::PassRefPtr<AXObject>() const
 {
     return m_private.get();
 }
 
 } // namespace blink