Rename BrowserAccessibilityComWin::GetOwner() to ::owner()

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 293 matching lines @@
   target_ids_.erase(
       std::remove(target_ids_.begin(), target_ids_.end(), target_id),
       target_ids_.end());
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_relationType(
     BSTR* relation_type) {
   if (!relation_type)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner())
+  if (!owner_->owner())
     return E_FAIL;
 
   *relation_type = SysAllocString(type_.c_str());
   DCHECK(*relation_type);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_nTargets(long* n_targets) {
   if (!n_targets)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner())
+  if (!owner_->owner())
     return E_FAIL;
 
   *n_targets = static_cast<long>(target_ids_.size());
 
   for (long i = *n_targets - 1; i >= 0; --i) {
     BrowserAccessibilityComWin* result = owner_->GetFromID(target_ids_[i]);
-    if (!result || !result->GetOwner()) {
+    if (!result || !result->owner()) {
       *n_targets = 0;
       break;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
                                                       IUnknown** target) {
   if (!target)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner())
+  if (!owner_->owner())
     return E_FAIL;
 
   auto* manager = owner_->Manager();
   if (!manager)
     return E_FAIL;
 
   if (target_index < 0 ||
       target_index >= static_cast<long>(target_ids_.size())) {
     return E_INVALIDARG;
   }
 
   BrowserAccessibility* result = manager->GetFromID(target_ids_[target_index]);
   if (!result || !result->instance_active())
     return E_FAIL;
 
   *target = static_cast<IAccessible*>(
       ToBrowserAccessibilityComWin(result)->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
                                                        IUnknown** targets,
                                                        long* n_targets) {
   if (!targets || !n_targets)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner())
+  if (!owner_->owner())
     return E_FAIL;
 
   long count = static_cast<long>(target_ids_.size());
   if (count > max_targets)
     count = max_targets;
 
   *n_targets = count;
   if (count == 0)
     return S_FALSE;
 
@@ skipping 26 matching lines @@
 
 BrowserAccessibilityComWin::~BrowserAccessibilityComWin() {
   for (BrowserAccessibilityRelation* relation : relations_)
     relation->Release();
 }
 
 //
 // IAccessible methods.
 //
 // Conventions:
-// * Always test for GetOwner() first and return E_FAIL if it's false.
+// * Always test for owner() first and return E_FAIL if it's false.
 // * Always check for invalid arguments first, even if they're unused.
 // * Return S_FALSE if the only output is a string argument and it's empty.
 // * There are some methods that don't touch any state such as get_toolkitName.
-//   For these rare cases, you may not need to call GetOwner().
+//   For these rare cases, you may not need to call owner().
 //
 
 HRESULT BrowserAccessibilityComWin::accDoDefaultAction(VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_DO_DEFAULT_ACTION);
 
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   // Return an error if it's not clickable.
-  if (!target->GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION))
+  if (!target->owner()->HasIntAttribute(ui::AX_ATTR_ACTION))
     return DISP_E_MEMBERNOTFOUND;
 
-  manager->DoDefaultAction(*target->GetOwner());
+  manager->DoDefaultAction(*target->owner());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accHitTest(LONG x_left,
                                                     LONG y_top,
                                                     VARIANT* child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
 
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   gfx::Point point(x_left, y_top);
-  if (!GetOwner()->GetScreenBoundsRect().Contains(point)) {
+  if (!owner()->GetScreenBoundsRect().Contains(point)) {
     // Return S_FALSE and VT_EMPTY when outside the object's boundaries.
     child->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   BrowserAccessibility* result = manager->CachingAsyncHitTest(point);
-  if (result == GetOwner()) {
+  if (result == owner()) {
     // Point is within this object.
     child->vt = VT_I4;
     child->lVal = CHILDID_SELF;
   } else {
     child->vt = VT_DISPATCH;
     child->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accLocation(LONG* x_left,
                                                      LONG* y_top,
                                                      LONG* width,
                                                      LONG* height,
                                                      VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_LOCATION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   // Forward all directions but NAVDIR_ 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);
   }
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   BrowserAccessibility* result = nullptr;
   switch (nav_dir) {
     case NAVDIR_DOWN:
-      result = target->GetOwner()->GetTableCell(
-          GetOwner()->GetTableRow() + GetOwner()->GetTableRowSpan(),
-          GetOwner()->GetTableColumn());
+      result = target->owner()->GetTableCell(
+          owner()->GetTableRow() + owner()->GetTableRowSpan(),
+          owner()->GetTableColumn());
       break;
     case NAVDIR_UP:
-      result = target->GetOwner()->GetTableCell(GetOwner()->GetTableRow() - 1,
-                                                GetOwner()->GetTableColumn());
+      result = target->owner()->GetTableCell(owner()->GetTableRow() - 1,
+                                             owner()->GetTableColumn());
       break;
     case NAVDIR_LEFT:
-      result = target->GetOwner()->GetTableCell(
-          GetOwner()->GetTableRow(), GetOwner()->GetTableColumn() - 1);
+      result = target->owner()->GetTableCell(owner()->GetTableRow(),
+                                             owner()->GetTableColumn() - 1);
       break;
     case NAVDIR_RIGHT:
-      result = target->GetOwner()->GetTableCell(
-          GetOwner()->GetTableRow(),
-          GetOwner()->GetTableColumn() + GetOwner()->GetTableColumnSpan());
+      result = target->owner()->GetTableCell(
+          owner()->GetTableRow(),
+          owner()->GetTableColumn() + owner()->GetTableColumnSpan());
       break;
   }
 
   if (!result) {
     end->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   end->vt = VT_DISPATCH;
   end->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accChild(VARIANT var_child,
                                                       IDispatch** disp_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!disp_child)
     return E_INVALIDARG;
 
   *disp_child = NULL;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_child);
   if (!target)
     return E_INVALIDARG;
 
   (*disp_child) = target->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accChildCount(LONG* child_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD_COUNT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!child_count)
     return E_INVALIDARG;
 
-  *child_count = GetOwner()->PlatformChildCount();
+  *child_count = owner()->PlatformChildCount();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accDefaultAction(
     VARIANT var_id,
     BSTR* def_action) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DEFAULT_ACTION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!def_action)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->get_localizedName(0, def_action);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accDescription(VARIANT var_id,
                                                             BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DESCRIPTION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   base::string16 description_str = target->description();
   if (description_str.empty())
     return S_FALSE;
 
   *desc = SysAllocString(description_str.c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accFocus(VARIANT* focus_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!focus_child)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* focus =
       static_cast<BrowserAccessibilityWin*>(manager->GetFocus());
-  if (focus == GetOwner()) {
+  if (focus == owner()) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus == NULL) {
     focus_child->vt = VT_EMPTY;
   } else {
     focus_child->vt = VT_DISPATCH;
     focus_child->pdispVal = focus->GetCOM()->NewReference();
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accHelp(VARIANT var_id,
                                                      BSTR* help) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   return AXPlatformNodeWin::get_accHelp(var_id, help);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accKeyboardShortcut(
     VARIANT var_id,
     BSTR* acc_key) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_KEYBOARD_SHORTCUT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!acc_key)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (target->HasStringAttribute(ui::AX_ATTR_KEY_SHORTCUTS)) {
     return target->GetStringAttributeAsBstr(ui::AX_ATTR_KEY_SHORTCUTS, acc_key);
   }
 
   return target->GetStringAttributeAsBstr(ui::AX_ATTR_SHORTCUT, acc_key);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accName(VARIANT var_id,
                                                      BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_NAME);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   return AXPlatformNodeWin::get_accName(var_id, name);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accParent(
     IDispatch** disp_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_PARENT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
   IAccessible* parent_obj =
-      ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent());
+      ToBrowserAccessibilityComWin(owner()->PlatformGetParent());
   if (parent_obj == NULL) {
     // This happens if we're the root of the tree;
     // return the IAccessible for the window.
     parent_obj =
         Manager()->ToBrowserAccessibilityManagerWin()->GetParentIAccessible();
     // |parent| can only be NULL if the manager was created before the parent
     // IAccessible was known and it wasn't subsequently set before a client
     // requested it. This has been fixed. |parent| may also be NULL during
     // destruction. Possible cases where this could occur include tabs being
     // dragged to a new window, etc.
     if (!parent_obj) {
       DVLOG(1) << "In Function: " << __func__
                << ". Parent IAccessible interface is NULL. Returning failure";
       return E_FAIL;
     }
   }
   parent_obj->AddRef();
   *disp_parent = parent_obj;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accRole(VARIANT var_id,
                                                      VARIANT* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_ROLE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (!target->role_name().empty()) {
     role->vt = VT_BSTR;
     role->bstrVal = SysAllocString(target->role_name().c_str());
   } else {
     role->vt = VT_I4;
     role->lVal = target->ia_role();
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accState(VARIANT var_id,
                                                       VARIANT* state) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!state)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state();
-  if (manager->GetFocus() == GetOwner())
+  if (manager->GetFocus() == owner())
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accValue(VARIANT var_id,
                                                       BSTR* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (target->ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
       target->ia_role() == ROLE_SYSTEM_SCROLLBAR ||
       target->ia_role() == ROLE_SYSTEM_SLIDER) {
     base::string16 value_text = target->GetValueText();
     *value = SysAllocString(value_text.c_str());
     DCHECK(*value);
     return S_OK;
   }
 
   // Expose color well value.
   if (target->ia2_role() == IA2_ROLE_COLOR_CHOOSER) {
     unsigned int color = static_cast<unsigned int>(
-        target->GetOwner()->GetIntAttribute(ui::AX_ATTR_COLOR_VALUE));
+        target->owner()->GetIntAttribute(ui::AX_ATTR_COLOR_VALUE));
     unsigned int red = SkColorGetR(color);
     unsigned int green = SkColorGetG(color);
     unsigned int blue = SkColorGetB(color);
     base::string16 value_text;
     value_text = base::UintToString16(red * 100 / 255) + L"% red " +
                  base::UintToString16(green * 100 / 255) + L"% green " +
                  base::UintToString16(blue * 100 / 255) + L"% blue";
     *value = SysAllocString(value_text.c_str());
     DCHECK(*value);
     return S_OK;
   }
 
   *value = SysAllocString(target->value().c_str());
   DCHECK(*value);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accHelpTopic(BSTR* help_file,
                                                           VARIANT var_id,
                                                           LONG* topic_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP_TOPIC);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accSelection(VARIANT* selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_SELECTION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
-  if (GetOwner()->GetRole() != ui::AX_ROLE_LIST_BOX)
+  if (owner()->GetRole() != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
-  for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
-    if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
+  for (size_t i = 0; i < owner()->InternalChildCount(); ++i) {
+    if (owner()->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 < GetOwner()->InternalChildCount(); ++i) {
-      if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
+    for (size_t i = 0; i < owner()->InternalChildCount(); ++i) {
+      if (owner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
         selected->vt = VT_DISPATCH;
         selected->pdispVal =
-            ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i))
+            ToBrowserAccessibilityComWin(owner()->InternalGetChild(i))
                 ->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 < GetOwner()->InternalChildCount(); ++i) {
-    if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
+  for (size_t i = 0; i < owner()->InternalChildCount(); ++i) {
+    if (owner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
       enum_variant->ItemAt(index)->vt = VT_DISPATCH;
       enum_variant->ItemAt(index)->pdispVal =
-          ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i))
+          ToBrowserAccessibilityComWin(owner()->InternalGetChild(i))
               ->NewReference();
       ++index;
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accSelect(LONG flags_sel,
                                                    VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
-    manager->SetFocus(*GetOwner());
+    manager->SetFocus(*owner());
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::put_accName(VARIANT var_id, BSTR put_name) {
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityComWin::put_accValue(VARIANT var_id, BSTR put_val) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::role(LONG* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ROLE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(BSTR* attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_GET_ATTRIBUTES);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!attributes)
     return E_INVALIDARG;
   *attributes = nullptr;
 
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   base::string16 str;
   for (const base::string16& attribute : ia2_attributes())
     str += attribute + L';';
 
   if (str.empty())
     return S_FALSE;
 
   *attributes = SysAllocString(str.c_str());
   DCHECK(*attributes);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_states(AccessibleStates* states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_STATES);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
 
   if (!states)
     return E_INVALIDARG;
 
   *states = ia2_state();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_uniqueID(LONG* unique_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNIQUE_ID);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!unique_id)
     return E_INVALIDARG;
 
-  *unique_id = -GetOwner()->unique_id();
+  *unique_id = -owner()->unique_id();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_windowHandle(HWND* window_handle) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_WINDOW_HANDLE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
   *window_handle =
       Manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
   if (!*window_handle)
     return E_FAIL;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_indexInParent(
     LONG* index_in_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INDEX_IN_PARENT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
   *index_in_parent = GetIndexInParent();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nRelations(LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_relations)
     return E_INVALIDARG;
 
   *n_relations = relations_.size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_relation(
     LONG relation_index,
     IAccessibleRelation** relation) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (relation_index < 0 ||
       relation_index >= static_cast<long>(relations_.size())) {
     return E_INVALIDARG;
   }
 
   if (!relation)
     return E_INVALIDARG;
 
   relations_[relation_index]->AddRef();
   *relation = relations_[relation_index];
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_relations(
     LONG max_relations,
     IAccessibleRelation** relations,
     LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!relations || !n_relations)
     return E_INVALIDARG;
 
   long count = static_cast<long>(relations_.size());
   *n_relations = count;
   if (count == 0)
     return S_FALSE;
 
   for (long i = 0; i < count; ++i) {
     relations_[i]->AddRef();
     relations[i] = relations_[i];
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollTo(IA2ScrollType scroll_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_SCROLL_TO);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
 
   if (!manager)
     return E_FAIL;
 
-  gfx::Rect r = GetOwner()->GetFrameBoundsRect();
+  gfx::Rect r = owner()->GetFrameBoundsRect();
   switch (scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
-      manager->ScrollToMakeVisible(*GetOwner(), gfx::Rect(r.x(), r.y(), 0, 0));
+      manager->ScrollToMakeVisible(*owner(), gfx::Rect(r.x(), r.y(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
-      manager->ScrollToMakeVisible(*GetOwner(),
+      manager->ScrollToMakeVisible(*owner(),
                                    gfx::Rect(r.right(), r.bottom(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_TOP_EDGE:
-      manager->ScrollToMakeVisible(*GetOwner(),
+      manager->ScrollToMakeVisible(*owner(),
                                    gfx::Rect(r.x(), r.y(), r.width(), 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_EDGE:
-      manager->ScrollToMakeVisible(*GetOwner(),
+      manager->ScrollToMakeVisible(*owner(),
                                    gfx::Rect(r.x(), r.bottom(), r.width(), 0));
       break;
     case IA2_SCROLL_TYPE_LEFT_EDGE:
-      manager->ScrollToMakeVisible(*GetOwner(),
+      manager->ScrollToMakeVisible(*owner(),
                                    gfx::Rect(r.x(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_RIGHT_EDGE:
-      manager->ScrollToMakeVisible(*GetOwner(),
+      manager->ScrollToMakeVisible(*owner(),
                                    gfx::Rect(r.right(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_ANYWHERE:
     default:
-      manager->ScrollToMakeVisible(*GetOwner(), r);
+      manager->ScrollToMakeVisible(*owner(), r);
       break;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_POINT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     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 (GetOwner()->PlatformGetParent()) {
-      scroll_to += GetOwner()
-                       ->PlatformGetParent()
-                       ->GetFrameBoundsRect()
-                       .OffsetFromOrigin();
+    if (owner()->PlatformGetParent()) {
+      scroll_to +=
+          owner()->PlatformGetParent()->GetFrameBoundsRect().OffsetFromOrigin();
     }
   } else {
     return E_INVALIDARG;
   }
 
-  manager->ScrollToPoint(*GetOwner(), scroll_to);
+  manager->ScrollToPoint(*owner(), scroll_to);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_GROUP_POSITION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
-  *group_level = GetOwner()->GetIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL);
-  *similar_items_in_group = GetOwner()->GetIntAttribute(ui::AX_ATTR_SET_SIZE);
-  *position_in_group = GetOwner()->GetIntAttribute(ui::AX_ATTR_POS_IN_SET);
+  *group_level = owner()->GetIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL);
+  *similar_items_in_group = owner()->GetIntAttribute(ui::AX_ATTR_SET_SIZE);
+  *position_in_group = owner()->GetIntAttribute(ui::AX_ATTR_POS_IN_SET);
 
   if (*group_level == *similar_items_in_group == *position_in_group == 0)
     return S_FALSE;
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_localizedExtendedRole(
     BSTR* localized_extended_role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_ROLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!localized_extended_role)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(ui::AX_ATTR_ROLE_DESCRIPTION,
                                   localized_extended_role);
 }
 
 //
@@ skipping 101 matching lines @@
   DCHECK(*toolkit_version);
   return *toolkit_version ? S_OK : E_FAIL;
 }
 
 //
 // IAccessibleImage methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_description(BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DESCRIPTION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   if (description().empty())
     return S_FALSE;
 
   *desc = SysAllocString(description().c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_imagePosition(
     IA2CoordinateType coordinate_type,
     LONG* x,
     LONG* y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_POSITION);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
-    gfx::Rect bounds = GetOwner()->GetScreenBoundsRect();
+    gfx::Rect bounds = owner()->GetScreenBoundsRect();
     *x = bounds.x();
     *y = bounds.y();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    gfx::Rect bounds = GetOwner()->GetPageBoundsRect();
+    gfx::Rect bounds = owner()->GetPageBoundsRect();
     gfx::Rect parent_bounds =
-        GetOwner()->PlatformGetParent()
-            ? GetOwner()->PlatformGetParent()->GetPageBoundsRect()
+        owner()->PlatformGetParent()
+            ? owner()->PlatformGetParent()->GetPageBoundsRect()
             : gfx::Rect();
     *x = bounds.x() - parent_bounds.x();
     *y = bounds.y() - parent_bounds.y();
   } else {
     return E_INVALIDARG;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_imageSize(LONG* height,
                                                        LONG* width) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_SIZE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
-  *height = GetOwner()->GetPageBoundsRect().height();
-  *width = GetOwner()->GetPageBoundsRect().width();
+  *height = owner()->GetPageBoundsRect().height();
+  *width = owner()->GetPageBoundsRect().width();
   return S_OK;
 }
 
 //
 // IAccessibleTable methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accessibleAt(
     long row,
     long column,
     IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      owner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (cell && ToBrowserAccessibilityComWin(cell)) {
     *accessible = static_cast<IAccessible*>(
         ToBrowserAccessibilityComWin(cell)->NewReference());
     return S_OK;
   }
 
   *accessible = nullptr;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_caption(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_childIndex(long row,
                                                         long column,
                                                         long* cell_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  int columns = GetOwner()->GetTableColumnCount();
+  int columns = owner()->GetTableColumnCount();
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  int rows = GetOwner()->GetTableRowCount();
+  int rows = owner()->GetTableRowCount();
   if (rows <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < rows; ++i) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(i, column);
+    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
     if (ToBrowserAccessibilityComWin(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;
       }
 
       if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
         *description = SysAllocString(
             ToBrowserAccessibilityComWin(cell)->description().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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
+  BrowserAccessibility* cell = owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
-  *column_count = GetOwner()->GetTableColumnCount();
+  *column_count = owner()->GetTableColumnCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
-  *row_count = GetOwner()->GetTableRowCount();
+  *row_count = owner()->GetTableRowCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedChildren(
     long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     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_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedColumns(
     long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowDescription(long row,
                                                             BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  if (row < 0 || row >= GetOwner()->GetTableRowCount())
+  if (row < 0 || row >= owner()->GetTableRowCount())
     return E_INVALIDARG;
 
-  int columns = GetOwner()->GetTableColumnCount();
+  int columns = owner()->GetTableColumnCount();
   if (columns <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < columns; ++i) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(row, i);
+    BrowserAccessibility* cell = owner()->GetTableCell(row, i);
     if (ToBrowserAccessibilityComWin(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;
       }
 
       if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
         *description = SysAllocString(
             ToBrowserAccessibilityComWin(cell)->description().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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetOwner()->GetTableCell(row, column);
+  BrowserAccessibility* cell = owner()->GetTableCell(row, column);
   if (!cell)
     return E_INVALIDARG;
 
-  *n_rows_spanned = GetOwner()->GetTableRowSpan();
+  *n_rows_spanned = owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
+  BrowserAccessibility* cell = owner()->GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
 
   *row_index = cell->GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedChildren(
     long max_children,
     long** children,
     long* n_children) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!children || !n_children)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_children = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long max_columns,
                                                              long** columns,
                                                              long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long max_rows,
                                                           long** rows,
                                                           long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_summary(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SUMMARY);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isColumnSelected(
     long column,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_COLUMN_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isRowSelected(
     long row,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_ROW_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(long row,
                                                         long column,
                                                         boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowColumnExtentsAtIndex(
     long index,
     long* row,
     long* column,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS_AT_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetOwner()->GetTableCell(index);
+  BrowserAccessibility* cell = owner()->GetTableCell(index);
   if (!cell)
     return E_INVALIDARG;
 
   *row = cell->GetTableRow();
   *column = cell->GetTableColumn();
-  *row_extents = GetOwner()->GetTableRowSpan();
-  *column_extents = GetOwner()->GetTableColumnSpan();
+  *row_extents = owner()->GetTableRowSpan();
+  *column_extents = owner()->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 23 matching lines @@
 
 //
 // IAccessibleTable2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_cellAt(long row,
                                                     long column,
                                                     IUnknown** cell) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CELL_AT);
   AddAccessibilityModeFlags(AccessibilityMode::kScreenReader);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!cell)
     return E_INVALIDARG;
 
   BrowserAccessibility* table_cell =
-      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      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));
   }
 
   *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);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedCells(
     IUnknown*** cells,
     long* n_selected_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!cells || !n_selected_cells)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_selected_cells = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long** columns,
                                                              long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long** rows,
                                                           long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
 //
 // IAccessibleTableCell methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnExtent(
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
-  *n_columns_spanned = GetOwner()->GetTableColumnSpan();
+  *n_columns_spanned = owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_column_header_cells)
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
-  BrowserAccessibility* table = GetOwner()->GetTable();
+  BrowserAccessibility* table = owner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int column = GetOwner()->GetTableColumn();
-  int columns = GetOwner()->GetTableColumnCount();
-  int rows = GetOwner()->GetTableRowCount();
+  int column = owner()->GetTableColumn();
+  int columns = owner()->GetTableColumnCount();
+  int rows = owner()->GetTableRowCount();
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   for (int i = 0; i < rows; ++i) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(i, column);
+    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
     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) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(i, column);
+    BrowserAccessibility* cell = owner()->GetTableCell(i, column);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           ToBrowserAccessibilityComWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  *column_index = GetOwner()->GetTableColumn();
+  *column_index = owner()->GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowExtent(long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  *n_rows_spanned = GetOwner()->GetTableRowSpan();
+  *n_rows_spanned = owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_row_header_cells)
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
-  BrowserAccessibility* table = GetOwner()->GetTable();
+  BrowserAccessibility* table = owner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int row = GetOwner()->GetTableRow();
-  int columns = GetOwner()->GetTableColumnCount();
-  int rows = GetOwner()->GetTableRowCount();
+  int row = owner()->GetTableRow();
+  int columns = owner()->GetTableColumnCount();
+  int rows = owner()->GetTableRowCount();
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   for (int i = 0; i < columns; ++i) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(row, i);
+    BrowserAccessibility* cell = owner()->GetTableCell(row, i);
     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) {
-    BrowserAccessibility* cell = GetOwner()->GetTableCell(row, 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());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  *row_index = GetOwner()->GetTableRow();
+  *row_index = owner()->GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowColumnExtents(
     long* row_index,
     long* column_index,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!row_index || !column_index || !row_extents || !column_extents ||
       !is_selected) {
     return E_INVALIDARG;
   }
 
-  *row_index = GetOwner()->GetTableRow();
-  *column_index = GetOwner()->GetTableColumn();
-  *row_extents = GetOwner()->GetTableRowSpan();
-  *column_extents = GetOwner()->GetTableColumnSpan();
+  *row_index = owner()->GetTableRow();
+  *column_index = owner()->GetTableColumn();
+  *row_extents = owner()->GetTableRowSpan();
+  *column_extents = owner()->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 (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
-  BrowserAccessibility* find_table = GetOwner()->GetTable();
+  BrowserAccessibility* find_table = owner()->GetTable();
   if (!find_table || !ToBrowserAccessibilityComWin(find_table)) {
     *table = nullptr;
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
       ToBrowserAccessibilityComWin(find_table)->NewReference());
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nCharacters(LONG* n_characters) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_CHARACTERS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
-  *n_characters = static_cast<LONG>(GetOwner()->GetText().size());
+  *n_characters = static_cast<LONG>(owner()->GetText().size());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_caretOffset(LONG* offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
-  if (!GetOwner()->HasCaret())
+  if (!owner()->HasCaret())
     return S_FALSE;
 
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   // The caret is always at the end of the selection.
   *offset = selection_end;
   if (*offset < 0)
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_characterExtents(
     LONG offset,
     IA2CoordinateType coordinate_type,
     LONG* out_x,
     LONG* out_y,
     LONG* out_width,
     LONG* out_height) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHARACTER_EXTENTS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetOwner()->GetText();
+  const base::string16& text_str = owner()->GetText();
   HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
     return E_INVALIDARG;
 
   gfx::Rect character_bounds;
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
-    character_bounds = GetOwner()->GetScreenBoundsForRange(offset, 1);
+    character_bounds = owner()->GetScreenBoundsForRange(offset, 1);
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    character_bounds = GetOwner()->GetPageBoundsForRange(offset, 1);
-    if (GetOwner()->PlatformGetParent()) {
-      character_bounds -= GetOwner()
-                              ->PlatformGetParent()
-                              ->GetPageBoundsRect()
-                              .OffsetFromOrigin();
+    character_bounds = owner()->GetPageBoundsForRange(offset, 1);
+    if (owner()->PlatformGetParent()) {
+      character_bounds -=
+          owner()->PlatformGetParent()->GetPageBoundsRect().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 BrowserAccessibilityComWin::get_nSelections(LONG* n_selections) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
       selection_start != selection_end) {
     *n_selections = 1;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selection(LONG selection_index,
                                                        LONG* start_offset,
                                                        LONG* end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   *start_offset = 0;
   *end_offset = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
@@ skipping 11 matching lines @@
   }
 
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_text(LONG start_offset,
                                                   LONG end_offset,
                                                   BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetOwner()->GetText();
+  const base::string16& text_str = owner()->GetText();
   HandleSpecialTextOffset(&start_offset);
   HandleSpecialTextOffset(&end_offset);
 
   // The spec allows the arguments to be reversed.
   if (start_offset > end_offset) {
     LONG tmp = start_offset;
     start_offset = end_offset;
     end_offset = tmp;
   }
 
@@ skipping 18 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textAtOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   HandleSpecialTextOffset(&offset);
   if (offset < 0)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetOwner()->GetText();
+  const base::string16& text_str = owner()->GetText();
   LONG text_len = text_str.length();
   if (offset > text_len)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
@@ skipping 22 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textBeforeOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_BEFORE_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     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 base::string16& text_str = GetOwner()->GetText();
+  const base::string16& text_str = owner()->GetText();
 
   *start_offset =
       FindBoundary(text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = offset;
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textAfterOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AFTER_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     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 base::string16& text_str = GetOwner()->GetText();
+  const base::string16& text_str = owner()->GetText();
 
   *start_offset = offset;
   *end_offset =
       FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_newText(IA2TextSegment* new_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEW_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!new_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (new_len == 0)
     return E_FAIL;
 
-  base::string16 substr = GetOwner()->GetText().substr(start, new_len);
+  base::string16 substr = owner()->GetText().substr(start, new_len);
   new_text->text = SysAllocString(substr.c_str());
   new_text->start = static_cast<long>(start);
   new_text->end = static_cast<long>(start + new_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_oldText(IA2TextSegment* old_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OLD_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!old_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (old_len == 0)
     return E_FAIL;
 
   base::string16 old_hypertext = old_win_attributes_->hypertext;
   base::string16 substr = old_hypertext.substr(start, old_len);
   old_text->text = SysAllocString(substr.c_str());
   old_text->start = static_cast<long>(start);
   old_text->end = static_cast<long>(start + old_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_offsetAtPoint(
     LONG x,
     LONG y,
     IA2CoordinateType coord_type,
     LONG* offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OFFSET_AT_POINT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     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;
   return S_OK;
@@ skipping 12 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollSubstringToPoint(
     LONG start_index,
     LONG end_index,
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_SUBSTRING_TO_POINT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (start_index > end_index)
     std::swap(start_index, end_index);
   LONG length = end_index - start_index + 1;
   DCHECK_GE(length, 0);
 
-  gfx::Rect string_bounds =
-      GetOwner()->GetPageBoundsForRange(start_index, length);
-  string_bounds -= GetOwner()->GetPageBoundsRect().OffsetFromOrigin();
+  gfx::Rect string_bounds = owner()->GetPageBoundsForRange(start_index, length);
+  string_bounds -= owner()->GetPageBoundsRect().OffsetFromOrigin();
   x -= string_bounds.x();
   y -= string_bounds.y();
 
   return scrollToPoint(coordinate_type, x, y);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::addSelection(LONG start_offset,
                                                       LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ADD_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   // We only support one selection.
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::removeSelection(LONG selection_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_REMOVE_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (selection_index != 0)
     return E_INVALIDARG;
 
   // Simply collapse the selection to the position of the caret if a caret is
   // visible, otherwise set the selection to 0.
   LONG caret_offset = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
-  if (GetOwner()->HasCaret() && selection_end >= 0)
+  if (owner()->HasCaret() && selection_end >= 0)
     caret_offset = selection_end;
   SetIA2HypertextSelection(caret_offset, caret_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setCaretOffset(LONG offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
   SetIA2HypertextSelection(offset, offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setSelection(LONG selection_index,
                                                       LONG start_offset,
                                                       LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
   if (selection_index != 0)
     return E_INVALIDARG;
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(LONG offset,
                                                         LONG* start_offset,
                                                         LONG* end_offset,
                                                         BSTR* text_attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IATEXT_GET_ATTRIBUTES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!start_offset || !end_offset || !text_attributes)
     return E_INVALIDARG;
 
   *start_offset = *end_offset = 0;
   *text_attributes = nullptr;
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
-  const base::string16 text = GetOwner()->GetText();
+  const base::string16 text = owner()->GetText();
   HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text.size()))
     return E_INVALIDARG;
 
   ComputeStylesIfNeeded();
   *start_offset = FindStartOfStyle(offset, ui::BACKWARDS_DIRECTION);
   *end_offset = FindStartOfStyle(offset, ui::FORWARDS_DIRECTION);
 
   base::string16 attributes_str;
   const std::vector<base::string16>& attributes =
@@ skipping 11 matching lines @@
 }
 
 //
 // IAccessibleHypertext methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nHyperlinks(
     long* hyperlink_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_HYPERLINKS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!hyperlink_count)
     return E_INVALIDARG;
 
   *hyperlink_count = hyperlink_offset_to_index().size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_hyperlink(
     long index,
     IAccessibleHyperlink** hyperlink) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!hyperlink || index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
   int32_t id = hyperlinks()[index];
   BrowserAccessibilityComWin* link =
-      ToBrowserAccessibilityComWin(GetOwner()->GetFromUniqueID(id));
+      ToBrowserAccessibilityComWin(owner()->GetFromUniqueID(id));
   if (!link)
     return E_FAIL;
 
   *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
 
   if (char_index < 0 ||
-      char_index >= static_cast<long>(GetOwner()->GetText().size())) {
+      char_index >= static_cast<long>(owner()->GetText().size())) {
     return E_INVALIDARG;
   }
 
   std::map<int32_t, int32_t>::iterator it =
       hyperlink_offset_to_index().find(char_index);
   if (it == hyperlink_offset_to_index().end()) {
     *hyperlink_index = -1;
     return S_FALSE;
   }
 
   *hyperlink_index = it->second;
   return S_OK;
 }
 
 //
 // IAccessibleHyperlink methods.
 //
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityComWin::get_anchor(long index,
                                                     VARIANT* anchor) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !IsHyperlink())
+  if (!owner() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have only one anchor, that is the text inside them.
   if (index != 0 || !anchor)
     return E_INVALIDARG;
 
-  BSTR ia2_hypertext = SysAllocString(GetOwner()->GetText().c_str());
+  BSTR ia2_hypertext = SysAllocString(owner()->GetText().c_str());
   DCHECK(ia2_hypertext);
   anchor->vt = VT_BSTR;
   anchor->bstrVal = ia2_hypertext;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(ia2_hypertext))
     return S_FALSE;
 
   return S_OK;
 }
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityComWin::get_anchorTarget(
     long index,
     VARIANT* anchor_target) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR_TARGET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !IsHyperlink())
+  if (!owner() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have at most one target, that is when they represent an
   // HTML hyperlink, i.e. an <a> element with a "href" attribute.
   if (index != 0 || !anchor_target)
     return E_INVALIDARG;
 
   BSTR target;
   if (!(ia_state() & STATE_SYSTEM_LINKED) ||
       FAILED(GetStringAttributeAsBstr(ui::AX_ATTR_URL, &target))) {
     target = SysAllocString(L"");
   }
   DCHECK(target);
   anchor_target->vt = VT_BSTR;
   anchor_target->bstrVal = target;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(target))
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_startIndex(long* index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_START_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !IsHyperlink())
+  if (!owner() || !IsHyperlink())
     return E_FAIL;
 
   if (!index)
     return E_INVALIDARG;
 
   int32_t hypertext_offset = 0;
-  auto* parent = GetOwner()->PlatformGetParent();
+  auto* parent = owner()->PlatformGetParent();
   if (parent) {
     hypertext_offset =
         ToBrowserAccessibilityComWin(parent)->GetHypertextOffsetFromChild(
             *this);
   }
   *index = static_cast<LONG>(hypertext_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_endIndex(long* index) {
@@ skipping 13 matching lines @@
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleAction partly implemented.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::nActions(long* n_actions) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_N_ACTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!n_actions)
     return E_INVALIDARG;
 
   // |IsHyperlink| is required for |IAccessibleHyperlink::anchor/anchorTarget|
   // to work properly because the |IAccessibleHyperlink| interface inherits from
   // |IAccessibleAction|.
-  if (IsHyperlink() || GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION)) {
+  if (IsHyperlink() || owner()->HasIntAttribute(ui::AX_ATTR_ACTION)) {
     *n_actions = 1;
   } else {
     *n_actions = 0;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::doAction(long action_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_DO_ACTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
-  if (!GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
+  if (!owner()->HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
     return E_INVALIDARG;
 
-  Manager()->DoDefaultAction(*GetOwner());
+  Manager()->DoDefaultAction(*owner());
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_description(long action_index,
                                             BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IAACTION_GET_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_keyBinding(long action_index,
                                                         long n_max_bindings,
                                                         BSTR** key_bindings,
                                                         long* n_bindings) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_KEY_BINDING);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_name(long action_index,
                                                   BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
   int action;
-  if (!GetOwner()->GetIntAttribute(ui::AX_ATTR_ACTION, &action) ||
+  if (!owner()->GetIntAttribute(ui::AX_ATTR_ACTION, &action) ||
       action_index != 0) {
     *name = nullptr;
     return E_INVALIDARG;
   }
 
   base::string16 action_verb =
       ui::ActionToUnlocalizedString(static_cast<ui::AXSupportedAction>(action));
   if (action_verb.empty() || action_verb == L"none") {
     *name = nullptr;
     return S_FALSE;
   }
 
   *name = SysAllocString(action_verb.c_str());
   DCHECK(name);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_localizedName(long action_index,
                                               BSTR* localized_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!localized_name)
     return E_INVALIDARG;
 
   int action;
-  if (!GetOwner()->GetIntAttribute(ui::AX_ATTR_ACTION, &action) ||
+  if (!owner()->GetIntAttribute(ui::AX_ATTR_ACTION, &action) ||
       action_index != 0) {
     *localized_name = nullptr;
     return E_INVALIDARG;
   }
 
   base::string16 action_verb =
       ui::ActionToString(static_cast<ui::AXSupportedAction>(action));
   if (action_verb.empty()) {
     *localized_name = nullptr;
     return S_FALSE;
   }
 
   *localized_name = SysAllocString(action_verb.c_str());
   DCHECK(localized_name);
   return S_OK;
 }
 
 //
 // IAccessibleValue methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_currentValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CURRENT_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_minimumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MINIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_maximumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MAXIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setCurrentValue(VARIANT new_value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CURRENT_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): Implement this.
   return E_NOTIMPL;
 }
 
 //
 // ISimpleDOMDocument methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_URL(BSTR* url) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_URL);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
-  if (GetOwner() != manager->GetRoot())
+  if (owner() != manager->GetRoot())
     return E_FAIL;
 
   std::string str = manager->GetTreeData().url;
   if (str.empty())
     return S_FALSE;
 
   *url = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*url);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_title(BSTR* title) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TITLE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().title;
   if (str.empty())
     return S_FALSE;
 
   *title = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*title);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_mimeType(BSTR* mime_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MIME_TYPE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().mimetype;
   if (str.empty())
     return S_FALSE;
 
   *mime_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*mime_type);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_docType(BSTR* doc_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOC_TYPE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().doctype;
@@ skipping 26 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nodeInfo(
     BSTR* node_name,
     short* name_space_id,
     BSTR* node_value,
     unsigned int* num_children,
     unsigned int* unique_id,
     unsigned short* node_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NODE_INFO);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node_name || !name_space_id || !node_value || !num_children ||
       !unique_id || !node_type) {
     return E_INVALIDARG;
   }
 
   base::string16 tag;
-  if (GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
+  if (owner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
     *node_name = SysAllocString(tag.c_str());
   else
     *node_name = nullptr;
 
   *name_space_id = 0;
   *node_value = SysAllocString(value().c_str());
-  *num_children = GetOwner()->PlatformChildCount();
-  *unique_id = -GetOwner()->unique_id();
+  *num_children = owner()->PlatformChildCount();
+  *unique_id = -owner()->unique_id();
 
-  if (GetOwner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
-      GetOwner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
+  if (owner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+      owner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
     *node_type = NODETYPE_DOCUMENT;
-  } else if (GetOwner()->IsTextOnlyObject()) {
+  } else if (owner()->IsTextOnlyObject()) {
     *node_type = NODETYPE_TEXT;
   } else {
     *node_type = NODETYPE_ELEMENT;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(
     unsigned short max_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values,
     unsigned short* num_attribs) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_GET_ATTRIBUTES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
-  if (*num_attribs > GetOwner()->GetHtmlAttributes().size())
-    *num_attribs = GetOwner()->GetHtmlAttributes().size();
+  if (*num_attribs > owner()->GetHtmlAttributes().size())
+    *num_attribs = owner()->GetHtmlAttributes().size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(
-        base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].first).c_str());
+        base::UTF8ToUTF16(owner()->GetHtmlAttributes()[i].first).c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(
-        base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].second).c_str());
+        base::UTF8ToUTF16(owner()->GetHtmlAttributes()[i].second).c_str());
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributesForNames(
     unsigned short num_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ATTRIBUTES_FOR_NAMES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     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 < GetOwner()->GetHtmlAttributes().size(); ++j) {
-      if (GetOwner()->GetHtmlAttributes()[j].first == name) {
+    for (unsigned int j = 0; j < owner()->GetHtmlAttributes().size(); ++j) {
+      if (owner()->GetHtmlAttributes()[j].first == name) {
         attrib_values[i] = SysAllocString(
-            base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[j].second)
-                .c_str());
+            base::UTF8ToUTF16(owner()->GetHtmlAttributes()[j].second).c_str());
         found = true;
         break;
       }
     }
     if (!found) {
       attrib_values[i] = NULL;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values,
     unsigned short* num_style_properties) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   base::string16 display;
   if (max_style_properties == 0 ||
-      !GetOwner()->GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
+      !owner()->GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
     *num_style_properties = 0;
     return S_OK;
   }
 
   *num_style_properties = 1;
   style_properties[0] = SysAllocString(L"display");
   style_values[0] = SysAllocString(display.c_str());
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_computedStyleForProperties(
     unsigned short num_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE_FOR_PROPERTIES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   for (unsigned short i = 0; i < num_style_properties; ++i) {
     base::string16 name = base::ToLowerASCII(
         reinterpret_cast<const base::char16*>(style_properties[i]));
     if (name == L"display") {
       base::string16 display =
-          GetOwner()->GetString16Attribute(ui::AX_ATTR_DISPLAY);
+          owner()->GetString16Attribute(ui::AX_ATTR_DISPLAY);
       style_values[i] = SysAllocString(display.c_str());
     } else {
       style_values[i] = NULL;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollTo(boolean placeTopLeft) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_SCROLL_TO);
   return scrollTo(placeTopLeft ? IA2_SCROLL_TYPE_TOP_LEFT
                                : IA2_SCROLL_TYPE_ANYWHERE);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_parentNode(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PARENT_NODE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent())
+  *node = ToBrowserAccessibilityComWin(owner()->PlatformGetParent())
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_firstChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FIRST_CHILD);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (GetOwner()->PlatformChildCount() == 0) {
+  if (owner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(0))
+  *node = ToBrowserAccessibilityComWin(owner()->PlatformGetChild(0))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_lastChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LAST_CHILD);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (GetOwner()->PlatformChildCount() == 0) {
+  if (owner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node =
-      ToBrowserAccessibilityComWin(
-          GetOwner()->PlatformGetChild(GetOwner()->PlatformChildCount() - 1))
-          ->NewReference();
+  *node = ToBrowserAccessibilityComWin(
+              owner()->PlatformGetChild(owner()->PlatformChildCount() - 1))
+              ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_previousSibling(
     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PREVIOUS_SIBLING);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!GetOwner()->PlatformGetParent() || GetIndexInParent() <= 0) {
+  if (!owner()->PlatformGetParent() || GetIndexInParent() <= 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(
-              GetOwner()->PlatformGetParent()->InternalGetChild(
+              owner()->PlatformGetParent()->InternalGetChild(
                   GetIndexInParent() - 1))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nextSibling(
     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEXT_SIBLING);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!GetOwner()->PlatformGetParent() || GetIndexInParent() < 0 ||
+  if (!owner()->PlatformGetParent() || GetIndexInParent() < 0 ||
       GetIndexInParent() >=
-          static_cast<int>(
-              GetOwner()->PlatformGetParent()->InternalChildCount()) -
+          static_cast<int>(owner()->PlatformGetParent()->InternalChildCount()) -
               1) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(
-              GetOwner()->PlatformGetParent()->InternalGetChild(
+              owner()->PlatformGetParent()->InternalGetChild(
                   GetIndexInParent() + 1))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_childAt(unsigned int child_index,
                                                      ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_AT);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (child_index >= GetOwner()->PlatformChildCount())
+  if (child_index >= owner()->PlatformChildCount())
     return E_INVALIDARG;
 
-  BrowserAccessibility* child = GetOwner()->PlatformGetChild(child_index);
+  BrowserAccessibility* child = owner()->PlatformGetChild(child_index);
   if (!child) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(child)->NewReference();
   return S_OK;
 }
 
 // We only support this method for retrieving MathML content.
 STDMETHODIMP BrowserAccessibilityComWin::get_innerHTML(BSTR* innerHTML) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INNER_HTML);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
-  if (GetOwner()->GetRole() != ui::AX_ROLE_MATH)
+  if (owner()->GetRole() != ui::AX_ROLE_MATH)
     return E_NOTIMPL;
 
   base::string16 inner_html =
-      GetOwner()->GetString16Attribute(ui::AX_ATTR_INNER_HTML);
+      owner()->GetString16Attribute(ui::AX_ATTR_INNER_HTML);
   *innerHTML = SysAllocString(inner_html.c_str());
   DCHECK(*innerHTML);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_localInterface(void** local_interface) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCAL_INTERFACE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_language(BSTR* language) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LANGUAGE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!language)
     return E_INVALIDARG;
   *language = nullptr;
 
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   base::string16 lang =
-      GetOwner()->GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE);
+      owner()->GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE);
   if (lang.empty())
     lang = L"en-US";
 
   *language = SysAllocString(lang.c_str());
   DCHECK(*language);
   return S_OK;
 }
 
 //
 // ISimpleDOMText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_domText(BSTR* dom_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOM_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(ui::AX_ATTR_NAME, dom_text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_clippedSubstringBounds(
     unsigned int start_index,
@@ skipping 14 matching lines @@
 STDMETHODIMP BrowserAccessibilityComWin::get_unclippedSubstringBounds(
     unsigned int start_index,
     unsigned int end_index,
     int* out_x,
     int* out_y,
     int* out_width,
     int* out_height) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNCLIPPED_SUBSTRING_BOUNDS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   unsigned int text_length =
-      static_cast<unsigned int>(GetOwner()->GetText().size());
+      static_cast<unsigned int>(owner()->GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
   gfx::Rect bounds =
-      GetOwner()->GetScreenBoundsForRange(start_index, end_index - start_index);
+      owner()->GetScreenBoundsForRange(start_index, end_index - start_index);
   *out_x = bounds.x();
   *out_y = bounds.y();
   *out_width = bounds.width();
   *out_height = bounds.height();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollToSubstring(
     unsigned int start_index,
     unsigned int end_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_SUBSTRING);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   auto* manager = Manager();
   if (!manager)
     return E_FAIL;
 
   unsigned int text_length =
-      static_cast<unsigned int>(GetOwner()->GetText().size());
+      static_cast<unsigned int>(owner()->GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
   manager->ScrollToMakeVisible(
-      *GetOwner(),
-      GetOwner()->GetPageBoundsForRange(start_index, end_index - start_index));
+      *owner(),
+      owner()->GetPageBoundsForRange(start_index, end_index - start_index));
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_fontFamily(BSTR* font_family) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FONT_FAMILY);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!font_family)
     return E_INVALIDARG;
   *font_family = nullptr;
 
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   base::string16 family =
-      GetOwner()->GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
+      owner()->GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
   if (family.empty())
     return S_FALSE;
 
   *font_family = SysAllocString(family.c_str());
   DCHECK(*font_family);
   return S_OK;
 }
 
 //
 // IServiceProvider methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::QueryService(REFGUID guid_service,
                                                       REFIID riid,
                                                       void** object) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_QUERY_SERVICE);
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (guid_service == GUID_IAccessibleContentDocument) {
     // Special Mozilla extension: return the accessible for the root document.
     // Screen readers use this to distinguish between a document loaded event
     // on the root document vs on an iframe.
-    BrowserAccessibility* node = GetOwner();
+    BrowserAccessibility* node = owner();
     while (node->PlatformGetParent())
       node = node->PlatformGetParent()->manager()->GetRoot();
     return ToBrowserAccessibilityComWin(node)->QueryInterface(IID_IAccessible2,
                                                               object);
   }
 
   if (guid_service == IID_IAccessible || guid_service == IID_IAccessible2 ||
       guid_service == IID_IAccessibleAction ||
       guid_service == IID_IAccessibleApplication ||
       guid_service == IID_IAccessibleHyperlink ||
@@ skipping 48 matching lines @@
     IAccessibleEx** acc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_CONVERT_RETURNED_ELEMENT);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::GetPatternProvider(
     PATTERNID id,
     IUnknown** provider) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PATTERN_PROVIDER);
   DVLOG(1) << "In Function: " << __func__ << " for pattern id: " << id;
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
-    if (GetOwner()->HasState(ui::AX_STATE_EDITABLE)) {
+    if (owner()->HasState(ui::AX_STATE_EDITABLE)) {
       DVLOG(1) << "Returning UIA text provider";
       base::win::UIATextProvider::CreateTextProvider(GetValueText(), true,
                                                      provider);
       return S_OK;
     }
   }
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::GetPropertyValue(PROPERTYID id,
                                                           VARIANT* ret) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PROPERTY_VALUE);
   DVLOG(1) << "In Function: " << __func__ << " for property id: " << id;
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
   V_VT(ret) = VT_EMPTY;
   if (id == UIA_ControlTypePropertyId) {
-    if (GetOwner()->HasState(ui::AX_STATE_EDITABLE)) {
+    if (owner()->HasState(ui::AX_STATE_EDITABLE)) {
       V_VT(ret) = VT_I4;
       ret->lVal = UIA_EditControlTypeId;
       DVLOG(1) << "Returning Edit control type";
     } else {
       DVLOG(1) << "Returning empty control type";
     }
   }
   return S_OK;
 }
 
@@ skipping 26 matching lines @@
     if (ia_role != ROLE_SYSTEM_GRAPHIC) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleTable || iid == IID_IAccessibleTable2) {
     if (ia_role != ROLE_SYSTEM_TABLE) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleTableCell) {
-    if (!accessibility->GetOwner()->IsCellOrTableHeaderRole()) {
+    if (!accessibility->owner()->IsCellOrTableHeaderRole()) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleValue) {
     if (ia_role != ROLE_SYSTEM_PROGRESSBAR &&
         ia_role != ROLE_SYSTEM_SCROLLBAR && ia_role != ROLE_SYSTEM_SLIDER) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_ISimpleDOMDocument) {
@@ skipping 12 matching lines @@
 
   return CComObjectRootBase::InternalQueryInterface(this_ptr, entries, iid,
                                                     object);
 }
 
 void BrowserAccessibilityComWin::ComputeStylesIfNeeded() {
   if (!offset_to_text_attributes().empty())
     return;
 
   std::map<int, std::vector<base::string16>> attributes_map;
-  if (GetOwner()->PlatformIsLeaf() || GetOwner()->IsSimpleTextControl()) {
+  if (owner()->PlatformIsLeaf() || owner()->IsSimpleTextControl()) {
     attributes_map[0] = ComputeTextAttributes();
     std::map<int, std::vector<base::string16>> spelling_attributes =
         GetSpellingAttributes();
     for (auto& spelling_attribute : spelling_attributes) {
       auto attributes_iterator = attributes_map.find(spelling_attribute.first);
       if (attributes_iterator == attributes_map.end()) {
         attributes_map[spelling_attribute.first] =
             std::move(spelling_attribute.second);
       } else {
         std::vector<base::string16>& existing_attributes =
@@ skipping 10 matching lines @@
         existing_attributes.insert(existing_attributes.end(),
                                    spelling_attribute.second.begin(),
                                    spelling_attribute.second.end());
       }
     }
     win_attributes_->offset_to_text_attributes.swap(attributes_map);
     return;
   }
 
   int start_offset = 0;
-  for (size_t i = 0; i < GetOwner()->PlatformChildCount(); ++i) {
-    auto* child = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(i));
+  for (size_t i = 0; i < owner()->PlatformChildCount(); ++i) {
+    auto* child = ToBrowserAccessibilityComWin(owner()->PlatformGetChild(i));
     DCHECK(child);
     std::vector<base::string16> attributes(child->ComputeTextAttributes());
 
     if (attributes_map.empty()) {
       attributes_map[start_offset] = attributes;
     } else {
       // Only add the attributes for this child if we are at the start of a new
       // style span.
       std::vector<base::string16> previous_attributes =
           attributes_map.rbegin()->second;
       if (!std::equal(attributes.begin(), attributes.end(),
                       previous_attributes.begin())) {
         attributes_map[start_offset] = attributes;
       }
     }
 
-    if (child->GetOwner()->IsTextOnlyObject())
-      start_offset += child->GetOwner()->GetText().length();
+    if (child->owner()->IsTextOnlyObject())
+      start_offset += child->owner()->GetText().length();
     else
       start_offset += 1;
   }
 
   win_attributes_->offset_to_text_attributes.swap(attributes_map);
 }
 
 // |offset| could either be a text character or a child index in case of
 // non-text objects.
 // TODO(nektar): Remove this function once selection bugs are fixed in Blink.
 AXPlatformPosition::AXPositionInstance
 BrowserAccessibilityComWin::CreatePositionForSelectionAt(int offset) const {
-  if (!GetOwner()->IsNativeTextControl() && !GetOwner()->IsTextOnlyObject()) {
+  if (!owner()->IsNativeTextControl() && !owner()->IsTextOnlyObject()) {
     auto* manager = Manager();
     DCHECK(manager);
     const BrowserAccessibilityComWin* child = this;
     // TODO(nektar): Make parents of text-only objects not include the text of
     // children in their hypertext.
-    for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
+    for (size_t i = 0; i < owner()->InternalChildCount(); ++i) {
       int new_offset = offset;
-      child = ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i));
+      child = ToBrowserAccessibilityComWin(owner()->InternalGetChild(i));
       DCHECK(child);
-      if (child->GetOwner()->IsTextOnlyObject()) {
-        new_offset -= child->GetOwner()->GetText().length();
+      if (child->owner()->IsTextOnlyObject()) {
+        new_offset -= child->owner()->GetText().length();
       } else {
         new_offset -= 1;
       }
       if (new_offset <= 0)
         break;
       offset = new_offset;
     }
     AXPlatformPositionInstance position =
-        AXPlatformPosition::CreateTextPosition(
-            manager->ax_tree_id(), child->GetOwner()->GetId(), offset,
-            ui::AX_TEXT_AFFINITY_DOWNSTREAM)
+        AXPlatformPosition::CreateTextPosition(manager->ax_tree_id(),
+                                               child->owner()->GetId(), offset,
+                                               ui::AX_TEXT_AFFINITY_DOWNSTREAM)
             ->AsLeafTextPosition();
     if (position->GetAnchor() &&
         position->GetAnchor()->GetRole() == ui::AX_ROLE_INLINE_TEXT_BOX) {
       return position->CreateParentPosition();
     }
     return position;
   }
-  return GetOwner()->CreatePositionAt(offset);
+  return owner()->CreatePositionAt(offset);
 }
 
 //
 // Private methods.
 //
 
 void BrowserAccessibilityComWin::UpdateStep1ComputeWinAttributes() {
   // Swap win_attributes_ to old_win_attributes_, allowing us to see
   // exactly what changed and fire appropriate events. Note that
   // old_win_attributes_ is cleared at the end of UpdateStep3FireEvents.
@@ skipping 37 matching lines @@
 
   // Expose container live region attributes.
   StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_STATUS, "container-live");
   StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_RELEVANT,
                        "container-relevant");
   BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_ATOMIC, "container-atomic");
   BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_BUSY, "container-busy");
 
   // Expose the non-standard explicit-name IA2 attribute.
   int name_from;
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_NAME_FROM, &name_from) &&
+  if (owner()->GetIntAttribute(ui::AX_ATTR_NAME_FROM, &name_from) &&
       name_from != ui::AX_NAME_FROM_CONTENTS) {
     win_attributes_->ia2_attributes.push_back(L"explicit-name:true");
   }
 
   // Expose the aria-current attribute.
   int32_t aria_current_state;
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_ARIA_CURRENT_STATE,
-                                  &aria_current_state)) {
+  if (owner()->GetIntAttribute(ui::AX_ATTR_ARIA_CURRENT_STATE,
+                               &aria_current_state)) {
     switch (static_cast<ui::AXAriaCurrentState>(aria_current_state)) {
       case ui::AX_ARIA_CURRENT_STATE_NONE:
         break;
       case ui::AX_ARIA_CURRENT_STATE_FALSE:
         win_attributes_->ia2_attributes.push_back(L"current:false");
         break;
       case ui::AX_ARIA_CURRENT_STATE_TRUE:
         win_attributes_->ia2_attributes.push_back(L"current:true");
         break;
       case ui::AX_ARIA_CURRENT_STATE_PAGE:
         win_attributes_->ia2_attributes.push_back(L"current:page");
         break;
       case ui::AX_ARIA_CURRENT_STATE_STEP:
         win_attributes_->ia2_attributes.push_back(L"current:step");
         break;
       case ui::AX_ARIA_CURRENT_STATE_LOCATION:
         win_attributes_->ia2_attributes.push_back(L"current:location");
         break;
       case ui::AX_ARIA_CURRENT_STATE_DATE:
         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 (GetOwner()->IsCellOrTableHeaderRole()) {
-    BrowserAccessibility* table = GetOwner()->PlatformGetParent();
+  if (owner()->IsCellOrTableHeaderRole()) {
+    BrowserAccessibility* table = owner()->PlatformGetParent();
     while (table && !table->IsTableLikeRole())
       table = table->PlatformGetParent();
     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] == GetOwner()->GetId()) {
+        if (unique_cell_ids[i] == owner()->GetId()) {
           win_attributes_->ia2_attributes.push_back(
               base::string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
     }
   }
 
   // Expose aria-colcount and aria-rowcount in a table, grid or treegrid.
-  if (GetOwner()->IsTableLikeRole()) {
+  if (owner()->IsTableLikeRole()) {
     IntAttributeToIA2(ui::AX_ATTR_ARIA_COLUMN_COUNT, "colcount");
     IntAttributeToIA2(ui::AX_ATTR_ARIA_ROW_COUNT, "rowcount");
   }
 
   // Expose aria-colindex and aria-rowindex in a cell or row.
-  if (GetOwner()->IsCellOrTableHeaderRole() ||
-      GetOwner()->GetRole() == ui::AX_ROLE_ROW) {
-    if (GetOwner()->GetRole() != ui::AX_ROLE_ROW)
+  if (owner()->IsCellOrTableHeaderRole() ||
+      owner()->GetRole() == ui::AX_ROLE_ROW) {
+    if (owner()->GetRole() != ui::AX_ROLE_ROW)
       IntAttributeToIA2(ui::AX_ATTR_ARIA_CELL_COLUMN_INDEX, "colindex");
     IntAttributeToIA2(ui::AX_ATTR_ARIA_CELL_ROW_INDEX, "rowindex");
   }
 
   // Expose row or column header sort direction.
   int32_t sort_direction;
   if ((ia_role() == ROLE_SYSTEM_COLUMNHEADER ||
        ia_role() == ROLE_SYSTEM_ROWHEADER) &&
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_SORT_DIRECTION,
-                                  &sort_direction)) {
+      owner()->GetIntAttribute(ui::AX_ATTR_SORT_DIRECTION, &sort_direction)) {
     switch (static_cast<ui::AXSortDirection>(sort_direction)) {
       case ui::AX_SORT_DIRECTION_NONE:
         break;
       case ui::AX_SORT_DIRECTION_UNSORTED:
         win_attributes_->ia2_attributes.push_back(L"sort:none");
         break;
       case ui::AX_SORT_DIRECTION_ASCENDING:
         win_attributes_->ia2_attributes.push_back(L"sort:ascending");
         break;
       case ui::AX_SORT_DIRECTION_DESCENDING:
         win_attributes_->ia2_attributes.push_back(L"sort:descending");
         break;
       case ui::AX_SORT_DIRECTION_OTHER:
         win_attributes_->ia2_attributes.push_back(L"sort:other");
         break;
     }
   }
 
-  win_attributes_->name = GetOwner()->GetString16Attribute(ui::AX_ATTR_NAME);
+  win_attributes_->name = owner()->GetString16Attribute(ui::AX_ATTR_NAME);
   win_attributes_->description =
-      GetOwner()->GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
+      owner()->GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
   StringAttributeToIA2(ui::AX_ATTR_PLACEHOLDER, "placeholder");
 
-  base::string16 value = GetOwner()->GetValue();
+  base::string16 value = owner()->GetValue();
   // On Windows, the value of a document should be its url.
-  if (GetOwner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
-      GetOwner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
+  if (owner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+      owner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
     value = base::UTF8ToUTF16(Manager()->GetTreeData().url);
   }
   // If this doesn't have a value and is linked then set its value to the url
   // attribute. This allows screen readers to read an empty link's destination.
   if (value.empty() && (ia_state() & STATE_SYSTEM_LINKED))
-    value = GetOwner()->GetString16Attribute(ui::AX_ATTR_URL);
+    value = owner()->GetString16Attribute(ui::AX_ATTR_URL);
   win_attributes_->value = value;
 
   ClearOwnRelations();
   AddBidirectionalRelations(IA2_RELATION_CONTROLLER_FOR,
                             IA2_RELATION_CONTROLLED_BY,
                             ui::AX_ATTR_CONTROLS_IDS);
   AddBidirectionalRelations(IA2_RELATION_DESCRIBED_BY,
                             IA2_RELATION_DESCRIPTION_FOR,
                             ui::AX_ATTR_DESCRIBEDBY_IDS);
   AddBidirectionalRelations(IA2_RELATION_FLOWS_TO, IA2_RELATION_FLOWS_FROM,
                             ui::AX_ATTR_FLOWTO_IDS);
   AddBidirectionalRelations(IA2_RELATION_LABELLED_BY, IA2_RELATION_LABEL_FOR,
                             ui::AX_ATTR_LABELLEDBY_IDS);
   AddBidirectionalRelations(IA2_RELATION_DETAILS, IA2_RELATION_DETAILS_FOR,
                             ui::AX_ATTR_DETAILS_IDS);
 
   int member_of_id;
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_MEMBER_OF_ID, &member_of_id))
+  if (owner()->GetIntAttribute(ui::AX_ATTR_MEMBER_OF_ID, &member_of_id))
     AddRelation(IA2_RELATION_MEMBER_OF, member_of_id);
 
   int error_message_id;
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_ERRORMESSAGE_ID,
-                                  &error_message_id))
+  if (owner()->GetIntAttribute(ui::AX_ATTR_ERRORMESSAGE_ID, &error_message_id))
     AddRelation(IA2_RELATION_ERROR_MESSAGE, error_message_id);
 
   // Expose slider value.
   if (ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
       ia_role() == ROLE_SYSTEM_SCROLLBAR || ia_role() == ROLE_SYSTEM_SLIDER) {
     base::string16 value_text = GetValueText();
     SanitizeStringAttributeForIA2(value_text, &value_text);
     win_attributes_->ia2_attributes.push_back(L"valuetext:" + value_text);
   }
 
   UpdateRequiredAttributes();
   // If this is a web area for a presentational iframe, give it a role of
   // something other than DOCUMENT so that the fact that it's a separate doc
   // is not exposed to AT.
-  if (GetOwner()->IsWebAreaForPresentationalIframe()) {
+  if (owner()->IsWebAreaForPresentationalIframe()) {
     win_attributes_->ia_role = ROLE_SYSTEM_GROUPING;
     win_attributes_->ia2_role = ROLE_SYSTEM_GROUPING;
   }
 }
 
 void BrowserAccessibilityComWin::UpdateStep2ComputeHypertext() {
-  if (GetOwner()->IsSimpleTextControl()) {
+  if (owner()->IsSimpleTextControl()) {
     win_attributes_->hypertext = value();
     return;
   }
 
-  if (!GetOwner()->PlatformChildCount()) {
-    if (GetOwner()->IsRichTextControl()) {
+  if (!owner()->PlatformChildCount()) {
+    if (owner()->IsRichTextControl()) {
       // We don't want to expose any associated label in IA2 Hypertext.
       return;
     }
     win_attributes_->hypertext = name();
     return;
   }
 
   // Construct the hypertext for this node, which contains the concatenation
   // of all of the static text and widespace of this node's children and an
   // embedded object character for all the other children. Build up a map from
   // the character index of each embedded object character to the id of the
   // child object it points to.
-  for (unsigned int i = 0; i < GetOwner()->PlatformChildCount(); ++i) {
-    auto* child = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(i));
+  for (unsigned int i = 0; i < owner()->PlatformChildCount(); ++i) {
+    auto* child = ToBrowserAccessibilityComWin(owner()->PlatformGetChild(i));
     DCHECK(child);
     // Similar to Firefox, we don't expose text-only objects in IA2 hypertext.
-    if (child->GetOwner()->IsTextOnlyObject()) {
+    if (child->owner()->IsTextOnlyObject()) {
       win_attributes_->hypertext += child->name();
     } else {
-      int32_t char_offset = static_cast<int32_t>(GetOwner()->GetText().size());
-      int32_t child_unique_id = child->GetOwner()->unique_id();
+      int32_t char_offset = static_cast<int32_t>(owner()->GetText().size());
+      int32_t child_unique_id = child->owner()->unique_id();
       int32_t index = hyperlinks().size();
       win_attributes_->hyperlink_offset_to_index[char_offset] = index;
       win_attributes_->hyperlinks.push_back(child_unique_id);
       win_attributes_->hypertext += kEmbeddedCharacter;
     }
   }
 }
 
 void BrowserAccessibilityComWin::UpdateStep3FireEvents(
     bool is_subtree_creation) {
@@ skipping 13 matching lines @@
       FireNativeEvent(EVENT_OBJECT_VALUECHANGE);
     if (ia_state() != old_win_attributes_->ia_state)
       FireNativeEvent(EVENT_OBJECT_STATECHANGE);
 
     // Handle selection being added or removed.
     bool is_selected_now = (ia_state() & STATE_SYSTEM_SELECTED) != 0;
     bool was_selected_before =
         (old_win_attributes_->ia_state & STATE_SYSTEM_SELECTED) != 0;
     if (is_selected_now || was_selected_before) {
       bool multiselect = false;
-      if (GetOwner()->PlatformGetParent() &&
-          GetOwner()->PlatformGetParent()->HasState(
-              ui::AX_STATE_MULTISELECTABLE))
+      if (owner()->PlatformGetParent() &&
+          owner()->PlatformGetParent()->HasState(ui::AX_STATE_MULTISELECTABLE))
         multiselect = true;
 
       if (multiselect) {
         // In a multi-select box, fire SELECTIONADD and SELECTIONREMOVE events.
         if (is_selected_now && !was_selected_before) {
           FireNativeEvent(EVENT_OBJECT_SELECTIONADD);
         } else if (!is_selected_now && was_selected_before) {
           FireNativeEvent(EVENT_OBJECT_SELECTIONREMOVE);
         }
       } else if (is_selected_now && !was_selected_before) {
         // In a single-select box, only fire SELECTION events.
         FireNativeEvent(EVENT_OBJECT_SELECTION);
       }
     }
 
     // Fire an event if this container object has scrolled.
     int sx = 0;
     int sy = 0;
-    if (GetOwner()->GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
-        GetOwner()->GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
+    if (owner()->GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
+        owner()->GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
       if (sx != previous_scroll_x_ || sy != previous_scroll_y_)
         FireNativeEvent(EVENT_SYSTEM_SCROLLINGEND);
       previous_scroll_x_ = sx;
       previous_scroll_y_ = sy;
     }
 
     // Fire hypertext-related events.
     int start, old_len, new_len;
     ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
     if (old_len > 0) {
       // In-process screen readers may call IAccessibleText::get_oldText
       // in reaction to this event to retrieve the text that was removed.
       FireNativeEvent(IA2_EVENT_TEXT_REMOVED);
     }
     if (new_len > 0) {
       // In-process screen readers may call IAccessibleText::get_newText
       // in reaction to this event to retrieve the text that was inserted.
       FireNativeEvent(IA2_EVENT_TEXT_INSERTED);
     }
 
     // Changing a static text node can affect the IAccessibleText hypertext
     // of the parent node, so force an update on the parent.
     BrowserAccessibilityComWin* parent =
-        ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent());
-    if (parent && GetOwner()->IsTextOnlyObject() &&
+        ToBrowserAccessibilityComWin(owner()->PlatformGetParent());
+    if (parent && owner()->IsTextOnlyObject() &&
         name() != old_win_attributes_->name) {
-      parent->GetOwner()->UpdatePlatformAttributes();
+      parent->owner()->UpdatePlatformAttributes();
     }
   }
 
   old_win_attributes_.reset(nullptr);
 }
 
 BrowserAccessibilityManager* BrowserAccessibilityComWin::Manager() const {
-  auto* owner = GetOwner();
-  DCHECK(owner);
+  DCHECK(owner());
 
-  auto* manager = owner->manager();
+  auto* manager = owner()->manager();
   DCHECK(manager);
   return manager;
 }
 
 std::vector<base::string16> BrowserAccessibilityComWin::ComputeTextAttributes()
     const {
   std::vector<base::string16> attributes;
 
   // We include list markers for now, but there might be other objects that are
   // auto generated.
   // TODO(nektar): Compute what objects are auto-generated in Blink.
-  if (GetOwner()->GetRole() == ui::AX_ROLE_LIST_MARKER)
+  if (owner()->GetRole() == ui::AX_ROLE_LIST_MARKER)
     attributes.push_back(L"auto-generated:true");
   else
     attributes.push_back(L"auto-generated:false");
 
   int color;
   base::string16 color_value(L"transparent");
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_BACKGROUND_COLOR, &color)) {
+  if (owner()->GetIntAttribute(ui::AX_ATTR_BACKGROUND_COLOR, &color)) {
     unsigned int alpha = SkColorGetA(color);
     unsigned int red = SkColorGetR(color);
     unsigned int green = SkColorGetG(color);
     unsigned int blue = SkColorGetB(color);
     if (alpha) {
       color_value = L"rgb(" + base::UintToString16(red) + L',' +
                     base::UintToString16(green) + L',' +
                     base::UintToString16(blue) + L')';
     }
   }
   SanitizeStringAttributeForIA2(color_value, &color_value);
   attributes.push_back(L"background-color:" + color_value);
 
-  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_COLOR, &color)) {
+  if (owner()->GetIntAttribute(ui::AX_ATTR_COLOR, &color)) {
     unsigned int red = SkColorGetR(color);
     unsigned int green = SkColorGetG(color);
     unsigned int blue = SkColorGetB(color);
     color_value = L"rgb(" + base::UintToString16(red) + L',' +
                   base::UintToString16(green) + L',' +
                   base::UintToString16(blue) + L')';
   } else {
     color_value = L"rgb(0,0,0)";
   }
   SanitizeStringAttributeForIA2(color_value, &color_value);
   attributes.push_back(L"color:" + color_value);
 
   base::string16 font_family(
-      GetOwner()->GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY));
+      owner()->GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY));
   // Attribute has no default value.
   if (!font_family.empty()) {
     SanitizeStringAttributeForIA2(font_family, &font_family);
     attributes.push_back(L"font-family:" + font_family);
   }
 
   float font_size;
   // Attribute has no default value.
   if (GetFloatAttribute(ui::AX_ATTR_FONT_SIZE, &font_size)) {
     // The IA2 Spec requires the value to be in pt, not in pixels.
     // There are 72 points per inch.
     // We assume that there are 96 pixels per inch on a standard display.
     // TODO(nektar): Figure out the current value of pixels per inch.
     float points = font_size * 72.0 / 96.0;
     attributes.push_back(L"font-size:" +
                          base::UTF8ToUTF16(base::DoubleToString(points)) +
                          L"pt");
   }
 
   auto text_style = static_cast<ui::AXTextStyle>(
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_TEXT_STYLE));
+      owner()->GetIntAttribute(ui::AX_ATTR_TEXT_STYLE));
   if (text_style == ui::AX_TEXT_STYLE_NONE) {
     attributes.push_back(L"font-style:normal");
     attributes.push_back(L"font-weight:normal");
   } else {
     if (text_style & ui::AX_TEXT_STYLE_ITALIC) {
       attributes.push_back(L"font-style:italic");
     } else {
       attributes.push_back(L"font-style:normal");
     }
 
     if (text_style & ui::AX_TEXT_STYLE_BOLD) {
       attributes.push_back(L"font-weight:bold");
     } else {
       attributes.push_back(L"font-weight:normal");
     }
   }
 
   auto invalid_state = static_cast<ui::AXInvalidState>(
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE));
+      owner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE));
   switch (invalid_state) {
     case ui::AX_INVALID_STATE_NONE:
     case ui::AX_INVALID_STATE_FALSE:
       attributes.push_back(L"invalid:false");
       break;
     case ui::AX_INVALID_STATE_TRUE:
       attributes.push_back(L"invalid:true");
       break;
     case ui::AX_INVALID_STATE_SPELLING:
     case ui::AX_INVALID_STATE_GRAMMAR: {
       base::string16 spelling_grammar_value;
       if (invalid_state & ui::AX_INVALID_STATE_SPELLING)
         spelling_grammar_value = L"spelling";
       else if (invalid_state & ui::AX_INVALID_STATE_GRAMMAR)
         spelling_grammar_value = L"grammar";
       else
         spelling_grammar_value = L"spelling,grammar";
       attributes.push_back(L"invalid:" + spelling_grammar_value);
       break;
     }
     case ui::AX_INVALID_STATE_OTHER: {
       base::string16 aria_invalid_value;
-      if (GetOwner()->GetString16Attribute(ui::AX_ATTR_ARIA_INVALID_VALUE,
-                                           &aria_invalid_value)) {
+      if (owner()->GetString16Attribute(ui::AX_ATTR_ARIA_INVALID_VALUE,
+                                        &aria_invalid_value)) {
         SanitizeStringAttributeForIA2(aria_invalid_value, &aria_invalid_value);
         attributes.push_back(L"invalid:" + aria_invalid_value);
       } else {
         // Set the attribute to L"true", since we cannot be more specific.
         attributes.push_back(L"invalid:true");
       }
       break;
     }
   }
 
   base::string16 language(
-      GetOwner()->GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE));
+      owner()->GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE));
   // Default value should be L"en-US".
   if (language.empty()) {
     attributes.push_back(L"language:en-US");
   } else {
     SanitizeStringAttributeForIA2(language, &language);
     attributes.push_back(L"language:" + language);
   }
 
   // TODO(nektar): Add Blink support for the following attributes.
   // Currently set to their default values as dictated by the IA2 Spec.
@@ skipping 21 matching lines @@
     // TODO(nektar): Figure out a more specific value.
     attributes.push_back(L"text-underline-style:solid");
     attributes.push_back(L"text-underline-type:single");
   } else {
     attributes.push_back(L"text-underline-style:none");
     attributes.push_back(L"text-underline-type:none");
   }
   attributes.push_back(L"text-underline-width:auto");
 
   auto text_direction = static_cast<ui::AXTextDirection>(
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION));
+      owner()->GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION));
   switch (text_direction) {
     case ui::AX_TEXT_DIRECTION_NONE:
     case ui::AX_TEXT_DIRECTION_LTR:
       attributes.push_back(L"writing-mode:lr");
       break;
     case ui::AX_TEXT_DIRECTION_RTL:
       attributes.push_back(L"writing-mode:rl");
       break;
     case ui::AX_TEXT_DIRECTION_TTB:
       attributes.push_back(L"writing-mode:tb");
       break;
     case ui::AX_TEXT_DIRECTION_BTT:
       // Not listed in the IA2 Spec.
       attributes.push_back(L"writing-mode:bt");
       break;
   }
 
   return attributes;
 }
 
 BrowserAccessibilityComWin* BrowserAccessibilityComWin::NewReference() {
   AddRef();
   return this;
 }
 
 std::map<int, std::vector<base::string16>>
 BrowserAccessibilityComWin::GetSpellingAttributes() {
   std::map<int, std::vector<base::string16>> spelling_attributes;
-  if (GetOwner()->IsTextOnlyObject()) {
+  if (owner()->IsTextOnlyObject()) {
     const std::vector<int32_t>& marker_types =
-        GetOwner()->GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
+        owner()->GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
     const std::vector<int>& marker_starts =
-        GetOwner()->GetIntListAttribute(ui::AX_ATTR_MARKER_STARTS);
+        owner()->GetIntListAttribute(ui::AX_ATTR_MARKER_STARTS);
     const std::vector<int>& marker_ends =
-        GetOwner()->GetIntListAttribute(ui::AX_ATTR_MARKER_ENDS);
+        owner()->GetIntListAttribute(ui::AX_ATTR_MARKER_ENDS);
     for (size_t i = 0; i < marker_types.size(); ++i) {
       if (!(static_cast<ui::AXMarkerType>(marker_types[i]) &
             ui::AX_MARKER_TYPE_SPELLING))
         continue;
       int start_offset = marker_starts[i];
       int end_offset = marker_ends[i];
       std::vector<base::string16> start_attributes;
       start_attributes.push_back(L"invalid:spelling");
       std::vector<base::string16> end_attributes;
       end_attributes.push_back(L"invalid:false");
       spelling_attributes[start_offset] = start_attributes;
       spelling_attributes[end_offset] = end_attributes;
     }
   }
-  if (GetOwner()->IsSimpleTextControl()) {
+  if (owner()->IsSimpleTextControl()) {
     int start_offset = 0;
     for (BrowserAccessibility* static_text =
              BrowserAccessibilityManager::NextTextOnlyObject(
-                 GetOwner()->InternalGetChild(0));
+                 owner()->InternalGetChild(0));
          static_text; static_text = static_text->GetNextSibling()) {
       auto* text_win = ToBrowserAccessibilityComWin(static_text);
       if (text_win) {
         std::map<int, std::vector<base::string16>> text_spelling_attributes =
             text_win->GetSpellingAttributes();
         for (auto& attribute : text_spelling_attributes) {
           spelling_attributes[start_offset + attribute.first] =
               std::move(attribute.second);
         }
-        start_offset +=
-            static_cast<int>(text_win->GetOwner()->GetText().length());
+        start_offset += static_cast<int>(text_win->owner()->GetText().length());
       }
     }
   }
   return spelling_attributes;
 }
 
 BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetTargetFromChildID(
     const VARIANT& var_id) {
-  if (!GetOwner())
+  if (!owner())
     return nullptr;
 
   if (var_id.vt != VT_I4)
     return nullptr;
 
   LONG child_id = var_id.lVal;
   if (child_id == CHILDID_SELF)
     return this;
 
   if (child_id >= 1 &&
-      child_id <= static_cast<LONG>(GetOwner()->PlatformChildCount()))
+      child_id <= static_cast<LONG>(owner()->PlatformChildCount()))
     return ToBrowserAccessibilityComWin(
-        GetOwner()->PlatformGetChild(child_id - 1));
+        owner()->PlatformGetChild(child_id - 1));
 
   BrowserAccessibilityComWin* child = ToBrowserAccessibilityComWin(
       BrowserAccessibility::GetFromUniqueID(-child_id));
-  if (child && child->GetOwner()->IsDescendantOf(GetOwner()))
+  if (child && child->owner()->IsDescendantOf(owner()))
     return child;
 
   return nullptr;
 }
 
 HRESULT BrowserAccessibilityComWin::GetStringAttributeAsBstr(
     ui::AXStringAttribute attribute,
     BSTR* value_bstr) {
   base::string16 str;
-  if (!GetOwner())
+  if (!owner())
     return E_FAIL;
 
-  if (!GetOwner()->GetString16Attribute(attribute, &str))
+  if (!owner()->GetString16Attribute(attribute, &str))
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
 
 // Static
 void BrowserAccessibilityComWin::SanitizeStringAttributeForIA2(
@@ skipping 19 matching lines @@
   AXPlatformPositionInstance end_position =
       CreatePositionForSelectionAt(static_cast<int>(end_offset));
   Manager()->SetSelection(AXPlatformRange(start_position->AsTextPosition(),
                                           end_position->AsTextPosition()));
 }
 
 void BrowserAccessibilityComWin::StringAttributeToIA2(
     ui::AXStringAttribute attribute,
     const char* ia2_attr) {
   base::string16 value;
-  if (GetOwner()->GetString16Attribute(attribute, &value)) {
+  if (owner()->GetString16Attribute(attribute, &value)) {
     SanitizeStringAttributeForIA2(value, &value);
     win_attributes_->ia2_attributes.push_back(base::ASCIIToUTF16(ia2_attr) +
                                               L":" + value);
   }
 }
 
 void BrowserAccessibilityComWin::BoolAttributeToIA2(
     ui::AXBoolAttribute attribute,
     const char* ia2_attr) {
   bool value;
-  if (GetOwner()->GetBoolAttribute(attribute, &value)) {
+  if (owner()->GetBoolAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
         (base::ASCIIToUTF16(ia2_attr) + L":") + (value ? L"true" : L"false"));
   }
 }
 
 void BrowserAccessibilityComWin::IntAttributeToIA2(ui::AXIntAttribute attribute,
                                                    const char* ia2_attr) {
   int value;
-  if (GetOwner()->GetIntAttribute(attribute, &value)) {
+  if (owner()->GetIntAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
         base::ASCIIToUTF16(ia2_attr) + L":" + base::IntToString16(value));
   }
 }
 
 bool BrowserAccessibilityComWin::IsHyperlink() const {
   int32_t hyperlink_index = -1;
-  auto* parent = GetOwner()->PlatformGetParent();
+  auto* parent = owner()->PlatformGetParent();
   if (parent) {
     hyperlink_index =
         ToBrowserAccessibilityComWin(parent)->GetHyperlinkIndexFromChild(*this);
   }
 
   if (hyperlink_index >= 0)
     return true;
   return false;
 }
 
 BrowserAccessibilityComWin*
 BrowserAccessibilityComWin::GetHyperlinkFromHypertextOffset(int offset) const {
   std::map<int32_t, int32_t>::iterator iterator =
       hyperlink_offset_to_index().find(offset);
   if (iterator == hyperlink_offset_to_index().end())
     return nullptr;
 
   int32_t index = iterator->second;
   DCHECK_GE(index, 0);
   DCHECK_LT(index, static_cast<int32_t>(hyperlinks().size()));
   int32_t id = hyperlinks()[index];
   BrowserAccessibilityComWin* hyperlink =
-      ToBrowserAccessibilityComWin(GetOwner()->GetFromUniqueID(id));
+      ToBrowserAccessibilityComWin(owner()->GetFromUniqueID(id));
   if (!hyperlink)
     return nullptr;
   return hyperlink;
 }
 
 int32_t BrowserAccessibilityComWin::GetHyperlinkIndexFromChild(
     const BrowserAccessibilityComWin& child) const {
   if (hyperlinks().empty())
     return -1;
 
   auto iterator = std::find(hyperlinks().begin(), hyperlinks().end(),
-                            child.GetOwner()->unique_id());
+                            child.owner()->unique_id());
   if (iterator == hyperlinks().end())
     return -1;
 
   return static_cast<int32_t>(iterator - hyperlinks().begin());
 }
 
 int32_t BrowserAccessibilityComWin::GetHypertextOffsetFromHyperlinkIndex(
     int32_t hyperlink_index) const {
   for (auto& offset_index : hyperlink_offset_to_index()) {
     if (offset_index.second == hyperlink_index)
       return offset_index.first;
   }
 
   return -1;
 }
 
 int32_t BrowserAccessibilityComWin::GetHypertextOffsetFromChild(
     BrowserAccessibilityComWin& child) {
-  DCHECK(child.GetOwner()->PlatformGetParent() == GetOwner());
+  DCHECK(child.owner()->PlatformGetParent() == owner());
 
   // Handle the case when we are dealing with a direct text-only child.
   // (Note that this object might be a platform leaf, e.g. an ARIA searchbox,
-  // and so |GetOwner()->InternalChild...| functions need to be used. Also,
+  // and so |owner()->InternalChild...| functions need to be used. Also,
   // direct text-only children should not be present at tree roots and so no
   // cross-tree traversal is necessary.)
-  if (child.GetOwner()->IsTextOnlyObject()) {
+  if (child.owner()->IsTextOnlyObject()) {
     int32_t hypertextOffset = 0;
     int32_t index_in_parent = child.GetIndexInParent();
     DCHECK_GE(index_in_parent, 0);
     DCHECK_LT(index_in_parent,
-              static_cast<int32_t>(GetOwner()->InternalChildCount()));
+              static_cast<int32_t>(owner()->InternalChildCount()));
     for (uint32_t i = 0; i < static_cast<uint32_t>(index_in_parent); ++i) {
       const BrowserAccessibilityComWin* sibling =
-          ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i));
+          ToBrowserAccessibilityComWin(owner()->InternalGetChild(i));
       DCHECK(sibling);
-      if (sibling->GetOwner()->IsTextOnlyObject())
-        hypertextOffset += sibling->GetOwner()->GetText().size();
+      if (sibling->owner()->IsTextOnlyObject())
+        hypertextOffset += sibling->owner()->GetText().size();
       else
         ++hypertextOffset;
     }
     return hypertextOffset;
   }
 
   int32_t hyperlink_index = GetHyperlinkIndexFromChild(child);
   if (hyperlink_index < 0)
     return -1;
 
   return GetHypertextOffsetFromHyperlinkIndex(hyperlink_index);
 }
 
 int32_t BrowserAccessibilityComWin::GetHypertextOffsetFromDescendant(
     const BrowserAccessibilityComWin& descendant) const {
   auto* parent_object =
-      ToBrowserAccessibilityComWin(descendant.GetOwner()->PlatformGetParent());
+      ToBrowserAccessibilityComWin(descendant.owner()->PlatformGetParent());
   auto* current_object = const_cast<BrowserAccessibilityComWin*>(&descendant);
   while (parent_object && parent_object != this) {
     current_object = parent_object;
     parent_object = ToBrowserAccessibilityComWin(
-        current_object->GetOwner()->PlatformGetParent());
+        current_object->owner()->PlatformGetParent());
   }
   if (!parent_object)
     return -1;
 
   return parent_object->GetHypertextOffsetFromChild(*current_object);
 }
 
 int BrowserAccessibilityComWin::GetHypertextOffsetFromEndpoint(
     const BrowserAccessibilityComWin& endpoint_object,
     int endpoint_offset) const {
   // There are three cases:
   // 1. Either the selection endpoint is inside this object or is an ancestor of
   // of this object. endpoint_offset should be returned.
   // 2. The selection endpoint is a pure descendant of this object. The offset
   // of the character corresponding to the subtree in which the endpoint is
   // located should be returned.
   // 3. The selection endpoint is in a completely different part of the tree.
   // Either 0 or text_length should be returned depending on the direction that
   // one needs to travel to find the endpoint.
 
   // Case 1.
   //
   // IsDescendantOf includes the case when endpoint_object == this.
-  if (GetOwner()->IsDescendantOf(endpoint_object.GetOwner()))
+  if (owner()->IsDescendantOf(endpoint_object.owner()))
     return endpoint_offset;
 
-  const BrowserAccessibility* common_parent = GetOwner();
-  int32_t index_in_common_parent = GetOwner()->GetIndexInParent();
+  const BrowserAccessibility* common_parent = owner();
+  int32_t index_in_common_parent = owner()->GetIndexInParent();
   while (common_parent &&
-         !endpoint_object.GetOwner()->IsDescendantOf(common_parent)) {
+         !endpoint_object.owner()->IsDescendantOf(common_parent)) {
     index_in_common_parent = common_parent->GetIndexInParent();
     common_parent = common_parent->PlatformGetParent();
   }
   if (!common_parent)
     return -1;
 
   DCHECK_GE(index_in_common_parent, 0);
   DCHECK(!(common_parent->IsTextOnlyObject()));
 
   // Case 2.
   //
   // We already checked in case 1 if our endpoint is inside this object.
   // We can safely assume that it is a descendant or in a completely different
   // part of the tree.
-  if (common_parent == GetOwner()) {
+  if (common_parent == owner()) {
     int32_t hypertext_offset =
         GetHypertextOffsetFromDescendant(endpoint_object);
-    if (endpoint_object.GetOwner()->PlatformGetParent() == GetOwner() &&
-        endpoint_object.GetOwner()->IsTextOnlyObject()) {
+    if (endpoint_object.owner()->PlatformGetParent() == owner() &&
+        endpoint_object.owner()->IsTextOnlyObject()) {
       hypertext_offset += endpoint_offset;
     }
 
     return hypertext_offset;
   }
 
   // Case 3.
   //
   // We can safely assume that the endpoint is in another part of the tree or
   // at common parent, and that this object is a descendant of common parent.
   int32_t endpoint_index_in_common_parent = -1;
   for (uint32_t i = 0; i < common_parent->InternalChildCount(); ++i) {
     const BrowserAccessibility* child = common_parent->InternalGetChild(i);
     DCHECK(child);
-    if (endpoint_object.GetOwner()->IsDescendantOf(child)) {
+    if (endpoint_object.owner()->IsDescendantOf(child)) {
       endpoint_index_in_common_parent = child->GetIndexInParent();
       break;
     }
   }
   DCHECK_GE(endpoint_index_in_common_parent, 0);
 
   if (endpoint_index_in_common_parent < index_in_common_parent)
     return 0;
   if (endpoint_index_in_common_parent > index_in_common_parent)
-    return GetOwner()->GetText().size();
+    return owner()->GetText().size();
 
   NOTREACHED();
   return -1;
 }
 
 int BrowserAccessibilityComWin::GetSelectionAnchor() const {
   int32_t anchor_id = Manager()->GetTreeData().sel_anchor_object_id;
   const BrowserAccessibilityComWin* anchor_object = GetFromID(anchor_id);
   if (!anchor_object)
     return -1;
 
   int anchor_offset = Manager()->GetTreeData().sel_anchor_offset;
   return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
 int BrowserAccessibilityComWin::GetSelectionFocus() const {
   int32_t focus_id = Manager()->GetTreeData().sel_focus_object_id;
   const BrowserAccessibilityComWin* focus_object = GetFromID(focus_id);
   if (!focus_object)
     return -1;
 
   int focus_offset = Manager()->GetTreeData().sel_focus_offset;
   return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
 void BrowserAccessibilityComWin::GetSelectionOffsets(int* selection_start,
                                                      int* selection_end) const {
   DCHECK(selection_start && selection_end);
 
-  if (GetOwner()->IsSimpleTextControl() &&
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
-                                  selection_start) &&
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, selection_end)) {
+  if (owner()->IsSimpleTextControl() &&
+      owner()->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START, selection_start) &&
+      owner()->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, selection_end)) {
     return;
   }
 
   *selection_start = GetSelectionAnchor();
   *selection_end = GetSelectionFocus();
   if (*selection_start < 0 || *selection_end < 0)
     return;
 
   // There are three cases when a selection would start and end on the same
   // character:
   // 1. Anchor and focus are both in a subtree that is to the right of this
   // object.
   // 2. Anchor and focus are both in a subtree that is to the left of this
   // object.
   // 3. Anchor and focus are in a subtree represented by a single embedded
   // object character.
   // Only case 3 refers to a valid selection because cases 1 and 2 fall
   // outside this object in their entirety.
   // Selections that span more than one character are by definition inside this
   // object, so checking them is not necessary.
-  if (*selection_start == *selection_end && !GetOwner()->HasCaret()) {
+  if (*selection_start == *selection_end && !owner()->HasCaret()) {
     *selection_start = -1;
     *selection_end = -1;
     return;
   }
 
   // The IA2 Spec says that if the largest of the two offsets falls on an
   // embedded object character and if there is a selection in that embedded
   // object, it should be incremented by one so that it points after the
   // embedded object character.
   // This is a signal to AT software that the embedded object is also part of
@@ skipping 66 matching lines @@
     int* start,
     int* old_len,
     int* new_len) {
   CHECK(old_win_attributes_);
 
   *start = 0;
   *old_len = 0;
   *new_len = 0;
 
   const base::string16& old_text = old_win_attributes_->hypertext;
-  const base::string16& new_text = GetOwner()->GetText();
+  const base::string16& new_text = owner()->GetText();
 
   size_t common_prefix = 0;
   while (common_prefix < old_text.size() && common_prefix < new_text.size() &&
          IsSameHypertextCharacter(common_prefix, common_prefix)) {
     ++common_prefix;
   }
 
   size_t common_suffix = 0;
   while (common_prefix + common_suffix < old_text.size() &&
          common_prefix + common_suffix < new_text.size() &&
          IsSameHypertextCharacter(old_text.size() - common_suffix - 1,
                                   new_text.size() - common_suffix - 1)) {
     ++common_suffix;
   }
 
   *start = common_prefix;
   *old_len = old_text.size() - common_prefix - common_suffix;
   *new_len = new_text.size() - common_prefix - common_suffix;
 }
 
 void BrowserAccessibilityComWin::HandleSpecialTextOffset(LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH) {
-    *offset = static_cast<LONG>(GetOwner()->GetText().length());
+    *offset = static_cast<LONG>(owner()->GetText().length());
   } else if (*offset == IA2_TEXT_OFFSET_CARET) {
     // We shouldn't call |get_caretOffset| here as it affects UMA counts.
     int selection_start, selection_end;
     GetSelectionOffsets(&selection_start, &selection_end);
     *offset = selection_end;
   }
 }
 
 ui::TextBoundaryType BrowserAccessibilityComWin::IA2TextBoundaryToTextBoundary(
     IA2TextBoundaryType ia2_boundary) {
@@ skipping 24 matching lines @@
   // affinity, otherwise default to downstream affinity.
   ui::AXTextAffinity affinity =
       start_offset == IA2_TEXT_OFFSET_CARET
           ? Manager()->GetTreeData().sel_focus_affinity
           : ui::AX_TEXT_AFFINITY_DOWNSTREAM;
 
   HandleSpecialTextOffset(&start_offset);
   if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD) {
     switch (direction) {
       case ui::FORWARDS_DIRECTION: {
-        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
-            static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position =
+            owner()->CreatePositionAt(static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance next_word =
             position->CreateNextWordStartPosition();
-        if (next_word->anchor_id() != GetOwner()->GetId())
+        if (next_word->anchor_id() != owner()->GetId())
           next_word = position->CreatePositionAtEndOfAnchor();
         return next_word->text_offset();
       }
       case ui::BACKWARDS_DIRECTION: {
-        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
-            static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position =
+            owner()->CreatePositionAt(static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance previous_word;
         if (!position->AtStartOfWord()) {
           previous_word = position->CreatePreviousWordStartPosition();
-          if (previous_word->anchor_id() != GetOwner()->GetId())
+          if (previous_word->anchor_id() != owner()->GetId())
             previous_word = position->CreatePositionAtStartOfAnchor();
         } else {
           previous_word = std::move(position);
         }
         return previous_word->text_offset();
       }
     }
   }
 
   if (ia2_boundary == IA2_TEXT_BOUNDARY_LINE) {
     switch (direction) {
       case ui::FORWARDS_DIRECTION: {
-        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
-            static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position =
+            owner()->CreatePositionAt(static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance next_line =
             position->CreateNextLineStartPosition();
-        if (next_line->anchor_id() != GetOwner()->GetId())
+        if (next_line->anchor_id() != owner()->GetId())
           next_line = position->CreatePositionAtEndOfAnchor();
         return next_line->text_offset();
       }
       case ui::BACKWARDS_DIRECTION: {
-        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
-            static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position =
+            owner()->CreatePositionAt(static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance previous_line;
         if (!position->AtStartOfLine()) {
           previous_line = position->CreatePreviousLineStartPosition();
-          if (previous_line->anchor_id() != GetOwner()->GetId())
+          if (previous_line->anchor_id() != owner()->GetId())
             previous_line = position->CreatePositionAtStartOfAnchor();
         } else {
           previous_line = std::move(position);
         }
         return previous_line->text_offset();
       }
     }
   }
 
   // TODO(nektar): |AXPosition| can handle other types of boundaries as well.
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
-  return ui::FindAccessibleTextBoundary(text, GetOwner()->GetLineStartOffsets(),
+  return ui::FindAccessibleTextBoundary(text, owner()->GetLineStartOffsets(),
                                         boundary, start_offset, direction,
                                         affinity);
 }
 
 LONG BrowserAccessibilityComWin::FindStartOfStyle(
     LONG start_offset,
     ui::TextBoundaryDirection direction) const {
-  LONG text_length = static_cast<LONG>(GetOwner()->GetText().length());
+  LONG text_length = static_cast<LONG>(owner()->GetText().length());
   DCHECK_GE(start_offset, 0);
   DCHECK_LE(start_offset, text_length);
 
   switch (direction) {
     case ui::BACKWARDS_DIRECTION: {
       if (offset_to_text_attributes().empty())
         return 0;
 
       auto iterator = offset_to_text_attributes().upper_bound(start_offset);
       --iterator;
       return static_cast<LONG>(iterator->first);
     }
     case ui::FORWARDS_DIRECTION: {
       const auto iterator =
           offset_to_text_attributes().upper_bound(start_offset);
       if (iterator == offset_to_text_attributes().end())
         return text_length;
       return static_cast<LONG>(iterator->first);
     }
   }
 
   NOTREACHED();
   return start_offset;
 }
 
 BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetFromID(
     int32_t id) const {
-  if (!GetOwner())
+  if (!owner())
     return nullptr;
   return ToBrowserAccessibilityComWin(Manager()->GetFromID(id));
 }
 
 bool BrowserAccessibilityComWin::IsListBoxOptionOrMenuListOption() {
-  if (!GetOwner()->PlatformGetParent())
+  if (!owner()->PlatformGetParent())
     return false;
 
-  int32_t role = GetOwner()->GetRole();
-  int32_t parent_role = GetOwner()->PlatformGetParent()->GetRole();
+  int32_t role = owner()->GetRole();
+  int32_t parent_role = owner()->PlatformGetParent()->GetRole();
 
   if (role == ui::AX_ROLE_LIST_BOX_OPTION &&
       parent_role == ui::AX_ROLE_LIST_BOX) {
     return true;
   }
 
   if (role == ui::AX_ROLE_MENU_LIST_OPTION &&
       parent_role == ui::AX_ROLE_MENU_LIST_POPUP) {
     return true;
   }
 
   return false;
 }
 
 void BrowserAccessibilityComWin::AddRelation(
     const base::string16& relation_type,
     int target_id) {
   // Reflexive relations don't need to be exposed through IA2.
-  if (target_id == GetOwner()->GetId())
+  if (target_id == owner()->GetId())
     return;
 
   CComObject<BrowserAccessibilityRelation>* relation;
   HRESULT hr =
       CComObject<BrowserAccessibilityRelation>::CreateInstance(&relation);
   DCHECK(SUCCEEDED(hr));
   relation->AddRef();
   relation->Initialize(this, relation_type);
   relation->AddTarget(target_id);
   relations_.push_back(relation);
 }
 
 void BrowserAccessibilityComWin::AddBidirectionalRelations(
     const base::string16& relation_type,
     const base::string16& reverse_relation_type,
     ui::AXIntListAttribute attribute) {
-  if (!GetOwner()->HasIntListAttribute(attribute))
+  if (!owner()->HasIntListAttribute(attribute))
     return;
 
   const std::vector<int32_t>& target_ids =
-      GetOwner()->GetIntListAttribute(attribute);
+      owner()->GetIntListAttribute(attribute);
   // Reflexive relations don't need to be exposed through IA2.
   std::vector<int32_t> filtered_target_ids;
-  int32_t current_id = GetOwner()->GetId();
+  int32_t current_id = owner()->GetId();
   std::copy_if(target_ids.begin(), target_ids.end(),
                std::back_inserter(filtered_target_ids),
                [current_id](int32_t id) { return id != current_id; });
   if (filtered_target_ids.empty())
     return;
 
   CComObject<BrowserAccessibilityRelation>* relation;
   HRESULT hr =
       CComObject<BrowserAccessibilityRelation>::CreateInstance(&relation);
   DCHECK(SUCCEEDED(hr));
   relation->AddRef();
   relation->Initialize(this, relation_type);
 
   for (int target_id : filtered_target_ids) {
     BrowserAccessibilityComWin* target =
         GetFromID(static_cast<int32_t>(target_id));
-    if (!target || !target->GetOwner())
+    if (!target || !target->owner())
       continue;
     relation->AddTarget(target_id);
-    target->AddRelation(reverse_relation_type, GetOwner()->GetId());
+    target->AddRelation(reverse_relation_type, owner()->GetId());
   }
 
   relations_.push_back(relation);
 }
 
 // Clears all the forward relations from this object to any other object and the
 // associated  reverse relations on the other objects, but leaves any reverse
 // relations on this object alone.
 void BrowserAccessibilityComWin::ClearOwnRelations() {
   RemoveBidirectionalRelationsOfType(IA2_RELATION_CONTROLLER_FOR,
@@ skipping 20 matching lines @@
 void BrowserAccessibilityComWin::RemoveBidirectionalRelationsOfType(
     const base::string16& relation_type,
     const base::string16& reverse_relation_type) {
   for (auto iter = relations_.begin(); iter != relations_.end();) {
     BrowserAccessibilityRelation* relation = *iter;
     DCHECK(relation);
     if (relation->get_type() == relation_type) {
       for (int target_id : relation->get_target_ids()) {
         BrowserAccessibilityComWin* target =
             GetFromID(static_cast<int32_t>(target_id));
-        if (!target || !target->GetOwner())
+        if (!target || !target->owner())
           continue;
         DCHECK_NE(target, this);
         target->RemoveTargetFromRelation(reverse_relation_type,
-                                         GetOwner()->GetId());
+                                         owner()->GetId());
       }
       iter = relations_.erase(iter);
       relation->Release();
     } else {
       ++iter;
     }
   }
 }
 
 void BrowserAccessibilityComWin::RemoveTargetFromRelation(
     const base::string16& relation_type,
     int target_id) {
   for (auto iter = relations_.begin(); iter != relations_.end();) {
     BrowserAccessibilityRelation* relation = *iter;
     DCHECK(relation);
     if (relation->get_type() == relation_type) {
       // If |target_id| is not present, |RemoveTarget| will do nothing.
       relation->RemoveTarget(target_id);
     }
     if (relation->get_target_ids().empty()) {
       iter = relations_.erase(iter);
       relation->Release();
     } else {
       ++iter;
     }
   }
 }
 
 void BrowserAccessibilityComWin::UpdateRequiredAttributes() {
-  if (GetOwner()->IsCellOrTableHeaderRole()) {
+  if (owner()->IsCellOrTableHeaderRole()) {
     // Expose colspan attribute.
     base::string16 colspan;
-    if (GetOwner()->GetHtmlAttribute("aria-colspan", &colspan)) {
+    if (owner()->GetHtmlAttribute("aria-colspan", &colspan)) {
       SanitizeStringAttributeForIA2(colspan, &colspan);
       win_attributes_->ia2_attributes.push_back(L"colspan:" + colspan);
     }
     // Expose rowspan attribute.
     base::string16 rowspan;
-    if (GetOwner()->GetHtmlAttribute("aria-rowspan", &rowspan)) {
+    if (owner()->GetHtmlAttribute("aria-rowspan", &rowspan)) {
       SanitizeStringAttributeForIA2(rowspan, &rowspan);
       win_attributes_->ia2_attributes.push_back(L"rowspan:" + rowspan);
     }
   }
 
   // Expose dropeffect attribute.
   base::string16 drop_effect;
-  if (GetOwner()->GetHtmlAttribute("aria-dropeffect", &drop_effect)) {
+  if (owner()->GetHtmlAttribute("aria-dropeffect", &drop_effect)) {
     SanitizeStringAttributeForIA2(drop_effect, &drop_effect);
     win_attributes_->ia2_attributes.push_back(L"dropeffect:" + drop_effect);
   }
 
   // Expose grabbed attribute.
   base::string16 grabbed;
-  if (GetOwner()->GetHtmlAttribute("aria-grabbed", &grabbed)) {
+  if (owner()->GetHtmlAttribute("aria-grabbed", &grabbed)) {
     SanitizeStringAttributeForIA2(grabbed, &grabbed);
     win_attributes_->ia2_attributes.push_back(L"grabbed:" + grabbed);
   }
 
   // Expose class attribute.
   base::string16 class_attr;
-  if (GetOwner()->GetHtmlAttribute("class", &class_attr)) {
+  if (owner()->GetHtmlAttribute("class", &class_attr)) {
     SanitizeStringAttributeForIA2(class_attr, &class_attr);
     win_attributes_->ia2_attributes.push_back(L"class:" + class_attr);
   }
 
   // Expose datetime attribute.
   base::string16 datetime;
-  if (GetOwner()->GetRole() == ui::AX_ROLE_TIME &&
-      GetOwner()->GetHtmlAttribute("datetime", &datetime)) {
+  if (owner()->GetRole() == ui::AX_ROLE_TIME &&
+      owner()->GetHtmlAttribute("datetime", &datetime)) {
     SanitizeStringAttributeForIA2(datetime, &datetime);
     win_attributes_->ia2_attributes.push_back(L"datetime:" + datetime);
   }
 
   // Expose id attribute.
   base::string16 id;
-  if (GetOwner()->GetHtmlAttribute("id", &id)) {
+  if (owner()->GetHtmlAttribute("id", &id)) {
     SanitizeStringAttributeForIA2(id, &id);
     win_attributes_->ia2_attributes.push_back(L"id:" + id);
   }
 
   // Expose src attribute.
   base::string16 src;
-  if (GetOwner()->GetRole() == ui::AX_ROLE_IMAGE &&
-      GetOwner()->GetHtmlAttribute("src", &src)) {
+  if (owner()->GetRole() == ui::AX_ROLE_IMAGE &&
+      owner()->GetHtmlAttribute("src", &src)) {
     SanitizeStringAttributeForIA2(src, &src);
     win_attributes_->ia2_attributes.push_back(L"src:" + src);
   }
 
   // Expose input-text type attribute.
   base::string16 type;
-  base::string16 html_tag =
-      GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
-  if (GetOwner()->IsSimpleTextControl() && html_tag == L"input" &&
-      GetOwner()->GetHtmlAttribute("type", &type)) {
+  base::string16 html_tag = owner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
+  if (owner()->IsSimpleTextControl() && html_tag == L"input" &&
+      owner()->GetHtmlAttribute("type", &type)) {
     SanitizeStringAttributeForIA2(type, &type);
     win_attributes_->ia2_attributes.push_back(L"text-input-type:" + type);
   }
 }
 
 void BrowserAccessibilityComWin::FireNativeEvent(LONG win_event_type) const {
   (new BrowserAccessibilityEventWin(BrowserAccessibilityEvent::FromTreeChange,
-                                    ui::AX_EVENT_NONE, win_event_type,
-                                    GetOwner()))
+                                    ui::AX_EVENT_NONE, win_event_type, owner()))
       ->Fire();
 }
 
 void BrowserAccessibilityComWin::InitRoleAndState() {
   int32_t ia_role = 0;
   int32_t ia_state = 0;
   base::string16 role_name;
   int32_t ia2_role = 0;
   int32_t ia2_state = IA2_STATE_OPAQUE;
 
-  if (GetOwner()->HasState(ui::AX_STATE_BUSY))
+  if (owner()->HasState(ui::AX_STATE_BUSY))
     ia_state |= STATE_SYSTEM_BUSY;
 
   const auto checked_state = static_cast<ui::AXCheckedState>(
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_CHECKED_STATE));
+      owner()->GetIntAttribute(ui::AX_ATTR_CHECKED_STATE));
   switch (checked_state) {
     case ui::AX_CHECKED_STATE_TRUE:
       ia_state |= STATE_SYSTEM_CHECKED;
       break;
     case ui::AX_CHECKED_STATE_MIXED:
       ia_state |= STATE_SYSTEM_MIXED;
       break;
     default:
       break;
   }
 
-  if (GetOwner()->HasState(ui::AX_STATE_COLLAPSED))
+  if (owner()->HasState(ui::AX_STATE_COLLAPSED))
     ia_state |= STATE_SYSTEM_COLLAPSED;
-  if (GetOwner()->HasState(ui::AX_STATE_EXPANDED))
+  if (owner()->HasState(ui::AX_STATE_EXPANDED))
     ia_state |= STATE_SYSTEM_EXPANDED;
-  if (GetOwner()->HasState(ui::AX_STATE_FOCUSABLE))
+  if (owner()->HasState(ui::AX_STATE_FOCUSABLE))
     ia_state |= STATE_SYSTEM_FOCUSABLE;
-  if (GetOwner()->HasState(ui::AX_STATE_HASPOPUP))
+  if (owner()->HasState(ui::AX_STATE_HASPOPUP))
     ia_state |= STATE_SYSTEM_HASPOPUP;
-  if (GetOwner()->HasIntAttribute(ui::AX_ATTR_INVALID_STATE) &&
-      GetOwner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE) !=
+  if (owner()->HasIntAttribute(ui::AX_ATTR_INVALID_STATE) &&
+      owner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE) !=
           ui::AX_INVALID_STATE_FALSE)
     ia2_state |= IA2_STATE_INVALID_ENTRY;
-  if (GetOwner()->HasState(ui::AX_STATE_INVISIBLE))
+  if (owner()->HasState(ui::AX_STATE_INVISIBLE))
     ia_state |= STATE_SYSTEM_INVISIBLE;
-  if (GetOwner()->HasState(ui::AX_STATE_LINKED))
+  if (owner()->HasState(ui::AX_STATE_LINKED))
     ia_state |= STATE_SYSTEM_LINKED;
-  if (GetOwner()->HasState(ui::AX_STATE_MULTISELECTABLE)) {
+  if (owner()->HasState(ui::AX_STATE_MULTISELECTABLE)) {
     ia_state |= STATE_SYSTEM_EXTSELECTABLE;
     ia_state |= STATE_SYSTEM_MULTISELECTABLE;
   }
   // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
-  if (GetOwner()->HasState(ui::AX_STATE_OFFSCREEN))
+  if (owner()->HasState(ui::AX_STATE_OFFSCREEN))
     ia_state |= STATE_SYSTEM_OFFSCREEN;
-  if (GetOwner()->HasState(ui::AX_STATE_PRESSED))
+  if (owner()->HasState(ui::AX_STATE_PRESSED))
     ia_state |= STATE_SYSTEM_PRESSED;
-  if (GetOwner()->HasState(ui::AX_STATE_PROTECTED))
+  if (owner()->HasState(ui::AX_STATE_PROTECTED))
     ia_state |= STATE_SYSTEM_PROTECTED;
-  if (GetOwner()->HasState(ui::AX_STATE_REQUIRED))
+  if (owner()->HasState(ui::AX_STATE_REQUIRED))
     ia2_state |= IA2_STATE_REQUIRED;
-  if (GetOwner()->HasState(ui::AX_STATE_SELECTABLE))
+  if (owner()->HasState(ui::AX_STATE_SELECTABLE))
     ia_state |= STATE_SYSTEM_SELECTABLE;
-  if (GetOwner()->HasState(ui::AX_STATE_SELECTED))
+  if (owner()->HasState(ui::AX_STATE_SELECTED))
     ia_state |= STATE_SYSTEM_SELECTED;
-  if (GetOwner()->HasState(ui::AX_STATE_VISITED))
+  if (owner()->HasState(ui::AX_STATE_VISITED))
     ia_state |= STATE_SYSTEM_TRAVERSED;
-  if (GetOwner()->HasState(ui::AX_STATE_DISABLED))
+  if (owner()->HasState(ui::AX_STATE_DISABLED))
     ia_state |= STATE_SYSTEM_UNAVAILABLE;
-  if (GetOwner()->HasState(ui::AX_STATE_VERTICAL))
+  if (owner()->HasState(ui::AX_STATE_VERTICAL))
     ia2_state |= IA2_STATE_VERTICAL;
-  if (GetOwner()->HasState(ui::AX_STATE_HORIZONTAL))
+  if (owner()->HasState(ui::AX_STATE_HORIZONTAL))
     ia2_state |= IA2_STATE_HORIZONTAL;
-  if (GetOwner()->HasState(ui::AX_STATE_VISITED))
+  if (owner()->HasState(ui::AX_STATE_VISITED))
     ia_state |= STATE_SYSTEM_TRAVERSED;
 
   // Expose whether or not the mouse is over an element, but suppress
   // this for tests because it can make the test results flaky depending
   // on the position of the mouse.
   BrowserAccessibilityStateImpl* accessibility_state =
       BrowserAccessibilityStateImpl::GetInstance();
   if (!accessibility_state->disable_hot_tracking_for_testing()) {
-    if (GetOwner()->HasState(ui::AX_STATE_HOVERED))
+    if (owner()->HasState(ui::AX_STATE_HOVERED))
       ia_state |= STATE_SYSTEM_HOTTRACKED;
   }
 
-  if (GetOwner()->HasState(ui::AX_STATE_EDITABLE))
+  if (owner()->HasState(ui::AX_STATE_EDITABLE))
     ia2_state |= IA2_STATE_EDITABLE;
 
-  if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
+  if (owner()->GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
     ia2_state |= IA2_STATE_EDITABLE;
 
-  if (!GetOwner()->GetStringAttribute(ui::AX_ATTR_AUTO_COMPLETE).empty())
+  if (!owner()->GetStringAttribute(ui::AX_ATTR_AUTO_COMPLETE).empty())
     ia2_state |= IA2_STATE_SUPPORTS_AUTOCOMPLETION;
 
-  if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_MODAL))
+  if (owner()->GetBoolAttribute(ui::AX_ATTR_MODAL))
     ia2_state |= IA2_STATE_MODAL;
 
-  base::string16 html_tag =
-      GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
-  switch (GetOwner()->GetRole()) {
+  base::string16 html_tag = owner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
+  switch (owner()->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_ANCHOR:
       ia_role = ROLE_SYSTEM_LINK;
       break;
     case ui::AX_ROLE_APPLICATION:
@@ skipping 15 matching lines @@
       ia2_role = IA2_ROLE_SECTION;
       break;
     case ui::AX_ROLE_BUSY_INDICATOR:
       ia_role = ROLE_SYSTEM_ANIMATION;
       ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_BUTTON:
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       break;
     case ui::AX_ROLE_CANVAS:
-      if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
+      if (owner()->GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
         role_name = L"canvas";
         ia2_role = IA2_ROLE_CANVAS;
       } else {
         ia_role = ROLE_SYSTEM_GRAPHIC;
       }
       break;
     case ui::AX_ROLE_CAPTION:
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_CAPTION;
       break;
@@ skipping 65 matching lines @@
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       break;
     case ui::AX_ROLE_DOCUMENT:
     case ui::AX_ROLE_ROOT_WEB_AREA:
     case ui::AX_ROLE_WEB_AREA:
       ia_role = ROLE_SYSTEM_DOCUMENT;
       ia_state |= STATE_SYSTEM_READONLY;
       ia_state |= STATE_SYSTEM_FOCUSABLE;
       break;
     case ui::AX_ROLE_EMBEDDED_OBJECT:
-      if (GetOwner()->PlatformChildCount()) {
+      if (owner()->PlatformChildCount()) {
         // Windows screen readers assume that IA2_ROLE_EMBEDDED_OBJECT
         // doesn't have any children, but it may be something like a
         // browser plugin that has a document inside.
         ia_role = ROLE_SYSTEM_GROUPING;
       } else {
         ia_role = ROLE_SYSTEM_CLIENT;
         ia2_role = IA2_ROLE_EMBEDDED_OBJECT;
       }
       break;
     case ui::AX_ROLE_FIGCAPTION:
@@ skipping 16 matching lines @@
       break;
     case ui::AX_ROLE_GRID:
       ia_role = ROLE_SYSTEM_TABLE;
       // TODO(aleventhal) this changed between ARIA 1.0 and 1.1,
       // need to determine whether grids/treegrids should really be readonly
       // or editable by default
       // ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_GROUP: {
       base::string16 aria_role =
-          GetOwner()->GetString16Attribute(ui::AX_ATTR_ROLE);
+          owner()->GetString16Attribute(ui::AX_ATTR_ROLE);
       if (aria_role == L"group" || html_tag == L"fieldset") {
         ia_role = ROLE_SYSTEM_GROUPING;
       } else if (html_tag == L"li") {
         ia_role = ROLE_SYSTEM_LISTITEM;
         ia_state |= STATE_SYSTEM_READONLY;
       } else {
         if (html_tag.empty())
           role_name = L"div";
         else
           role_name = html_tag;
@@ skipping 149 matching lines @@
         ia_role = ROLE_SYSTEM_GROUPING;
         ia2_role = IA2_ROLE_SECTION;
       } else {
         ia_role = ROLE_SYSTEM_PANE;
       }
       break;
     case ui::AX_ROLE_ROW: {
       // Role changes depending on whether row is inside a treegrid
       // https://www.w3.org/TR/core-aam-1.1/#role-map-row
       ia_role =
-          IsInTreeGrid(GetOwner()) ? ROLE_SYSTEM_OUTLINEITEM : ROLE_SYSTEM_ROW;
+          IsInTreeGrid(owner()) ? ROLE_SYSTEM_OUTLINEITEM : ROLE_SYSTEM_ROW;
       break;
     }
     case ui::AX_ROLE_ROW_HEADER:
       ia_role = ROLE_SYSTEM_ROWHEADER;
       break;
     case ui::AX_ROLE_RUBY:
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_TEXT_FRAME;
       break;
     case ui::AX_ROLE_RULER:
@@ skipping 62 matching lines @@
       ia_role = ROLE_SYSTEM_LISTITEM;
       ia_state |= STATE_SYSTEM_READONLY;
       break;
     case ui::AX_ROLE_TOGGLE_BUTTON:
       ia_role = ROLE_SYSTEM_PUSHBUTTON;
       ia2_role = IA2_ROLE_TOGGLE_BUTTON;
       break;
     case ui::AX_ROLE_TEXT_FIELD:
     case ui::AX_ROLE_SEARCH_BOX:
       ia_role = ROLE_SYSTEM_TEXT;
-      if (GetOwner()->HasState(ui::AX_STATE_MULTILINE)) {
+      if (owner()->HasState(ui::AX_STATE_MULTILINE)) {
         ia2_state |= IA2_STATE_MULTI_LINE;
       } else {
         ia2_state |= IA2_STATE_SINGLE_LINE;
       }
-      if (GetOwner()->HasState(ui::AX_STATE_READ_ONLY))
+      if (owner()->HasState(ui::AX_STATE_READ_ONLY))
         ia_state |= STATE_SYSTEM_READONLY;
       ia2_state |= IA2_STATE_SELECTABLE_TEXT;
       break;
     case ui::AX_ROLE_ABBR:
     case ui::AX_ROLE_TIME:
       role_name = html_tag;
       ia_role = ROLE_SYSTEM_TEXT;
       ia2_role = IA2_ROLE_TEXT_FRAME;
       break;
     case ui::AX_ROLE_TIMER:
@@ skipping 38 matching lines @@
       ia_role = ROLE_SYSTEM_CLIENT;
       break;
   }
 
   // Compute the final value of READONLY for MSAA.
   //
   // We always set the READONLY state for elements that have the
   // aria-readonly attribute and for a few roles (in the switch above),
   // including read-only text fields.
   // The majority of focusable controls should not have the read-only state set.
-  if (GetOwner()->HasState(ui::AX_STATE_FOCUSABLE) &&
+  if (owner()->HasState(ui::AX_STATE_FOCUSABLE) &&
       ia_role != ROLE_SYSTEM_DOCUMENT && ia_role != ROLE_SYSTEM_TEXT) {
     ia_state &= ~(STATE_SYSTEM_READONLY);
   }
-  if (!GetOwner()->HasState(ui::AX_STATE_READ_ONLY))
+  if (!owner()->HasState(ui::AX_STATE_READ_ONLY))
     ia_state &= ~(STATE_SYSTEM_READONLY);
-  if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
+  if (owner()->GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
     ia_state |= STATE_SYSTEM_READONLY;
 
   // 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;
 
@@ skipping 21 matching lines @@
 
 BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
     BrowserAccessibility* obj) {
   if (!obj || !obj->IsNative())
     return nullptr;
   auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
   return result;
 }
 
 }  // namespace content