Split out the MSCOM pieces of BrowserAccessibilityWin into a seperate class.

content/browser/accessibility/browser_accessibility_com_win.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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_win.h"
+#include "content/browser/accessibility/browser_accessibility_com_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/enum_variant.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_event_win.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
+#include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/accessibility_mode.h"
 #include "content/public/common/content_client.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_text_utils.h"
 #include "ui/base/win/accessibility_ids_win.h"
 #include "ui/base/win/accessibility_misc_utils.h"
 #include "ui/base/win/atl_module.h"
 
 namespace {
@@ skipping 160 matching lines @@
   UMA_API_TABLECELL_GET_ROW_INDEX = 155,
   UMA_API_UNSELECT_COLUMN = 156,
   UMA_API_UNSELECT_ROW = 157,
 
   // This must always be the last enum. It's okay for its value to
   // increase, but none of the other enum values may change.
   UMA_API_MAX
 };
 
 #define WIN_ACCESSIBILITY_API_HISTOGRAM(enum_value) \
-    UMA_HISTOGRAM_ENUMERATION("Accessibility.WinAPIs", enum_value, UMA_API_MAX)
+  UMA_HISTOGRAM_ENUMERATION("Accessibility.WinAPIs", enum_value, UMA_API_MAX)
 
 // There is no easy way to decouple |kScreenReader| and |kHTML| accessibility
 // modes when Windows screen readers are used. For example, certain roles use
 // the HTML tag name. Input fields require their type attribute to be exposed.
 const uint32_t kScreenReaderAndHTMLAccessibilityModes =
     content::AccessibilityMode::kScreenReader |
     content::AccessibilityMode::kHTML;
 
