Fixes for contenteditable caret and selection handling in Windows.

content/browser/accessibility/browser_accessibility_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 189 matching lines @@
 
 // static
 BrowserAccessibility* BrowserAccessibility::Create() {
   ui::win::CreateATLModuleIfNeeded();
   CComObject<BrowserAccessibilityWin>* instance;
   HRESULT hr = CComObject<BrowserAccessibilityWin>::CreateInstance(&instance);
   DCHECK(SUCCEEDED(hr));
   return instance->NewReference();
 }
 
+const BrowserAccessibilityWin* BrowserAccessibility::ToBrowserAccessibilityWin()
+    const {
+  return static_cast<const BrowserAccessibilityWin*>(this);
+}
+
 BrowserAccessibilityWin* BrowserAccessibility::ToBrowserAccessibilityWin() {
   return static_cast<BrowserAccessibilityWin*>(this);
 }
 
 BrowserAccessibilityWin::BrowserAccessibilityWin()
     : win_attributes_(new WinAttributes()),
       previous_scroll_x_(0),
       previous_scroll_y_(0) {
   // Start unique IDs at -1 and decrement each time, because get_accChild
   // uses positive IDs to enumerate children, so we use negative IDs to
@@ skipping 1783 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
-  *offset = selection_start;
-  if (selection_start < 0)
+  // The caret is always at the end of the selection, if a selection exists.
+  *offset = selection_end;
+  if (*offset < 0)
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_characterExtents(
     LONG offset,
     enum IA2CoordinateType coordinate_type,
     LONG* out_x,
     LONG* out_y,
@@ skipping 33 matching lines @@
   if (!instance_active())
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
-      selection_start != selection_end)
+      selection_start != selection_end) {
     *n_selections = 1;
+  }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
                                                     LONG* start_offset,
                                                     LONG* end_offset) {
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   LONG n_selections = 0;
   if (FAILED(get_nSelections(&n_selections)) || n_selections < 1)
     return E_INVALIDARG;
 
   *start_offset = 0;
   *end_offset = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0) {
+    // We should ignore the direction of the selection when exposing start and
+    // end offsets. According to the IA2 Spec the end offset is always increased
+    // by one past the end of the selection. This wouldn't make sense if
+    // end < start.
+    if (selection_end < selection_start)
+      std::swap(selection_start, selection_end);
+
     *start_offset = selection_start;
     *end_offset = selection_end;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
                                                LONG end_offset,
                                                BSTR* text) {
@@ skipping 1539 matching lines @@
   int value;
   if (GetIntAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
         base::ASCIIToUTF16(ia2_attr) + L":" +
         base::IntToString16(value));
   }
 }
 
 int32 BrowserAccessibilityWin::GetHyperlinkIndexFromChild(
     const BrowserAccessibilityWin& child) const {
+  if (hyperlinks().empty())
+    return -1;
+
   auto iterator = std::find(
       hyperlinks().begin(), hyperlinks().end(), child.GetId());
   if (iterator == hyperlinks().end())
     return -1;
 
   return static_cast<int32>(iterator - hyperlinks().begin());
 }
 
 int32 BrowserAccessibilityWin::GetHypertextOffsetFromHyperlinkIndex(
     int32 hyperlink_index) const {
-  auto& offsets_map = hyperlink_offset_to_index();
-  for (auto& offset_index : offsets_map) {
+  for (auto& offset_index : hyperlink_offset_to_index()) {
     if (offset_index.second == hyperlink_index)
       return offset_index.first;
   }
 
   return -1;
 }
 
 int32 BrowserAccessibilityWin::GetHypertextOffsetFromChild(
     const BrowserAccessibilityWin& child) const {
   int32 hyperlink_index = GetHyperlinkIndexFromChild(child);
@@ skipping 10 matching lines @@
   while (parent_object && parent_object != this) {
     current_object = parent_object;
     parent_object = current_object->GetParent()->ToBrowserAccessibilityWin();
   }
   if (!parent_object)
     return -1;
 
   return parent_object->GetHypertextOffsetFromChild(*current_object);
 }
 
+int BrowserAccessibilityWin::GetHypertextOffsetFromEndpoint(
+    const BrowserAccessibilityWin& endpoint_object,
+    int endpoint_offset) const {
+  // There are three cases:
+  // 1. Either the selection endpoint is inside this object or is an ancestor of
+  // of this object. endpoint_offset should be returned.
+  // 2. The selection endpoint is a pure descendant of this object. The offset
+  // of the embedded object character corresponding to the subtree in which
+  // the endpoint is located should be returned.
+  // 3. The selection endpoint is in a completely different part of the tree.
+  // Either 0 or text_length should be returned depending on the direction that
+  // one needs to travel to find the endpoint.
+
+  // Case 1.
+  //
+  // IsDescendantOf includes the case when endpoint_object == this.
+  if (IsDescendantOf(&endpoint_object) ||
+      // Handle the case when the endpoint is a direct text-only child.
+      // The selection offset should still be valid on the parent.
+      (endpoint_object.IsTextOnlyObject() &&
+       endpoint_object.GetParent() == this)) {
+    return endpoint_offset;
+  }
+
+  const BrowserAccessibility* common_parent = this;
+  int32 index_in_common_parent = 0;
+  while (common_parent && !endpoint_object.IsDescendantOf(common_parent)) {
+    index_in_common_parent = common_parent->GetIndexInParent();
+    common_parent = common_parent->GetParent();
+  }
+  if (!common_parent)
+    return -1;
+
+  auto common_parent_win = common_parent->ToBrowserAccessibilityWin();
+  DCHECK_GE(index_in_common_parent, 0);
+  DCHECK(!(common_parent_win->IsTextOnlyObject()));
+
+  // Case 2.
+  //
+  // We already checked in case 1 if our endpoint is inside this object.
+  // We can safely assume that it is a descendant or in a completely different
+  // part of the tree.
+  if (common_parent_win == this) {
+    // Text only objects must have a parent.
+    DCHECK(!endpoint_object.IsTextOnlyObject() || endpoint_object.GetParent());
+    // Text only objects that are direct descendants should behave as if they
+    // are part of their parent when computing hyperlink offsets.
+    const BrowserAccessibilityWin& nearest_non_text_endpoint =
+        endpoint_object.IsTextOnlyObject()
+            ? *(endpoint_object.GetParent()->ToBrowserAccessibilityWin())
+            : endpoint_object;
+
+    return GetHypertextOffsetFromDescendant(nearest_non_text_endpoint);
+  }
+
+  // Case 3.
+  //
+  // We can safely assume that the endpoint is in another part of the tree or
+  // at common parent, and that this object is a descendant of common parent.
+  int32 endpoint_index_in_common_parent = 0;
+  for (size_t i = 0; i < common_parent->PlatformChildCount(); ++i) {
+    BrowserAccessibility* child = common_parent->PlatformGetChild(i);
+    DCHECK(child);
+    if (endpoint_object.IsDescendantOf(child)) {
+      endpoint_index_in_common_parent = child->GetIndexInParent();
+      break;
+    }
+  }
+  DCHECK_GE(endpoint_index_in_common_parent, 0);
+
+  if (endpoint_index_in_common_parent < index_in_common_parent)
+    return 0;
+  if (endpoint_index_in_common_parent > index_in_common_parent)
+    return TextForIAccessibleText().length();
+
+  NOTREACHED();
+  return -1;
+}
+
 int BrowserAccessibilityWin::GetSelectionAnchor() const {
   BrowserAccessibility* root = manager()->GetRoot();
   int32 anchor_id;
   if (!root || !root->GetIntAttribute(ui::AX_ATTR_ANCHOR_OBJECT_ID, &anchor_id))
     return -1;
 
   BrowserAccessibilityWin* anchor_object = manager()->GetFromID(
       anchor_id)->ToBrowserAccessibilityWin();
   if (!anchor_object)
     return -1;
 
-  // Includes the case when anchor_object == this.
-  if (IsDescendantOf(anchor_object) ||
-      // Text only objects that are direct descendants should behave as if they
-      // are part of this object when computing hypertext.
-      (anchor_object->GetParent() == this &&
-      anchor_object->IsTextOnlyObject())) {
-    int anchor_offset;
-    if (!root->GetIntAttribute(ui::AX_ATTR_ANCHOR_OFFSET, &anchor_offset))
-      return -1;
+  int anchor_offset;
+  if (!root->GetIntAttribute(ui::AX_ATTR_ANCHOR_OFFSET, &anchor_offset))
+    return -1;
 
-    return anchor_offset;
-  }
-
-  if (anchor_object->IsDescendantOf(this))
-    return GetHypertextOffsetFromDescendant(*anchor_object);
-
-  return -1;
+  return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
 int BrowserAccessibilityWin::GetSelectionFocus() const {
   BrowserAccessibility* root = manager()->GetRoot();
   int32 focus_id;
   if (!root || !root->GetIntAttribute(ui::AX_ATTR_FOCUS_OBJECT_ID, &focus_id))
     return -1;
 
   BrowserAccessibilityWin* focus_object = manager()->GetFromID(
       focus_id)->ToBrowserAccessibilityWin();
   if (!focus_object)
     return -1;
 
-  // Includes the case when focus_object == this.
-  if (IsDescendantOf(focus_object) ||
-      // Text only objects that are direct descendants should behave as if they
-      // are part of this object when computing hypertext.
-      (focus_object->GetParent() == this && focus_object->IsTextOnlyObject())) {
-    int focus_offset;
-    if (!root->GetIntAttribute(ui::AX_ATTR_FOCUS_OFFSET, &focus_offset))
-      return -1;
+  int focus_offset;
+  if (!root->GetIntAttribute(ui::AX_ATTR_FOCUS_OFFSET, &focus_offset))
+    return -1;
 
-    return focus_offset;
-  }
-
-  if (focus_object->IsDescendantOf(this))
-    return GetHypertextOffsetFromDescendant(*focus_object);
-
-  return -1;
+  return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
 void BrowserAccessibilityWin::GetSelectionOffsets(
     int* selection_start, int* selection_end) const {
   DCHECK(selection_start && selection_end);
 
   if (IsEditableText() && !HasState(ui::AX_STATE_RICHLY_EDITABLE) &&
       GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START, selection_start) &&
       GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, selection_end)) {
     return;
   }
 
   *selection_start = GetSelectionAnchor();
   *selection_end = GetSelectionFocus();
   if (*selection_start < 0 || *selection_end < 0)
     return;
 
-  if (*selection_end < *selection_start)
-    std::swap(*selection_start, *selection_end);
+  // If the selection is collapsed or if it only spans one character, return the
+  // selection offsets only if the caret is active on this object or any of its
+  // children.
+  // The focus object indicates the caret position.
+  if (*selection_start == *selection_end) {
+    BrowserAccessibility* root = manager()->GetRoot();
+    int32 focus_id;
+    if (!root || !root->GetIntAttribute(ui::AX_ATTR_FOCUS_OBJECT_ID, &focus_id))
+      return;
 
-  // IA2 Spec says that the end of the selection should be after the last
-  // embedded object character that is part of the selection, if there is one.
-  if (hyperlink_offset_to_index().find(*selection_end) !=
-      hyperlink_offset_to_index().end()) {
-    ++(*selection_end);
+    BrowserAccessibilityWin* focus_object =
+        manager()->GetFromID(focus_id)->ToBrowserAccessibilityWin();
+    if (!focus_object)
+      return;
+
+    if (!focus_object->IsDescendantOf(this) &&
+        !(IsTextOnlyObject() && GetParent() == focus_object)) {
+      *selection_start = -1;
+      *selection_end = -1;
+      return;
+    }
   }
+
+  // The IA2 Spec says that if the largest of the two offsets falls on an
+  // embedded object character and if there is a selection in that embedded
+  // object, it should be incremented by one so that it points after the
+  // embedded object character.
+  // This is a signal to AT software that the embedded object is also part of
+  // the selection.
+  int* largest_offset =
+      (*selection_start <= *selection_end) ? selection_end : selection_start;
+  auto current_object = const_cast<BrowserAccessibilityWin*>(this);
+  LONG hyperlink_index;
+  HRESULT hr =
+      current_object->get_hyperlinkIndex(*largest_offset, &hyperlink_index);
+  if (hr != S_OK)
+    return;
+
+  DCHECK_GE(hyperlink_index, 0);
+  base::win::ScopedComPtr<IAccessibleHyperlink> hyperlink;
+  hr = current_object->get_hyperlink(hyperlink_index, hyperlink.Receive());
+  DCHECK(SUCCEEDED(hr));
+  base::win::ScopedComPtr<IAccessibleText> hyperlink_text;
+  hr = hyperlink.QueryInterface(hyperlink_text.Receive());
+  DCHECK(SUCCEEDED(hr));
+  LONG n_selections = 0;
+  hr = hyperlink_text->get_nSelections(&n_selections);
+  DCHECK(SUCCEEDED(hr));
+  if (n_selections > 0)
+    ++(*largest_offset);
 }
 
 base::string16 BrowserAccessibilityWin::GetNameRecursive() const {
   if (!name().empty()) {
     return name();
   }
 
   base::string16 result;
   for (uint32 i = 0; i < PlatformChildCount(); ++i) {
     result += PlatformGetChild(i)->ToBrowserAccessibilityWin()->
         GetNameRecursive();
   }
   return result;
 }
 
 base::string16 BrowserAccessibilityWin::GetValueText() {
   float fval;
   base::string16 value = this->value();
 
   if (value.empty() &&
       GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
     value = base::UTF8ToUTF16(base::DoubleToString(fval));
   }
   return value;
 }
 
-base::string16 BrowserAccessibilityWin::TextForIAccessibleText() {
+base::string16 BrowserAccessibilityWin::TextForIAccessibleText() const {
   switch (GetRole()) {
     case ui::AX_ROLE_TEXT_FIELD:
     case ui::AX_ROLE_MENU_LIST_OPTION:
       return value();
     default:
       return hypertext();
   }
 }
 
 bool BrowserAccessibilityWin::IsSameHypertextCharacter(size_t old_char_index,
@@ skipping 686 matching lines @@
     ia2_role = ia_role;
 
   win_attributes_->ia_role = ia_role;
   win_attributes_->ia_state = ia_state;
   win_attributes_->role_name = role_name;
   win_attributes_->ia2_role = ia2_role;
   win_attributes_->ia2_state = ia2_state;
 }
 
 }  // namespace content