Converts accNavigate over to the AXPlatformNode code.

content/browser/accessibility/browser_accessibility_com_win.cc

 // Copyright (c) 2017 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_com_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 446 matching lines @@
   return AXPlatformNodeWin::accLocation(x_left, y_top, width, height, var_id);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accNavigate(LONG nav_dir,
                                                      VARIANT start,
                                                      VARIANT* end) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_NAVIGATE);
   if (!owner())
     return E_FAIL;
 
-  // Forward all non-spatial directions (e.g. NAVDIR_NEXT) to the platform node
-  // implementation.
-  if (nav_dir != NAVDIR_DOWN && nav_dir != NAVDIR_UP &&
-      nav_dir != NAVDIR_LEFT && nav_dir != NAVDIR_RIGHT) {
-    return AXPlatformNodeWin::accNavigate(nav_dir, start, end);
-  }
-
-  if (end) {
-    end->vt = VT_EMPTY;
-  } else {
-    return E_INVALIDARG;
-  }
-
-  BrowserAccessibilityComWin* target = GetTargetFromChildID(start);
-  if (!target)
-    return E_INVALIDARG;
-
-  BrowserAccessibility* result = nullptr;
-  // Only handle spatial directions for tables here.
-  switch (nav_dir) {
-    case NAVDIR_DOWN:
-      result = target->owner()->GetTableCell(
-          owner()->GetTableRow() + owner()->GetTableRowSpan(),
-          owner()->GetTableColumn());
-      break;
-    case NAVDIR_UP:
-      result = target->owner()->GetTableCell(owner()->GetTableRow() - 1,
-                                             owner()->GetTableColumn());
-      break;
-    case NAVDIR_LEFT:
-      result = target->owner()->GetTableCell(owner()->GetTableRow(),
-                                             owner()->GetTableColumn() - 1);
-      break;
-    case NAVDIR_RIGHT:
-      result = target->owner()->GetTableCell(
-          owner()->GetTableRow(),
-          owner()->GetTableColumn() + owner()->GetTableColumnSpan());
-      break;
-  }
-
-  if (!result)
-    return S_FALSE;
-
-  end->vt = VT_DISPATCH;
-  end->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
-  return S_OK;
+  return AXPlatformNodeWin::accNavigate(nav_dir, start, end);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accChild(VARIANT var_child,
                                                       IDispatch** disp_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
   if (!owner())
     return E_FAIL;
 
   return AXPlatformNodeWin::get_accChild(var_child, disp_child);
 }
@@ skipping 595 matching lines @@
     long column,
     IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell =
