Cleanup, no functional change.

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/string_number_conversions.h"
@@ skipping 96 matching lines @@
   for (long i = *n_targets - 1; i >= 0; --i) {
     BrowserAccessibility* result = manager->GetFromRendererID(target_ids_[i]);
     if (!result || !result->instance_active()) {
       *n_targets = 0;
       break;
     }
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityRelation::get_target(
-    long target_index, IUnknown** target) {
+STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
+                                                      IUnknown** target) {
   if (!target)
     return E_INVALIDARG;
 
   if (!owner_->instance_active())
     return E_FAIL;
 
   if (target_index < 0 ||
       target_index >= static_cast<long>(target_ids_.size())) {
     return E_INVALIDARG;
   }
 
   BrowserAccessibilityManager* manager = owner_->manager();
   BrowserAccessibility* result =
       manager->GetFromRendererID(target_ids_[target_index]);
   if (!result || !result->instance_active())
     return E_FAIL;
 
   *target = static_cast<IAccessible*>(
       result->ToBrowserAccessibilityWin()->NewReference());
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityRelation::get_targets(
-    long max_targets, IUnknown** targets, long* n_targets) {
+STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
+                                                       IUnknown** targets,
+                                                       long* n_targets) {
   if (!targets || !n_targets)
     return E_INVALIDARG;
 
   if (!owner_->instance_active())
     return E_FAIL;
 
   long count = static_cast<long>(target_ids_.size());
   if (count > max_targets)
     count = max_targets;
 
@@ skipping 82 matching lines @@
     // Point is within this object.
     child->vt = VT_I4;
     child->lVal = CHILDID_SELF;
   } else {
     child->vt = VT_DISPATCH;
     child->pdispVal = result->ToBrowserAccessibilityWin()->NewReference();
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left, LONG* y_top,
-                                                  LONG* width, LONG* height,
+STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left,

[dmazzoni, 2012/11/13 03:54:02]

The style guide used to allow this, oh well.

+                                                  LONG* y_top,
+                                                  LONG* width,
+                                                  LONG* height,
                                                   VARIANT var_id) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!x_left || !y_top || !width || !height)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   gfx::Rect bounds = target->GetGlobalBoundsRect();
   *x_left = bounds.x();
   *y_top  = bounds.y();
   *width  = bounds.width();
   *height = bounds.height();
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accNavigate(
-    LONG nav_dir, VARIANT start, VARIANT* end) {
+STDMETHODIMP BrowserAccessibilityWin::accNavigate(LONG nav_dir,
+                                                  VARIANT start,
+                                                  VARIANT* end) {
   BrowserAccessibilityWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) &&
       start.lVal != CHILDID_SELF) {
     // MSAA states that navigating to first/last child can only be from self.
     return E_INVALIDARG;
   }
 
@@ skipping 192 matching lines @@
     // return the IAccessible for the window.
     parent = manager_->ToBrowserAccessibilityManagerWin()->
              GetParentWindowIAccessible();
   }
 
   parent->AddRef();
   *disp_parent = parent;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accRole(
-    VARIANT var_id, VARIANT* role) {
+STDMETHODIMP BrowserAccessibilityWin::get_accRole(VARIANT var_id,
+                                                  VARIANT* role) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
@@ skipping 20 matching lines @@
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state_;
   if (manager_->GetFocus(NULL) == this)
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accValue(
-    VARIANT var_id, BSTR* value) {
+STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
+                                                   BSTR* value) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   *value = SysAllocString(target->value_.c_str());
 
   DCHECK(*value);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(
-    BSTR* help_file, VARIANT var_id, LONG* topic_id) {
+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 (role_ != AccessibilityNodeData::ROLE_LISTBOX)
     return E_NOTIMPL;
 
@@ skipping 287 matching lines @@
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(
       AccessibilityNodeData::ATTR_DESCRIPTION, desc);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_imagePosition(
-    enum IA2CoordinateType coordinate_type, LONG* x, LONG* y) {
+    enum IA2CoordinateType coordinate_type,
+    LONG* x,
+    LONG* y) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     HWND parent_hwnd = manager_->GetParentView();
     POINT top_left = {0, 0};
     ::ClientToScreen(parent_hwnd, &top_left);
@@ skipping 70 matching lines @@
   if (!instance_active_)
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_childIndex(
-    long row,
-    long column,
-    long* cell_index) {
+STDMETHODIMP BrowserAccessibilityWin::get_childIndex(long row,
+                                                     long column,
+                                                     long* cell_index) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 12 matching lines @@
   for (size_t i = 0; i < unique_cell_ids_.size(); ++i) {
     if (unique_cell_ids_[i] == cell_id) {
       *cell_index = (long)i;
       return S_OK;
     }
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnDescription(
-    long column,
-    BSTR* description) {
+STDMETHODIMP BrowserAccessibilityWin::get_columnDescription(long column,
+                                                            BSTR* description) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 62 matching lines @@
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnHeader(
     IAccessibleTable** accessible_table,
     long* starting_row_index) {
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(
-    long cell_index,
-    long* column_index) {
+STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long cell_index,
+                                                      long* column_index) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   int cell_id_count = static_cast<int>(unique_cell_ids_.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids_[cell_index];
   BrowserAccessibilityWin* cell =
       manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
   int col_index;
   if (cell &&
       cell->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
     *column_index = col_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nColumns(
-    long* column_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_nColumns(long* column_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   int columns;
   if (GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns)) {
     *column_count = columns;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nRows(
-    long* row_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_nRows(long* row_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   int rows;
   if (GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_ROW_COUNT, &rows)) {
     *row_count = rows;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(
-    long* cell_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(long* cell_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!cell_count)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
   *cell_count = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(
-    long* column_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(long* column_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(
-    long* row_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(long* row_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(
-    long row,
-    BSTR* description) {
+STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(long row,
+                                                         BSTR* description) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 17 matching lines @@
       }
 
       return cell->GetStringAttributeAsBstr(
           AccessibilityNodeData::ATTR_DESCRIPTION, description);
     }
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(
-    long row,
-    long column,
-    long* n_rows_spanned) {
+STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(long row,
+                                                      long column,
+                                                      long* n_rows_spanned) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 15 matching lines @@
           AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       rowspan >= 1) {
     *n_rows_spanned = rowspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowHeader(
-    IAccessibleTable **accessible_table,
+    IAccessibleTable** accessible_table,
     long* starting_column_index) {
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(
-    long cell_index,
-    long* row_index) {
+STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long cell_index,
+                                                   long* row_index) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   int cell_id_count = static_cast<int>(unique_cell_ids_.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids_[cell_index];
   BrowserAccessibilityWin* cell =
       manager_->GetFromRendererID(cell_id)->ToBrowserAccessibilityWin();
   int cell_row_index;
   if (cell &&
       cell->GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &cell_row_index)) {
     *row_index = cell_row_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(
-    long max_children,
-    long** children,
-    long* n_children) {
+STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(long max_children,
+                                                           long** children,
+                                                           long* n_children) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!children || !n_children)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_children = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(
-    long max_columns,
-    long** columns,
-    long* n_columns) {
+STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long max_columns,
+                                                          long** columns,
+                                                          long* n_columns) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(
-    long max_rows,
-    long** rows,
-    long* n_rows) {
+STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long max_rows,
+                                                       long** rows,
+                                                       long* n_rows) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_summary(
-    IUnknown** accessible) {
+STDMETHODIMP BrowserAccessibilityWin::get_summary(IUnknown** accessible) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_isColumnSelected(
     long column,
     boolean* is_selected) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(
-    long row,
-    boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(long row,
+                                                        boolean* is_selected) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isSelected(
-    long row,
-    long column,
-    boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityWin::get_isSelected(long row,
+                                                     long column,
+                                                     boolean* is_selected) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
@@ skipping 34 matching lines @@
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 //
 // IAccessibleTable2 methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_cellAt(
-    long row,
-    long column,
-    IUnknown** cell) {
+STDMETHODIMP BrowserAccessibilityWin::get_cellAt(long row,
+                                                 long column,
+                                                 IUnknown** cell) {
   return get_accessibleAt(row, column, cell);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedCells(long* cell_count) {
   return get_nSelectedChildren(cell_count);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedCells(
     IUnknown*** cells,
     long* n_selected_cells) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!cells || !n_selected_cells)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_selected_cells = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(
-    long** columns,
-    long* n_columns) {
+STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long** columns,
+                                                          long* n_columns) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(
-    long** rows,
-    long* n_rows) {
+STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long** rows,
+                                                       long* n_rows) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
@@ skipping 76 matching lines @@
     if (cell && cell->role_ == AccessibilityNodeData::ROLE_COLUMN_HEADER) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(
-    long* column_index) {
+STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   int column;
   if (GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
     *column_index = column;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(
-    long* n_rows_spanned) {
+STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(long* n_rows_spanned) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   int rowspan;
   if (GetIntAttribute(
           AccessibilityNodeData::ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       rowspan >= 1) {
@@ skipping 58 matching lines @@
     if (cell && cell->role_ == AccessibilityNodeData::ROLE_ROW_HEADER) {
       (*cell_accessibles)[index] =
           static_cast<IAccessible*>(cell->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(
-    long* row_index) {
+STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   int row;
   if (GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row)) {
     *row_index = row;
     return S_OK;
   }
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isSelected(
-    boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityWin::get_isSelected(boolean* is_selected) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   *is_selected = false;
   return S_OK;
 }
 
@@ skipping 29 matching lines @@
     *column_index = column;
     *row_extents = rowspan;
     *column_extents = colspan;
     *is_selected = false;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_table(
-    IUnknown** table) {
+STDMETHODIMP BrowserAccessibilityWin::get_table(IUnknown** table) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
 
   int row;
   int column;
   GetIntAttribute(AccessibilityNodeData::ATTR_TABLE_CELL_ROW_INDEX, &row);
@@ skipping 28 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
+  *offset = 0;
   if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
       role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
     int sel_start = 0;
-    if (GetIntAttribute(
-            AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start)) {
+    if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
+                        &sel_start))
       *offset = sel_start;
-    } else {
-      *offset = 0;
-    }
-  } else {
-    *offset = 0;
   }
 
   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 (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
       role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
     int sel_start = 0;
     int sel_end = 0;
-    if (GetIntAttribute(
-            AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start) &&
+    if (GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_START,
+                        &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end) &&
-        sel_start != sel_end) {
+        sel_start != sel_end)
       *n_selections = 1;
-    } else {
-      *n_selections = 0;
-    }
-  } else {
-    *n_selections = 0;
   }
 
   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 (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD ||
       role_ == AccessibilityNodeData::ROLE_TEXTAREA) {
     int sel_start = 0;
     int sel_end = 0;
     if (GetIntAttribute(
             AccessibilityNodeData::ATTR_TEXT_SEL_START, &sel_start) &&
         GetIntAttribute(AccessibilityNodeData::ATTR_TEXT_SEL_END, &sel_end)) {
       *start_offset = sel_start;
       *end_offset = sel_end;
-    } else {
-      *start_offset = 0;
-      *end_offset = 0;
     }
-  } else {
-    *start_offset = 0;
-    *end_offset = 0;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_text(
-    LONG start_offset, LONG end_offset, BSTR* text) {
+STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
+                                               LONG end_offset,
+                                               BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
   const string16& text_str = TextForIAccessibleText();
 
   // Handle special text offsets.
   HandleSpecialTextOffset(text_str, &start_offset);
@@ skipping 19 matching lines @@
     return S_FALSE;
 
   *text = SysAllocString(substr.c_str());
   DCHECK(*text);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textAtOffset(
     LONG offset,
     enum IA2TextBoundaryType boundary_type,
-    LONG* start_offset, LONG* end_offset,
+    LONG* start_offset,
+    LONG* end_offset,
     BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     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) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
   const string16& text_str = TextForIAccessibleText();
 
   *start_offset = FindBoundary(
       text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = FindBoundary(
       text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textBeforeOffset(
     LONG offset,
     enum IA2TextBoundaryType boundary_type,
-    LONG* start_offset, LONG* end_offset,
+    LONG* start_offset,
+    LONG* end_offset,
     BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     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) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
   const string16& text_str = TextForIAccessibleText();
 
   *start_offset = FindBoundary(
       text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = offset;
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textAfterOffset(
     LONG offset,
     enum IA2TextBoundaryType boundary_type,
-    LONG* start_offset, LONG* end_offset,
+    LONG* start_offset,
+    LONG* end_offset,
     BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     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 33 matching lines @@
   if (!old_text)
     return E_INVALIDARG;
 
   old_text->text = SysAllocString(old_text_.c_str());
   old_text->start = 0;
   old_text->end = static_cast<long>(old_text_.size());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_offsetAtPoint(
-    LONG x, LONG y, enum IA2CoordinateType coord_type, LONG* offset) {
+    LONG x,
+    LONG y,
+    enum IA2CoordinateType coord_type,
+    LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement this. We're returning S_OK for now so that
   // screen readers still return partially accurate results rather than
   // completely failing.
   *offset = 0;
@@ skipping 10 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityWin::scrollSubstringToPoint(
     LONG start_index,
     LONG end_index,
     enum IA2CoordinateType coordinate_type,
     LONG x, LONG y) {
   // TODO(dmazzoni): adjust this for the start and end index, too.
   return scrollToPoint(coordinate_type, x, y);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::addSelection(
-    LONG start_offset, LONG end_offset) {
+STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
+                                                   LONG end_offset) {
   if (!instance_active_)
     return E_FAIL;
 
   const string16& text_str = TextForIAccessibleText();
   HandleSpecialTextOffset(text_str, &start_offset);
   HandleSpecialTextOffset(text_str, &end_offset);
 
   manager_->SetTextSelection(*this, start_offset, end_offset);
   return S_OK;
 }
@@ skipping 295 matching lines @@
     if (!found) {
       attrib_values[i] = NULL;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
-    BSTR *style_properties,
-    BSTR *style_values,
+    BSTR* style_properties,
+    BSTR* style_values,
     unsigned short *num_style_properties)  {
   if (!instance_active_)
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   string16 display;
@@ skipping 33 matching lines @@
     } else {
       style_values[i] = NULL;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
   return scrollTo(placeTopLeft ?
-                  IA2_SCROLL_TYPE_TOP_LEFT :
-                  IA2_SCROLL_TYPE_ANYWHERE);
+      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();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node)  {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (children_.size()) {
-    *node = children_[0]->ToBrowserAccessibilityWin()->NewReference();
-    return S_OK;
-  } else {
+  if (children_.empty()) {
     *node = NULL;
     return S_FALSE;
   }
+
+  *node = children_[0]->ToBrowserAccessibilityWin()->NewReference();
+  return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (children_.size()) {
-    *node = children_[children_.size() - 1]->ToBrowserAccessibilityWin()->
-        NewReference();
-    return S_OK;
-  } else {
+  if (children_.empty()) {
     *node = NULL;
     return S_FALSE;
   }
+
+  *node = (*children_.rbegin())->ToBrowserAccessibilityWin()->NewReference();
+  return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
     ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (parent_ && index_in_parent_ > 0) {
-    *node = parent_->children()[index_in_parent_ - 1]->
-        ToBrowserAccessibilityWin()->NewReference();
-    return S_OK;
-  } else {
+  if (!parent_ || index_in_parent_ <= 0) {
     *node = NULL;
     return S_FALSE;
   }
+
+  *node = parent_->children()[index_in_parent_ - 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) {
-    *node = parent_->children()[index_in_parent_ + 1]->
-        ToBrowserAccessibilityWin()->NewReference();
-    return S_OK;
-  } else {
+  if (!parent_ ||
+      index_in_parent_ < 0 ||
+      index_in_parent_ >= static_cast<int>(parent_->children().size()) - 1) {
     *node = NULL;
     return S_FALSE;
   }
+
+  *node = parent_->children()[index_in_parent_ + 1]->
+      ToBrowserAccessibilityWin()->NewReference();
+  return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_childAt(
     unsigned int child_index,
     ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (child_index < children_.size()) {
-    *node = children_[child_index]->ToBrowserAccessibilityWin()->NewReference();
-    return S_OK;
-  } else {
     *node = NULL;
     return S_FALSE;
   }
+
+  *node = children_[child_index]->ToBrowserAccessibilityWin()->NewReference();
+  return S_OK;
 }
 
 //
 // ISimpleDOMText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
   if (name_.empty())
     return S_FALSE;
 
   *dom_text = SysAllocString(name_.c_str());
   DCHECK(*dom_text);
   return S_OK;
 }
 
 //
 // IServiceProvider methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::QueryService(
-    REFGUID guidService, REFIID riid, void** object) {
+STDMETHODIMP BrowserAccessibilityWin::QueryService(REFGUID guidService,
+                                                   REFIID riid,
+                                                   void** object) {
   if (!instance_active_)
     return E_FAIL;
 
   if (guidService == IID_IAccessible ||
       guidService == IID_IAccessible2 ||
       guidService == IID_IAccessibleAction ||
       guidService == IID_IAccessibleHyperlink ||
       guidService == IID_IAccessibleHypertext ||
       guidService == IID_IAccessibleImage ||
       guidService == IID_IAccessibleTable ||
@@ skipping 14 matching lines @@
   // All methods in the IAccessibleEx interface are unimplemented.
   if (riid == IID_IAccessibleEx &&
       base::win::GetVersion() >= base::win::VERSION_WIN8) {
     return QueryInterface(riid, object);
   }
 
   *object = NULL;
   return E_FAIL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::GetPatternProvider(
-    PATTERNID id, IUnknown** provider) {
+STDMETHODIMP BrowserAccessibilityWin::GetPatternProvider(PATTERNID id,
+                                                         IUnknown** provider) {
   DVLOG(1) << "In Function: "
            << __FUNCTION__
            << " for pattern id: "
            << id;
   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
     if (IsEditableText()) {
       // The BrowserAccessibilityManager keeps track of instances when
       // we don't want to show the on-screen keyboard.
       if (!manager_->IsOSKAllowed(GetGlobalBoundsRect()))
         return E_NOTIMPL;
@@ skipping 128 matching lines @@
       value_ = UTF8ToUTF16(base::DoubleToString(fval));
     }
     ia2_attributes_.push_back(L"valuetext:" + value_);
   }
 
   // Expose table cell index.
   if (ia_role_ == ROLE_SYSTEM_CELL) {
     BrowserAccessibility* table = parent();
     while (table && table->role() != AccessibilityNodeData::ROLE_TABLE)
       table = table->parent();
-    if (table) {
-      const std::vector<int32>& unique_cell_ids = table->unique_cell_ids();
-      int index = -1;
-      for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
-        if (unique_cell_ids[i] == renderer_id_) {
-          index = static_cast<int>(i);
-          break;
-        }
+    DCHECK(table);

[dmazzoni, 2012/11/13 03:54:02]

This isn't safe; it's possible for a web author to create a cell that isn't a
descendant of a table.

[Peter Kasting, 2012/11/13 04:02:08]

Then the old code was wrong to NOTREACHED().  NOTREACHED() and DCHECK() both
mean "this absolutely cannot happen".

I can restore the conditional and simply eliminate the "else" arm, if that's the
correct answer.

[dmazzoni, 2012/11/13 04:12:13]

You're right, that was a poor choice. Please eliminate the "else" arm, thanks.

+    const std::vector<int32>& unique_cell_ids = table->unique_cell_ids();
+    for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
+      if (unique_cell_ids[i] == renderer_id_) {
+        ia2_attributes_.push_back(
+            string16(L"table-cell-index:") + base::IntToString16(i));
       }
-      if (index >= 0) {
-        ia2_attributes_.push_back(string16(L"table-cell-index:") +
-                                  base::IntToString16(index));
-      }
-    } else {
-      NOTREACHED();
     }
   }
 
   // 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
   // appropriate accessible name on Windows, we need to apply some logic
   // to the fields we get from WebKit.
   //
   // TODO(dmazzoni): move most of this logic into WebKit.
@@ skipping 17 matching lines @@
   GetStringAttribute(AccessibilityNodeData::ATTR_DESCRIPTION, &description);
   GetStringAttribute(AccessibilityNodeData::ATTR_HELP, &help);
 
   // WebKit annoyingly puts the title in the description if there's no other
   // description, which just confuses the rest of the logic. Put it back.
   // Now "help" is always the value of the "title" attribute, if present.
   if (GetHtmlAttribute("title", &title_attr) &&
       description == title_attr &&
       help.empty()) {
     help = description;
-    description = L"";
-    string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION] = L"";
+    description.clear();
+    string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION].clear();
     string_attributes_[AccessibilityNodeData::ATTR_HELP] = help;
   }
 
   // Now implement the main logic: the descripion should become the name if
   // it's nonempty, and the help should become the description if
   // there's no description - or the name if there's no name or description.
   if (!description.empty()) {
     name_ = description;
-    description = L"";
+    description.clear();
     string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION] = description;
   }
   if (!help.empty() && description.empty()) {
     description = help;
     string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION] = help;
-    string_attributes_[AccessibilityNodeData::ATTR_HELP] = L"";
+    string_attributes_[AccessibilityNodeData::ATTR_HELP].clear();
   }
   if (!description.empty() && name_.empty() && !title_elem_id) {
     name_ = description;
-    description = L"";
-    string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION] = L"";
+    description.clear();
+    string_attributes_[AccessibilityNodeData::ATTR_DESCRIPTION].clear();
   }
 
   // If it's a text field, also consider the placeholder.
   string16 placeholder;
   if (role_ == AccessibilityNodeData::ROLE_TEXT_FIELD &&
       HasState(AccessibilityNodeData::STATE_FOCUSABLE) &&
       GetHtmlAttribute("placeholder", &placeholder)) {
     if (name_.empty() && !title_elem_id) {
       name_ = placeholder;
     } else if (description.empty()) {
@@ skipping 78 matching lines @@
   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 (role_ == AccessibilityNodeData::ROLE_LISTBOX_OPTION &&
         (ia_state_ & STATE_SYSTEM_FOCUSABLE) &&
         (ia_state_ & STATE_SYSTEM_SELECTABLE) &&
         (ia_state_ & STATE_SYSTEM_FOCUSED) &&
         !(old_ia_state_ & STATE_SYSTEM_FOCUSED)) {
-      ::NotifyWinEvent(EVENT_OBJECT_FOCUS,
-                       manager_->GetParentView(),
-                       OBJID_CLIENT,
-                       child_id());
+      ::NotifyWinEvent(EVENT_OBJECT_FOCUS, manager_->GetParentView(),
+                       OBJID_CLIENT, child_id());
     }
 
     if ((ia_state_ & STATE_SYSTEM_SELECTED) &&
         !(old_ia_state_ & STATE_SYSTEM_SELECTED)) {
-      ::NotifyWinEvent(EVENT_OBJECT_SELECTIONADD,
-                       manager_->GetParentView(),
-                       OBJID_CLIENT,
-                       child_id());
+      ::NotifyWinEvent(EVENT_OBJECT_SELECTIONADD, manager_->GetParentView(),
+                       OBJID_CLIENT, child_id());
     } else if (!(ia_state_ & STATE_SYSTEM_SELECTED) &&
                (old_ia_state_ & STATE_SYSTEM_SELECTED)) {
-      ::NotifyWinEvent(EVENT_OBJECT_SELECTIONREMOVE,
-                       manager_->GetParentView(),
-                       OBJID_CLIENT,
-                       child_id());
+      ::NotifyWinEvent(EVENT_OBJECT_SELECTIONREMOVE, manager_->GetParentView(),
+                       OBJID_CLIENT, child_id());
     }
 
     old_ia_state_ = ia_state_;
   }
 
   first_time_ = false;
 }
 
 void BrowserAccessibilityWin::NativeAddReference() {
   AddRef();
@@ skipping 21 matching lines @@
   if (child_id == CHILDID_SELF)
     return this;
 
   if (child_id >= 1 && child_id <= static_cast<LONG>(children_.size()))
     return children_[child_id - 1]->ToBrowserAccessibilityWin();
 
   return manager_->GetFromChildID(child_id)->ToBrowserAccessibilityWin();
 }
 
 HRESULT BrowserAccessibilityWin::GetStringAttributeAsBstr(
-    AccessibilityNodeData::StringAttribute attribute, BSTR* value_bstr) {
+    AccessibilityNodeData::StringAttribute attribute,
+    BSTR* value_bstr) {
   string16 str;
 
   if (!GetStringAttribute(attribute, &str))
     return S_FALSE;
 
   if (str.empty())
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
 
 void BrowserAccessibilityWin::StringAttributeToIA2(
-    AccessibilityNodeData::StringAttribute attribute, const char* ia2_attr) {
+    AccessibilityNodeData::StringAttribute attribute,
+    const char* ia2_attr) {
   string16 value;
   if (GetStringAttribute(attribute, &value))
     ia2_attributes_.push_back(ASCIIToUTF16(ia2_attr) + L":" + value);
 }
 
 void BrowserAccessibilityWin::BoolAttributeToIA2(
-    AccessibilityNodeData::BoolAttribute attribute, const char* ia2_attr) {
+    AccessibilityNodeData::BoolAttribute attribute,
+    const char* ia2_attr) {
   bool value;
   if (GetBoolAttribute(attribute, &value)) {
     ia2_attributes_.push_back((ASCIIToUTF16(ia2_attr) + L":") +
                               (value ? L"true" : L"false"));
   }
 }
 
 void BrowserAccessibilityWin::IntAttributeToIA2(
-    AccessibilityNodeData::IntAttribute attribute, const char* ia2_attr) {
+    AccessibilityNodeData::IntAttribute attribute,
+    const char* ia2_attr) {
   int value;
   if (GetIntAttribute(attribute, &value))
     ia2_attributes_.push_back(ASCIIToUTF16(ia2_attr) + L":" +
                               base::IntToString16(value));
 }
 
 const string16& BrowserAccessibilityWin::TextForIAccessibleText() {
-  if (IsEditableText()) {
+  if (IsEditableText())
     return value_;
-  } else if (role_ == AccessibilityNodeData::ROLE_STATIC_TEXT) {
-    return name_;
-  } else {
-    return hypertext_;
-  }
+  return (role_ == AccessibilityNodeData::ROLE_STATIC_TEXT) ?
+      name_ : hypertext_;
 }
 
-void BrowserAccessibilityWin::HandleSpecialTextOffset(
-    const string16& text, LONG* offset) {
-  if (*offset == IA2_TEXT_OFFSET_LENGTH) {
+void BrowserAccessibilityWin::HandleSpecialTextOffset(const string16& text,
+                                                      LONG* offset) {
+  if (*offset == IA2_TEXT_OFFSET_LENGTH)
     *offset = static_cast<LONG>(text.size());
-  } else if (*offset == IA2_TEXT_OFFSET_CARET) {
+  else if (*offset == IA2_TEXT_OFFSET_CARET)
     get_caretOffset(offset);
-  }
 }
 
 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;
@@ skipping 502 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