Implemented SetSelection for the Web content on 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 411 matching lines @@
     return E_FAIL;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   // Return an error if it's not clickable.
   if (!target->HasIntAttribute(ui::AX_ATTR_ACTION))
     return DISP_E_MEMBERNOTFOUND;
 
-  manager()->DoDefaultAction(*target);
+  manager_->DoDefaultAction(*target);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left,
                                                  LONG y_top,
                                                  VARIANT* child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
   if (!instance_active())
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   gfx::Point point(x_left, y_top);
   if (!GetScreenBoundsRect().Contains(point)) {
     // Return S_FALSE and VT_EMPTY when outside the object's boundaries.
     child->vt = VT_EMPTY;
     return S_FALSE;
   }
 
-  BrowserAccessibility* result = manager()->CachingAsyncHitTest(point);
+  BrowserAccessibility* result = manager_->CachingAsyncHitTest(point);
   if (result == this) {
     // Point is within this object.
     child->vt = VT_I4;
     child->lVal = CHILDID_SELF;
   } else {
     child->vt = VT_DISPATCH;
     child->pdispVal = ToBrowserAccessibilityWin(result)->NewReference();
   }
   return S_OK;
 }
@@ skipping 145 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
   if (!instance_active())
     return E_FAIL;
 
   if (!focus_child)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* focus = static_cast<BrowserAccessibilityWin*>(
-      manager()->GetFocus());
+  BrowserAccessibilityWin* focus =
+      static_cast<BrowserAccessibilityWin*>(manager_->GetFocus());
   if (focus == this) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus == NULL) {
     focus_child->vt = VT_EMPTY;
   } else {
     focus_child->vt = VT_DISPATCH;
     focus_child->pdispVal = focus->NewReference();
   }
 
