Refactor BrowserAccessibility to prepare for AXNode (re-land)

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 "base/strings/string_number_conversions.h"
@@ skipping 475 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
   if (!instance_active())
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
-  IAccessible* parent_obj = parent()->ToBrowserAccessibilityWin();
+  IAccessible* parent_obj = GetParent()->ToBrowserAccessibilityWin();
   if (parent_obj == NULL) {
     // This happens if we're the root of the tree;
     // return the IAccessible for the window.
     parent_obj =
          manager()->ToBrowserAccessibilityManagerWin()->parent_iaccessible();
     // |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.
@@ skipping 97 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
                                                        VARIANT var_id,
                                                        LONG* topic_id) {
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
   if (!instance_active())
     return E_FAIL;
 
-  if (blink_role() != ui::AX_ROLE_LIST_BOX)
+  if (GetRole() != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
-  for (size_t i = 0; i < children().size(); ++i) {
-    if (children()[i]->HasState(ui::AX_STATE_SELECTED))
+  for (size_t i = 0; i < InternalChildCount(); ++i) {
+    if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
       ++selected_count;
   }
 
   if (selected_count == 0) {
     selected->vt = VT_EMPTY;
     return S_OK;
   }
 
   if (selected_count == 1) {
-    for (size_t i = 0; i < children().size(); ++i) {
-      if (children()[i]->HasState(ui::AX_STATE_SELECTED)) {
+    for (size_t i = 0; i < InternalChildCount(); ++i) {
+      if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
         selected->vt = VT_DISPATCH;
         selected->pdispVal =
-            children()[i]->ToBrowserAccessibilityWin()->NewReference();
+            InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
         return S_OK;
       }
     }
   }
 
   // Multiple items are selected.
   base::win::EnumVariant* enum_variant =
       new base::win::EnumVariant(selected_count);
   enum_variant->AddRef();
   unsigned long index = 0;
-  for (size_t i = 0; i < children().size(); ++i) {
-    if (children()[i]->HasState(ui::AX_STATE_SELECTED)) {
+  for (size_t i = 0; i < InternalChildCount(); ++i) {
+    if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
       enum_variant->ItemAt(index)->vt = VT_DISPATCH;
       enum_variant->ItemAt(index)->pdispVal =
-        children()[i]->ToBrowserAccessibilityWin()->NewReference();
+        InternalGetChild(i)->ToBrowserAccessibilityWin()->NewReference();
       ++index;
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accSelect(
@@ skipping 83 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
   if (!instance_active())
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
-  *index_in_parent = this->index_in_parent();
+  *index_in_parent = this->GetIndexInParent();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nRelations(LONG* n_relations) {
   if (!instance_active())
     return E_FAIL;
 
   if (!n_relations)
     return E_INVALIDARG;
 
@@ skipping 40 matching lines @@
     relations[i] = relations_[i];
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollTo(enum IA2ScrollType scroll_type) {
   if (!instance_active())
     return E_FAIL;
 
-  gfx::Rect r = location();
+  gfx::Rect r = GetLocation();
   switch(scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
       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));
       break;
     case IA2_SCROLL_TYPE_TOP_EDGE:
       manager()->ScrollToMakeVisible(
@@ skipping 27 matching lines @@
     LONG x,
     LONG y) {
   if (!instance_active())
     return E_FAIL;
 
   gfx::Point scroll_to(x, y);
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     scroll_to -= manager()->GetViewBounds().OffsetFromOrigin();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    if (parent())
-      scroll_to += parent()->location().OffsetFromOrigin();
+    if (GetParent())
+      scroll_to += GetParent()->GetLocation().OffsetFromOrigin();
   } else {
     return E_INVALIDARG;
   }
 
   manager()->ScrollToPoint(*this, scroll_to);
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   if (!instance_active())
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
-  if (blink_role() == ui::AX_ROLE_LIST_BOX_OPTION &&
-      parent() &&
-      parent()->role() == ui::AX_ROLE_LIST_BOX) {
+  if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
+      GetParent() &&
+      GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
     *group_level = 0;
-    *similar_items_in_group = parent()->PlatformChildCount();
-    *position_in_group = index_in_parent() + 1;
+    *similar_items_in_group = GetParent()->PlatformChildCount();
+    *position_in_group = GetIndexInParent() + 1;
     return S_OK;
   }
 
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleApplication methods.
 //
 
@@ skipping 88 matching lines @@
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     HWND parent_hwnd =
         manager()->ToBrowserAccessibilityManagerWin()->parent_hwnd();
     POINT top_left = {0, 0};
     ::ClientToScreen(parent_hwnd, &top_left);
-    *x = location().x() + top_left.x;
-    *y = location().y() + top_left.y;
+    *x = GetLocation().x() + top_left.x;
+    *y = GetLocation().y() + top_left.y;
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    *x = location().x();
-    *y = location().y();
-    if (parent()) {
-      *x -= parent()->location().x();
-      *y -= parent()->location().y();
+    *x = GetLocation().x();
+    *y = GetLocation().y();
+    if (GetParent()) {
+      *x -= GetParent()->GetLocation().x();
+      *y -= GetParent()->GetLocation().y();
     }
   } else {
     return E_INVALIDARG;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_imageSize(LONG* height, LONG* width) {
   if (!instance_active())
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
-  *height = location().height();
-  *width = location().width();
+  *height = GetLocation().height();
+  *width = GetLocation().width();
   return S_OK;
 }
 
 //
 // IAccessibleTable methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_accessibleAt(
     long row,
     long column,
@@ skipping 103 matching lines @@
 
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
         manager()->GetFromRendererID(cell_id));
-    if (cell && cell->blink_role() == ui::AX_ROLE_COLUMN_HEADER) {
+    if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           ui::AX_ATTR_DESCRIPTION, description);
     }
@@ skipping 166 matching lines @@
 
   if (row < 0 || row >= rows)
     return E_INVALIDARG;
 
   const std::vector<int32>& cell_ids = GetIntListAttribute(
       ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
     BrowserAccessibilityWin* cell =
         manager()->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->blink_role() == ui::AX_ROLE_ROW_HEADER) {
+    if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       return cell->GetStringAttributeAsBstr(
           ui::AX_ATTR_DESCRIPTION, description);
     }
@@ skipping 301 matching lines @@
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
 
   int column;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
     return S_FALSE;
   }
 
-  BrowserAccessibility* table = parent();
-  while (table && table->role() != ui::AX_ROLE_TABLE)
-    table = table->parent();
+  BrowserAccessibility* table = GetParent();
+  while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+    table = table->GetParent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   const std::vector<int32>& cell_ids = table->GetIntListAttribute(
       ui::AX_ATTR_CELL_IDS);
 
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibilityWin* cell =
         manager()->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
-    if (cell && cell->blink_role() == ui::AX_ROLE_COLUMN_HEADER)
+    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()->GetFromRendererID(cell_id);
-    if (cell && cell->role() == ui::AX_ROLE_COLUMN_HEADER) {
+    if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           cell->ToBrowserAccessibilityWin()->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
@@ skipping 41 matching lines @@
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
 
   int row;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
     return S_FALSE;
   }
 
-  BrowserAccessibility* table = parent();
-  while (table && table->role() != ui::AX_ROLE_TABLE)
-    table = table->parent();
+  BrowserAccessibility* table = GetParent();
+  while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+    table = table->GetParent();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   int columns;
   int rows;
   if (!table->GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
       !table->GetIntAttribute(
           ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   const std::vector<int32>& 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()->GetFromRendererID(cell_id);
-    if (cell && cell->role() == ui::AX_ROLE_ROW_HEADER)
+    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()->GetFromRendererID(cell_id);
-    if (cell && cell->role() == ui::AX_ROLE_ROW_HEADER) {
+    if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           cell->ToBrowserAccessibilityWin()->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
@@ skipping 67 matching lines @@
 
   if (!table)
     return E_INVALIDARG;
 
 
   int row;
   int column;
   GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row);
   GetIntAttribute(ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column);
 
-  BrowserAccessibility* find_table = parent();
-  while (find_table && find_table->role() != ui::AX_ROLE_TABLE)
-    find_table = find_table->parent();
+  BrowserAccessibility* find_table = GetParent();
+  while (find_table && find_table->GetRole() != ui::AX_ROLE_TABLE)
+    find_table = find_table->GetParent();
   if (!find_table) {
     NOTREACHED();
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
       find_table->ToBrowserAccessibilityWin()->NewReference());
 
   return S_OK;
 }
@@ skipping 14 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   *offset = 0;
-  if (blink_role() == ui::AX_ROLE_TEXT_FIELD ||
-      blink_role() == ui::AX_ROLE_TEXT_AREA) {
+  if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+      GetRole() == ui::AX_ROLE_TEXT_AREA) {
     int sel_start = 0;
     if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
                         &sel_start))
       *offset = sel_start;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_characterExtents(
@@ skipping 13 matching lines @@
   HandleSpecialTextOffset(text_str, &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 = GetGlobalBoundsForRange(offset, 1);
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     character_bounds = GetLocalBoundsForRange(offset, 1);
-    character_bounds -= location().OffsetFromOrigin();
+    character_bounds -= GetLocation().OffsetFromOrigin();
   } else {
     return E_INVALIDARG;
   }
 
   *out_x = character_bounds.x();
   *out_y = character_bounds.y();
   *out_width = character_bounds.width();
   *out_height = character_bounds.height();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
   if (!instance_active())
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
-  if (blink_role() == ui::AX_ROLE_TEXT_FIELD ||
-      blink_role() == ui::AX_ROLE_TEXT_AREA) {
+  if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+      GetRole() == ui::AX_ROLE_TEXT_AREA) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
                         &sel_start) &&
         GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end) &&
         sel_start != sel_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;
 
   *start_offset = 0;
   *end_offset = 0;
-  if (blink_role() == ui::AX_ROLE_TEXT_FIELD ||
-      blink_role() == ui::AX_ROLE_TEXT_AREA) {
+  if (GetRole() == ui::AX_ROLE_TEXT_FIELD ||
+      GetRole() == ui::AX_ROLE_TEXT_AREA) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(
             ui::AX_ATTR_TEXT_SEL_START, &sel_start) &&
         GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, &sel_end)) {
       *start_offset = sel_start;
       *end_offset = sel_end;
     }
   }
 
@@ skipping 263 matching lines @@
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink ||
       index < 0 ||
       index >= static_cast<long>(hyperlinks_.size())) {
     return E_INVALIDARG;
   }
 
   BrowserAccessibilityWin* child =
-      children()[hyperlinks_[index]]->ToBrowserAccessibilityWin();
+      InternalGetChild(hyperlinks_[index])->ToBrowserAccessibilityWin();
   *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   if (!instance_active())
     return E_FAIL;
 
@@ skipping 174 matching lines @@
     short* name_space_id,
     BSTR* attrib_values,
     unsigned short* num_attribs) {
   if (!instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
-  if (*num_attribs > html_attributes().size())
-    *num_attribs = html_attributes().size();
+  if (*num_attribs > GetHtmlAttributes().size())
+    *num_attribs = GetHtmlAttributes().size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(
-        base::UTF8ToUTF16(html_attributes()[i].first).c_str());
+        base::UTF8ToUTF16(GetHtmlAttributes()[i].first).c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(
-        base::UTF8ToUTF16(html_attributes()[i].second).c_str());
+        base::UTF8ToUTF16(GetHtmlAttributes()[i].second).c_str());
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributesForNames(
     unsigned short num_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values) {
   if (!instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values)
     return E_INVALIDARG;
 
   for (unsigned short i = 0; i < num_attribs; ++i) {
     name_space_id[i] = 0;
     bool found = false;
     std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
-    for (unsigned int j = 0;  j < html_attributes().size(); ++j) {
-      if (html_attributes()[j].first == name) {
+    for (unsigned int j = 0;  j < GetHtmlAttributes().size(); ++j) {
+      if (GetHtmlAttributes()[j].first == name) {
         attrib_values[i] = SysAllocString(
-            base::UTF8ToUTF16(html_attributes()[j].second).c_str());
+            base::UTF8ToUTF16(GetHtmlAttributes()[j].second).c_str());
         found = true;
         break;
       }
     }
     if (!found) {
       attrib_values[i] = NULL;
     }
   }
   return S_OK;
 }
@@ skipping 59 matching lines @@
       IA2_SCROLL_TYPE_TOP_LEFT : IA2_SCROLL_TYPE_ANYWHERE);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  *node = parent()->ToBrowserAccessibilityWin()->NewReference();
+  *node = GetParent()->ToBrowserAccessibilityWin()->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node)  {
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
@@ skipping 24 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
     ISimpleDOMNode** node) {
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!parent() || index_in_parent() <= 0) {
+  if (!GetParent() || GetIndexInParent() <= 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = parent()->children()[index_in_parent() - 1]->
+  *node = GetParent()->InternalGetChild(GetIndexInParent() - 1)->
       ToBrowserAccessibilityWin()->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!parent() ||
-      index_in_parent() < 0 ||
-      index_in_parent() >= static_cast<int>(parent()->children().size()) - 1) {
+  if (!GetParent() ||
+      GetIndexInParent() < 0 ||
+      GetIndexInParent() >= static_cast<int>(
+          GetParent()->InternalChildCount()) - 1) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = parent()->children()[index_in_parent() + 1]->
+  *node = GetParent()->InternalGetChild(GetIndexInParent() + 1)->
       ToBrowserAccessibilityWin()->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_childAt(
     unsigned int child_index,
     ISimpleDOMNode** node) {
   if (!instance_active())
     return E_FAIL;
 
@@ skipping 240 matching lines @@
 
   // Expose the "display" and "tag" attributes.
   StringAttributeToIA2(ui::AX_ATTR_DISPLAY, "display");
   StringAttributeToIA2(ui::AX_ATTR_HTML_TAG, "tag");
   StringAttributeToIA2(ui::AX_ATTR_ROLE, "xml-roles");
 
   // Expose "level" attribute for headings, trees, etc.
   IntAttributeToIA2(ui::AX_ATTR_HIERARCHICAL_LEVEL, "level");
 
   // Expose the set size and position in set for listbox options.
-  if (blink_role() == ui::AX_ROLE_LIST_BOX_OPTION &&
-      parent() &&
-      parent()->role() == ui::AX_ROLE_LIST_BOX) {
+  if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
+      GetParent() &&
+      GetParent()->GetRole() == ui::AX_ROLE_LIST_BOX) {
     ia2_attributes_.push_back(
-        L"setsize:" + base::IntToString16(parent()->PlatformChildCount()));
+        L"setsize:" + base::IntToString16(GetParent()->PlatformChildCount()));
     ia2_attributes_.push_back(
-        L"setsize:" + base::IntToString16(index_in_parent() + 1));
+        L"setsize:" + base::IntToString16(GetIndexInParent() + 1));
   }
 
   if (ia_role_ == ROLE_SYSTEM_CHECKBUTTON ||
       ia_role_ == ROLE_SYSTEM_RADIOBUTTON ||
       ia2_role_ == IA2_ROLE_TOGGLE_BUTTON) {
     ia2_attributes_.push_back(L"checkable:true");
   }
 
   // Expose live region attributes.
   StringAttributeToIA2(ui::AX_ATTR_LIVE_STATUS, "live");
@@ skipping 13 matching lines @@
 
   // Expose slider value.
   if (ia_role_ == ROLE_SYSTEM_PROGRESSBAR ||
       ia_role_ == ROLE_SYSTEM_SCROLLBAR ||
       ia_role_ == ROLE_SYSTEM_SLIDER) {
     ia2_attributes_.push_back(L"valuetext:" + GetValueText());
   }
 
   // Expose table cell index.
   if (ia_role_ == ROLE_SYSTEM_CELL) {
-    BrowserAccessibility* table = parent();
-    while (table && table->role() != ui::AX_ROLE_TABLE)
-      table = table->parent();
+    BrowserAccessibility* table = GetParent();
+    while (table && table->GetRole() != ui::AX_ROLE_TABLE)
+      table = table->GetParent();
     if (table) {
       const std::vector<int32>& unique_cell_ids = table->GetIntListAttribute(
           ui::AX_ATTR_UNIQUE_CELL_IDS);
       for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
-        if (unique_cell_ids[i] == renderer_id()) {
+        if (unique_cell_ids[i] == GetId()) {
           ia2_attributes_.push_back(
               base::string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
     }
   }
 
   // The calculation of the accessible name of an element has been
   // standardized in the HTML to Platform Accessibility APIs Implementation
   // Guide (http://www.w3.org/TR/html-aapi/). In order to return the
@@ skipping 43 matching lines @@
     description = help;
     help.clear();
   }
   if (!description.empty() && name().empty() && !title_elem_id) {
     set_name(description);
     description.clear();
   }
 
   // If it's a text field, also consider the placeholder.
   std::string placeholder;
-  if (blink_role() == ui::AX_ROLE_TEXT_FIELD &&
+  if (GetRole() == ui::AX_ROLE_TEXT_FIELD &&
       HasState(ui::AX_STATE_FOCUSABLE) &&
       GetHtmlAttribute("placeholder", &placeholder)) {
     if (name().empty() && !title_elem_id) {
       set_name(placeholder);
     } else if (description.empty()) {
       description = placeholder;
     }
   }
 
   SetStringAttribute(ui::AX_ATTR_DESCRIPTION, description);
   SetStringAttribute(ui::AX_ATTR_HELP, help);
 
   // On Windows, the value of a document should be its url.
-  if (blink_role() == ui::AX_ROLE_ROOT_WEB_AREA ||
-      blink_role() == ui::AX_ROLE_WEB_AREA) {
+  if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+      GetRole() == ui::AX_ROLE_WEB_AREA) {
     set_value(GetStringAttribute(ui::AX_ATTR_DOC_URL));
   }
 
   // For certain roles (listbox option, static text, and list marker)
   // WebKit stores the main accessible text in the "value" - swap it so
   // that it's the "name".
   if (name().empty() &&
-      (blink_role() == ui::AX_ROLE_LIST_BOX_OPTION ||
-       blink_role() == ui::AX_ROLE_STATIC_TEXT ||
-       blink_role() == ui::AX_ROLE_LIST_MARKER)) {
+      (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION ||
+       GetRole() == ui::AX_ROLE_STATIC_TEXT ||
+       GetRole() == ui::AX_ROLE_LIST_MARKER)) {
     std::string tmp = value();
     set_value(name());
     set_name(tmp);
   }
 
   // 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))
     set_value(GetStringAttribute(ui::AX_ATTR_URL));
 
@@ skipping 18 matching lines @@
 
 void BrowserAccessibilityWin::PostInitialize() {
   BrowserAccessibility::PostInitialize();
 
   // Construct the hypertext for this node.
   hyperlink_offset_to_index_.clear();
   hyperlinks_.clear();
   hypertext_.clear();
   for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
     BrowserAccessibility* child = PlatformGetChild(i);
-    if (child->role() == ui::AX_ROLE_STATIC_TEXT) {
+    if (child->GetRole() == ui::AX_ROLE_STATIC_TEXT) {
       hypertext_ += base::UTF8ToUTF16(child->name());
     } else {
       hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
       hypertext_ += kEmbeddedCharacter;
       hyperlinks_.push_back(i);
     }
   }
   DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
 
   // Fire an event when an alert first appears.
-  if (blink_role() == ui::AX_ROLE_ALERT && first_time_)
+  if (GetRole() == ui::AX_ROLE_ALERT && first_time_)
     manager()->NotifyAccessibilityEvent(ui::AX_EVENT_ALERT, this);
 
   // Fire events if text has changed.
   base::string16 text = TextForIAccessibleText();
   if (previous_text_ != text) {
     if (!previous_text_.empty() && !text.empty()) {
       manager()->NotifyAccessibilityEvent(
           ui::AX_EVENT_SHOW, this);
     }
 
     // TODO(dmazzoni): Look into HIDE events, too.
 
     old_text_ = previous_text_;
     previous_text_ = text;
   }
 
   BrowserAccessibilityManagerWin* manager =
       this->manager()->ToBrowserAccessibilityManagerWin();
 
   // Fire events if the state has changed.
   if (!first_time_ && ia_state_ != old_ia_state_) {
     // Normally focus events are handled elsewhere, however
     // focus for managed descendants is platform-specific.
     // Fire a focus event if the focused descendant in a multi-select
     // list box changes.
-    if (blink_role() == ui::AX_ROLE_LIST_BOX_OPTION &&
+    if (GetRole() == ui::AX_ROLE_LIST_BOX_OPTION &&
         (ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
         (ia_state_ & STATE_SYSTEM_SELECTABLE) &&
         (ia_state_ & STATE_SYSTEM_FOCUSED) &&
         !(old_ia_state_ & STATE_SYSTEM_FOCUSED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_FOCUS, unique_id_win());
     }
 
     if ((ia_state_ & STATE_SYSTEM_SELECTED) &&
         !(old_ia_state_ & STATE_SYSTEM_SELECTED)) {
       manager->MaybeCallNotifyWinEvent(EVENT_OBJECT_SELECTIONADD,
@@ skipping 115 matching lines @@
   if (value.empty() &&
       GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
     value = base::UTF8ToUTF16(base::DoubleToString(fval));
   }
   return value;
 }
 
 base::string16 BrowserAccessibilityWin::TextForIAccessibleText() {
   if (IsEditableText())
     return base::UTF8ToUTF16(value());
-  return (blink_role() == ui::AX_ROLE_STATIC_TEXT) ?
+  return (GetRole() == ui::AX_ROLE_STATIC_TEXT) ?
       base::UTF8ToUTF16(name()) : hypertext_;
 }
 
 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);
@@ skipping 99 matching lines @@
   if (GetBoolAttribute(ui::AX_ATTR_BUTTON_MIXED))
     ia_state_ |= STATE_SYSTEM_MIXED;
 
   if (GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
     ia2_state_ |= IA2_STATE_EDITABLE;
 
   base::string16 html_tag = GetString16Attribute(
       ui::AX_ATTR_HTML_TAG);
   ia_role_ = 0;
   ia2_role_ = 0;
-  switch (blink_role()) {
+  switch (GetRole()) {
     case ui::AX_ROLE_ALERT:
       ia_role_ = ROLE_SYSTEM_ALERT;
       break;
     case ui::AX_ROLE_ALERT_DIALOG:
       ia_role_ = ROLE_SYSTEM_DIALOG;
       break;
     case ui::AX_ROLE_APPLICATION:
       ia_role_ = ROLE_SYSTEM_APPLICATION;
       break;
     case ui::AX_ROLE_ARTICLE:
@@ skipping 398 matching lines @@
   // The role should always be set.
   DCHECK(!role_name_.empty() || ia_role_);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role_)
     ia2_role_ = ia_role_;
 }
 
 }  // namespace content