-const WCHAR *const IA2_RELATION_DETAILS = L"details";
-const WCHAR *const IA2_RELATION_DETAILS_FOR = L"detailsFor";
-const WCHAR *const IA2_RELATION_ERROR_MESSAGE = L"errorMessage";
+const WCHAR* const IA2_RELATION_DETAILS = L"details";
+const WCHAR* const IA2_RELATION_DETAILS_FOR = L"detailsFor";
+const WCHAR* const IA2_RELATION_ERROR_MESSAGE = L"errorMessage";
 
 }  // namespace
 
 namespace content {
 
+using AXPlatformPositionInstance = AXPlatformPosition::AXPositionInstance;
+using AXPlatformRange = ui::AXRange<AXPlatformPositionInstance::element_type>;
+
 // These nonstandard GUIDs are taken directly from the Mozilla sources
 // (accessible/src/msaa/nsAccessNodeWrap.cpp); some documentation is here:
 // http://developer.mozilla.org/en/Accessibility/AT-APIs/ImplementationFeatures/MSAA
 const GUID GUID_ISimpleDOM = {0x0c539790,
                               0x12e4,
                               0x11cf,
                               {0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8}};
 const GUID GUID_IAccessibleContentDocument = {
     0xa5d8e1f3,
     0x3571,
     0x4d8f,
     {0x95, 0x21, 0x07, 0xed, 0x28, 0xfb, 0x07, 0x2e}};
 
-const base::char16 BrowserAccessibilityWin::kEmbeddedCharacter = L'\xfffc';
+const base::char16 BrowserAccessibilityComWin::kEmbeddedCharacter = L'\xfffc';
 
 void AddAccessibilityModeFlags(AccessibilityMode mode_flags) {
   BrowserAccessibilityStateImpl::GetInstance()->AddAccessibilityModeFlags(
       mode_flags);
 }
 
 //
 // BrowserAccessibilityRelation
 //
 // A simple implementation of IAccessibleRelation, used to represent
 // a relationship between two accessible nodes in the tree.
 //
 
 class BrowserAccessibilityRelation
     : public CComObjectRootEx<CComMultiThreadModel>,
       public IAccessibleRelation {
   BEGIN_COM_MAP(BrowserAccessibilityRelation)
-    COM_INTERFACE_ENTRY(IAccessibleRelation)
+  COM_INTERFACE_ENTRY(IAccessibleRelation)
   END_COM_MAP()
 
   CONTENT_EXPORT BrowserAccessibilityRelation() {}
   CONTENT_EXPORT virtual ~BrowserAccessibilityRelation() {}
 
-  CONTENT_EXPORT void Initialize(BrowserAccessibilityWin* owner,
+  CONTENT_EXPORT void Initialize(BrowserAccessibilityComWin* owner,
                                  const base::string16& type);
   CONTENT_EXPORT void AddTarget(int target_id);
   CONTENT_EXPORT void RemoveTarget(int target_id);
 
   // Accessors.
   const base::string16& get_type() const { return type_; }
   const std::vector<int>& get_target_ids() const { return target_ids_; }
 
   // IAccessibleRelation methods.
   CONTENT_EXPORT STDMETHODIMP get_relationType(BSTR* relation_type) override;
   CONTENT_EXPORT STDMETHODIMP get_nTargets(long* n_targets) override;
-  CONTENT_EXPORT STDMETHODIMP
-  get_target(long target_index, IUnknown** target) override;
-  CONTENT_EXPORT STDMETHODIMP
-  get_targets(long max_targets, IUnknown** targets, long* n_targets) override;
+  CONTENT_EXPORT STDMETHODIMP get_target(long target_index,
+                                         IUnknown** target) override;
+  CONTENT_EXPORT STDMETHODIMP get_targets(long max_targets,
+                                          IUnknown** targets,
+                                          long* n_targets) override;
 
   // IAccessibleRelation methods not implemented.
   CONTENT_EXPORT STDMETHODIMP
   get_localizedRelationType(BSTR* relation_type) override {
     return E_NOTIMPL;
   }
 
  private:
   base::string16 type_;
-  base::win::ScopedComPtr<BrowserAccessibilityWin> owner_;
+  base::win::ScopedComPtr<BrowserAccessibilityComWin> owner_;
   std::vector<int> target_ids_;
 };
 
-void BrowserAccessibilityRelation::Initialize(BrowserAccessibilityWin* owner,
+void BrowserAccessibilityRelation::Initialize(BrowserAccessibilityComWin* owner,
                                               const base::string16& type) {
   owner_ = owner;
   type_ = type;
 }
 
 void BrowserAccessibilityRelation::AddTarget(int target_id) {
   target_ids_.push_back(target_id);
 }
 
 void BrowserAccessibilityRelation::RemoveTarget(int target_id) {
   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_->instance_active())
+  if (!owner_->GetOwner()->instance_active())
     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_->instance_active())
+  if (!owner_->GetOwner()->instance_active())
     return E_FAIL;
 
   *n_targets = static_cast<long>(target_ids_.size());
 
   for (long i = *n_targets - 1; i >= 0; --i) {
-    BrowserAccessibilityWin* result = owner_->GetFromID(target_ids_[i]);
-    if (!result || !result->instance_active()) {
+    BrowserAccessibilityComWin* result = owner_->GetFromID(target_ids_[i]);
+    if (!result || !result->GetOwner()->instance_active()) {
       *n_targets = 0;
       break;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
                                                       IUnknown** target) {
   if (!target)
     return E_INVALIDARG;
 
-  if (!owner_->instance_active())
+  if (!owner_->GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = owner_->GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (target_index < 0 ||
       target_index >= static_cast<long>(target_ids_.size())) {
     return E_INVALIDARG;
   }
 
-  BrowserAccessibility* result = owner_->GetFromID(target_ids_[target_index]);
+  BrowserAccessibility* result = manager->GetFromID(target_ids_[target_index]);
   if (!result || !result->instance_active())
     return E_FAIL;
 
   *target = static_cast<IAccessible*>(
-      ToBrowserAccessibilityWin(result)->NewReference());
+      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_->instance_active())
+  if (!owner_->GetOwner()->instance_active())
     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;
 
   for (long i = 0; i < count; ++i) {
     HRESULT result = get_target(i, &targets[i]);
     if (result != S_OK)
       return result;
   }
 
   return S_OK;
 }
 
 //
-// BrowserAccessibilityWin::WinAttributes
+// BrowserAccessibilityComWin::WinAttributes
 //
 
-BrowserAccessibilityWin::WinAttributes::WinAttributes()
-    : ia_role(0),
-      ia_state(0),
-      ia2_role(0),
-      ia2_state(0) {
-}
+BrowserAccessibilityComWin::WinAttributes::WinAttributes()
+    : ia_role(0), ia_state(0), ia2_role(0), ia2_state(0) {}
 
-BrowserAccessibilityWin::WinAttributes::~WinAttributes() {
-}
+BrowserAccessibilityComWin::WinAttributes::~WinAttributes() {}
 
 //
-// BrowserAccessibilityWin
+// BrowserAccessibilityComWin
 //
+BrowserAccessibilityComWin::BrowserAccessibilityComWin()
+    : owner_(nullptr),
+      win_attributes_(new WinAttributes()),
+      previous_scroll_x_(0),
+      previous_scroll_y_(0) {}
 
-// static
-BrowserAccessibility* BrowserAccessibility::Create() {
-  ui::win::CreateATLModuleIfNeeded();
-  CComObject<BrowserAccessibilityWin>* instance;
-  HRESULT hr = CComObject<BrowserAccessibilityWin>::CreateInstance(&instance);
-  DCHECK(SUCCEEDED(hr));
-  return instance->NewReference();
-}
-
-BrowserAccessibilityWin::BrowserAccessibilityWin()
-    : win_attributes_(new WinAttributes()),
-      previous_scroll_x_(0),
-      previous_scroll_y_(0) {
-}
-
-BrowserAccessibilityWin::~BrowserAccessibilityWin() {
+BrowserAccessibilityComWin::~BrowserAccessibilityComWin() {
   for (BrowserAccessibilityRelation* relation : relations_)
     relation->Release();
 }
 
 //
 // IAccessible methods.
 //
 // Conventions:
-// * Always test for instance_active() first and return E_FAIL if it's false.
+// * Always test for GetOwner() and GetOwner()->instance_active first and
+//   return E_FAIL if either are 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.
 //
 
-HRESULT BrowserAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
+HRESULT BrowserAccessibilityComWin::accDoDefaultAction(VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_DO_DEFAULT_ACTION);
-  if (!instance_active())
+
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  auto* manager = GetOwner()->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->HasIntAttribute(ui::AX_ATTR_ACTION))
+  if (!target->GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION))
     return DISP_E_MEMBERNOTFOUND;
 
-  manager_->DoDefaultAction(*target);
+  manager->DoDefaultAction(*target->GetOwner());
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left,
-                                                 LONG y_top,
-                                                 VARIANT* child) {
+STDMETHODIMP BrowserAccessibilityComWin::accHitTest(LONG x_left,
+                                                    LONG y_top,
+                                                    VARIANT* child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
-  if (!instance_active())
+
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   gfx::Point point(x_left, y_top);
-  if (!GetScreenBoundsRect().Contains(point)) {
+  if (!GetOwner()->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 == this) {
+  BrowserAccessibility* result = manager->CachingAsyncHitTest(point);
+  if (result == GetOwner()) {
     // Point is within this object.
     child->vt = VT_I4;
     child->lVal = CHILDID_SELF;
   } else {
     child->vt = VT_DISPATCH;
-    child->pdispVal = ToBrowserAccessibilityWin(result)->NewReference();
+    child->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left,
-                                                  LONG* y_top,
-                                                  LONG* width,
-                                                  LONG* height,
-                                                  VARIANT var_id) {
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  return GetPlatformNodeWin()->accLocation(x_left, y_top, width, height,
-                                           var_id);
+  return AXPlatformNodeWin::accLocation(x_left, y_top, width, height, var_id);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accNavigate(LONG nav_dir,
-                                                  VARIANT start,
-                                                  VARIANT* end) {
+STDMETHODIMP BrowserAccessibilityComWin::accNavigate(LONG nav_dir,
+                                                     VARIANT start,
+                                                     VARIANT* end) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_NAVIGATE);
+  if (!GetOwner() || !GetOwner()->instance_active())
+    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 GetPlatformNodeWin()->accNavigate(nav_dir, start, end);
+    return AXPlatformNodeWin::accNavigate(nav_dir, start, end);
   }
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(start);
+  BrowserAccessibilityComWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   BrowserAccessibility* result = nullptr;
   switch (nav_dir) {
     case NAVDIR_DOWN:
-      result = target->GetTableCell(GetTableRow() + GetTableRowSpan(),
-                                    GetTableColumn());
+      result = target->GetOwner()->GetTableCell(
+          GetOwner()->GetTableRow() + GetOwner()->GetTableRowSpan(),
+          GetOwner()->GetTableColumn());
       break;
     case NAVDIR_UP:
-      result = target->GetTableCell(GetTableRow() - 1, GetTableColumn());
+      result = target->GetOwner()->GetTableCell(GetOwner()->GetTableRow() - 1,
+                                                GetOwner()->GetTableColumn());
       break;
     case NAVDIR_LEFT:
-      result = target->GetTableCell(GetTableRow(), GetTableColumn() - 1);
+      result = target->GetOwner()->GetTableCell(
+          GetOwner()->GetTableRow(), GetOwner()->GetTableColumn() - 1);
       break;
     case NAVDIR_RIGHT:
-      result = target->GetTableCell(GetTableRow(),
-                                    GetTableColumn() + GetTableColumnSpan());
+      result = target->GetOwner()->GetTableCell(
+          GetOwner()->GetTableRow(),
+          GetOwner()->GetTableColumn() + GetOwner()->GetTableColumnSpan());
       break;
   }
 
   if (!result) {
     end->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   end->vt = VT_DISPATCH;
-  end->pdispVal = ToBrowserAccessibilityWin(result)->NewReference();
+  end->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accChild(VARIANT var_child,
-                                                   IDispatch** disp_child) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accChild(VARIANT var_child,
+                                                      IDispatch** disp_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!disp_child)
     return E_INVALIDARG;
 
   *disp_child = NULL;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_child);
+  BrowserAccessibilityComWin* target = GetTargetFromChildID(var_child);
   if (!target)
     return E_INVALIDARG;
 
   (*disp_child) = target->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accChildCount(LONG* child_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accChildCount(LONG* child_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD_COUNT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!child_count)
     return E_INVALIDARG;
 
-  *child_count = PlatformChildCount();
+  *child_count = GetOwner()->PlatformChildCount();
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accDefaultAction(VARIANT var_id,
-                                                           BSTR* def_action) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accDefaultAction(
+    VARIANT var_id,
+    BSTR* def_action) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DEFAULT_ACTION);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!def_action)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->get_localizedName(0, def_action);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accDescription(VARIANT var_id,
-                                                         BSTR* desc) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accDescription(VARIANT var_id,
+                                                            BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DESCRIPTION);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  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 BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accFocus(VARIANT* focus_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!focus_child)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* focus =
-      static_cast<BrowserAccessibilityWin*>(manager_->GetFocus());
-  if (focus == this) {
+      static_cast<BrowserAccessibilityWin*>(manager->GetFocus());
+  if (focus == GetOwner()) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus == NULL) {
     focus_child->vt = VT_EMPTY;
   } else {
     focus_child->vt = VT_DISPATCH;
-    focus_child->pdispVal = focus->NewReference();
+    focus_child->pdispVal = focus->GetCOM()->NewReference();
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accHelp(VARIANT var_id, BSTR* help) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accHelp(VARIANT var_id,
+                                                     BSTR* help) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  return GetPlatformNodeWin()->get_accHelp(var_id, help);
+  return AXPlatformNodeWin::get_accHelp(var_id, help);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accKeyboardShortcut(VARIANT var_id,
-                                                              BSTR* acc_key) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accKeyboardShortcut(
+    VARIANT var_id,
+    BSTR* acc_key) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_KEYBOARD_SHORTCUT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!acc_key)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  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_KEY_SHORTCUTS, acc_key);
   }
 
-  return target->GetStringAttributeAsBstr(
-      ui::AX_ATTR_SHORTCUT, acc_key);
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_SHORTCUT, acc_key);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accName(VARIANT var_id, BSTR* name) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accName(VARIANT var_id,
+                                                     BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_NAME);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  return GetPlatformNodeWin()->get_accName(var_id, name);
+  return AXPlatformNodeWin::get_accName(var_id, name);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accParent(
+    IDispatch** disp_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_PARENT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
-  IAccessible* parent_obj = ToBrowserAccessibilityWin(PlatformGetParent());
+  IAccessible* parent_obj =
+      ToBrowserAccessibilityComWin(GetOwner()->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_obj = GetOwner()
+                     ->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 BrowserAccessibilityWin::get_accRole(VARIANT var_id,
-                                                  VARIANT* role) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accRole(VARIANT var_id,
+                                                     VARIANT* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_ROLE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  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 BrowserAccessibilityWin::get_accState(VARIANT var_id,
-                                                   VARIANT* state) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accState(VARIANT var_id,
+                                                      VARIANT* state) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!state)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state();
-  if (manager_->GetFocus() == this)
+  if (manager->GetFocus() == GetOwner())
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
-                                                   BSTR* value) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accValue(VARIANT var_id,
+                                                      BSTR* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
-  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
+  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->GetIntAttribute(ui::AX_ATTR_COLOR_VALUE));
+        target->GetOwner()->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 BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
-                                                       VARIANT var_id,
-                                                       LONG* topic_id) {
+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 BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
+STDMETHODIMP BrowserAccessibilityComWin::get_accSelection(VARIANT* selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_SELECTION);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())

[dmazzoni, 2017/05/08 04:45:24]

I don't see any purpose for BrowserAccessibility::instance_active anymore.

We should just check GetOwner here and if it's null, we're not active,
then get rid of BrowserAccessibility::Destroy() and replace it with just a
simple public destructor.

Oh, and we should probably have AXPlatformNodeWin own an
AXPlatformNodeComWin to match this.

Most of that can wait for a follow-up, but I think it would be safe to only
check GetOwner() and not bother checking instance_active(). If you look at
the code, there should never be a case where instance_active() returns
false, but GetOwner() is still valid.

[dougt, 2017/05/08 16:53:36]

I would like to only test GetOwner() in a follow up.  This is a pretty big
change and I was hoping to keep the logic nearly identical.

     return E_FAIL;
 
-  if (GetRole() != ui::AX_ROLE_LIST_BOX)
+  if (GetOwner()->GetRole() != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
-  for (size_t i = 0; i < InternalChildCount(); ++i) {
-    if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
+  for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
+    if (GetOwner()->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 < InternalChildCount(); ++i) {
-      if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
+    for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
+      if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
         selected->vt = VT_DISPATCH;
         selected->pdispVal =
-            ToBrowserAccessibilityWin(InternalGetChild(i))->NewReference();
+            ToBrowserAccessibilityComWin(GetOwner()->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 < InternalChildCount(); ++i) {
-    if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
+  for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
+    if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED)) {
       enum_variant->ItemAt(index)->vt = VT_DISPATCH;
       enum_variant->ItemAt(index)->pdispVal =
-          ToBrowserAccessibilityWin(InternalGetChild(i))->NewReference();
+          ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i))
+              ->NewReference();
       ++index;
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::accSelect(
-    LONG flags_sel, VARIANT var_id) {
+STDMETHODIMP BrowserAccessibilityComWin::accSelect(LONG flags_sel,
+                                                   VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
-    manager_->SetFocus(*this);
+    manager->SetFocus(*GetOwner());
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::put_accName(VARIANT var_id, BSTR put_name) {
+BrowserAccessibilityComWin::put_accName(VARIANT var_id, BSTR put_name) {
   return E_NOTIMPL;
 }
 STDMETHODIMP
-BrowserAccessibilityWin::put_accValue(VARIANT var_id, BSTR put_val) {
+BrowserAccessibilityComWin::put_accValue(VARIANT var_id, BSTR put_val) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
+STDMETHODIMP BrowserAccessibilityComWin::role(LONG* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ROLE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
+STDMETHODIMP BrowserAccessibilityComWin::get_attributes(BSTR* attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_GET_ATTRIBUTES);
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!attributes)
     return E_INVALIDARG;
   *attributes = nullptr;
 
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::get_states(AccessibleStates* states) {
+STDMETHODIMP BrowserAccessibilityComWin::get_states(AccessibleStates* states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_STATES);
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
-    return E_FAIL;
 
   if (!states)
     return E_INVALIDARG;
 
   *states = ia2_state();
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_uniqueID(LONG* unique_id) {
+STDMETHODIMP BrowserAccessibilityComWin::get_uniqueID(LONG* unique_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNIQUE_ID);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!unique_id)
     return E_INVALIDARG;
 
-  *unique_id = -this->unique_id();
+  *unique_id = -GetOwner()->unique_id();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
+STDMETHODIMP BrowserAccessibilityComWin::get_windowHandle(HWND* window_handle) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_WINDOW_HANDLE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
-  *window_handle =
-      manager_->ToBrowserAccessibilityManagerWin()->GetParentHWND();
+  *window_handle = GetOwner()
+                       ->manager()
+                       ->ToBrowserAccessibilityManagerWin()

[dmazzoni, 2017/05/08 04:45:24]

Optional:
Since GetOwner()->manager() is used a lot, and sometimes
ToBrowserAccessibilityManagerWin(), how about a
convenience method GetManager() that returns a
BrowserAccessibilityManagerWin*?

[dougt, 2017/05/08 16:53:36]

Acknowledged.  Good follow up.  Noted.

+                       ->GetParentHWND();
   if (!*window_handle)
     return E_FAIL;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
+STDMETHODIMP BrowserAccessibilityComWin::get_indexInParent(
+    LONG* index_in_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INDEX_IN_PARENT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
-  *index_in_parent = this->GetIndexInParent();
+  *index_in_parent = GetIndexInParent();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nRelations(LONG* n_relations) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nRelations(LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_relations)
     return E_INVALIDARG;
 
   *n_relations = relations_.size();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_relation(
+STDMETHODIMP BrowserAccessibilityComWin::get_relation(
     LONG relation_index,
     IAccessibleRelation** relation) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::get_relations(
+STDMETHODIMP BrowserAccessibilityComWin::get_relations(
     LONG max_relations,
     IAccessibleRelation** relations,
     LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::scrollTo(IA2ScrollType scroll_type) {
+STDMETHODIMP BrowserAccessibilityComWin::scrollTo(IA2ScrollType scroll_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_SCROLL_TO);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  gfx::Rect r = GetFrameBoundsRect();
-  switch(scroll_type) {
+  auto* manager = GetOwner()->manager();
+
+  if (!manager)
+    return E_FAIL;
+
+  gfx::Rect r = GetOwner()->GetFrameBoundsRect();
+  switch (scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
-      manager_->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
+      manager->ScrollToMakeVisible(*GetOwner(), gfx::Rect(r.x(), r.y(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
-      manager_->ScrollToMakeVisible(*this,
-                                    gfx::Rect(r.right(), r.bottom(), 0, 0));
+      manager->ScrollToMakeVisible(*GetOwner(),
+                                   gfx::Rect(r.right(), r.bottom(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_TOP_EDGE:
-      manager_->ScrollToMakeVisible(*this,
-                                    gfx::Rect(r.x(), r.y(), r.width(), 0));
+      manager->ScrollToMakeVisible(*GetOwner(),
+                                   gfx::Rect(r.x(), r.y(), r.width(), 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_EDGE:
-      manager_->ScrollToMakeVisible(*this,
-                                    gfx::Rect(r.x(), r.bottom(), r.width(), 0));
+      manager->ScrollToMakeVisible(*GetOwner(),
+                                   gfx::Rect(r.x(), r.bottom(), r.width(), 0));
       break;
     case IA2_SCROLL_TYPE_LEFT_EDGE:
-      manager_->ScrollToMakeVisible(*this,
-                                    gfx::Rect(r.x(), r.y(), 0, r.height()));
+      manager->ScrollToMakeVisible(*GetOwner(),
+                                   gfx::Rect(r.x(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_RIGHT_EDGE:
-      manager_->ScrollToMakeVisible(*this,
-                                    gfx::Rect(r.right(), r.y(), 0, r.height()));
+      manager->ScrollToMakeVisible(*GetOwner(),
+                                   gfx::Rect(r.right(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_ANYWHERE:
     default:
-      manager_->ScrollToMakeVisible(*this, r);
+      manager->ScrollToMakeVisible(*GetOwner(), r);
       break;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::scrollToPoint(
+STDMETHODIMP BrowserAccessibilityComWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_POINT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   gfx::Point scroll_to(x, y);
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
-    scroll_to -= manager_->GetViewBounds().OffsetFromOrigin();
+    scroll_to -= manager->GetViewBounds().OffsetFromOrigin();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    if (PlatformGetParent())
-      scroll_to += PlatformGetParent()->GetFrameBoundsRect().OffsetFromOrigin();
+    if (GetOwner()->PlatformGetParent())
+      scroll_to += GetOwner()
+                       ->PlatformGetParent()

[dmazzoni, 2017/05/08 04:45:24]

I think we want braces for readability since this wraps onto multiple lines?

[dougt, 2017/05/08 16:53:36]

Done.  Two places fixed.

+                       ->GetFrameBoundsRect()
+                       .OffsetFromOrigin();
   } else {
     return E_INVALIDARG;
   }
 
-  manager_->ScrollToPoint(*this, scroll_to);
+  manager->ScrollToPoint(*GetOwner(), scroll_to);
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
-  *group_level = GetIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL);
-  *similar_items_in_group = GetIntAttribute(ui::AX_ATTR_SET_SIZE);
-  *position_in_group = GetIntAttribute(ui::AX_ATTR_POS_IN_SET);
+  *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);
 
   if (*group_level == *similar_items_in_group == *position_in_group == 0)
     return S_FALSE;
   return S_OK;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::get_localizedExtendedRole(
+BrowserAccessibilityComWin::get_localizedExtendedRole(
     BSTR* localized_extended_role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_ROLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!localized_extended_role)
     return E_INVALIDARG;
 
-  return GetStringAttributeAsBstr(
-      ui::AX_ATTR_ROLE_DESCRIPTION, localized_extended_role);
+  return GetStringAttributeAsBstr(ui::AX_ATTR_ROLE_DESCRIPTION,
+                                  localized_extended_role);
 }
 
 //
 // IAccessible2 methods not implemented.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_extendedRole(BSTR* extended_role) {
+STDMETHODIMP BrowserAccessibilityComWin::get_extendedRole(BSTR* extended_role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_EXTENDED_ROLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 STDMETHODIMP
-BrowserAccessibilityWin::get_nExtendedStates(LONG* n_extended_states) {
+BrowserAccessibilityComWin::get_nExtendedStates(LONG* n_extended_states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_EXTENDED_STATES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 STDMETHODIMP
-BrowserAccessibilityWin::get_extendedStates(LONG max_extended_states,
-                                            BSTR** extended_states,
-                                            LONG* n_extended_states) {
+BrowserAccessibilityComWin::get_extendedStates(LONG max_extended_states,
+                                               BSTR** extended_states,
+                                               LONG* n_extended_states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_EXTENDED_STATES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 STDMETHODIMP
-BrowserAccessibilityWin::get_localizedExtendedStates(
+BrowserAccessibilityComWin::get_localizedExtendedStates(
     LONG max_localized_extended_states,
     BSTR** localized_extended_states,
     LONG* n_localized_extended_states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_STATES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
-STDMETHODIMP BrowserAccessibilityWin::get_locale(IA2Locale* locale) {
+STDMETHODIMP BrowserAccessibilityComWin::get_locale(IA2Locale* locale) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleApplication methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_appName(BSTR* app_name) {
+STDMETHODIMP BrowserAccessibilityComWin::get_appName(BSTR* app_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_NAME);
-  // No need to check |instance_active()| because this interface is
-  // global, and doesn't depend on any local state.
+  // No need to check |GetOwner()| or |GetOwner->manager()| because this
+  // interface is global, and doesn't depend on any local state.
 
   if (!app_name)
     return E_INVALIDARG;
 
   // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
   // the part before the "/".
-  std::vector<std::string> product_components = base::SplitString(
-      GetContentClient()->GetProduct(), "/",
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> product_components =
+      base::SplitString(GetContentClient()->GetProduct(), "/",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2U, product_components.size());
   if (product_components.size() != 2)
     return E_FAIL;
   *app_name = SysAllocString(base::UTF8ToUTF16(product_components[0]).c_str());
   DCHECK(*app_name);
   return *app_name ? S_OK : E_FAIL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_appVersion(BSTR* app_version) {
+STDMETHODIMP BrowserAccessibilityComWin::get_appVersion(BSTR* app_version) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_VERSION);
-  // No need to check |instance_active()| because this interface is
+  // No need to check |GetOwner()->manager()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!app_version)
     return E_INVALIDARG;
 
   // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
   // the part after the "/".
-  std::vector<std::string> product_components = base::SplitString(
-      GetContentClient()->GetProduct(), "/",
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> product_components =
+      base::SplitString(GetContentClient()->GetProduct(), "/",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2U, product_components.size());
   if (product_components.size() != 2)
     return E_FAIL;
   *app_version =
       SysAllocString(base::UTF8ToUTF16(product_components[1]).c_str());
   DCHECK(*app_version);
   return *app_version ? S_OK : E_FAIL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_toolkitName(BSTR* toolkit_name) {
+STDMETHODIMP BrowserAccessibilityComWin::get_toolkitName(BSTR* toolkit_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TOOLKIT_NAME);
-  // No need to check |instance_active()| because this interface is
+  // No need to check |GetOwner()->manager()| because this interface is

[dmazzoni, 2017/05/08 04:45:24]

This is slightly confusing, how about just |GetOwner()|

[dougt, 2017/05/08 16:53:36]

yeah, this comment is useless.

Basically what it's saying is that "unlike all of the other methods we've
implemented... in this method, since we're not touching owner, or manager, or
whatever, we don't have to test for owner, or manager, or whatever.".  It's sort
of obvious.

I think this comment exists because up above all of the IAccessibile method
impls, there is a comment section called "Conventions" which demands that we
call GetOwner().  What I am going to do is remove these two confusing comments,
and update the Conventions comment block with an exception.

   // global, and doesn't depend on any local state.
 
   if (!toolkit_name)
     return E_INVALIDARG;
 
   // This is hard-coded; all products based on the Chromium engine
   // will have the same toolkit name, so that assistive technology can
   // detect any Chrome-based product.
   *toolkit_name = SysAllocString(L"Chrome");
   DCHECK(*toolkit_name);
   return *toolkit_name ? S_OK : E_FAIL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_toolkitVersion(
+STDMETHODIMP BrowserAccessibilityComWin::get_toolkitVersion(
     BSTR* toolkit_version) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TOOLKIT_VERSION);
-  // No need to check |instance_active()| because this interface is
+  // No need to check |GetOwner()->manager()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!toolkit_version)
     return E_INVALIDARG;
 
   std::string user_agent = GetContentClient()->GetUserAgent();
   *toolkit_version = SysAllocString(base::UTF8ToUTF16(user_agent).c_str());
   DCHECK(*toolkit_version);
   return *toolkit_version ? S_OK : E_FAIL;
 }
 
 //
 // IAccessibleImage methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_description(BSTR* desc) {
+STDMETHODIMP BrowserAccessibilityComWin::get_description(BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DESCRIPTION);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::get_imagePosition(
+STDMETHODIMP BrowserAccessibilityComWin::get_imagePosition(
     IA2CoordinateType coordinate_type,
     LONG* x,
     LONG* y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_POSITION);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
-    gfx::Rect bounds = GetScreenBoundsRect();
+    gfx::Rect bounds = GetOwner()->GetScreenBoundsRect();
     *x = bounds.x();
     *y = bounds.y();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    gfx::Rect bounds = GetPageBoundsRect();
-    gfx::Rect parent_bounds = PlatformGetParent()
-                                  ? PlatformGetParent()->GetPageBoundsRect()
-                                  : gfx::Rect();
+    gfx::Rect bounds = GetOwner()->GetPageBoundsRect();
+    gfx::Rect parent_bounds =
+        GetOwner()->PlatformGetParent()
+            ? GetOwner()->PlatformGetParent()->GetPageBoundsRect()
+            : gfx::Rect();
     *x = bounds.x() - parent_bounds.x();
     *y = bounds.y() - parent_bounds.y();
   } else {
     return E_INVALIDARG;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_imageSize(LONG* height, LONG* width) {
+STDMETHODIMP BrowserAccessibilityComWin::get_imageSize(LONG* height,
+                                                       LONG* width) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_SIZE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
-  *height = GetPageBoundsRect().height();
-  *width = GetPageBoundsRect().width();
+  *height = GetOwner()->GetPageBoundsRect().height();
+  *width = GetOwner()->GetPageBoundsRect().width();
   return S_OK;
 }
 
 //
 // IAccessibleTable methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_accessibleAt(
+STDMETHODIMP BrowserAccessibilityComWin::get_accessibleAt(
     long row,
     long column,
     IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetTableCell(static_cast<int>(row), static_cast<int>(column));
-  if (cell && ToBrowserAccessibilityWin(cell)) {
+      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
+  if (cell && ToBrowserAccessibilityComWin(cell)) {
     *accessible = static_cast<IAccessible*>(
-        ToBrowserAccessibilityWin(cell)->NewReference());
+        ToBrowserAccessibilityComWin(cell)->NewReference());
     return S_OK;
   }
 
   *accessible = nullptr;
   return E_INVALIDARG;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_caption(IUnknown** accessible) {
+STDMETHODIMP BrowserAccessibilityComWin::get_caption(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_childIndex(long row,
-                                                     long column,
-                                                     long* cell_index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_childIndex(long row,
+                                                        long column,
+                                                        long* cell_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      GetOwner()->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 BrowserAccessibilityWin::get_columnDescription(long column,
-                                                            BSTR* description) {
+STDMETHODIMP BrowserAccessibilityComWin::get_columnDescription(
+    long column,
+    BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  int columns = GetTableColumnCount();
+  int columns = GetOwner()->GetTableColumnCount();
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
-  int rows = GetTableRowCount();
+  int rows = GetOwner()->GetTableRowCount();
   if (rows <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < rows; ++i) {
-    const BrowserAccessibility* cell = GetTableCell(i, column);
-    if (ToBrowserAccessibilityWin(cell) &&
+    BrowserAccessibility* cell = GetOwner()->GetTableCell(i, column);
+    if (ToBrowserAccessibilityComWin(cell) &&
         cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
-      base::string16 cell_name = cell->GetString16Attribute(
-          ui::AX_ATTR_NAME);
+      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 (ToBrowserAccessibilityWin(cell)->description().size() > 0) {
+      if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
         *description = SysAllocString(
-            ToBrowserAccessibilityWin(cell)->description().c_str());
+            ToBrowserAccessibilityComWin(cell)->description().c_str());
         return S_OK;
       }
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnExtentAt(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
-      GetTableCell(static_cast<int>(row), static_cast<int>(column));
+      GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (!cell)
     return E_INVALIDARG;
 
   *n_columns_spanned = cell->GetTableColumnSpan();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnHeader(
+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 BrowserAccessibilityWin::get_columnIndex(long cell_index,
-                                                      long* column_index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long cell_index,
+                                                         long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetTableCell(cell_index);
+  BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
   *column_index = cell->GetTableColumn();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nColumns(long* column_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nColumns(long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
-  *column_count = GetTableColumnCount();
+  *column_count = GetOwner()->GetTableColumnCount();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nRows(long* row_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
-  *row_count = GetTableRowCount();
+  *row_count = GetOwner()->GetTableRowCount();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(long* cell_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedChildren(
+    long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cell_count)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
   *cell_count = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(long* column_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedColumns(
+    long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(long* row_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(long row,
-                                                         BSTR* description) {
+STDMETHODIMP BrowserAccessibilityComWin::get_rowDescription(long row,
+                                                            BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
-  if (row < 0 || row >= GetTableRowCount())
+  if (row < 0 || row >= GetOwner()->GetTableRowCount())
     return E_INVALIDARG;
 
-  int columns = GetTableColumnCount();
+  int columns = GetOwner()->GetTableColumnCount();
   if (columns <= 0) {
     *description = nullptr;
     return S_FALSE;
   }
 
   for (int i = 0; i < columns; ++i) {
-    const BrowserAccessibility* cell = GetTableCell(row, i);
-    if (ToBrowserAccessibilityWin(cell) &&
+    BrowserAccessibility* cell = GetOwner()->GetTableCell(row, i);
+    if (ToBrowserAccessibilityComWin(cell) &&
         cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
-      base::string16 cell_name = cell->GetString16Attribute(
-          ui::AX_ATTR_NAME);
+      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 (ToBrowserAccessibilityWin(cell)->description().size() > 0) {
+      if (ToBrowserAccessibilityComWin(cell)->description().size() > 0) {
         *description = SysAllocString(
-            ToBrowserAccessibilityWin(cell)->description().c_str());
+            ToBrowserAccessibilityComWin(cell)->description().c_str());
         return S_OK;
       }
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(long row,
-                                                      long column,
-                                                      long* n_rows_spanned) {
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetTableCell(row, column);
+  BrowserAccessibility* cell = GetOwner()->GetTableCell(row, column);
   if (!cell)
     return E_INVALIDARG;
 
-  *n_rows_spanned = GetTableRowSpan();
+  *n_rows_spanned = GetOwner()->GetTableRowSpan();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowHeader(
+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 BrowserAccessibilityWin::get_rowIndex(long cell_index,
-                                                   long* row_index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long cell_index,
+                                                      long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetTableCell(cell_index);
+  BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
 
   *row_index = cell->GetTableRow();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(long max_children,
-                                                           long** children,
-                                                           long* n_children) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedChildren(
+    long max_children,
+    long** children,
+    long* n_children) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!children || !n_children)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_children = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long max_columns,
-                                                          long** columns,
-                                                          long* n_columns) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long max_columns,
+                                                             long** columns,
+                                                             long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long max_rows,
-                                                       long** rows,
-                                                       long* n_rows) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long max_rows,
+                                                          long** rows,
+                                                          long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_summary(IUnknown** accessible) {
+STDMETHODIMP BrowserAccessibilityComWin::get_summary(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SUMMARY);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isColumnSelected(
+STDMETHODIMP BrowserAccessibilityComWin::get_isColumnSelected(
     long column,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_COLUMN_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(long row,
-                                                        boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityComWin::get_isRowSelected(
+    long row,
+    boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_ROW_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isSelected(long row,
-                                                     long column,
-                                                     boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(long row,
+                                                        long column,
+                                                        boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtentsAtIndex(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
-  BrowserAccessibility* cell = GetTableCell(index);
+  BrowserAccessibility* cell = GetOwner()->GetTableCell(index);
   if (!cell)
     return E_INVALIDARG;
 
   *row = cell->GetTableRow();
   *column = cell->GetTableColumn();
-  *row_extents = GetTableRowSpan();
-  *column_extents = GetTableColumnSpan();
+  *row_extents = GetOwner()->GetTableRowSpan();
+  *column_extents = GetOwner()->GetTableColumnSpan();
   *is_selected = false;  // Not supported.
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::selectRow(long row) {
+STDMETHODIMP BrowserAccessibilityComWin::selectRow(long row) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SELECT_ROW);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::selectColumn(long column) {
+STDMETHODIMP BrowserAccessibilityComWin::selectColumn(long column) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SELECT_COLUMN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::unselectRow(long row) {
+STDMETHODIMP BrowserAccessibilityComWin::unselectRow(long row) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_UNSELECT_ROW);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::unselectColumn(long column) {
+STDMETHODIMP BrowserAccessibilityComWin::unselectColumn(long column) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_UNSELECT_COLUMN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::get_modelChange(IA2TableModelChange* model_change) {
+BrowserAccessibilityComWin::get_modelChange(IA2TableModelChange* model_change) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleTable2 methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_cellAt(long row,
-                                                 long column,
-                                                 IUnknown** cell) {
+STDMETHODIMP BrowserAccessibilityComWin::get_cellAt(long row,
+                                                    long column,
+                                                    IUnknown** cell) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CELL_AT);
   AddAccessibilityModeFlags(AccessibilityMode::kScreenReader);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cell)
     return E_INVALIDARG;
 
   BrowserAccessibility* table_cell =
-      GetTableCell(static_cast<int>(row), static_cast<int>(column));
-  if (ToBrowserAccessibilityWin(table_cell)) {
-    return ToBrowserAccessibilityWin(table_cell)
+      GetOwner()->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 BrowserAccessibilityWin::get_nSelectedCells(long* cell_count) {
+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 BrowserAccessibilityWin::get_selectedCells(
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedCells(
     IUnknown*** cells,
     long* n_selected_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cells || !n_selected_cells)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_selected_cells = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long** columns,
-                                                          long* n_columns) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long** columns,
+                                                             long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long** rows,
-                                                       long* n_rows) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long** rows,
+                                                          long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
-
 //
 // IAccessibleTableCell methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnExtent(
+STDMETHODIMP BrowserAccessibilityComWin::get_columnExtent(
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
-  *n_columns_spanned = GetTableColumnSpan();
+  *n_columns_spanned = GetOwner()->GetTableColumnSpan();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnHeaderCells(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cell_accessibles || !n_column_header_cells)
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
-  BrowserAccessibility* table = GetTable();
+  BrowserAccessibility* table = GetOwner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int column = GetTableColumn();
-  int columns = GetTableColumnCount();
-  int rows = GetTableRowCount();
+  int column = GetOwner()->GetTableColumn();
+  int columns = GetOwner()->GetTableColumnCount();
+  int rows = GetOwner()->GetTableRowCount();
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   for (int i = 0; i < rows; ++i) {
-    BrowserAccessibility* cell = GetTableCell(i, column);
+    BrowserAccessibility* cell = GetOwner()->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])));
+  *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 = GetTableCell(i, column);
+    BrowserAccessibility* cell = GetOwner()->GetTableCell(i, column);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
-          ToBrowserAccessibilityWin(cell)->NewReference());
+          ToBrowserAccessibilityComWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
-  *column_index = GetTableColumn();
+  *column_index = GetOwner()->GetTableColumn();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(long* n_rows_spanned) {
+STDMETHODIMP BrowserAccessibilityComWin::get_rowExtent(long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
-  *n_rows_spanned = GetTableRowSpan();
+  *n_rows_spanned = GetOwner()->GetTableRowSpan();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowHeaderCells(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!cell_accessibles || !n_row_header_cells)
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
-  BrowserAccessibility* table = GetTable();
+  BrowserAccessibility* table = GetOwner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
   }
 
-  int row = GetTableRow();
-  int columns = GetTableColumnCount();
-  int rows = GetTableRowCount();
+  int row = GetOwner()->GetTableRow();
+  int columns = GetOwner()->GetTableColumnCount();
+  int rows = GetOwner()->GetTableRowCount();
   if (columns <= 0 || rows <= 0 || row < 0 || row >= rows)
     return S_FALSE;
 
   for (int i = 0; i < columns; ++i) {
-    BrowserAccessibility* cell = GetTableCell(row, i);
+    BrowserAccessibility* cell = GetOwner()->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])));
+  *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 = GetTableCell(row, i);
+    BrowserAccessibility* cell = GetOwner()->GetTableCell(row, i);
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
-          ToBrowserAccessibilityWin(cell)->NewReference());
+          ToBrowserAccessibilityComWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
-  *row_index = GetTableRow();
+  *row_index = GetOwner()->GetTableRow();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_isSelected(boolean* is_selected) {
+STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   *is_selected = false;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtents(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  if (!row_index ||
-      !column_index ||
-      !row_extents ||
-      !column_extents ||
+  if (!row_index || !column_index || !row_extents || !column_extents ||
       !is_selected) {
     return E_INVALIDARG;
   }
 
-  *row_index = GetTableRow();
-  *column_index = GetTableColumn();
-  *row_extents = GetTableRowSpan();
-  *column_extents = GetTableColumnSpan();
+  *row_index = GetOwner()->GetTableRow();
+  *column_index = GetOwner()->GetTableColumn();
+  *row_extents = GetOwner()->GetTableRowSpan();
+  *column_extents = GetOwner()->GetTableColumnSpan();
   *is_selected = false;  // Not supported.
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_table(IUnknown** table) {
+STDMETHODIMP BrowserAccessibilityComWin::get_table(IUnknown** table) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TABLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
-  BrowserAccessibility* find_table = GetTable();
-  if (!find_table || !ToBrowserAccessibilityWin(find_table)) {
+  BrowserAccessibility* find_table = GetOwner()->GetTable();
+  if (!find_table || !ToBrowserAccessibilityComWin(find_table)) {
     *table = nullptr;
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
-      ToBrowserAccessibilityWin(find_table)->NewReference());
+      ToBrowserAccessibilityComWin(find_table)->NewReference());
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_nCharacters(LONG* n_characters) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nCharacters(LONG* n_characters) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_CHARACTERS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
-  *n_characters = static_cast<LONG>(GetText().size());
+  *n_characters = static_cast<LONG>(GetOwner()->GetText().size());
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
+STDMETHODIMP BrowserAccessibilityComWin::get_caretOffset(LONG* offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
-  if (!HasCaret())
+  if (!GetOwner()->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 BrowserAccessibilityWin::get_characterExtents(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetText();
+  const base::string16& text_str = GetOwner()->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 = GetScreenBoundsForRange(offset, 1);
+    character_bounds = GetOwner()->GetScreenBoundsForRange(offset, 1);
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
-    character_bounds = GetPageBoundsForRange(offset, 1);
-    if (PlatformGetParent())
-      character_bounds -=
-          PlatformGetParent()->GetPageBoundsRect().OffsetFromOrigin();
+    character_bounds = GetOwner()->GetPageBoundsForRange(offset, 1);
+    if (GetOwner()->PlatformGetParent())
+      character_bounds -= GetOwner()
+                              ->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 BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nSelections(LONG* n_selections) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::get_selection(LONG selection_index,
-                                                    LONG* start_offset,
-                                                    LONG* end_offset) {
+STDMETHODIMP BrowserAccessibilityComWin::get_selection(LONG selection_index,
+                                                       LONG* start_offset,
+                                                       LONG* end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 &&
       selection_start != selection_end) {
     // We should ignore the direction of the selection when exposing start and
     // end offsets. According to the IA2 Spec the end offset is always increased
     // by one past the end of the selection. This wouldn't make sense if
     // end < start.
     if (selection_end < selection_start)
       std::swap(selection_start, selection_end);
 
     *start_offset = selection_start;
     *end_offset = selection_end;
     return S_OK;
   }
 
   return E_INVALIDARG;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
-                                               LONG end_offset,
-                                               BSTR* text) {
+STDMETHODIMP BrowserAccessibilityComWin::get_text(LONG start_offset,
+                                                  LONG end_offset,
+                                                  BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
-  const base::string16& text_str = GetText();
+  const base::string16& text_str = GetOwner()->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;
   }
 
   // The spec does not allow the start or end offsets to be out or range;
   // we must return an error if so.
   LONG len = text_str.length();
   if (start_offset < 0)
     return E_INVALIDARG;
   if (end_offset > len)
     return E_INVALIDARG;
 
-  base::string16 substr = text_str.substr(start_offset,
-                                          end_offset - start_offset);
+  base::string16 substr =
+      text_str.substr(start_offset, end_offset - start_offset);
 
   if (substr.empty())
     return S_FALSE;
 
   *text = SysAllocString(substr.c_str());
   DCHECK(*text);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_textAtOffset(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 = GetText();
+  const base::string16& text_str = GetOwner()->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;
     return S_FALSE;
   }
 
   // According to the IA2 Spec, only line boundaries should succeed when
   // the offset is one past the end of the text.
   if (offset == text_len) {
     if (boundary_type == IA2_TEXT_BOUNDARY_LINE) {
       --offset;
     } else {
       *start_offset = 0;
       *end_offset = 0;
       *text = nullptr;
       return S_FALSE;
     }
   }
 
-  *start_offset = FindBoundary(
-      text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
-  *end_offset = FindBoundary(
-      text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
+  *start_offset =
+      FindBoundary(text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
+  *end_offset =
+      FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_textBeforeOffset(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
-  const base::string16& text_str = GetText();
+  const base::string16& text_str = GetOwner()->GetText();
 
-  *start_offset = FindBoundary(
-      text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
+  *start_offset =
+      FindBoundary(text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = offset;
   return get_text(*start_offset, *end_offset, text);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_textAfterOffset(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
-  const base::string16& text_str = GetText();
+  const base::string16& text_str = GetOwner()->GetText();
 
   *start_offset = offset;
-  *end_offset = FindBoundary(
-      text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
+  *end_offset =
+      FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_newText(IA2TextSegment* new_text) {
+STDMETHODIMP BrowserAccessibilityComWin::get_newText(IA2TextSegment* new_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEW_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 = GetText().substr(start, new_len);
+  base::string16 substr = GetOwner()->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 BrowserAccessibilityWin::get_oldText(IA2TextSegment* old_text) {
+STDMETHODIMP BrowserAccessibilityComWin::get_oldText(IA2TextSegment* old_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OLD_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 BrowserAccessibilityWin::get_offsetAtPoint(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement this. We're returning S_OK for now so that
   // screen readers still return partially accurate results rather than
   // completely failing.
   *offset = 0;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::scrollSubstringTo(
+STDMETHODIMP BrowserAccessibilityComWin::scrollSubstringTo(
     LONG start_index,
     LONG end_index,
     IA2ScrollType scroll_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_SUBSTRING_TO);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   // TODO(dmazzoni): adjust this for the start and end index, too.
   return scrollTo(scroll_type);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::scrollSubstringToPoint(
+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() || !GetOwner()->instance_active())
+    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 = GetPageBoundsForRange(start_index, length);
-  string_bounds -= GetPageBoundsRect().OffsetFromOrigin();
+  gfx::Rect string_bounds =
+      GetOwner()->GetPageBoundsForRange(start_index, length);
+  string_bounds -= GetOwner()->GetPageBoundsRect().OffsetFromOrigin();
   x -= string_bounds.x();
   y -= string_bounds.y();
 
   return scrollToPoint(coordinate_type, x, y);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
-                                                   LONG end_offset) {
+STDMETHODIMP BrowserAccessibilityComWin::addSelection(LONG start_offset,
+                                                      LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ADD_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   // We only support one selection.
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::removeSelection(LONG selection_index) {
+STDMETHODIMP BrowserAccessibilityComWin::removeSelection(LONG selection_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_REMOVE_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 (HasCaret() && selection_end >= 0)
+  if (GetOwner()->HasCaret() && selection_end >= 0)
     caret_offset = selection_end;
   SetIA2HypertextSelection(caret_offset, caret_offset);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::setCaretOffset(LONG offset) {
+STDMETHODIMP BrowserAccessibilityComWin::setCaretOffset(LONG offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
   SetIA2HypertextSelection(offset, offset);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::setSelection(LONG selection_index,
-                                                   LONG start_offset,
-                                                   LONG end_offset) {
+STDMETHODIMP BrowserAccessibilityComWin::setSelection(LONG selection_index,
+                                                      LONG start_offset,
+                                                      LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
   if (selection_index != 0)
     return E_INVALIDARG;
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_attributes(LONG offset,
-                                                     LONG* start_offset,
-                                                     LONG* end_offset,
-                                                     BSTR* text_attributes) {
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  const base::string16 text = GetText();
+  const base::string16 text = GetOwner()->GetText();
   HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text.size()))
     return E_INVALIDARG;
 
   ComputeStylesIfNeeded();
   *start_offset = FindStartOfStyle(offset, ui::BACKWARDS_DIRECTION);
   *end_offset = FindStartOfStyle(offset, ui::FORWARDS_DIRECTION);
 
   base::string16 attributes_str;
   const std::vector<base::string16>& attributes =
       offset_to_text_attributes().find(*start_offset)->second;
   for (const base::string16& attribute : attributes) {
     attributes_str += attribute + L';';
   }
 
   if (attributes.empty())
     return S_FALSE;
 
   *text_attributes = SysAllocString(attributes_str.c_str());
   DCHECK(*text_attributes);
   return S_OK;
 }
 
 //
 // IAccessibleHypertext methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nHyperlinks(
+    long* hyperlink_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_HYPERLINKS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!hyperlink_count)
     return E_INVALIDARG;
 
   *hyperlink_count = hyperlink_offset_to_index().size();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_hyperlink(
+STDMETHODIMP BrowserAccessibilityComWin::get_hyperlink(
     long index,
     IAccessibleHyperlink** hyperlink) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  if (!hyperlink ||
-      index < 0 ||
+  if (!hyperlink || index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
   int32_t id = hyperlinks()[index];
-  BrowserAccessibilityWin* link =
-      ToBrowserAccessibilityWin(GetFromUniqueID(id));
+  BrowserAccessibilityComWin* link =
+      ToBrowserAccessibilityComWin(GetOwner()->GetFromUniqueID(id));
   if (!link)
     return E_FAIL;
 
   *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
+STDMETHODIMP BrowserAccessibilityComWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
 
-  if (char_index < 0 || char_index >= static_cast<long>(GetText().size())) {
+  if (char_index < 0 ||
+      char_index >= static_cast<long>(GetOwner()->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 BrowserAccessibilityWin::get_anchor(long index, VARIANT* anchor) {
+STDMETHODIMP BrowserAccessibilityComWin::get_anchor(long index,
+                                                    VARIANT* anchor) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active() || !IsHyperlink())
+  if (!GetOwner()->instance_active() || !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(GetText().c_str());
+  BSTR ia2_hypertext = SysAllocString(GetOwner()->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 BrowserAccessibilityWin::get_anchorTarget(long index,
-                                                       VARIANT* anchor_target) {
+STDMETHODIMP BrowserAccessibilityComWin::get_anchorTarget(
+    long index,
+    VARIANT* anchor_target) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR_TARGET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active() || !IsHyperlink())
+  if (!GetOwner()->instance_active() || !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 BrowserAccessibilityWin::get_startIndex(long* index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_startIndex(long* index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_START_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active() || !IsHyperlink())
+  if (!GetOwner()->instance_active() || !IsHyperlink())
     return E_FAIL;
 
   if (!index)
     return E_INVALIDARG;
 
   int32_t hypertext_offset = 0;
-  auto* parent = PlatformGetParent();
+  auto* parent = GetOwner()->PlatformGetParent();
   if (parent) {
     hypertext_offset =
-        ToBrowserAccessibilityWin(parent)->GetHypertextOffsetFromChild(*this);
+        ToBrowserAccessibilityComWin(parent)->GetHypertextOffsetFromChild(
+            *this);
   }
   *index = static_cast<LONG>(hypertext_offset);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_endIndex(long* index) {
+STDMETHODIMP BrowserAccessibilityComWin::get_endIndex(long* index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_END_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   LONG start_index;
   HRESULT hr = get_startIndex(&start_index);
   if (hr == S_OK)
     *index = start_index + 1;
   return hr;
 }
 
 // This method is deprecated in the IA2 Spec.
-STDMETHODIMP BrowserAccessibilityWin::get_valid(boolean* valid) {
+STDMETHODIMP BrowserAccessibilityComWin::get_valid(boolean* valid) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_VALID);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleAction partly implemented.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::nActions(long* n_actions) {
+STDMETHODIMP BrowserAccessibilityComWin::nActions(long* n_actions) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_N_ACTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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() || HasIntAttribute(ui::AX_ATTR_ACTION)) {
+  if (IsHyperlink() || GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION)) {
     *n_actions = 1;
   } else {
     *n_actions = 0;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::doAction(long action_index) {
+STDMETHODIMP BrowserAccessibilityComWin::doAction(long action_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_DO_ACTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  if (!HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
+  if (!GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
     return E_INVALIDARG;
 
-  manager_->DoDefaultAction(*this);
+  GetOwner()->manager()->DoDefaultAction(*GetOwner());
   return S_OK;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::get_description(long action_index, BSTR* description) {
+BrowserAccessibilityComWin::get_description(long action_index,
+                                            BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IAACTION_GET_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_keyBinding(long action_index,
-                                                     long n_max_bindings,
-                                                     BSTR** key_bindings,
-                                                     long* n_bindings) {
+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 BrowserAccessibilityWin::get_name(long action_index, BSTR* name) {
+STDMETHODIMP BrowserAccessibilityComWin::get_name(long action_index,
+                                                  BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
   int action;
-  if (!GetIntAttribute(ui::AX_ATTR_ACTION, &action) || action_index != 0) {
+  if (!GetOwner()->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
-BrowserAccessibilityWin::get_localizedName(long action_index,
-                                           BSTR* localized_name) {
+BrowserAccessibilityComWin::get_localizedName(long action_index,
+                                              BSTR* localized_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!localized_name)
     return E_INVALIDARG;
 
   int action;
-  if (!GetIntAttribute(ui::AX_ATTR_ACTION, &action) || action_index != 0) {
+  if (!GetOwner()->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 BrowserAccessibilityWin::get_currentValue(VARIANT* value) {
+STDMETHODIMP BrowserAccessibilityComWin::get_currentValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CURRENT_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
-  if (GetFloatAttribute(
-          ui::AX_ATTR_VALUE_FOR_RANGE, &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 BrowserAccessibilityWin::get_minimumValue(VARIANT* value) {
+STDMETHODIMP BrowserAccessibilityComWin::get_minimumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MINIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
-  if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE,
-                        &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 BrowserAccessibilityWin::get_maximumValue(VARIANT* value) {
+STDMETHODIMP BrowserAccessibilityComWin::get_maximumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MAXIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
-  if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE,
-                        &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 BrowserAccessibilityWin::setCurrentValue(VARIANT new_value) {
+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 BrowserAccessibilityWin::get_URL(BSTR* url) {
+STDMETHODIMP BrowserAccessibilityComWin::get_URL(BSTR* url) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_URL);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
-  if (this != manager_->GetRoot())
+  if (GetOwner() != manager->GetRoot())
     return E_FAIL;
 
-  std::string str = manager_->GetTreeData().url;
+  std::string str = manager->GetTreeData().url;
   if (str.empty())
     return S_FALSE;
 
   *url = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*url);
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
+STDMETHODIMP BrowserAccessibilityComWin::get_title(BSTR* title) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TITLE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
-  std::string str = manager_->GetTreeData().title;
+  std::string str = manager->GetTreeData().title;
   if (str.empty())
     return S_FALSE;
 
   *title = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*title);
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
+STDMETHODIMP BrowserAccessibilityComWin::get_mimeType(BSTR* mime_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MIME_TYPE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
-  std::string str = manager_->GetTreeData().mimetype;
+  std::string str = manager->GetTreeData().mimetype;
   if (str.empty())
     return S_FALSE;
 
   *mime_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*mime_type);
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
+STDMETHODIMP BrowserAccessibilityComWin::get_docType(BSTR* doc_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOC_TYPE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+
+  auto* manager = GetOwner()->manager();
+  if (!manager)
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
-  std::string str = manager_->GetTreeData().doctype;
+  std::string str = manager->GetTreeData().doctype;
   if (str.empty())
     return S_FALSE;
 
   *doc_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*doc_type);
 
   return S_OK;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::get_nameSpaceURIForID(short name_space_id,
-                                               BSTR* name_space_uri) {
+BrowserAccessibilityComWin::get_nameSpaceURIForID(short name_space_id,
+                                                  BSTR* name_space_uri) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAMESPACE_URI_FOR_ID);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::put_alternateViewMediaTypes(
+BrowserAccessibilityComWin::put_alternateViewMediaTypes(
     BSTR* comma_separated_media_types) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_PUT_ALTERNATE_VIEW_MEDIA_TYPES);
   return E_NOTIMPL;
 }
 
 //
 // ISimpleDOMNode methods.
 //
 
-STDMETHODIMP BrowserAccessibilityWin::get_nodeInfo(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node_name || !name_space_id || !node_value || !num_children ||
       !unique_id || !node_type) {
     return E_INVALIDARG;
   }
 
   base::string16 tag;
-  if (GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
+  if (GetOwner()->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 = PlatformChildCount();
-  *unique_id = -this->unique_id();
+  *num_children = GetOwner()->PlatformChildCount();
+  *unique_id = -GetOwner()->unique_id();
 
-  if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
-    GetRole() == ui::AX_ROLE_WEB_AREA) {
+  if (GetOwner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+      GetOwner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
     *node_type = NODETYPE_DOCUMENT;
-  } else if (IsTextOnlyObject()) {
+  } else if (GetOwner()->IsTextOnlyObject()) {
     *node_type = NODETYPE_TEXT;
   } else {
     *node_type = NODETYPE_ELEMENT;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_attributes(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
-  if (*num_attribs > GetHtmlAttributes().size())
-    *num_attribs = GetHtmlAttributes().size();
+  if (*num_attribs > GetOwner()->GetHtmlAttributes().size())
+    *num_attribs = GetOwner()->GetHtmlAttributes().size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(
-        base::UTF8ToUTF16(GetHtmlAttributes()[i].first).c_str());
+        base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].first).c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(
-        base::UTF8ToUTF16(GetHtmlAttributes()[i].second).c_str());
+        base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].second).c_str());
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_attributesForNames(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values)
     return E_INVALIDARG;
 
   for (unsigned short i = 0; i < num_attribs; ++i) {
     name_space_id[i] = 0;
     bool found = false;
     std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
-    for (unsigned int j = 0;  j < GetHtmlAttributes().size(); ++j) {
-      if (GetHtmlAttributes()[j].first == name) {
+    for (unsigned int j = 0; j < GetOwner()->GetHtmlAttributes().size(); ++j) {
+      if (GetOwner()->GetHtmlAttributes()[j].first == name) {
         attrib_values[i] = SysAllocString(
-            base::UTF8ToUTF16(GetHtmlAttributes()[j].second).c_str());
+            base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[j].second)
+                .c_str());
         found = true;
         break;
       }
     }
     if (!found) {
       attrib_values[i] = NULL;
     }
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_computedStyle(
+STDMETHODIMP BrowserAccessibilityComWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values,
-    unsigned short *num_style_properties)  {
+    unsigned short* num_style_properties) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 ||
-      !GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
+      !GetOwner()->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 BrowserAccessibilityWin::get_computedStyleForProperties(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 = GetString16Attribute(
-          ui::AX_ATTR_DISPLAY);
+      base::string16 display =
+          GetOwner()->GetString16Attribute(ui::AX_ATTR_DISPLAY);
       style_values[i] = SysAllocString(display.c_str());
     } else {
       style_values[i] = NULL;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
+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);
+  return scrollTo(placeTopLeft ? IA2_SCROLL_TYPE_TOP_LEFT
+                               : IA2_SCROLL_TYPE_ANYWHERE);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityComWin::get_parentNode(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PARENT_NODE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  *node = ToBrowserAccessibilityWin(PlatformGetParent())->NewReference();
+  *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent())
+              ->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node)  {
+STDMETHODIMP BrowserAccessibilityComWin::get_firstChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FIRST_CHILD);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (PlatformChildCount() == 0) {
+  if (GetOwner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityWin(PlatformGetChild(0))->NewReference();
+  *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(0))
+              ->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityComWin::get_lastChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LAST_CHILD);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (PlatformChildCount() == 0) {
+  if (GetOwner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityWin(
-      PlatformGetChild(PlatformChildCount() - 1))->NewReference();
+  *node =
+      ToBrowserAccessibilityComWin(
+          GetOwner()->PlatformGetChild(GetOwner()->PlatformChildCount() - 1))
+          ->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
+STDMETHODIMP BrowserAccessibilityComWin::get_previousSibling(
     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PREVIOUS_SIBLING);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!PlatformGetParent() || GetIndexInParent() <= 0) {
+  if (!GetOwner()->PlatformGetParent() || GetIndexInParent() <= 0) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityWin(
-              PlatformGetParent()->InternalGetChild(GetIndexInParent() - 1))
+  *node = ToBrowserAccessibilityComWin(
+              GetOwner()->PlatformGetParent()->InternalGetChild(
+                  GetIndexInParent() - 1))
               ->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityComWin::get_nextSibling(
+    ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEXT_SIBLING);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (!PlatformGetParent() || GetIndexInParent() < 0 ||
+  if (!GetOwner()->PlatformGetParent() || GetIndexInParent() < 0 ||
       GetIndexInParent() >=
-          static_cast<int>(PlatformGetParent()->InternalChildCount()) - 1) {
+          static_cast<int>(
+              GetOwner()->PlatformGetParent()->InternalChildCount()) -
+              1) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityWin(
-              PlatformGetParent()->InternalGetChild(GetIndexInParent() + 1))
+  *node = ToBrowserAccessibilityComWin(
+              GetOwner()->PlatformGetParent()->InternalGetChild(
+                  GetIndexInParent() + 1))
               ->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_childAt(
-    unsigned int child_index,
-    ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityComWin::get_childAt(unsigned int child_index,
+                                                     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_AT);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
-  if (child_index >= PlatformChildCount())
+  if (child_index >= GetOwner()->PlatformChildCount())
     return E_INVALIDARG;
 
-  BrowserAccessibility* child = PlatformGetChild(child_index);
+  BrowserAccessibility* child = GetOwner()->PlatformGetChild(child_index);
   if (!child) {
     *node = NULL;
     return S_FALSE;
   }
 
-  *node = ToBrowserAccessibilityWin(child)->NewReference();
+  *node = ToBrowserAccessibilityComWin(child)->NewReference();
   return S_OK;
 }
 
 // We only support this method for retrieving MathML content.
-STDMETHODIMP BrowserAccessibilityWin::get_innerHTML(BSTR* innerHTML) {
+STDMETHODIMP BrowserAccessibilityComWin::get_innerHTML(BSTR* innerHTML) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INNER_HTML);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (GetRole() != ui::AX_ROLE_MATH)
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
+  if (GetOwner()->GetRole() != ui::AX_ROLE_MATH)
     return E_NOTIMPL;
-  if (!instance_active())
-    return E_FAIL;
 
-  base::string16 inner_html = GetString16Attribute(ui::AX_ATTR_INNER_HTML);
+  base::string16 inner_html =
+      GetOwner()->GetString16Attribute(ui::AX_ATTR_INNER_HTML);
   *innerHTML = SysAllocString(inner_html.c_str());
   DCHECK(*innerHTML);
   return S_OK;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::get_localInterface(void** local_interface) {
+BrowserAccessibilityComWin::get_localInterface(void** local_interface) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCAL_INTERFACE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_language(BSTR* language) {
+STDMETHODIMP BrowserAccessibilityComWin::get_language(BSTR* language) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LANGUAGE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!language)
     return E_INVALIDARG;
   *language = nullptr;
 
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  base::string16 lang = GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE);
+  base::string16 lang =
+      GetOwner()->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 BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
+STDMETHODIMP BrowserAccessibilityComWin::get_domText(BSTR* dom_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOM_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
-  return GetStringAttributeAsBstr(
-      ui::AX_ATTR_NAME, dom_text);
+  return GetStringAttributeAsBstr(ui::AX_ATTR_NAME, dom_text);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_clippedSubstringBounds(
+STDMETHODIMP BrowserAccessibilityComWin::get_clippedSubstringBounds(
     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_CLIPPED_SUBSTRING_BOUNDS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
   // TODO(dmazzoni): fully support this API by intersecting the
   // rect with the container's rect.
-  return get_unclippedSubstringBounds(
-      start_index, end_index, out_x, out_y, out_width, out_height);
+  return get_unclippedSubstringBounds(start_index, end_index, out_x, out_y,
+                                      out_width, out_height);
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_unclippedSubstringBounds(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
-  unsigned int text_length = static_cast<unsigned int>(GetText().size());
+  unsigned int text_length =
+      static_cast<unsigned int>(GetOwner()->GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
-  gfx::Rect bounds = GetScreenBoundsForRange(
-      start_index, end_index - start_index);
+  gfx::Rect bounds =
+      GetOwner()->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 BrowserAccessibilityWin::scrollToSubstring(
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
-  unsigned int text_length = static_cast<unsigned int>(GetText().size());
+  auto* manager = GetOwner()->manager();
+  if (!manager)
+    return E_FAIL;
+
+  unsigned int text_length =
+      static_cast<unsigned int>(GetOwner()->GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
-  manager_->ScrollToMakeVisible(
-      *this, GetPageBoundsForRange(start_index, end_index - start_index));
+  manager->ScrollToMakeVisible(
+      *GetOwner(),
+      GetOwner()->GetPageBoundsForRange(start_index, end_index - start_index));
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_fontFamily(BSTR* font_family) {
+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 (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     return E_FAIL;
 
   base::string16 family =
-      GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
+      GetOwner()->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 BrowserAccessibilityWin::QueryService(REFGUID guid_service,
-                                                   REFIID riid,
-                                                   void** object) {
+STDMETHODIMP BrowserAccessibilityComWin::QueryService(REFGUID guid_service,
+                                                      REFIID riid,
+                                                      void** object) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_QUERY_SERVICE);
-  if (!instance_active())
+  if (!GetOwner() || !GetOwner()->instance_active())
     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 = this;
+    BrowserAccessibility* node = GetOwner();
     while (node->PlatformGetParent())
       node = node->PlatformGetParent()->manager()->GetRoot();
-    return ToBrowserAccessibilityWin(node)->QueryInterface(
-        IID_IAccessible2, object);
+    return ToBrowserAccessibilityComWin(node)->QueryInterface(IID_IAccessible2,
+                                                              object);
   }
 
-  if (guid_service == IID_IAccessible ||
-      guid_service == IID_IAccessible2 ||
+  if (guid_service == IID_IAccessible || guid_service == IID_IAccessible2 ||
       guid_service == IID_IAccessibleAction ||
       guid_service == IID_IAccessibleApplication ||
       guid_service == IID_IAccessibleHyperlink ||
       guid_service == IID_IAccessibleHypertext ||
       guid_service == IID_IAccessibleImage ||
       guid_service == IID_IAccessibleTable ||
       guid_service == IID_IAccessibleTable2 ||
       guid_service == IID_IAccessibleTableCell ||
       guid_service == IID_IAccessibleText ||
       guid_service == IID_IAccessibleValue ||
       guid_service == IID_ISimpleDOMDocument ||
       guid_service == IID_ISimpleDOMNode ||
-      guid_service == IID_ISimpleDOMText ||
-      guid_service == GUID_ISimpleDOM) {
+      guid_service == IID_ISimpleDOMText || guid_service == GUID_ISimpleDOM) {
     return QueryInterface(riid, object);
   }
 
   // We only support the IAccessibleEx interface on Windows 8 and above. This
   // is needed for the on-screen Keyboard to show up in metro mode, when the
   // user taps an editable portion on the page.
   // All methods in the IAccessibleEx interface are unimplemented.
   if (riid == IID_IAccessibleEx &&
       base::win::GetVersion() >= base::win::VERSION_WIN8) {
     return QueryInterface(riid, object);
   }
 
   *object = NULL;
   return E_FAIL;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::GetObjectForChild(long child_id, IAccessibleEx** ret) {
+BrowserAccessibilityComWin::GetObjectForChild(long child_id,
+                                              IAccessibleEx** ret) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OBJECT_FOR_CHILD);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::GetIAccessiblePair(IAccessible** acc, long* child_id) {
+BrowserAccessibilityComWin::GetIAccessiblePair(IAccessible** acc,
+                                               long* child_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IACCESSIBLE_PAIR);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::GetRuntimeId(SAFEARRAY** runtime_id) {
+STDMETHODIMP BrowserAccessibilityComWin::GetRuntimeId(SAFEARRAY** runtime_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RUNTIME_ID);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
-BrowserAccessibilityWin::ConvertReturnedElement(
+BrowserAccessibilityComWin::ConvertReturnedElement(
     IRawElementProviderSimple* element,
     IAccessibleEx** acc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_CONVERT_RETURNED_ELEMENT);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::GetPatternProvider(PATTERNID id,
-                                                         IUnknown** provider) {
+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() || !GetOwner()->instance_active())
+    return E_FAIL;
+
   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
-    if (HasState(ui::AX_STATE_EDITABLE)) {
+    if (GetOwner()->HasState(ui::AX_STATE_EDITABLE)) {
       DVLOG(1) << "Returning UIA text provider";
-      base::win::UIATextProvider::CreateTextProvider(
-          GetValueText(), true, provider);
+      base::win::UIATextProvider::CreateTextProvider(GetValueText(), true,
+                                                     provider);
       return S_OK;
     }
   }
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::GetPropertyValue(PROPERTYID id,
-                                                       VARIANT* ret) {
+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() || !GetOwner()->instance_active())
+    return E_FAIL;
+
   V_VT(ret) = VT_EMPTY;
   if (id == UIA_ControlTypePropertyId) {
-    if (HasState(ui::AX_STATE_EDITABLE)) {
+    if (GetOwner()->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;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_ProviderOptions(
+STDMETHODIMP BrowserAccessibilityComWin::get_ProviderOptions(
     ProviderOptions* ret) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PROVIDER_OPTIONS);
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibilityWin::get_HostRawElementProvider(
+STDMETHODIMP BrowserAccessibilityComWin::get_HostRawElementProvider(
     IRawElementProviderSimple** provider) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HOST_RAW_ELEMENT_PROVIDER);
   return E_NOTIMPL;
 }
 
 //
 // CComObjectRootEx methods.
 //
 
 // static
-HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
+HRESULT WINAPI BrowserAccessibilityComWin::InternalQueryInterface(
     void* this_ptr,
     const _ATL_INTMAP_ENTRY* entries,
     REFIID iid,
     void** object) {
-  BrowserAccessibilityWin* accessibility =
-      reinterpret_cast<BrowserAccessibilityWin*>(this_ptr);
+  BrowserAccessibilityComWin* accessibility =
+      reinterpret_cast<BrowserAccessibilityComWin*>(this_ptr);
   int32_t ia_role = accessibility->ia_role();
   if (iid == IID_IAccessibleImage) {
     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->IsCellOrTableHeaderRole()) {
+    if (!accessibility->GetOwner()->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) {
+        ia_role != ROLE_SYSTEM_SCROLLBAR && ia_role != ROLE_SYSTEM_SLIDER) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_ISimpleDOMDocument) {
     if (ia_role != ROLE_SYSTEM_DOCUMENT) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleHyperlink) {
     auto* ax_object =
-        reinterpret_cast<const BrowserAccessibilityWin*>(this_ptr);
+        reinterpret_cast<const BrowserAccessibilityComWin*>(this_ptr);
     if (!ax_object || !ax_object->IsHyperlink()) {
       *object = nullptr;
       return E_NOINTERFACE;
     }
   }
 
-  return CComObjectRootBase::InternalQueryInterface(
-      this_ptr, entries, iid, object);
+  return CComObjectRootBase::InternalQueryInterface(this_ptr, entries, iid,
+                                                    object);
 }
 
-void BrowserAccessibilityWin::ComputeStylesIfNeeded() {
+void BrowserAccessibilityComWin::ComputeStylesIfNeeded() {
   if (!offset_to_text_attributes().empty())
     return;
 
   std::map<int, std::vector<base::string16>> attributes_map;
-  if (PlatformIsLeaf() || IsSimpleTextControl()) {
+  if (GetOwner()->PlatformIsLeaf() || GetOwner()->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 < PlatformChildCount(); ++i) {
-    auto* child = ToBrowserAccessibilityWin(PlatformGetChild(i));
+  for (size_t i = 0; i < GetOwner()->PlatformChildCount(); ++i) {
+    auto* child = ToBrowserAccessibilityComWin(GetOwner()->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->IsTextOnlyObject())
-      start_offset += child->GetText().length();
+    if (child->GetOwner()->IsTextOnlyObject())
+      start_offset += child->GetOwner()->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.
-BrowserAccessibilityWin::AXPlatformPositionInstance
-BrowserAccessibilityWin::CreatePositionForSelectionAt(int offset) const {
-  if (!IsNativeTextControl() && !IsTextOnlyObject()) {
-    DCHECK(manager_);
-    const BrowserAccessibilityWin* child = this;
+AXPlatformPosition::AXPositionInstance
+BrowserAccessibilityComWin::CreatePositionForSelectionAt(int offset) const {
+  if (!GetOwner()->IsNativeTextControl() && !GetOwner()->IsTextOnlyObject()) {
+    auto* manager = GetOwner()->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 < InternalChildCount(); ++i) {
+    for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
       int new_offset = offset;
-      child = ToBrowserAccessibilityWin(InternalGetChild(i));
+      child = ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i));
       DCHECK(child);
-      if (child->IsTextOnlyObject()) {
-        new_offset -= child->GetText().length();
+      if (child->GetOwner()->IsTextOnlyObject()) {
+        new_offset -= child->GetOwner()->GetText().length();
       } else {
         new_offset -= 1;
       }
       if (new_offset <= 0)
         break;
       offset = new_offset;
     }
     AXPlatformPositionInstance position =
-        AXPlatformPosition::CreateTextPosition(manager_->ax_tree_id(),
-                                               child->GetId(), offset,
-                                               ui::AX_TEXT_AFFINITY_DOWNSTREAM)
+        AXPlatformPosition::CreateTextPosition(
+            manager->ax_tree_id(), child->GetOwner()->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 CreatePositionAt(offset);
-}
-
-base::string16 BrowserAccessibilityWin::GetText() const {
-  if (PlatformIsChildOfLeaf())
-    return BrowserAccessibility::GetText();
-  return win_attributes_->hypertext;
+  return GetOwner()->CreatePositionAt(offset);
 }
 
 //
 // Private methods.
 //
 
-void BrowserAccessibilityWin::UpdateStep1ComputeWinAttributes() {
+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.
   old_win_attributes_.swap(win_attributes_);
   win_attributes_.reset(new WinAttributes());
 
   InitRoleAndState();
 
   win_attributes_->ia2_attributes.clear();
 
@@ skipping 22 matching lines @@
     win_attributes_->ia2_attributes.push_back(L"checkable:true");
   }
 
   // Expose live region attributes.
   StringAttributeToIA2(ui::AX_ATTR_LIVE_STATUS, "live");
   StringAttributeToIA2(ui::AX_ATTR_LIVE_RELEVANT, "relevant");
   BoolAttributeToIA2(ui::AX_ATTR_LIVE_ATOMIC, "atomic");
   BoolAttributeToIA2(ui::AX_ATTR_LIVE_BUSY, "busy");
 
   // Expose container live region attributes.
-  StringAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_STATUS,
-                       "container-live");
+  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");
+  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 (GetIntAttribute(ui::AX_ATTR_NAME_FROM, &name_from) &&
+  if (GetOwner()->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 (GetIntAttribute(ui::AX_ATTR_ARIA_CURRENT_STATE, &aria_current_state)) {
+  if (GetOwner()->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 (IsCellOrTableHeaderRole()) {
-    BrowserAccessibility* table = PlatformGetParent();
+  if (GetOwner()->IsCellOrTableHeaderRole()) {
+    BrowserAccessibility* table = GetOwner()->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] == GetId()) {
+        if (unique_cell_ids[i] == GetOwner()->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 (IsTableLikeRole()) {
+  if (GetOwner()->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 (IsCellOrTableHeaderRole() || GetRole() == ui::AX_ROLE_ROW) {
-    if (GetRole() != ui::AX_ROLE_ROW)
+  if (GetOwner()->IsCellOrTableHeaderRole() ||
+      GetOwner()->GetRole() == ui::AX_ROLE_ROW) {
+    if (GetOwner()->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) &&
-      GetIntAttribute(ui::AX_ATTR_SORT_DIRECTION, &sort_direction)) {
+       ia_role() == ROLE_SYSTEM_ROWHEADER) &&
+      GetOwner()->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 = GetString16Attribute(ui::AX_ATTR_NAME);
-  win_attributes_->description = GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
+  win_attributes_->name = GetOwner()->GetString16Attribute(ui::AX_ATTR_NAME);
+  win_attributes_->description =
+      GetOwner()->GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
   StringAttributeToIA2(ui::AX_ATTR_PLACEHOLDER, "placeholder");
 
-  base::string16 value = GetValue();
+  base::string16 value = GetOwner()->GetValue();
   // On Windows, the value of a document should be its url.
-  if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
-      GetRole() == ui::AX_ROLE_WEB_AREA) {
-    value = base::UTF8ToUTF16(manager_->GetTreeData().url);
+  if (GetOwner()->GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
+      GetOwner()->GetRole() == ui::AX_ROLE_WEB_AREA) {
+    value = base::UTF8ToUTF16(GetOwner()->manager()->GetTreeData().url);
   }
   // If this doesn't have a value and is linked then set its value to the url
   // attribute. This allows screen readers to read an empty link's destination.
   if (value.empty() && (ia_state() & STATE_SYSTEM_LINKED))
-    value = GetString16Attribute(ui::AX_ATTR_URL);
+    value = GetOwner()->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 (GetIntAttribute(ui::AX_ATTR_MEMBER_OF_ID, &member_of_id))
+  if (GetOwner()->GetIntAttribute(ui::AX_ATTR_MEMBER_OF_ID, &member_of_id))
     AddRelation(IA2_RELATION_MEMBER_OF, member_of_id);
 
   int error_message_id;
-  if (GetIntAttribute(ui::AX_ATTR_ERRORMESSAGE_ID, &error_message_id))
+  if (GetOwner()->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) {
+      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 (IsWebAreaForPresentationalIframe()) {
+  if (GetOwner()->IsWebAreaForPresentationalIframe()) {
     win_attributes_->ia_role = ROLE_SYSTEM_GROUPING;
     win_attributes_->ia2_role = ROLE_SYSTEM_GROUPING;
   }
 }
 
-void BrowserAccessibilityWin::UpdateStep2ComputeHypertext() {
-  if (IsSimpleTextControl()) {
+void BrowserAccessibilityComWin::UpdateStep2ComputeHypertext() {
+  if (GetOwner()->IsSimpleTextControl()) {
     win_attributes_->hypertext = value();
     return;
   }
 
-  if (!PlatformChildCount()) {
-    if (IsRichTextControl()) {
+  if (!GetOwner()->PlatformChildCount()) {
+    if (GetOwner()->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 < PlatformChildCount(); ++i) {
-    auto* child = ToBrowserAccessibilityWin(PlatformGetChild(i));
+  for (unsigned int i = 0; i < GetOwner()->PlatformChildCount(); ++i) {
+    auto* child = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(i));
     DCHECK(child);
     // Similar to Firefox, we don't expose text-only objects in IA2 hypertext.
-    if (child->IsTextOnlyObject()) {
+    if (child->GetOwner()->IsTextOnlyObject()) {
       win_attributes_->hypertext += child->name();
     } else {
-      int32_t char_offset = static_cast<int32_t>(GetText().size());
-      int32_t child_unique_id = child->unique_id();
+      int32_t char_offset = static_cast<int32_t>(GetOwner()->GetText().size());
+      int32_t child_unique_id = child->GetOwner()->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 BrowserAccessibilityWin::UpdateStep3FireEvents(bool is_subtree_creation) {
+void BrowserAccessibilityComWin::UpdateStep3FireEvents(
+    bool is_subtree_creation) {
   // Fire an event when a new subtree is created.
   if (is_subtree_creation)
     FireNativeEvent(EVENT_OBJECT_SHOW);
 
   // The rest of the events only fire on changes, not on new objects.
   if (old_win_attributes_->ia_role != 0 ||
       !old_win_attributes_->role_name.empty()) {
     // Fire an event if the name, description, help, or value changes.
     if (name() != old_win_attributes_->name)
       FireNativeEvent(EVENT_OBJECT_NAMECHANGE);
     if (description() != old_win_attributes_->description)
       FireNativeEvent(EVENT_OBJECT_DESCRIPTIONCHANGE);
     if (value() != old_win_attributes_->value)
       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 (PlatformGetParent() &&
-          PlatformGetParent()->HasState(ui::AX_STATE_MULTISELECTABLE))
+      if (GetOwner()->PlatformGetParent() &&
+          GetOwner()->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 (GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
-        GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
+    if (GetOwner()->GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
+        GetOwner()->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.
-    BrowserAccessibilityWin* parent =
-        ToBrowserAccessibilityWin(PlatformGetParent());
-    if (parent && IsTextOnlyObject() &&
+    BrowserAccessibilityComWin* parent =
+        ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent());
+    if (parent && GetOwner()->IsTextOnlyObject() &&
         name() != old_win_attributes_->name) {
-      parent->UpdatePlatformAttributes();
+      parent->GetOwner()->UpdatePlatformAttributes();
     }
   }
 
   old_win_attributes_.reset(nullptr);
 }
 
-void BrowserAccessibilityWin::UpdatePlatformAttributes() {
-  UpdateStep1ComputeWinAttributes();
-  UpdateStep2ComputeHypertext();
-  UpdateStep3FireEvents(false);
-}
-
-void BrowserAccessibilityWin::OnSubtreeWillBeDeleted() {
-  FireNativeEvent(EVENT_OBJECT_HIDE);
-}
-
-void BrowserAccessibilityWin::NativeAddReference() {
-  AddRef();
-}
-
-void BrowserAccessibilityWin::NativeReleaseReference() {
-  Release();
-}
-
-bool BrowserAccessibilityWin::IsNative() const {
-  return true;
-}
-
-void BrowserAccessibilityWin::OnLocationChanged() {
-  FireNativeEvent(EVENT_OBJECT_LOCATIONCHANGE);
-}
-
-std::vector<base::string16> BrowserAccessibilityWin::ComputeTextAttributes()
+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 (GetRole() == ui::AX_ROLE_LIST_MARKER)
+  if (GetOwner()->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 (GetIntAttribute(ui::AX_ATTR_BACKGROUND_COLOR, &color)) {
+  if (GetOwner()->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 (GetIntAttribute(ui::AX_ATTR_COLOR, &color)) {
+  if (GetOwner()->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(
-      GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY));
+      GetOwner()->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>(GetIntAttribute(ui::AX_ATTR_TEXT_STYLE));
+  auto text_style = static_cast<ui::AXTextStyle>(
+      GetOwner()->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>(
-      GetIntAttribute(ui::AX_ATTR_INVALID_STATE));
+      GetOwner()->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 (GetString16Attribute(ui::AX_ATTR_ARIA_INVALID_VALUE,
-                               &aria_invalid_value)) {
+      if (GetOwner()->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(GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE));
+  base::string16 language(
+      GetOwner()->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>(
-      GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION));
+      GetOwner()->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;
 }
 
-BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
+BrowserAccessibilityComWin* BrowserAccessibilityComWin::NewReference() {
   AddRef();
   return this;
 }
 
 std::map<int, std::vector<base::string16>>
-BrowserAccessibilityWin::GetSpellingAttributes() const {
+BrowserAccessibilityComWin::GetSpellingAttributes() {
   std::map<int, std::vector<base::string16>> spelling_attributes;
-  if (IsTextOnlyObject()) {
+  if (GetOwner()->IsTextOnlyObject()) {
     const std::vector<int32_t>& marker_types =
-        GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
+        GetOwner()->GetIntListAttribute(ui::AX_ATTR_MARKER_TYPES);
     const std::vector<int>& marker_starts =
-        GetIntListAttribute(ui::AX_ATTR_MARKER_STARTS);
+        GetOwner()->GetIntListAttribute(ui::AX_ATTR_MARKER_STARTS);
     const std::vector<int>& marker_ends =
-        GetIntListAttribute(ui::AX_ATTR_MARKER_ENDS);
+        GetOwner()->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 (IsSimpleTextControl()) {
+  if (GetOwner()->IsSimpleTextControl()) {
     int start_offset = 0;
-    for (const BrowserAccessibility* static_text =
+    for (BrowserAccessibility* static_text =
              BrowserAccessibilityManager::NextTextOnlyObject(
-                 InternalGetChild(0));
+                 GetOwner()->InternalGetChild(0));
          static_text; static_text = static_text->GetNextSibling()) {
-      auto* text_win = ToBrowserAccessibilityWin(static_text);
+      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->GetText().length());
+        start_offset +=
+            static_cast<int>(text_win->GetOwner()->GetText().length());
       }
     }
   }
   return spelling_attributes;
 }
 
-BrowserAccessibilityWin* BrowserAccessibilityWin::GetTargetFromChildID(
+BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetTargetFromChildID(
     const VARIANT& var_id) {
+  if (!GetOwner() || !GetOwner()->instance_active())
+    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>(PlatformChildCount()))
-    return ToBrowserAccessibilityWin(PlatformGetChild(child_id - 1));
+  if (child_id >= 1 &&
+      child_id <= static_cast<LONG>(GetOwner()->PlatformChildCount()))
+    return ToBrowserAccessibilityComWin(
+        GetOwner()->PlatformGetChild(child_id - 1));
 
-  BrowserAccessibilityWin* child = ToBrowserAccessibilityWin(
+  BrowserAccessibilityComWin* child = ToBrowserAccessibilityComWin(
       BrowserAccessibility::GetFromUniqueID(-child_id));
-  if (child && child->IsDescendantOf(this))
+  if (child && child->GetOwner()->IsDescendantOf(GetOwner()))
     return child;
 
   return nullptr;
 }
 
-HRESULT BrowserAccessibilityWin::GetStringAttributeAsBstr(
+HRESULT BrowserAccessibilityComWin::GetStringAttributeAsBstr(
     ui::AXStringAttribute attribute,
     BSTR* value_bstr) {
   base::string16 str;
+  if (!GetOwner() || !GetOwner()->instance_active())
+    return E_FAIL;
 
-  if (!GetString16Attribute(attribute, &str))
+  if (!GetOwner()->GetString16Attribute(attribute, &str))
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
 
 // Static
-void BrowserAccessibilityWin::SanitizeStringAttributeForIA2(
+void BrowserAccessibilityComWin::SanitizeStringAttributeForIA2(
     const base::string16& input,
     base::string16* output) {
   DCHECK(output);
   // According to the IA2 Spec, these characters need to be escaped with a
   // backslash: backslash, colon, comma, equals and semicolon.
   // Note that backslash must be replaced first.
   base::ReplaceChars(input, L"\\", L"\\\\", output);
   base::ReplaceChars(*output, L":", L"\\:", output);
   base::ReplaceChars(*output, L",", L"\\,", output);
   base::ReplaceChars(*output, L"=", L"\\=", output);
   base::ReplaceChars(*output, L";", L"\\;", output);
 }
 
-void BrowserAccessibilityWin::SetIA2HypertextSelection(LONG start_offset,
-                                                       LONG end_offset) {
+void BrowserAccessibilityComWin::SetIA2HypertextSelection(LONG start_offset,
+                                                          LONG end_offset) {
   HandleSpecialTextOffset(&start_offset);
   HandleSpecialTextOffset(&end_offset);
   AXPlatformPositionInstance start_position =
       CreatePositionForSelectionAt(static_cast<int>(start_offset));
   AXPlatformPositionInstance end_position =
       CreatePositionForSelectionAt(static_cast<int>(end_offset));
-  manager_->SetSelection(AXPlatformRange(start_position->AsTextPosition(),
-                                         end_position->AsTextPosition()));
+  GetOwner()->manager()->SetSelection(AXPlatformRange(
+      start_position->AsTextPosition(), end_position->AsTextPosition()));
 }
 
-void BrowserAccessibilityWin::StringAttributeToIA2(
+void BrowserAccessibilityComWin::StringAttributeToIA2(
     ui::AXStringAttribute attribute,
     const char* ia2_attr) {
   base::string16 value;
-  if (GetString16Attribute(attribute, &value)) {
+  if (GetOwner()->GetString16Attribute(attribute, &value)) {
     SanitizeStringAttributeForIA2(value, &value);
-    win_attributes_->ia2_attributes.push_back(
-        base::ASCIIToUTF16(ia2_attr) + L":" + value);
+    win_attributes_->ia2_attributes.push_back(base::ASCIIToUTF16(ia2_attr) +
+                                              L":" + value);
   }
 }
 
-void BrowserAccessibilityWin::BoolAttributeToIA2(
+void BrowserAccessibilityComWin::BoolAttributeToIA2(
     ui::AXBoolAttribute attribute,
     const char* ia2_attr) {
   bool value;
-  if (GetBoolAttribute(attribute, &value)) {
+  if (GetOwner()->GetBoolAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
-        (base::ASCIIToUTF16(ia2_attr) + L":") +
-        (value ? L"true" : L"false"));
+        (base::ASCIIToUTF16(ia2_attr) + L":") + (value ? L"true" : L"false"));
   }
 }
 
-void BrowserAccessibilityWin::IntAttributeToIA2(
-    ui::AXIntAttribute attribute,
-    const char* ia2_attr) {
+void BrowserAccessibilityComWin::IntAttributeToIA2(ui::AXIntAttribute attribute,
+                                                   const char* ia2_attr) {
   int value;
-  if (GetIntAttribute(attribute, &value)) {
+  if (GetOwner()->GetIntAttribute(attribute, &value)) {
     win_attributes_->ia2_attributes.push_back(
-        base::ASCIIToUTF16(ia2_attr) + L":" +
-        base::IntToString16(value));
+        base::ASCIIToUTF16(ia2_attr) + L":" + base::IntToString16(value));
   }
 }
 
-bool BrowserAccessibilityWin::IsHyperlink() const {
+bool BrowserAccessibilityComWin::IsHyperlink() const {
   int32_t hyperlink_index = -1;
-  auto* parent = PlatformGetParent();
+  auto* parent = GetOwner()->PlatformGetParent();
   if (parent) {
     hyperlink_index =
-        ToBrowserAccessibilityWin(parent)->GetHyperlinkIndexFromChild(*this);
+        ToBrowserAccessibilityComWin(parent)->GetHyperlinkIndexFromChild(*this);
   }
 
   if (hyperlink_index >= 0)
     return true;
   return false;
 }
 
-BrowserAccessibilityWin*
-BrowserAccessibilityWin::GetHyperlinkFromHypertextOffset(int offset) const {
+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];
-  BrowserAccessibilityWin* hyperlink =
-      ToBrowserAccessibilityWin(GetFromUniqueID(id));
+  BrowserAccessibilityComWin* hyperlink =
+      ToBrowserAccessibilityComWin(GetOwner()->GetFromUniqueID(id));
   if (!hyperlink)
     return nullptr;
   return hyperlink;
 }
 
-int32_t BrowserAccessibilityWin::GetHyperlinkIndexFromChild(
-    const BrowserAccessibilityWin& child) const {
+int32_t BrowserAccessibilityComWin::GetHyperlinkIndexFromChild(
+    const BrowserAccessibilityComWin& child) const {
   if (hyperlinks().empty())
     return -1;
 
-  auto iterator =
-      std::find(hyperlinks().begin(), hyperlinks().end(), child.unique_id());
+  auto iterator = std::find(hyperlinks().begin(), hyperlinks().end(),
+                            child.GetOwner()->unique_id());
   if (iterator == hyperlinks().end())
     return -1;
 
   return static_cast<int32_t>(iterator - hyperlinks().begin());
 }
 
-int32_t BrowserAccessibilityWin::GetHypertextOffsetFromHyperlinkIndex(
+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 BrowserAccessibilityWin::GetHypertextOffsetFromChild(
-    const BrowserAccessibilityWin& child) const {
-  DCHECK(child.PlatformGetParent() == this);
+int32_t BrowserAccessibilityComWin::GetHypertextOffsetFromChild(
+    BrowserAccessibilityComWin& child) {
+  DCHECK(child.GetOwner()->PlatformGetParent() == GetOwner());
 
   // 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 |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.IsTextOnlyObject()) {
+  // and so |GetOwner()->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()) {
     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>(InternalChildCount()));
+    DCHECK_LT(index_in_parent,
+              static_cast<int32_t>(GetOwner()->InternalChildCount()));
     for (uint32_t i = 0; i < static_cast<uint32_t>(index_in_parent); ++i) {
-      const BrowserAccessibilityWin* sibling =
-          ToBrowserAccessibilityWin(InternalGetChild(i));
+      const BrowserAccessibilityComWin* sibling =
+          ToBrowserAccessibilityComWin(GetOwner()->InternalGetChild(i));
       DCHECK(sibling);
-      if (sibling->IsTextOnlyObject())
-        hypertextOffset += sibling->GetText().size();
+      if (sibling->GetOwner()->IsTextOnlyObject())
+        hypertextOffset += sibling->GetOwner()->GetText().size();
       else
         ++hypertextOffset;
     }
     return hypertextOffset;
   }
 
   int32_t hyperlink_index = GetHyperlinkIndexFromChild(child);
   if (hyperlink_index < 0)
     return -1;
 
   return GetHypertextOffsetFromHyperlinkIndex(hyperlink_index);
 }
 
-int32_t BrowserAccessibilityWin::GetHypertextOffsetFromDescendant(
-    const BrowserAccessibilityWin& descendant) const {
+int32_t BrowserAccessibilityComWin::GetHypertextOffsetFromDescendant(
+    const BrowserAccessibilityComWin& descendant) const {
   auto* parent_object =
-      ToBrowserAccessibilityWin(descendant.PlatformGetParent());
-  auto* current_object = const_cast<BrowserAccessibilityWin*>(&descendant);
+      ToBrowserAccessibilityComWin(descendant.GetOwner()->PlatformGetParent());
+  auto* current_object = const_cast<BrowserAccessibilityComWin*>(&descendant);
   while (parent_object && parent_object != this) {
     current_object = parent_object;
-    parent_object =
-        ToBrowserAccessibilityWin(current_object->PlatformGetParent());
+    parent_object = ToBrowserAccessibilityComWin(
+        current_object->GetOwner()->PlatformGetParent());
   }
   if (!parent_object)
     return -1;
 
   return parent_object->GetHypertextOffsetFromChild(*current_object);
 }
 
-int BrowserAccessibilityWin::GetHypertextOffsetFromEndpoint(
-    const BrowserAccessibilityWin& endpoint_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 (IsDescendantOf(&endpoint_object))
+  if (GetOwner()->IsDescendantOf(endpoint_object.GetOwner()))
     return endpoint_offset;
 
-  const BrowserAccessibility* common_parent = this;
-  int32_t index_in_common_parent = GetIndexInParent();
-  while (common_parent && !endpoint_object.IsDescendantOf(common_parent)) {
+  const BrowserAccessibility* common_parent = GetOwner();
+  int32_t index_in_common_parent = GetOwner()->GetIndexInParent();
+  while (common_parent &&
+         !endpoint_object.GetOwner()->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 == this) {
+  if (common_parent == GetOwner()) {
     int32_t hypertext_offset =
         GetHypertextOffsetFromDescendant(endpoint_object);
-    if (endpoint_object.PlatformGetParent() == this &&
-        endpoint_object.IsTextOnlyObject()) {
+    if (endpoint_object.GetOwner()->PlatformGetParent() == GetOwner() &&
+        endpoint_object.GetOwner()->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.IsDescendantOf(child)) {
+    if (endpoint_object.GetOwner()->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 GetText().size();
+    return GetOwner()->GetText().size();
 
   NOTREACHED();
   return -1;
 }
 
-int BrowserAccessibilityWin::GetSelectionAnchor() const {
-  int32_t anchor_id = manager_->GetTreeData().sel_anchor_object_id;
-  const BrowserAccessibilityWin* anchor_object = GetFromID(anchor_id);
+int BrowserAccessibilityComWin::GetSelectionAnchor() const {
+  int32_t anchor_id = GetOwner()->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;
+  int anchor_offset = GetOwner()->manager()->GetTreeData().sel_anchor_offset;
   return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
-int BrowserAccessibilityWin::GetSelectionFocus() const {
-  int32_t focus_id = manager_->GetTreeData().sel_focus_object_id;
-  const BrowserAccessibilityWin* focus_object = GetFromID(focus_id);
+int BrowserAccessibilityComWin::GetSelectionFocus() const {
+  int32_t focus_id = GetOwner()->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;
+  int focus_offset = GetOwner()->manager()->GetTreeData().sel_focus_offset;
   return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
-void BrowserAccessibilityWin::GetSelectionOffsets(
-    int* selection_start, int* selection_end) const {
+void BrowserAccessibilityComWin::GetSelectionOffsets(int* selection_start,
+                                                     int* selection_end) const {
   DCHECK(selection_start && selection_end);
 
-  if (IsSimpleTextControl() &&
-      GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START, selection_start) &&
-      GetIntAttribute(ui::AX_ATTR_TEXT_SEL_END, selection_end)) {
+  if (GetOwner()->IsSimpleTextControl() &&
+      GetOwner()->GetIntAttribute(ui::AX_ATTR_TEXT_SEL_START,
+                                  selection_start) &&
+      GetOwner()->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 && !HasCaret()) {
+  if (*selection_start == *selection_end && !GetOwner()->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
   // the selection.
   int* largest_offset =
       (*selection_start <= *selection_end) ? selection_end : selection_start;
-  BrowserAccessibilityWin* hyperlink =
+  BrowserAccessibilityComWin* hyperlink =
       GetHyperlinkFromHypertextOffset(*largest_offset);
   if (!hyperlink)
     return;
 
   LONG n_selections = 0;
   HRESULT hr = hyperlink->get_nSelections(&n_selections);
   DCHECK(SUCCEEDED(hr));
   if (n_selections > 0)
     ++(*largest_offset);
 }
 
-base::string16 BrowserAccessibilityWin::GetValueText() {
+base::string16 BrowserAccessibilityComWin::GetValueText() {
   float fval;
-  base::string16 value = this->value();
+  base::string16 result = value();
 
-  if (value.empty() &&
-      GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
-    value = base::UTF8ToUTF16(base::DoubleToString(fval));
+  if (result.empty() && GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &fval)) {
+    result = base::UTF8ToUTF16(base::DoubleToString(fval));
   }
-  return value;
+  return result;
 }
 
-bool BrowserAccessibilityWin::IsSameHypertextCharacter(size_t old_char_index,
-                                                       size_t new_char_index) {
+bool BrowserAccessibilityComWin::IsSameHypertextCharacter(
+    size_t old_char_index,
+    size_t new_char_index) {
   CHECK(old_win_attributes_);
 
   // For anything other than the "embedded character", we just compare the
   // characters directly.
   base::char16 old_ch = old_win_attributes_->hypertext[old_char_index];
   base::char16 new_ch = win_attributes_->hypertext[new_char_index];
   if (old_ch != new_ch)
     return false;
   if (old_ch == new_ch && new_ch != kEmbeddedCharacter)
     return true;
 
   // If it's an embedded character, they're only identical if the child id
   // the hyperlink points to is the same.
   std::map<int32_t, int32_t>& old_offset_to_index =
       old_win_attributes_->hyperlink_offset_to_index;
   std::vector<int32_t>& old_hyperlinks = old_win_attributes_->hyperlinks;
   int32_t old_hyperlinks_count = static_cast<int32_t>(old_hyperlinks.size());
   std::map<int32_t, int32_t>::iterator iter;
   iter = old_offset_to_index.find(old_char_index);
   int old_index = (iter != old_offset_to_index.end()) ? iter->second : -1;
-  int old_child_id = (old_index >= 0 && old_index < old_hyperlinks_count) ?
-      old_hyperlinks[old_index] : -1;
+  int old_child_id = (old_index >= 0 && old_index < old_hyperlinks_count)
+                         ? old_hyperlinks[old_index]
+                         : -1;
 
   std::map<int32_t, int32_t>& new_offset_to_index =
       win_attributes_->hyperlink_offset_to_index;
   std::vector<int32_t>& new_hyperlinks = win_attributes_->hyperlinks;
   int32_t new_hyperlinks_count = static_cast<int32_t>(new_hyperlinks.size());
   iter = new_offset_to_index.find(new_char_index);
   int new_index = (iter != new_offset_to_index.end()) ? iter->second : -1;
-  int new_child_id = (new_index >= 0 && new_index < new_hyperlinks_count) ?
-      new_hyperlinks[new_index] : -1;
+  int new_child_id = (new_index >= 0 && new_index < new_hyperlinks_count)
+                         ? new_hyperlinks[new_index]
+                         : -1;
 
   return old_child_id == new_child_id;
 }
 
-void BrowserAccessibilityWin::ComputeHypertextRemovedAndInserted(
-    int* start, int* old_len, int* new_len) {
+void BrowserAccessibilityComWin::ComputeHypertextRemovedAndInserted(
+    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 = GetText();
+  const base::string16& new_text = GetOwner()->GetText();
 
   size_t common_prefix = 0;
-  while (common_prefix < old_text.size() &&
-         common_prefix < new_text.size() &&
+  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)) {
+         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 BrowserAccessibilityWin::HandleSpecialTextOffset(LONG* offset) {
+void BrowserAccessibilityComWin::HandleSpecialTextOffset(LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH) {
-    *offset = static_cast<LONG>(GetText().length());
+    *offset = static_cast<LONG>(GetOwner()->GetText().length());
   } else if (*offset == IA2_TEXT_OFFSET_CARET) {
     // We shouldn't call |get_caretOffset| here as it affects UMA counts.
     int selection_start, selection_end;
     GetSelectionOffsets(&selection_start, &selection_end);
     *offset = selection_end;
   }
 }
 
-ui::TextBoundaryType BrowserAccessibilityWin::IA2TextBoundaryToTextBoundary(
+ui::TextBoundaryType BrowserAccessibilityComWin::IA2TextBoundaryToTextBoundary(
     IA2TextBoundaryType ia2_boundary) {
-  switch(ia2_boundary) {
+  switch (ia2_boundary) {
     case IA2_TEXT_BOUNDARY_CHAR:
       return ui::CHAR_BOUNDARY;
     case IA2_TEXT_BOUNDARY_WORD:
       return ui::WORD_BOUNDARY;
     case IA2_TEXT_BOUNDARY_LINE:
       return ui::LINE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_SENTENCE:
       return ui::SENTENCE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_PARAGRAPH:
       return ui::PARAGRAPH_BOUNDARY;
     case IA2_TEXT_BOUNDARY_ALL:
       return ui::ALL_BOUNDARY;
   }
   NOTREACHED();
   return ui::CHAR_BOUNDARY;
 }
 
-LONG BrowserAccessibilityWin::FindBoundary(
+LONG BrowserAccessibilityComWin::FindBoundary(
     const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   // If the boundary is relative to the caret, use the selection
   // affinity, otherwise default to downstream affinity.
-  ui::AXTextAffinity affinity = start_offset == IA2_TEXT_OFFSET_CARET
-                                    ? manager_->GetTreeData().sel_focus_affinity
-                                    : ui::AX_TEXT_AFFINITY_DOWNSTREAM;
+  ui::AXTextAffinity affinity =
+      start_offset == IA2_TEXT_OFFSET_CARET
+          ? GetOwner()->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 =
-            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
+            static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance next_word =
             position->CreateNextWordStartPosition();
-        if (next_word->anchor_id() != GetId())
+        if (next_word->anchor_id() != GetOwner()->GetId())
           next_word = position->CreatePositionAtEndOfAnchor();
         return next_word->text_offset();
       }
       case ui::BACKWARDS_DIRECTION: {
-        AXPlatformPositionInstance position =
-            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
+            static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance previous_word;
         if (!position->AtStartOfWord()) {
           previous_word = position->CreatePreviousWordStartPosition();
-          if (previous_word->anchor_id() != GetId())
+          if (previous_word->anchor_id() != GetOwner()->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 =
-            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
+            static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance next_line =
             position->CreateNextLineStartPosition();
-        if (next_line->anchor_id() != GetId())
+        if (next_line->anchor_id() != GetOwner()->GetId())
           next_line = position->CreatePositionAtEndOfAnchor();
         return next_line->text_offset();
       }
       case ui::BACKWARDS_DIRECTION: {
-        AXPlatformPositionInstance position =
-            CreatePositionAt(static_cast<int>(start_offset), affinity);
+        AXPlatformPositionInstance position = GetOwner()->CreatePositionAt(
+            static_cast<int>(start_offset), affinity);
         AXPlatformPositionInstance previous_line;
         if (!position->AtStartOfLine()) {
           previous_line = position->CreatePreviousLineStartPosition();
-          if (previous_line->anchor_id() != GetId())
+          if (previous_line->anchor_id() != GetOwner()->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, GetLineStartOffsets(), boundary,
-                                        start_offset, direction, affinity);
+  return ui::FindAccessibleTextBoundary(text, GetOwner()->GetLineStartOffsets(),
+                                        boundary, start_offset, direction,
+                                        affinity);
 }
 
-LONG BrowserAccessibilityWin::FindStartOfStyle(
+LONG BrowserAccessibilityComWin::FindStartOfStyle(
     LONG start_offset,
     ui::TextBoundaryDirection direction) const {
-  LONG text_length = static_cast<LONG>(GetText().length());
+  LONG text_length = static_cast<LONG>(GetOwner()->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;
 }
 
-BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32_t id) const {
-  if (!instance_active())
+BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetFromID(
+    int32_t id) const {
+  if (!GetOwner() || !GetOwner()->instance_active())
     return nullptr;
-  return ToBrowserAccessibilityWin(manager_->GetFromID(id));
+  return ToBrowserAccessibilityComWin(GetOwner()->manager()->GetFromID(id));
 }
 
-bool BrowserAccessibilityWin::IsListBoxOptionOrMenuListOption() {
-  if (!PlatformGetParent())
+bool BrowserAccessibilityComWin::IsListBoxOptionOrMenuListOption() {
+  if (!GetOwner()->PlatformGetParent())
     return false;
 
-  int32_t role = GetRole();
-  int32_t parent_role = PlatformGetParent()->GetRole();
+  int32_t role = GetOwner()->GetRole();
+  int32_t parent_role = GetOwner()->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 BrowserAccessibilityWin::AddRelation(const base::string16& relation_type,
-                                          int target_id) {
+void BrowserAccessibilityComWin::AddRelation(
+    const base::string16& relation_type,
+    int target_id) {
   // Reflexive relations don't need to be exposed through IA2.
-  if (target_id == GetId())
+  if (target_id == GetOwner()->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 BrowserAccessibilityWin::AddBidirectionalRelations(
+void BrowserAccessibilityComWin::AddBidirectionalRelations(
     const base::string16& relation_type,
     const base::string16& reverse_relation_type,
     ui::AXIntListAttribute attribute) {
-  if (!HasIntListAttribute(attribute))
+  if (!GetOwner()->HasIntListAttribute(attribute))
     return;
 
-  const std::vector<int32_t>& target_ids = GetIntListAttribute(attribute);
+  const std::vector<int32_t>& target_ids =
+      GetOwner()->GetIntListAttribute(attribute);
   // Reflexive relations don't need to be exposed through IA2.
   std::vector<int32_t> filtered_target_ids;
-  int32_t current_id = GetId();
+  int32_t current_id = GetOwner()->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) {
-    BrowserAccessibilityWin* target =
+    BrowserAccessibilityComWin* target =
         GetFromID(static_cast<int32_t>(target_id));
-    if (!target || !target->instance_active())
+    if (!target || !target->GetOwner()->instance_active())
       continue;
     relation->AddTarget(target_id);
-    target->AddRelation(reverse_relation_type, GetId());
+    target->AddRelation(reverse_relation_type, GetOwner()->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 BrowserAccessibilityWin::ClearOwnRelations() {
+void BrowserAccessibilityComWin::ClearOwnRelations() {
   RemoveBidirectionalRelationsOfType(IA2_RELATION_CONTROLLER_FOR,
                                      IA2_RELATION_CONTROLLED_BY);
   RemoveBidirectionalRelationsOfType(IA2_RELATION_DESCRIBED_BY,
                                      IA2_RELATION_DESCRIPTION_FOR);
   RemoveBidirectionalRelationsOfType(IA2_RELATION_FLOWS_TO,
                                      IA2_RELATION_FLOWS_FROM);
   RemoveBidirectionalRelationsOfType(IA2_RELATION_LABELLED_BY,
                                      IA2_RELATION_LABEL_FOR);
 
   relations_.erase(
       std::remove_if(relations_.begin(), relations_.end(),
                      [](BrowserAccessibilityRelation* relation) {
                        if (relation->get_type() == IA2_RELATION_MEMBER_OF) {
                          relation->Release();
                          return true;
                        }
                        return false;
                      }),
       relations_.end());
 }
 
-void BrowserAccessibilityWin::RemoveBidirectionalRelationsOfType(
+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()) {
-        BrowserAccessibilityWin* target =
+        BrowserAccessibilityComWin* target =
             GetFromID(static_cast<int32_t>(target_id));
-        if (!target || !target->instance_active())
+        if (!target || !target->GetOwner()->instance_active())
           continue;
         DCHECK_NE(target, this);
-        target->RemoveTargetFromRelation(reverse_relation_type, GetId());
+        target->RemoveTargetFromRelation(reverse_relation_type,
+                                         GetOwner()->GetId());
       }
       iter = relations_.erase(iter);
       relation->Release();
     } else {
       ++iter;
     }
   }
 }
 
-void BrowserAccessibilityWin::RemoveTargetFromRelation(
+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 BrowserAccessibilityWin::UpdateRequiredAttributes() {
-  if (IsCellOrTableHeaderRole()) {
+void BrowserAccessibilityComWin::UpdateRequiredAttributes() {
+  if (GetOwner()->IsCellOrTableHeaderRole()) {
     // Expose colspan attribute.
     base::string16 colspan;
-    if (GetHtmlAttribute("aria-colspan", &colspan)) {
+    if (GetOwner()->GetHtmlAttribute("aria-colspan", &colspan)) {
       SanitizeStringAttributeForIA2(colspan, &colspan);
       win_attributes_->ia2_attributes.push_back(L"colspan:" + colspan);
     }
     // Expose rowspan attribute.
     base::string16 rowspan;
-    if (GetHtmlAttribute("aria-rowspan", &rowspan)) {
+    if (GetOwner()->GetHtmlAttribute("aria-rowspan", &rowspan)) {
       SanitizeStringAttributeForIA2(rowspan, &rowspan);
       win_attributes_->ia2_attributes.push_back(L"rowspan:" + rowspan);
     }
   }
 
   // Expose dropeffect attribute.
   base::string16 drop_effect;
-  if (GetHtmlAttribute("aria-dropeffect", &drop_effect)) {
+  if (GetOwner()->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 (GetHtmlAttribute("aria-grabbed", &grabbed)) {
+  if (GetOwner()->GetHtmlAttribute("aria-grabbed", &grabbed)) {
     SanitizeStringAttributeForIA2(grabbed, &grabbed);
     win_attributes_->ia2_attributes.push_back(L"grabbed:" + grabbed);
   }
 
   // Expose class attribute.
   base::string16 class_attr;
-  if (GetHtmlAttribute("class", &class_attr)) {
+  if (GetOwner()->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 (GetRole() == ui::AX_ROLE_TIME &&
-      GetHtmlAttribute("datetime", &datetime)) {
+  if (GetOwner()->GetRole() == ui::AX_ROLE_TIME &&
+      GetOwner()->GetHtmlAttribute("datetime", &datetime)) {
     SanitizeStringAttributeForIA2(datetime, &datetime);
     win_attributes_->ia2_attributes.push_back(L"datetime:" + datetime);
   }
 
   // Expose id attribute.
   base::string16 id;
-  if (GetHtmlAttribute("id", &id)) {
+  if (GetOwner()->GetHtmlAttribute("id", &id)) {
     SanitizeStringAttributeForIA2(id, &id);
     win_attributes_->ia2_attributes.push_back(L"id:" + id);
   }
 
   // Expose src attribute.
   base::string16 src;
-  if (GetRole() == ui::AX_ROLE_IMAGE && GetHtmlAttribute("src", &src)) {
+  if (GetOwner()->GetRole() == ui::AX_ROLE_IMAGE &&
+      GetOwner()->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 = GetString16Attribute(ui::AX_ATTR_HTML_TAG);
-  if (IsSimpleTextControl() && html_tag == L"input" &&
-      GetHtmlAttribute("type", &type)) {
+  base::string16 html_tag =
+      GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
+  if (GetOwner()->IsSimpleTextControl() && html_tag == L"input" &&
+      GetOwner()->GetHtmlAttribute("type", &type)) {
     SanitizeStringAttributeForIA2(type, &type);
     win_attributes_->ia2_attributes.push_back(L"text-input-type:" + type);
   }
 }
 
-void BrowserAccessibilityWin::FireNativeEvent(LONG win_event_type) const {
-  (new BrowserAccessibilityEventWin(
-      BrowserAccessibilityEvent::FromTreeChange,
-      ui::AX_EVENT_NONE,
-      win_event_type,
-      this))->Fire();
+void BrowserAccessibilityComWin::FireNativeEvent(LONG win_event_type) const {
+  (new BrowserAccessibilityEventWin(BrowserAccessibilityEvent::FromTreeChange,
+                                    ui::AX_EVENT_NONE, win_event_type,
+                                    GetOwner()))
+      ->Fire();
 }
 
-ui::AXPlatformNodeWin* BrowserAccessibilityWin::GetPlatformNodeWin() const {
-  DCHECK(platform_node_);
-  return static_cast<ui::AXPlatformNodeWin*>(platform_node_);
-}
-
-void BrowserAccessibilityWin::InitRoleAndState() {
+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 (HasState(ui::AX_STATE_BUSY))
+  if (GetOwner()->HasState(ui::AX_STATE_BUSY))
     ia_state |= STATE_SYSTEM_BUSY;
 
   const auto checked_state = static_cast<ui::AXCheckedState>(
-      GetIntAttribute(ui::AX_ATTR_CHECKED_STATE));
+      GetOwner()->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 (HasState(ui::AX_STATE_COLLAPSED))
+  if (GetOwner()->HasState(ui::AX_STATE_COLLAPSED))
     ia_state |= STATE_SYSTEM_COLLAPSED;
-  if (HasState(ui::AX_STATE_EXPANDED))
+  if (GetOwner()->HasState(ui::AX_STATE_EXPANDED))
     ia_state |= STATE_SYSTEM_EXPANDED;
-  if (HasState(ui::AX_STATE_FOCUSABLE))
+  if (GetOwner()->HasState(ui::AX_STATE_FOCUSABLE))
     ia_state |= STATE_SYSTEM_FOCUSABLE;
-  if (HasState(ui::AX_STATE_HASPOPUP))
+  if (GetOwner()->HasState(ui::AX_STATE_HASPOPUP))
     ia_state |= STATE_SYSTEM_HASPOPUP;
-  if (HasIntAttribute(ui::AX_ATTR_INVALID_STATE) &&
-      GetIntAttribute(ui::AX_ATTR_INVALID_STATE) != ui::AX_INVALID_STATE_FALSE)
+  if (GetOwner()->HasIntAttribute(ui::AX_ATTR_INVALID_STATE) &&
+      GetOwner()->GetIntAttribute(ui::AX_ATTR_INVALID_STATE) !=
+          ui::AX_INVALID_STATE_FALSE)
     ia2_state |= IA2_STATE_INVALID_ENTRY;
-  if (HasState(ui::AX_STATE_INVISIBLE))
+  if (GetOwner()->HasState(ui::AX_STATE_INVISIBLE))
     ia_state |= STATE_SYSTEM_INVISIBLE;
-  if (HasState(ui::AX_STATE_LINKED))
+  if (GetOwner()->HasState(ui::AX_STATE_LINKED))
     ia_state |= STATE_SYSTEM_LINKED;
-  if (HasState(ui::AX_STATE_MULTISELECTABLE)) {
+  if (GetOwner()->HasState(ui::AX_STATE_MULTISELECTABLE)) {
     ia_state |= STATE_SYSTEM_EXTSELECTABLE;
     ia_state |= STATE_SYSTEM_MULTISELECTABLE;
   }
   // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect.
-  if (HasState(ui::AX_STATE_OFFSCREEN))
+  if (GetOwner()->HasState(ui::AX_STATE_OFFSCREEN))
     ia_state |= STATE_SYSTEM_OFFSCREEN;
-  if (HasState(ui::AX_STATE_PRESSED))
+  if (GetOwner()->HasState(ui::AX_STATE_PRESSED))
     ia_state |= STATE_SYSTEM_PRESSED;
-  if (HasState(ui::AX_STATE_PROTECTED))
+  if (GetOwner()->HasState(ui::AX_STATE_PROTECTED))
     ia_state |= STATE_SYSTEM_PROTECTED;
-  if (HasState(ui::AX_STATE_REQUIRED))
+  if (GetOwner()->HasState(ui::AX_STATE_REQUIRED))
     ia2_state |= IA2_STATE_REQUIRED;
-  if (HasState(ui::AX_STATE_SELECTABLE))
+  if (GetOwner()->HasState(ui::AX_STATE_SELECTABLE))
     ia_state |= STATE_SYSTEM_SELECTABLE;
-  if (HasState(ui::AX_STATE_SELECTED))
+  if (GetOwner()->HasState(ui::AX_STATE_SELECTED))
     ia_state |= STATE_SYSTEM_SELECTED;
-  if (HasState(ui::AX_STATE_VISITED))
+  if (GetOwner()->HasState(ui::AX_STATE_VISITED))
     ia_state |= STATE_SYSTEM_TRAVERSED;
-  if (HasState(ui::AX_STATE_DISABLED))
+  if (GetOwner()->HasState(ui::AX_STATE_DISABLED))
     ia_state |= STATE_SYSTEM_UNAVAILABLE;
-  if (HasState(ui::AX_STATE_VERTICAL))
+  if (GetOwner()->HasState(ui::AX_STATE_VERTICAL))
     ia2_state |= IA2_STATE_VERTICAL;
-  if (HasState(ui::AX_STATE_HORIZONTAL))
+  if (GetOwner()->HasState(ui::AX_STATE_HORIZONTAL))
     ia2_state |= IA2_STATE_HORIZONTAL;
-  if (HasState(ui::AX_STATE_VISITED))
+  if (GetOwner()->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 (HasState(ui::AX_STATE_HOVERED))
+    if (GetOwner()->HasState(ui::AX_STATE_HOVERED))
       ia_state |= STATE_SYSTEM_HOTTRACKED;
   }
 
-  if (HasState(ui::AX_STATE_EDITABLE))
+  if (GetOwner()->HasState(ui::AX_STATE_EDITABLE))
     ia2_state |= IA2_STATE_EDITABLE;
 
-  if (GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
+  if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_CAN_SET_VALUE))
     ia2_state |= IA2_STATE_EDITABLE;
 
-  if (!GetStringAttribute(ui::AX_ATTR_AUTO_COMPLETE).empty())
+  if (!GetOwner()->GetStringAttribute(ui::AX_ATTR_AUTO_COMPLETE).empty())
     ia2_state |= IA2_STATE_SUPPORTS_AUTOCOMPLETION;
 
-  if (GetBoolAttribute(ui::AX_ATTR_MODAL))
+  if (GetOwner()->GetBoolAttribute(ui::AX_ATTR_MODAL))
     ia2_state |= IA2_STATE_MODAL;
 
-  base::string16 html_tag = GetString16Attribute(
-      ui::AX_ATTR_HTML_TAG);
-  switch (GetRole()) {
+  base::string16 html_tag =
+      GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG);
+  switch (GetOwner()->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 (GetBoolAttribute(ui::AX_ATTR_CANVAS_HAS_FALLBACK)) {
+      if (GetOwner()->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 (PlatformChildCount()) {
+      if (GetOwner()->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 15 matching lines @@
       ia2_role = IA2_ROLE_FOOTER;
       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 = GetString16Attribute(
-          ui::AX_ATTR_ROLE);
+      base::string16 aria_role =
+          GetOwner()->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 148 matching lines @@
       if (html_tag == L"section") {
         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(this) ? ROLE_SYSTEM_OUTLINEITEM : ROLE_SYSTEM_ROW;
+      ia_role =
+          IsInTreeGrid(GetOwner()) ? 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 (HasState(ui::AX_STATE_MULTILINE)) {
+      if (GetOwner()->HasState(ui::AX_STATE_MULTILINE)) {
         ia2_state |= IA2_STATE_MULTI_LINE;
       } else {
         ia2_state |= IA2_STATE_SINGLE_LINE;
       }
-      if (HasState(ui::AX_STATE_READ_ONLY))
+      if (GetOwner()->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 (HasState(ui::AX_STATE_FOCUSABLE) && ia_role != ROLE_SYSTEM_DOCUMENT &&
-      ia_role != ROLE_SYSTEM_TEXT) {
+  if (GetOwner()->HasState(ui::AX_STATE_FOCUSABLE) &&
+      ia_role != ROLE_SYSTEM_DOCUMENT && ia_role != ROLE_SYSTEM_TEXT) {
     ia_state &= ~(STATE_SYSTEM_READONLY);
   }
-  if (!HasState(ui::AX_STATE_READ_ONLY))
+  if (!GetOwner()->HasState(ui::AX_STATE_READ_ONLY))
     ia_state &= ~(STATE_SYSTEM_READONLY);
-  if (GetBoolAttribute(ui::AX_ATTR_ARIA_READONLY))
+  if (GetOwner()->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;
 
   win_attributes_->ia_role = ia_role;
   win_attributes_->ia_state = ia_state;
   win_attributes_->role_name = role_name;
   win_attributes_->ia2_role = ia2_role;
   win_attributes_->ia2_state = ia2_state;
 }
 
-bool BrowserAccessibilityWin::IsInTreeGrid(const BrowserAccessibility* item) {
+bool BrowserAccessibilityComWin::IsInTreeGrid(
+    const BrowserAccessibility* item) {
   BrowserAccessibility* container = item->PlatformGetParent();
   if (container && container->GetRole() == ui::AX_ROLE_GROUP) {
     // If parent was a rowgroup, we need to look at the grandparent
     container = container->PlatformGetParent();
   }
 
   if (!container) {
     return false;
   }
 
   return container->GetRole() == ui::AX_ROLE_TREE_GRID;
 }
 
-BrowserAccessibilityWin* ToBrowserAccessibilityWin(BrowserAccessibility* obj) {
-  DCHECK(!obj || obj->IsNative());
-  return static_cast<BrowserAccessibilityWin*>(obj);
-}
-
-const BrowserAccessibilityWin*
-ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
-  DCHECK(!obj || obj->IsNative());
-  return static_cast<const BrowserAccessibilityWin*>(obj);
+BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
+    BrowserAccessibility* obj) {
+  if (!obj || !obj->IsNative())
+    return nullptr;
+  auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
+  return result;
 }
 
 }  // namespace content