-      owner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
-  if (cell && ToBrowserAccessibilityComWin(cell)) {
-    *accessible = static_cast<IAccessible*>(
-        ToBrowserAccessibilityComWin(cell)->NewReference());
+  AXPlatformNodeBase* cell =
+      GetTableCell(static_cast<int>(row), static_cast<int>(column));
+  if (cell) {
+    auto* node_win = static_cast<AXPlatformNodeWin*>(cell);
+    node_win->AddRef();
+
+    *accessible = static_cast<IAccessible*>(node_win);
     return S_OK;
   }
 
   *accessible = nullptr;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_caption(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
@@ skipping 12 matching lines @@
                                                         long column,
                                                         long* cell_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell =
-      owner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+  auto* cell = GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (cell) {
     *cell_index = static_cast<LONG>(cell->GetTableCellIndex());
     return S_OK;
   }
 
   *cell_index = 0;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnDescription(
     long column,
     BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  int columns = owner()->GetTableColumnCount();
+  int columns = GetTableColumnCount();
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  int rows = owner()->GetTableRowCount();
+  int rows = GetTableRowCount();
   if (rows <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < rows; ++i) {
-    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
-    if (ToBrowserAccessibilityComWin(cell) &&
-        cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
+    auto* cell = GetTableCell(i, column);
+    if (cell && cell->GetData().role == 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;
       }
 
-      if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
-        *description = SysAllocString(
-            ToBrowserAccessibilityComWin(cell)->description().c_str());
+      cell_name = cell->GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
+      if (cell_name.size() > 0) {
+        *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnExtentAt(
     long row,
     long column,
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell =
-      owner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+  auto* cell = GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (!cell)
     return E_INVALIDARG;
 
   *n_columns_spanned = cell->GetTableColumnSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnHeader(
     IAccessibleTable** accessible_table,
     long* starting_row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long cell_index,
                                                          long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = owner()->GetTableCell(cell_index);
+  auto* cell = GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
   *column_index = cell->GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nColumns(long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
-  *column_count = owner()->GetTableColumnCount();
+  *column_count = GetTableColumnCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
-  *row_count = owner()->GetTableRowCount();
+  *row_count = GetTableRowCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedChildren(
     long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
@@ skipping 35 matching lines @@
 STDMETHODIMP BrowserAccessibilityComWin::get_rowDescription(long row,
                                                             BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  if (row < 0 || row >= owner()->GetTableRowCount())
+  if (row < 0 || row >= GetTableRowCount())
     return E_INVALIDARG;
 
-  int columns = owner()->GetTableColumnCount();
+  int columns = GetTableColumnCount();
   if (columns <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < columns; ++i) {
-    BrowserAccessibility* cell = owner()->GetTableCell(row, i);
-    if (ToBrowserAccessibilityComWin(cell) &&
-        cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
+    auto* cell = GetTableCell(row, i);
+    if (cell && cell->GetData().role == 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;
       }
-
-      if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
-        *description = SysAllocString(
-            ToBrowserAccessibilityComWin(cell)->description().c_str());
+      cell_name = cell->GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
+      if (cell_name.size() > 0) {
+        *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowExtentAt(long row,
                                                          long column,
                                                          long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = owner()->GetTableCell(row, column);
+  auto* cell = GetTableCell(row, column);
   if (!cell)
     return E_INVALIDARG;
 
-  *n_rows_spanned = owner()->GetTableRowSpan();
+  *n_rows_spanned = GetTableRowSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowHeader(
     IAccessibleTable** accessible_table,
     long* starting_column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long cell_index,
                                                       long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = owner()->GetTableCell(cell_index);
+  auto* cell = GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
 
   *row_index = cell->GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedChildren(
     long max_children,
     long** children,
@@ skipping 113 matching lines @@
     long* column_extents,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS_AT_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = owner()->GetTableCell(index);
+  auto* cell = GetTableCell(index);
   if (!cell)
     return E_INVALIDARG;
 
   *row = cell->GetTableRow();
   *column = cell->GetTableColumn();
-  *row_extents = owner()->GetTableRowSpan();
-  *column_extents = owner()->GetTableColumnSpan();
+  *row_extents = GetTableRowSpan();
+  *column_extents = GetTableColumnSpan();
   *is_selected = false;  // Not supported.
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::selectRow(long row) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SELECT_ROW);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
@@ skipping 29 matching lines @@
                                                     long column,
                                                     IUnknown** cell) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CELL_AT);
   AddAccessibilityModeFlags(AccessibilityMode::kScreenReader);
   if (!owner())
     return E_FAIL;
 
   if (!cell)
     return E_INVALIDARG;
 
-  BrowserAccessibility* table_cell =
-      owner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
-  if (ToBrowserAccessibilityComWin(table_cell)) {
-    return ToBrowserAccessibilityComWin(table_cell)
-        ->QueryInterface(IID_IUnknown, reinterpret_cast<void**>(cell));
+  AXPlatformNodeBase* table_cell =
+      GetTableCell(static_cast<int>(row), static_cast<int>(column));
+  if (table_cell) {
+    auto* node_win = static_cast<AXPlatformNodeWin*>(table_cell);
+    node_win->AddRef();
+    *cell = static_cast<IAccessible*>(node_win);
+    return S_OK;
   }
 
   *cell = nullptr;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedCells(long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return get_nSelectedChildren(cell_count);
@@ skipping 52 matching lines @@
 STDMETHODIMP BrowserAccessibilityComWin::get_columnExtent(
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
-  *n_columns_spanned = owner()->GetTableColumnSpan();
+  *n_columns_spanned = GetTableColumnSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_column_header_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_column_header_cells)
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
-  BrowserAccessibility* table = owner()->GetTable();
+  auto* table = GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int column = owner()->GetTableColumn();
-  int columns = owner()->GetTableColumnCount();
-  int rows = owner()->GetTableRowCount();
+  int column = GetTableColumn();
+  int columns = GetTableColumnCount();
+  int rows = GetTableRowCount();
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   for (int i = 0; i < rows; ++i) {
-    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
-    if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
+    auto* cell = GetTableCell(i, column);
+    if (cell && cell->GetData().role == 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) {
-    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
-    if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
-      (*cell_accessibles)[index] = static_cast<IAccessible*>(
-          ToBrowserAccessibilityComWin(cell)->NewReference());
+    AXPlatformNodeBase* cell = GetTableCell(i, column);
+    if (cell && cell->GetData().role == ui::AX_ROLE_COLUMN_HEADER) {
+      auto* node_win = static_cast<AXPlatformNodeWin*>(cell);
+      node_win->AddRef();
+
+      (*cell_accessibles)[index] = static_cast<IAccessible*>(node_win);
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  *column_index = owner()->GetTableColumn();
+  *column_index = GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowExtent(long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  *n_rows_spanned = owner()->GetTableRowSpan();
+  *n_rows_spanned = GetTableRowSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_row_header_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_row_header_cells)
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
-  BrowserAccessibility* table = owner()->GetTable();
+  auto* table = GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int row = owner()->GetTableRow();
-  int columns = owner()->GetTableColumnCount();
-  int rows = owner()->GetTableRowCount();
+  int row = GetTableRow();
+  int columns = GetTableColumnCount();
+  int rows = GetTableRowCount();
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   for (int i = 0; i < columns; ++i) {
-    BrowserAccessibility* cell = owner()->GetTableCell(row, i);
-    if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER)
+    auto* cell = GetTableCell(row, i);
+    if (cell && cell->GetData().role == 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) {
-    BrowserAccessibility* cell = owner()->GetTableCell(row, i);
-    if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
-      (*cell_accessibles)[index] = static_cast<IAccessible*>(
-          ToBrowserAccessibilityComWin(cell)->NewReference());
+    AXPlatformNodeBase* cell = GetTableCell(row, i);
+    if (cell && cell->GetData().role == ui::AX_ROLE_ROW_HEADER) {
+      auto* node_win = static_cast<AXPlatformNodeWin*>(cell);
+      node_win->AddRef();
+
+      (*cell_accessibles)[index] = static_cast<IAccessible*>(node_win);
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  *row_index = owner()->GetTableRow();
+  *row_index = GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!is_selected)
@@ skipping 12 matching lines @@
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!row_index || !column_index || !row_extents || !column_extents ||
       !is_selected) {
     return E_INVALIDARG;
   }
 
-  *row_index = owner()->GetTableRow();
-  *column_index = owner()->GetTableColumn();
-  *row_extents = owner()->GetTableRowSpan();
-  *column_extents = owner()->GetTableColumnSpan();
+  *row_index = GetTableRow();
+  *column_index = GetTableColumn();
+  *row_extents = GetTableRowSpan();
+  *column_extents = GetTableColumnSpan();
   *is_selected = false;  // Not supported.
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_table(IUnknown** table) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TABLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!owner())
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
-  BrowserAccessibility* find_table = owner()->GetTable();
-  if (!find_table || !ToBrowserAccessibilityComWin(find_table)) {
+  auto* find_table = GetTable();
+  if (!find_table) {
     *table = nullptr;
     return S_FALSE;
   }
 
-  *table = static_cast<IAccessibleTable*>(
-      ToBrowserAccessibilityComWin(find_table)->NewReference());
+  // The IAccessibleTable interface is still on the BrowserAccessibilityComWin
+  // class.
+  auto* node_win = static_cast<BrowserAccessibilityComWin*>(find_table);
+  node_win->AddRef();
+
+  *table = static_cast<IAccessibleTable*>(node_win);
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nCharacters(LONG* n_characters) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_CHARACTERS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
@@ skipping 1744 matching lines @@
         win_attributes_->ia2_attributes.push_back(L"current:date");
         break;
       case ui::AX_ARIA_CURRENT_STATE_TIME:
         win_attributes_->ia2_attributes.push_back(L"current:time");
         break;
     }
   }
 
   // Expose table cell index.
   if (ui::IsCellOrTableHeaderRole(owner()->GetRole())) {
-    BrowserAccessibility* table = owner()->PlatformGetParent();
-    while (table && !ui::IsTableLikeRole(table->GetRole()))
-      table = table->PlatformGetParent();
+    BrowserAccessibilityWin* win_parent =
+        static_cast<BrowserAccessibilityWin*>(owner()->PlatformGetParent());
+    AXPlatformNodeBase* table = win_parent->GetCOM();
+
+    while (table && !ui::IsTableLikeRole(table->GetData().role))
+      table = FromNativeViewAccessible(table->GetParent());
+
     if (table) {
       const std::vector<int32_t>& 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] == owner()->GetId()) {
           win_attributes_->ia2_attributes.push_back(
               base::string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
     }
@@ skipping 1758 matching lines @@
 
 BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
     BrowserAccessibility* obj) {
   if (!obj || !obj->IsNative())
     return nullptr;
   auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
   return result;
 }
 
 }  // namespace content