@@ skipping 64 matching lines @@
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
   IAccessible* parent_obj = ToBrowserAccessibilityWin(GetParent());
   if (parent_obj == NULL) {
     // This happens if we're the root of the tree;
     // return the IAccessible for the window.
     parent_obj =
-        manager()->ToBrowserAccessibilityManagerWin()->GetParentIAccessible();
+        manager_->ToBrowserAccessibilityManagerWin()->GetParentIAccessible();
     // |parent| can only be NULL if the manager was created before the parent
     // IAccessible was known and it wasn't subsequently set before a client
     // requested it. This has been fixed. |parent| may also be NULL during
     // destruction. Possible cases where this could occur include tabs being
     // dragged to a new window, etc.
     if (!parent_obj) {
       DVLOG(1) << "In Function: " << __func__
                << ". Parent IAccessible interface is NULL. Returning failure";
       return E_FAIL;
     }
@@ skipping 34 matching lines @@
 
   if (!state)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state();
-  if (manager()->GetFocus() == this)
+  if (manager_->GetFocus() == this)
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
                                                    BSTR* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
   if (!instance_active())
     return E_FAIL;
@@ skipping 91 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accSelect(
     LONG flags_sel, VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
   if (!instance_active())
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
-    manager()->SetFocus(*this);
+    manager_->SetFocus(*this);
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::put_accName(VARIANT var_id, BSTR put_name) {
   return E_NOTIMPL;
 }
@@ skipping 68 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_WINDOW_HANDLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
   *window_handle =
-      manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
+      manager_->ToBrowserAccessibilityManagerWin()->GetParentHWND();
   if (!*window_handle)
     return E_FAIL;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INDEX_IN_PARENT);
   if (!instance_active())
     return E_FAIL;
@@ skipping 65 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollTo(IA2ScrollType scroll_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_SCROLL_TO);
   if (!instance_active())
     return E_FAIL;
 
   gfx::Rect r = GetFrameBoundsRect();
   switch(scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
-      manager()->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
+      manager_->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
-      manager()->ScrollToMakeVisible(
-          *this, gfx::Rect(r.right(), r.bottom(), 0, 0));
+      manager_->ScrollToMakeVisible(*this,
+                                    gfx::Rect(r.right(), r.bottom(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_TOP_EDGE:
-      manager()->ScrollToMakeVisible(
-          *this, gfx::Rect(r.x(), r.y(), r.width(), 0));
+      manager_->ScrollToMakeVisible(*this,
+                                    gfx::Rect(r.x(), r.y(), r.width(), 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_EDGE:
-      manager()->ScrollToMakeVisible(
-          *this, gfx::Rect(r.x(), r.bottom(), r.width(), 0));
-    break;
+      manager_->ScrollToMakeVisible(*this,
+                                    gfx::Rect(r.x(), r.bottom(), r.width(), 0));
+      break;
     case IA2_SCROLL_TYPE_LEFT_EDGE:
-      manager()->ScrollToMakeVisible(
-          *this, gfx::Rect(r.x(), r.y(), 0, r.height()));
+      manager_->ScrollToMakeVisible(*this,
+                                    gfx::Rect(r.x(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_RIGHT_EDGE:
-      manager()->ScrollToMakeVisible(
-          *this, gfx::Rect(r.right(), r.y(), 0, r.height()));
+      manager_->ScrollToMakeVisible(*this,
+                                    gfx::Rect(r.right(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_ANYWHERE:
     default:
-      manager()->ScrollToMakeVisible(*this, r);
+      manager_->ScrollToMakeVisible(*this, r);
       break;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_POINT);
   if (!instance_active())
     return E_FAIL;
 
   gfx::Point scroll_to(x, y);
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
-    scroll_to -= manager()->GetViewBounds().OffsetFromOrigin();
+    scroll_to -= manager_->GetViewBounds().OffsetFromOrigin();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     if (GetParent())
       scroll_to += GetParent()->GetFrameBoundsRect().OffsetFromOrigin();
   } else {
     return E_INVALIDARG;
   }
 
-  manager()->ScrollToPoint(*this, scroll_to);
+  manager_->ScrollToPoint(*this, scroll_to);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_GROUP_POSITION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
@@ skipping 941 matching lines @@
     BrowserAccessibilityWin* cell = GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
       (*n_column_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_column_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
-    BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+    BrowserAccessibility* cell = manager_->GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           ToBrowserAccessibilityWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
@@ skipping 72 matching lines @@
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   const std::vector<int32_t>& cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
 
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
-    BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+    BrowserAccessibility* cell = manager_->GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
       (*n_row_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_row_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
-    BrowserAccessibility* cell = manager()->GetFromID(cell_id);
+    BrowserAccessibility* cell = manager_->GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           ToBrowserAccessibilityWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
@@ skipping 147 matching lines @@
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHARACTER_EXTENTS);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER |
                             ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES);
   if (!instance_active())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &offset);
-
+  HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
     return E_INVALIDARG;
 
   gfx::Rect character_bounds;
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     character_bounds = GetScreenBoundsForRange(offset, 1);
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     character_bounds = GetPageBoundsForRange(offset, 1);
     if (GetParent())
       character_bounds -= GetParent()->GetPageBoundsRect().OffsetFromOrigin();
@@ skipping 68 matching lines @@
                                                BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &start_offset);
-  HandleSpecialTextOffset(text_str, &end_offset);
+  HandleSpecialTextOffset(&start_offset);
+  HandleSpecialTextOffset(&end_offset);
 
   // The spec allows the arguments to be reversed.
   if (start_offset > end_offset) {
     LONG tmp = start_offset;
     start_offset = end_offset;
     end_offset = tmp;
   }
 
   // The spec does not allow the start or end offsets to be out or range;
   // we must return an error if so.
@@ skipping 23 matching lines @@
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER |
                             ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &offset);
+  HandleSpecialTextOffset(&offset);
   if (offset < 0)
     return E_INVALIDARG;
 
   LONG text_len = text_str.length();
   if (offset > text_len)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
@@ skipping 190 matching lines @@
   return scrollToPoint(coordinate_type, x, y);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
                                                    LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ADD_SELECTION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
 
-  const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &start_offset);
-  HandleSpecialTextOffset(text_str, &end_offset);
-
-  manager()->SetTextSelection(*this, start_offset, end_offset);
+  // We only support one selection.
+  SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::removeSelection(LONG selection_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_REMOVE_SELECTION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
 
   if (selection_index != 0)
     return E_INVALIDARG;
 
-  manager()->SetTextSelection(*this, 0, 0);
+  // Simply collapse the selection to the position of the caret if a caret is
+  // visible, otherwise set the selection to 0.
+  LONG caret_offset = 0;
+  int selection_start, selection_end;
+  GetSelectionOffsets(&selection_start, &selection_end);
+  if (HasCaret() && selection_end >= 0)
+    caret_offset = selection_end;
+  SetIA2HypertextSelection(caret_offset, caret_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::setCaretOffset(LONG offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CARET_OFFSET);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
-
-  const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &offset);
-  manager()->SetTextSelection(*this, offset, offset);
+  SetIA2HypertextSelection(offset, offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::setSelection(LONG selection_index,
                                                    LONG start_offset,
                                                    LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_SELECTION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
-
   if (selection_index != 0)
     return E_INVALIDARG;
-
-  const base::string16& text_str = GetText();
-  HandleSpecialTextOffset(text_str, &start_offset);
-  HandleSpecialTextOffset(text_str, &end_offset);
-
-  manager()->SetTextSelection(*this, start_offset, end_offset);
+  SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(LONG offset,
                                                      LONG* start_offset,
                                                      LONG* end_offset,
                                                      BSTR* text_attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IATEXT_GET_ATTRIBUTES);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!start_offset || !end_offset || !text_attributes)
     return E_INVALIDARG;
 
   *start_offset = *end_offset = 0;
   *text_attributes = nullptr;
   if (!instance_active())
     return E_FAIL;
 
-  const base::string16& text = GetText();
-  HandleSpecialTextOffset(text, &offset);
+  const base::string16 text = GetText();
+  HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text.size()))
     return E_INVALIDARG;
 
   ComputeStylesIfNeeded();
   *start_offset = FindStartOfStyle(offset, ui::BACKWARDS_DIRECTION);
   *end_offset = FindStartOfStyle(offset, ui::FORWARDS_DIRECTION);
 
   base::string16 attributes_str;
   const std::vector<base::string16>& attributes =
       offset_to_text_attributes().find(*start_offset)->second;
@@ skipping 197 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityWin::doAction(long action_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_DO_ACTION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!instance_active())
     return E_FAIL;
 
   if (!HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
     return E_INVALIDARG;
 
-  manager()->DoDefaultAction(*this);
+  manager_->DoDefaultAction(*this);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_description(long action_index, BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IAACTION_GET_DESCRIPTION);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   return E_NOTIMPL;
 }
 
@@ skipping 141 matching lines @@
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_URL(BSTR* url) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_URL);
   if (!instance_active())
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
-  if (this != manager()->GetRoot())
+  if (this != manager_->GetRoot())
     return E_FAIL;
 
-  std::string str = manager()->GetTreeData().url;
+  std::string str = manager_->GetTreeData().url;
   if (str.empty())
     return S_FALSE;
 
   *url = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*url);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TITLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
-  std::string str = manager()->GetTreeData().title;
+  std::string str = manager_->GetTreeData().title;
   if (str.empty())
     return S_FALSE;
 
   *title = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*title);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MIME_TYPE);
   if (!instance_active())
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
-  std::string str = manager()->GetTreeData().mimetype;
+  std::string str = manager_->GetTreeData().mimetype;
   if (str.empty())
     return S_FALSE;
 
   *mime_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*mime_type);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOC_TYPE);
   if (!instance_active())
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
-  std::string str = manager()->GetTreeData().doctype;
+  std::string str = manager_->GetTreeData().doctype;
   if (str.empty())
     return S_FALSE;
 
   *doc_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*doc_type);
 
   return S_OK;
 }
 
 STDMETHODIMP
@@ skipping 394 matching lines @@
                             ACCESSIBILITY_MODE_FLAG_INLINE_TEXT_BOXES);
   if (!instance_active())
     return E_FAIL;
 
   unsigned int text_length = static_cast<unsigned int>(GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
-  manager()->ScrollToMakeVisible(*this, GetPageBoundsForRange(
-      start_index, end_index - start_index));
+  manager_->ScrollToMakeVisible(
+      *this, GetPageBoundsForRange(start_index, end_index - start_index));
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_fontFamily(BSTR* font_family) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FONT_FAMILY);
   AddAccessibilityModeFlags(ACCESSIBILITY_MODE_FLAG_SCREEN_READER);
   if (!font_family)
     return E_INVALIDARG;
   *font_family = nullptr;
@@ skipping 398 matching lines @@
   }
 
   win_attributes_->name = GetString16Attribute(ui::AX_ATTR_NAME);
   win_attributes_->description = GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
   StringAttributeToIA2(ui::AX_ATTR_PLACEHOLDER, "placeholder");
 
   base::string16 value = GetValue();
   // On Windows, the value of a document should be its url.
   if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
       GetRole() == ui::AX_ROLE_WEB_AREA) {
-    value = base::UTF8ToUTF16(manager()->GetTreeData().url);
+    value = base::UTF8ToUTF16(manager_->GetTreeData().url);
   }
   // If this doesn't have a value and is linked then set its value to the url
   // attribute. This allows screen readers to read an empty link's destination.
   if (value.empty() && (ia_state() & STATE_SYSTEM_LINKED))
     value = GetString16Attribute(ui::AX_ATTR_URL);
   win_attributes_->value = value;
 
   ClearOwnRelations();
   AddBidirectionalRelations(IA2_RELATION_CONTROLLER_FOR,
                             IA2_RELATION_CONTROLLED_BY,
@@ skipping 162 matching lines @@
 }
 
 bool BrowserAccessibilityWin::IsNative() const {
   return true;
 }
 
 void BrowserAccessibilityWin::OnLocationChanged() {
   FireNativeEvent(EVENT_OBJECT_LOCATIONCHANGE);
 }
 
+// |offset| could either be a text character or a child index in case of
+// non-text objects.
+BrowserAccessibilityWin::AXPlatformPositionInstance

[dmazzoni, 2017/02/14 20:17:58]

can you make this shorter with the "using" keyword, like:

using AXBrowserPosition = BrowserAccessibilityWin::AXPlatformPositionInstance;

+BrowserAccessibilityWin::CreatePositionAt(int offset) const {
+  if (!IsTextOnlyObject()) {
+    DCHECK(manager_);
+    return AXPlatformPosition::CreateTreePosition(manager_->ax_tree_id(),
+                                                  GetId(), offset);
+  }
+  return BrowserAccessibility::CreatePositionAt(offset);
+}
+
 std::vector<base::string16> BrowserAccessibilityWin::ComputeTextAttributes()
     const {
   std::vector<base::string16> attributes;
 
   // We include list markers for now, but there might be other objects that are
   // auto generated.
   // TODO(nektar): Compute what objects are auto-generated in Blink.
   if (GetRole() == ui::AX_ROLE_LIST_MARKER)
     attributes.push_back(L"auto-generated:true");
   else
@@ skipping 257 matching lines @@
   // According to the IA2 Spec, these characters need to be escaped with a
   // backslash: backslash, colon, comma, equals and semicolon.
   // Note that backslash must be replaced first.
   base::ReplaceChars(input, L"\\", L"\\\\", output);
   base::ReplaceChars(*output, L":", L"\\:", output);
   base::ReplaceChars(*output, L",", L"\\,", output);
   base::ReplaceChars(*output, L"=", L"\\=", output);
   base::ReplaceChars(*output, L";", L"\\;", output);
 }
 
+void BrowserAccessibilityWin::SetIA2HypertextSelection(LONG start_offset,
+                                                       LONG end_offset) {
+  HandleSpecialTextOffset(&start_offset);
+  HandleSpecialTextOffset(&end_offset);
+  AXPlatformPositionInstance start_position =
+      CreatePositionAt(static_cast<int>(start_offset));
+  AXPlatformPositionInstance end_position =
+      CreatePositionAt(static_cast<int>(end_offset));
+  manager_->SetSelection(AXPlatformRange(start_position->AsLeafTextPosition(),
+                                         end_position->AsLeafTextPosition()));
+}
+
 void BrowserAccessibilityWin::StringAttributeToIA2(
     ui::AXStringAttribute attribute,
     const char* ia2_attr) {
   base::string16 value;
   if (GetString16Attribute(attribute, &value)) {
     SanitizeStringAttributeForIA2(value, &value);
     win_attributes_->ia2_attributes.push_back(
         base::ASCIIToUTF16(ia2_attr) + L":" + value);
   }
 }
@@ skipping 186 matching lines @@
   if (endpoint_index_in_common_parent < index_in_common_parent)
     return 0;
   if (endpoint_index_in_common_parent > index_in_common_parent)
     return GetText().size();
 
   NOTREACHED();
   return -1;
 }
 
 int BrowserAccessibilityWin::GetSelectionAnchor() const {
-  int32_t anchor_id = manager()->GetTreeData().sel_anchor_object_id;
+  int32_t anchor_id = manager_->GetTreeData().sel_anchor_object_id;
   const BrowserAccessibilityWin* anchor_object = GetFromID(anchor_id);
   if (!anchor_object)
     return -1;
 
-  int anchor_offset = manager()->GetTreeData().sel_anchor_offset;
+  int anchor_offset = manager_->GetTreeData().sel_anchor_offset;
   return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
 int BrowserAccessibilityWin::GetSelectionFocus() const {
-  int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
+  int32_t focus_id = manager_->GetTreeData().sel_focus_object_id;
   const BrowserAccessibilityWin* focus_object = GetFromID(focus_id);
   if (!focus_object)
     return -1;
 
-  int focus_offset = manager()->GetTreeData().sel_focus_offset;
+  int focus_offset = manager_->GetTreeData().sel_focus_offset;
   return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
 void BrowserAccessibilityWin::GetSelectionOffsets(
     int* selection_start, int* selection_end) const {
   DCHECK(selection_start && selection_end);
 
   if (IsSimpleTextControl() &&
       GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START, selection_start) &&
       GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, selection_end)) {
@@ skipping 116 matching lines @@
              old_text.size() - common_suffix - 1,
              new_text.size() - common_suffix - 1)) {
     ++common_suffix;
   }
 
   *start = common_prefix;
   *old_len = old_text.size() - common_prefix - common_suffix;
   *new_len = new_text.size() - common_prefix - common_suffix;
 }
 
-void BrowserAccessibilityWin::HandleSpecialTextOffset(
-    const base::string16& text,
-    LONG* offset) {
-  if (*offset == IA2_TEXT_OFFSET_LENGTH)
-    *offset = static_cast<LONG>(text.size());
-  else if (*offset == IA2_TEXT_OFFSET_CARET)
-    get_caretOffset(offset);
+void BrowserAccessibilityWin::HandleSpecialTextOffset(LONG* offset) {
+  if (*offset == IA2_TEXT_OFFSET_LENGTH) {
+    *offset = static_cast<LONG>(GetText().length());
+  } else if (*offset == IA2_TEXT_OFFSET_CARET) {
+    // We shouldn't call |get_caretOffset| here as it affects UMA counts.
+    int selection_start, selection_end;
+    GetSelectionOffsets(&selection_start, &selection_end);
+    *offset = selection_end;
+  }
 }
 
 ui::TextBoundaryType BrowserAccessibilityWin::IA2TextBoundaryToTextBoundary(
     IA2TextBoundaryType ia2_boundary) {
   switch(ia2_boundary) {
     case IA2_TEXT_BOUNDARY_CHAR:
       return ui::CHAR_BOUNDARY;
     case IA2_TEXT_BOUNDARY_WORD:
       return ui::WORD_BOUNDARY;
     case IA2_TEXT_BOUNDARY_LINE:
       return ui::LINE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_SENTENCE:
       return ui::SENTENCE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_PARAGRAPH:
       return ui::PARAGRAPH_BOUNDARY;
     case IA2_TEXT_BOUNDARY_ALL:
       return ui::ALL_BOUNDARY;
   }
   NOTREACHED();
   return ui::CHAR_BOUNDARY;
 }
 
 LONG BrowserAccessibilityWin::FindBoundary(
     const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   // If the boundary is relative to the caret, use the selection
   // affinity, otherwise default to downstream affinity.
-  ui::AXTextAffinity affinity =
-      start_offset == IA2_TEXT_OFFSET_CARET ?
-      manager()->GetTreeData().sel_focus_affinity :
-      ui::AX_TEXT_AFFINITY_DOWNSTREAM;
+  ui::AXTextAffinity affinity = start_offset == IA2_TEXT_OFFSET_CARET
+                                    ? manager_->GetTreeData().sel_focus_affinity
+                                    : ui::AX_TEXT_AFFINITY_DOWNSTREAM;
 
-  HandleSpecialTextOffset(text, &start_offset);
+  HandleSpecialTextOffset(&start_offset);
   if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD)
     return GetWordStartBoundary(static_cast<int>(start_offset), direction);
   if (ia2_boundary == IA2_TEXT_BOUNDARY_LINE) {
     return GetLineStartBoundary(
         static_cast<int>(start_offset), direction, affinity);
   }
 
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   return ui::FindAccessibleTextBoundary(text, GetLineStartOffsets(), boundary,
                                         start_offset, direction, affinity);
@@ skipping 24 matching lines @@
     }
   }
 
   NOTREACHED();
   return start_offset;
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32_t id) const {
   if (!instance_active())
     return nullptr;
-  return ToBrowserAccessibilityWin(manager()->GetFromID(id));
+  return ToBrowserAccessibilityWin(manager_->GetFromID(id));
 }
 
 bool BrowserAccessibilityWin::IsListBoxOptionOrMenuListOption() {
   if (!GetParent())
     return false;
 
   int32_t role = GetRole();
   int32_t parent_role = GetParent()->GetRole();
 
   if (role == ui::AX_ROLE_LIST_BOX_OPTION &&
@@ skipping 783 matching lines @@
   return static_cast<BrowserAccessibilityWin*>(obj);
 }
 
 const BrowserAccessibilityWin*
 ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
   DCHECK(!obj || obj->IsNative());
   return static_cast<const BrowserAccessibilityWin*>(obj);
 }
 
 }  // namespace content