BrowserAccessibilityWin precondition only needs to check for a valid owner

content/browser/accessibility/browser_accessibility_com_win.cc

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_com_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 293 matching lines @@
   target_ids_.erase(
       std::remove(target_ids_.begin(), target_ids_.end(), target_id),
       target_ids_.end());
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_relationType(
     BSTR* relation_type) {
   if (!relation_type)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner()->instance_active())
+  if (!owner_->GetOwner())
     return E_FAIL;
 
   *relation_type = SysAllocString(type_.c_str());
   DCHECK(*relation_type);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_nTargets(long* n_targets) {
   if (!n_targets)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner()->instance_active())
+  if (!owner_->GetOwner())
     return E_FAIL;
 
   *n_targets = static_cast<long>(target_ids_.size());
 
   for (long i = *n_targets - 1; i >= 0; --i) {
     BrowserAccessibilityComWin* result = owner_->GetFromID(target_ids_[i]);
-    if (!result || !result->GetOwner()->instance_active()) {
+    if (!result || !result->GetOwner()) {
       *n_targets = 0;
       break;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
                                                       IUnknown** target) {
   if (!target)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner()->instance_active())
+  if (!owner_->GetOwner())
     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 = manager->GetFromID(target_ids_[target_index]);
   if (!result || !result->instance_active())
     return E_FAIL;
 
   *target = static_cast<IAccessible*>(
       ToBrowserAccessibilityComWin(result)->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
                                                        IUnknown** targets,
                                                        long* n_targets) {
   if (!targets || !n_targets)
     return E_INVALIDARG;
 
-  if (!owner_->GetOwner()->instance_active())
+  if (!owner_->GetOwner())
     return E_FAIL;
 
   long count = static_cast<long>(target_ids_.size());
   if (count > max_targets)
     count = max_targets;
 
   *n_targets = count;
   if (count == 0)
     return S_FALSE;
 
@@ skipping 26 matching lines @@
 
 BrowserAccessibilityComWin::~BrowserAccessibilityComWin() {
   for (BrowserAccessibilityRelation* relation : relations_)
     relation->Release();
 }
 
 //
 // IAccessible methods.
 //
 // Conventions:
-// * Always test for GetOwner() and GetOwner()->instance_active first and
-//   return E_FAIL if either are false.
+// * Always test for GetOwner() first and return E_FAIL if it's false.
 // * Always check for invalid arguments first, even if they're unused.
 // * Return S_FALSE if the only output is a string argument and it's empty.
 // * There are some methods that don't touch any state such as get_toolkitName.
 //   For these rare cases, you may not need to call GetOwner().
 //
 
 HRESULT BrowserAccessibilityComWin::accDoDefaultAction(VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_DO_DEFAULT_ACTION);
 
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   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->GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION))
     return DISP_E_MEMBERNOTFOUND;
 
   manager->DoDefaultAction(*target->GetOwner());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accHitTest(LONG x_left,
                                                     LONG y_top,
                                                     VARIANT* child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
 
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   gfx::Point point(x_left, y_top);
@@ skipping 14 matching lines @@
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accLocation(LONG* x_left,
                                                      LONG* y_top,
                                                      LONG* width,
                                                      LONG* height,
                                                      VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_LOCATION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   return AXPlatformNodeWin::accLocation(x_left, y_top, width, height, var_id);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accNavigate(LONG nav_dir,
                                                      VARIANT start,
                                                      VARIANT* end) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_NAVIGATE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   // Forward all directions but NAVDIR_ to the platform node implementation.
   if (nav_dir != NAVDIR_DOWN && nav_dir != NAVDIR_UP &&
       nav_dir != NAVDIR_LEFT && nav_dir != NAVDIR_RIGHT) {
     return AXPlatformNodeWin::accNavigate(nav_dir, start, end);
   }
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(start);
   if (!target)
@@ skipping 27 matching lines @@
   }
 
   end->vt = VT_DISPATCH;
   end->pdispVal = ToBrowserAccessibilityComWin(result)->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accChild(VARIANT var_child,
                                                       IDispatch** disp_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!disp_child)
     return E_INVALIDARG;
 
   *disp_child = NULL;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_child);
   if (!target)
     return E_INVALIDARG;
 
   (*disp_child) = target->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accChildCount(LONG* child_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD_COUNT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!child_count)
     return E_INVALIDARG;
 
   *child_count = GetOwner()->PlatformChildCount();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accDefaultAction(
     VARIANT var_id,
     BSTR* def_action) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DEFAULT_ACTION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!def_action)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->get_localizedName(0, def_action);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accDescription(VARIANT var_id,
                                                             BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DESCRIPTION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   base::string16 description_str = target->description();
   if (description_str.empty())
     return S_FALSE;
 
   *desc = SysAllocString(description_str.c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accFocus(VARIANT* focus_child) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     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 == 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->GetCOM()->NewReference();
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accHelp(VARIANT var_id,
                                                      BSTR* help) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   return AXPlatformNodeWin::get_accHelp(var_id, help);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accKeyboardShortcut(
     VARIANT var_id,
     BSTR* acc_key) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_KEYBOARD_SHORTCUT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!acc_key)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (target->HasStringAttribute(ui::AX_ATTR_KEY_SHORTCUTS)) {
     return target->GetStringAttributeAsBstr(ui::AX_ATTR_KEY_SHORTCUTS, acc_key);
   }
 
   return target->GetStringAttributeAsBstr(ui::AX_ATTR_SHORTCUT, acc_key);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accName(VARIANT var_id,
                                                      BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_NAME);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   return AXPlatformNodeWin::get_accName(var_id, name);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accParent(
     IDispatch** disp_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_PARENT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
   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.
@@ skipping 13 matching lines @@
     }
   }
   parent_obj->AddRef();
   *disp_parent = parent_obj;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accRole(VARIANT var_id,
                                                      VARIANT* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_ROLE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (!target->role_name().empty()) {
     role->vt = VT_BSTR;
     role->bstrVal = SysAllocString(target->role_name().c_str());
   } else {
     role->vt = VT_I4;
     role->lVal = target->ia_role();
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accState(VARIANT var_id,
                                                       VARIANT* state) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!state)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state();
   if (manager->GetFocus() == GetOwner())
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accValue(VARIANT var_id,
                                                       BSTR* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   BrowserAccessibilityComWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (target->ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
@@ skipping 28 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accHelpTopic(BSTR* help_file,
                                                           VARIANT var_id,
                                                           LONG* topic_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP_TOPIC);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accSelection(VARIANT* selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_SELECTION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (GetOwner()->GetRole() != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
   for (size_t i = 0; i < GetOwner()->InternalChildCount(); ++i) {
     if (GetOwner()->InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
       ++selected_count;
   }
@@ skipping 31 matching lines @@
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::accSelect(LONG flags_sel,
                                                    VARIANT var_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
     manager->SetFocus(*GetOwner());
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::put_accName(VARIANT var_id, BSTR put_name) {
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityComWin::put_accValue(VARIANT var_id, BSTR put_val) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::role(LONG* role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ROLE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(BSTR* attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_GET_ATTRIBUTES);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!attributes)
     return E_INVALIDARG;
   *attributes = nullptr;
 
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   base::string16 str;
   for (const base::string16& attribute : ia2_attributes())
     str += attribute + L';';
 
   if (str.empty())
     return S_FALSE;
 
   *attributes = SysAllocString(str.c_str());
   DCHECK(*attributes);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_states(AccessibleStates* states) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_STATES);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
 
   if (!states)
     return E_INVALIDARG;
 
   *states = ia2_state();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_uniqueID(LONG* unique_id) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNIQUE_ID);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!unique_id)
     return E_INVALIDARG;
 
   *unique_id = -GetOwner()->unique_id();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_windowHandle(HWND* window_handle) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_WINDOW_HANDLE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
   *window_handle = GetOwner()
                        ->manager()
                        ->ToBrowserAccessibilityManagerWin()
                        ->GetParentHWND();
   if (!*window_handle)
     return E_FAIL;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_indexInParent(
     LONG* index_in_parent) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INDEX_IN_PARENT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
   *index_in_parent = GetIndexInParent();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nRelations(LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_relations)
     return E_INVALIDARG;
 
   *n_relations = relations_.size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_relation(
     LONG relation_index,
     IAccessibleRelation** relation) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (relation_index < 0 ||
       relation_index >= static_cast<long>(relations_.size())) {
     return E_INVALIDARG;
   }
 
   if (!relation)
     return E_INVALIDARG;
 
   relations_[relation_index]->AddRef();
   *relation = relations_[relation_index];
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_relations(
     LONG max_relations,
     IAccessibleRelation** relations,
     LONG* n_relations) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!relations || !n_relations)
     return E_INVALIDARG;
 
   long count = static_cast<long>(relations_.size());
   *n_relations = count;
   if (count == 0)
     return S_FALSE;
 
   for (long i = 0; i < count; ++i) {
     relations_[i]->AddRef();
     relations[i] = relations_[i];
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollTo(IA2ScrollType scroll_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_SCROLL_TO);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
 
   if (!manager)
     return E_FAIL;
 
   gfx::Rect r = GetOwner()->GetFrameBoundsRect();
   switch (scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
@@ skipping 26 matching lines @@
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_POINT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     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();
@@ skipping 12 matching lines @@
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_GROUP_POSITION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
   *group_level = GetOwner()->GetIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL);
   *similar_items_in_group = GetOwner()->GetIntAttribute(ui::AX_ATTR_SET_SIZE);
   *position_in_group = GetOwner()->GetIntAttribute(ui::AX_ATTR_POS_IN_SET);
 
   if (*group_level == *similar_items_in_group == *position_in_group == 0)
     return S_FALSE;
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_localizedExtendedRole(
     BSTR* localized_extended_role) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_ROLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!localized_extended_role)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(ui::AX_ATTR_ROLE_DESCRIPTION,
                                   localized_extended_role);
 }
 
 //
@@ skipping 33 matching lines @@
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleApplication methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_appName(BSTR* app_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_NAME);
-  // 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);
   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 BrowserAccessibilityComWin::get_appVersion(BSTR* app_version) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_VERSION);
-  // 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);
   DCHECK_EQ(2U, product_components.size());
@@ skipping 29 matching lines @@
   DCHECK(*toolkit_version);
   return *toolkit_version ? S_OK : E_FAIL;
 }
 
 //
 // IAccessibleImage methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_description(BSTR* desc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DESCRIPTION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   if (description().empty())
     return S_FALSE;
 
   *desc = SysAllocString(description().c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_imagePosition(
     IA2CoordinateType coordinate_type,
     LONG* x,
     LONG* y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_POSITION);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     gfx::Rect bounds = GetOwner()->GetScreenBoundsRect();
     *x = bounds.x();
     *y = bounds.y();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     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 BrowserAccessibilityComWin::get_imageSize(LONG* height,
                                                        LONG* width) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_SIZE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
   *height = GetOwner()->GetPageBoundsRect().height();
   *width = GetOwner()->GetPageBoundsRect().width();
   return S_OK;
 }
 
 //
 // IAccessibleTable methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_accessibleAt(
     long row,
     long column,
     IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
       GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (cell && ToBrowserAccessibilityComWin(cell)) {
     *accessible = static_cast<IAccessible*>(
         ToBrowserAccessibilityComWin(cell)->NewReference());
     return S_OK;
   }
 
   *accessible = nullptr;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_caption(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_childIndex(long row,
                                                         long column,
                                                         long* cell_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
       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 BrowserAccessibilityComWin::get_columnDescription(
     long column,
     BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   int columns = GetOwner()->GetTableColumnCount();
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   int rows = GetOwner()->GetTableRowCount();
@@ skipping 23 matching lines @@
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnExtentAt(
     long row,
     long column,
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell =
       GetOwner()->GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (!cell)
     return E_INVALIDARG;
 
   *n_columns_spanned = cell->GetTableColumnSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnHeader(
     IAccessibleTable** accessible_table,
     long* starting_row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long cell_index,
                                                          long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
   *column_index = cell->GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nColumns(long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = GetOwner()->GetTableColumnCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = GetOwner()->GetTableRowCount();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedChildren(
     long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cell_count)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
   *cell_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedColumns(
     long* column_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelectedRows(long* row_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowDescription(long row,
                                                             BSTR* description) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   if (row < 0 || row >= GetOwner()->GetTableRowCount())
     return E_INVALIDARG;
 
   int columns = GetOwner()->GetTableColumnCount();
   if (columns <= 0) {
@@ skipping 21 matching lines @@
 
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowExtentAt(long row,
                                                          long column,
                                                          long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT_AT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell = GetOwner()->GetTableCell(row, column);
   if (!cell)
     return E_INVALIDARG;
 
   *n_rows_spanned = GetOwner()->GetTableRowSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowHeader(
     IAccessibleTable** accessible_table,
     long* starting_column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long cell_index,
                                                       long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell = GetOwner()->GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
 
   *row_index = cell->GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedChildren(
     long max_children,
     long** children,
     long* n_children) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CHILDREN);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!children || !n_children)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_children = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long max_columns,
                                                              long** columns,
                                                              long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long max_rows,
                                                           long** rows,
                                                           long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_summary(IUnknown** accessible) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SUMMARY);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isColumnSelected(
     long column,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_COLUMN_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isRowSelected(
     long row,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_ROW_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(long row,
                                                         long column,
                                                         boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowColumnExtentsAtIndex(
     long index,
     long* row,
     long* column,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS_AT_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
   BrowserAccessibility* cell = GetOwner()->GetTableCell(index);
   if (!cell)
     return E_INVALIDARG;
 
   *row = cell->GetTableRow();
@@ skipping 36 matching lines @@
 
 //
 // IAccessibleTable2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_cellAt(long row,
                                                     long column,
                                                     IUnknown** cell) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CELL_AT);
   AddAccessibilityModeFlags(AccessibilityMode::kScreenReader);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cell)
     return E_INVALIDARG;
 
   BrowserAccessibility* 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 BrowserAccessibilityComWin::get_nSelectedCells(long* cell_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return get_nSelectedChildren(cell_count);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedCells(
     IUnknown*** cells,
     long* n_selected_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cells || !n_selected_cells)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_selected_cells = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedColumns(long** columns,
                                                              long* n_columns) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_COLUMNS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selectedRows(long** rows,
                                                           long* n_rows) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_ROWS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
 //
 // IAccessibleTableCell methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnExtent(
     long* n_columns_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   *n_columns_spanned = GetOwner()->GetTableColumnSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_column_header_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_column_header_cells)
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
   BrowserAccessibility* table = GetOwner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
@@ skipping 22 matching lines @@
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_columnIndex(long* column_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_COLUMN_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   *column_index = GetOwner()->GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowExtent(long* n_rows_spanned) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   *n_rows_spanned = GetOwner()->GetTableRowSpan();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_row_header_cells) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER_CELLS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!cell_accessibles || !n_row_header_cells)
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
   BrowserAccessibility* table = GetOwner()->GetTable();
   if (!table) {
     NOTREACHED();
     return S_FALSE;
@@ skipping 22 matching lines @@
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowIndex(long* row_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_ROW_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   *row_index = GetOwner()->GetTableRow();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_isSelected(boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_IS_SELECTED);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_rowColumnExtents(
     long* row_index,
     long* column_index,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!row_index || !column_index || !row_extents || !column_extents ||
       !is_selected) {
     return E_INVALIDARG;
   }
 
   *row_index = GetOwner()->GetTableRow();
   *column_index = GetOwner()->GetTableColumn();
   *row_extents = GetOwner()->GetTableRowSpan();
   *column_extents = GetOwner()->GetTableColumnSpan();
   *is_selected = false;  // Not supported.
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_table(IUnknown** table) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TABLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
   BrowserAccessibility* find_table = GetOwner()->GetTable();
   if (!find_table || !ToBrowserAccessibilityComWin(find_table)) {
     *table = nullptr;
     return S_FALSE;
   }
 
   *table = static_cast<IAccessibleTable*>(
       ToBrowserAccessibilityComWin(find_table)->NewReference());
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nCharacters(LONG* n_characters) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_CHARACTERS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
   *n_characters = static_cast<LONG>(GetOwner()->GetText().size());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_caretOffset(LONG* offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   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 BrowserAccessibilityComWin::get_characterExtents(
     LONG offset,
     IA2CoordinateType coordinate_type,
     LONG* out_x,
     LONG* out_y,
     LONG* out_width,
     LONG* out_height) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHARACTER_EXTENTS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetOwner()->GetText();
   HandleSpecialTextOffset(&offset);
   if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
     return E_INVALIDARG;
 
@@ skipping 16 matching lines @@
   *out_y = character_bounds.y();
   *out_width = character_bounds.width();
   *out_height = character_bounds.height();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nSelections(LONG* n_selections) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
       selection_start != selection_end) {
     *n_selections = 1;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_selection(LONG selection_index,
                                                        LONG* start_offset,
                                                        LONG* end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   *start_offset = 0;
   *end_offset = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
@@ skipping 11 matching lines @@
   }
 
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_text(LONG start_offset,
                                                   LONG end_offset,
                                                   BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetOwner()->GetText();
   HandleSpecialTextOffset(&start_offset);
   HandleSpecialTextOffset(&end_offset);
 
   // The spec allows the arguments to be reversed.
@@ skipping 24 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textAtOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   HandleSpecialTextOffset(&offset);
   if (offset < 0)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetOwner()->GetText();
@@ skipping 32 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textBeforeOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_BEFORE_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     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;
@@ skipping 11 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_textAfterOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AFTER_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
   const base::string16& text_str = GetOwner()->GetText();
 
   *start_offset = offset;
   *end_offset =
       FindBoundary(text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_newText(IA2TextSegment* new_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEW_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!new_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (new_len == 0)
     return E_FAIL;
 
   base::string16 substr = GetOwner()->GetText().substr(start, new_len);
   new_text->text = SysAllocString(substr.c_str());
   new_text->start = static_cast<long>(start);
   new_text->end = static_cast<long>(start + new_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_oldText(IA2TextSegment* old_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OLD_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!old_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (old_len == 0)
     return E_FAIL;
 
   base::string16 old_hypertext = old_win_attributes_->hypertext;
   base::string16 substr = old_hypertext.substr(start, old_len);
   old_text->text = SysAllocString(substr.c_str());
   old_text->start = static_cast<long>(start);
   old_text->end = static_cast<long>(start + old_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_offsetAtPoint(
     LONG x,
     LONG y,
     IA2CoordinateType coord_type,
     LONG* offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OFFSET_AT_POINT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement this. We're returning S_OK for now so that
   // screen readers still return partially accurate results rather than
   // completely failing.
   *offset = 0;
   return S_OK;
@@ skipping 12 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollSubstringToPoint(
     LONG start_index,
     LONG end_index,
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_SUBSTRING_TO_POINT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (start_index > end_index)
     std::swap(start_index, end_index);
   LONG length = end_index - start_index + 1;
   DCHECK_GE(length, 0);
 
   gfx::Rect string_bounds =
       GetOwner()->GetPageBoundsForRange(start_index, length);
   string_bounds -= GetOwner()->GetPageBoundsRect().OffsetFromOrigin();
   x -= string_bounds.x();
   y -= string_bounds.y();
 
   return scrollToPoint(coordinate_type, x, y);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::addSelection(LONG start_offset,
                                                       LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ADD_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   // We only support one selection.
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::removeSelection(LONG selection_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_REMOVE_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (selection_index != 0)
     return E_INVALIDARG;
 
   // Simply collapse the selection to the position of the caret if a caret is
   // visible, otherwise set the selection to 0.
   LONG caret_offset = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (GetOwner()->HasCaret() && selection_end >= 0)
     caret_offset = selection_end;
   SetIA2HypertextSelection(caret_offset, caret_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setCaretOffset(LONG offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CARET_OFFSET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
   SetIA2HypertextSelection(offset, offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setSelection(LONG selection_index,
                                                       LONG start_offset,
                                                       LONG end_offset) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_SELECTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
   if (selection_index != 0)
     return E_INVALIDARG;
   SetIA2HypertextSelection(start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(LONG offset,
                                                         LONG* start_offset,
                                                         LONG* end_offset,
                                                         BSTR* text_attributes) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IATEXT_GET_ATTRIBUTES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!start_offset || !end_offset || !text_attributes)
     return E_INVALIDARG;
 
   *start_offset = *end_offset = 0;
   *text_attributes = nullptr;
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   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);
@@ skipping 14 matching lines @@
 }
 
 //
 // IAccessibleHypertext methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nHyperlinks(
     long* hyperlink_count) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_HYPERLINKS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!hyperlink_count)
     return E_INVALIDARG;
 
   *hyperlink_count = hyperlink_offset_to_index().size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_hyperlink(
     long index,
     IAccessibleHyperlink** hyperlink) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!hyperlink || index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
   int32_t id = hyperlinks()[index];
   BrowserAccessibilityComWin* link =
       ToBrowserAccessibilityComWin(GetOwner()->GetFromUniqueID(id));
   if (!link)
     return E_FAIL;
 
   *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
 
   if (char_index < 0 ||
       char_index >= static_cast<long>(GetOwner()->GetText().size())) {
     return E_INVALIDARG;
   }
 
@@ skipping 10 matching lines @@
 
 //
 // IAccessibleHyperlink methods.
 //
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityComWin::get_anchor(long index,
                                                     VARIANT* anchor) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner()->instance_active() || !IsHyperlink())
+  if (!GetOwner() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have only one anchor, that is the text inside them.
   if (index != 0 || !anchor)
     return E_INVALIDARG;
 
   BSTR ia2_hypertext = SysAllocString(GetOwner()->GetText().c_str());
   DCHECK(ia2_hypertext);
   anchor->vt = VT_BSTR;
   anchor->bstrVal = ia2_hypertext;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(ia2_hypertext))
     return S_FALSE;
 
   return S_OK;
 }
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityComWin::get_anchorTarget(
     long index,
     VARIANT* anchor_target) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR_TARGET);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner()->instance_active() || !IsHyperlink())
+  if (!GetOwner() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have at most one target, that is when they represent an
   // HTML hyperlink, i.e. an <a> element with a "href" attribute.
   if (index != 0 || !anchor_target)
     return E_INVALIDARG;
 
   BSTR target;
   if (!(ia_state() & STATE_SYSTEM_LINKED) ||
       FAILED(GetStringAttributeAsBstr(ui::AX_ATTR_URL, &target))) {
     target = SysAllocString(L"");
   }
   DCHECK(target);
   anchor_target->vt = VT_BSTR;
   anchor_target->bstrVal = target;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(target))
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_startIndex(long* index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_START_INDEX);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner()->instance_active() || !IsHyperlink())
+  if (!GetOwner() || !IsHyperlink())
     return E_FAIL;
 
   if (!index)
     return E_INVALIDARG;
 
   int32_t hypertext_offset = 0;
   auto* parent = GetOwner()->PlatformGetParent();
   if (parent) {
     hypertext_offset =
         ToBrowserAccessibilityComWin(parent)->GetHypertextOffsetFromChild(
@@ skipping 20 matching lines @@
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleAction partly implemented.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::nActions(long* n_actions) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_N_ACTIONS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!n_actions)
     return E_INVALIDARG;
 
   // |IsHyperlink| is required for |IAccessibleHyperlink::anchor/anchorTarget|
   // to work properly because the |IAccessibleHyperlink| interface inherits from
   // |IAccessibleAction|.
   if (IsHyperlink() || GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION)) {
     *n_actions = 1;
   } else {
     *n_actions = 0;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::doAction(long action_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_DO_ACTION);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!GetOwner()->HasIntAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
     return E_INVALIDARG;
 
   GetOwner()->manager()->DoDefaultAction(*GetOwner());
   return S_OK;
 }
 
 STDMETHODIMP
@@ skipping 10 matching lines @@
                                                         long* n_bindings) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_KEY_BINDING);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_name(long action_index,
                                                   BSTR* name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
   int action;
   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
 BrowserAccessibilityComWin::get_localizedName(long action_index,
                                               BSTR* localized_name) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_NAME);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!localized_name)
     return E_INVALIDARG;
 
   int action;
   if (!GetOwner()->GetIntAttribute(ui::AX_ATTR_ACTION, &action) ||
       action_index != 0) {
     *localized_name = nullptr;
     return E_INVALIDARG;
@@ skipping 11 matching lines @@
   return S_OK;
 }
 
 //
 // IAccessibleValue methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_currentValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CURRENT_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_minimumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MINIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_maximumValue(VARIANT* value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MAXIMUM_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::setCurrentValue(VARIANT new_value) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CURRENT_VALUE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   // TODO(dmazzoni): Implement this.
   return E_NOTIMPL;
 }
 
 //
 // ISimpleDOMDocument methods.
 //
 
 STDMETHODIMP BrowserAccessibilityComWin::get_URL(BSTR* url) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_URL);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
   if (GetOwner() != manager->GetRoot())
     return E_FAIL;
 
   std::string str = manager->GetTreeData().url;
   if (str.empty())
     return S_FALSE;
 
   *url = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*url);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_title(BSTR* title) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TITLE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().title;
   if (str.empty())
     return S_FALSE;
 
   *title = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*title);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_mimeType(BSTR* mime_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MIME_TYPE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().mimetype;
   if (str.empty())
     return S_FALSE;
 
   *mime_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*mime_type);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_docType(BSTR* doc_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOC_TYPE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   auto* manager = GetOwner()->manager();
   if (!manager)
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
   std::string str = manager->GetTreeData().doctype;
@@ skipping 26 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nodeInfo(
     BSTR* node_name,
     short* name_space_id,
     BSTR* node_value,
     unsigned int* num_children,
     unsigned int* unique_id,
     unsigned short* node_type) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NODE_INFO);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node_name || !name_space_id || !node_value || !num_children ||
       !unique_id || !node_type) {
     return E_INVALIDARG;
   }
 
   base::string16 tag;
   if (GetOwner()->GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
     *node_name = SysAllocString(tag.c_str());
@@ skipping 18 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributes(
     unsigned short max_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values,
     unsigned short* num_attribs) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_GET_ATTRIBUTES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
   if (*num_attribs > GetOwner()->GetHtmlAttributes().size())
     *num_attribs = GetOwner()->GetHtmlAttributes().size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(
         base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].first).c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(
         base::UTF8ToUTF16(GetOwner()->GetHtmlAttributes()[i].second).c_str());
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_attributesForNames(
     unsigned short num_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ATTRIBUTES_FOR_NAMES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values)
     return E_INVALIDARG;
 
   for (unsigned short i = 0; i < num_attribs; ++i) {
     name_space_id[i] = 0;
     bool found = false;
     std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
     for (unsigned int j = 0; j < GetOwner()->GetHtmlAttributes().size(); ++j) {
@@ skipping 13 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values,
     unsigned short* num_style_properties) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   base::string16 display;
   if (max_style_properties == 0 ||
       !GetOwner()->GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
     *num_style_properties = 0;
     return S_OK;
   }
 
   *num_style_properties = 1;
   style_properties[0] = SysAllocString(L"display");
   style_values[0] = SysAllocString(display.c_str());
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_computedStyleForProperties(
     unsigned short num_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE_FOR_PROPERTIES);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     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]));
@@ skipping 10 matching lines @@
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollTo(boolean placeTopLeft) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_SCROLL_TO);
   return scrollTo(placeTopLeft ? IA2_SCROLL_TYPE_TOP_LEFT
                                : IA2_SCROLL_TYPE_ANYWHERE);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_parentNode(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PARENT_NODE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetParent())
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_firstChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FIRST_CHILD);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (GetOwner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(GetOwner()->PlatformGetChild(0))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_lastChild(ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LAST_CHILD);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (GetOwner()->PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node =
       ToBrowserAccessibilityComWin(
           GetOwner()->PlatformGetChild(GetOwner()->PlatformChildCount() - 1))
           ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_previousSibling(
     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PREVIOUS_SIBLING);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (!GetOwner()->PlatformGetParent() || GetIndexInParent() <= 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(
               GetOwner()->PlatformGetParent()->InternalGetChild(
                   GetIndexInParent() - 1))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_nextSibling(
     ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEXT_SIBLING);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (!GetOwner()->PlatformGetParent() || GetIndexInParent() < 0 ||
       GetIndexInParent() >=
           static_cast<int>(
               GetOwner()->PlatformGetParent()->InternalChildCount()) -
               1) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(
               GetOwner()->PlatformGetParent()->InternalGetChild(
                   GetIndexInParent() + 1))
               ->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_childAt(unsigned int child_index,
                                                      ISimpleDOMNode** node) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_AT);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (child_index >= GetOwner()->PlatformChildCount())
     return E_INVALIDARG;
 
   BrowserAccessibility* child = GetOwner()->PlatformGetChild(child_index);
   if (!child) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityComWin(child)->NewReference();
   return S_OK;
 }
 
 // We only support this method for retrieving MathML content.
 STDMETHODIMP BrowserAccessibilityComWin::get_innerHTML(BSTR* innerHTML) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INNER_HTML);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
   if (GetOwner()->GetRole() != ui::AX_ROLE_MATH)
     return E_NOTIMPL;
 
   base::string16 inner_html =
       GetOwner()->GetString16Attribute(ui::AX_ATTR_INNER_HTML);
   *innerHTML = SysAllocString(inner_html.c_str());
   DCHECK(*innerHTML);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityComWin::get_localInterface(void** local_interface) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCAL_INTERFACE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_language(BSTR* language) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LANGUAGE);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!language)
     return E_INVALIDARG;
   *language = nullptr;
 
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   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 BrowserAccessibilityComWin::get_domText(BSTR* dom_text) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOM_TEXT);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(ui::AX_ATTR_NAME, dom_text);
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_clippedSubstringBounds(
     unsigned int start_index,
@@ skipping 14 matching lines @@
 STDMETHODIMP BrowserAccessibilityComWin::get_unclippedSubstringBounds(
     unsigned int start_index,
     unsigned int end_index,
     int* out_x,
     int* out_y,
     int* out_width,
     int* out_height) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNCLIPPED_SUBSTRING_BOUNDS);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   unsigned int text_length =
       static_cast<unsigned int>(GetOwner()->GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
   gfx::Rect bounds =
       GetOwner()->GetScreenBoundsForRange(start_index, end_index - start_index);
   *out_x = bounds.x();
   *out_y = bounds.y();
   *out_width = bounds.width();
   *out_height = bounds.height();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::scrollToSubstring(
     unsigned int start_index,
     unsigned int end_index) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_SUBSTRING);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes |
                             AccessibilityMode::kInlineTextBoxes);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   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(
       *GetOwner(),
       GetOwner()->GetPageBoundsForRange(start_index, end_index - start_index));
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::get_fontFamily(BSTR* font_family) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FONT_FAMILY);
   AddAccessibilityModeFlags(kScreenReaderAndHTMLAccessibilityModes);
   if (!font_family)
     return E_INVALIDARG;
   *font_family = nullptr;
 
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   base::string16 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 BrowserAccessibilityComWin::QueryService(REFGUID guid_service,
                                                       REFIID riid,
                                                       void** object) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_QUERY_SERVICE);
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (guid_service == GUID_IAccessibleContentDocument) {
     // Special Mozilla extension: return the accessible for the root document.
     // Screen readers use this to distinguish between a document loaded event
     // on the root document vs on an iframe.
     BrowserAccessibility* node = GetOwner();
     while (node->PlatformGetParent())
       node = node->PlatformGetParent()->manager()->GetRoot();
     return ToBrowserAccessibilityComWin(node)->QueryInterface(IID_IAccessible2,
@@ skipping 55 matching lines @@
     IAccessibleEx** acc) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_CONVERT_RETURNED_ELEMENT);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::GetPatternProvider(
     PATTERNID id,
     IUnknown** provider) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PATTERN_PROVIDER);
   DVLOG(1) << "In Function: " << __func__ << " for pattern id: " << id;
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
     if (GetOwner()->HasState(ui::AX_STATE_EDITABLE)) {
       DVLOG(1) << "Returning UIA text provider";
       base::win::UIATextProvider::CreateTextProvider(GetValueText(), true,
                                                      provider);
       return S_OK;
     }
   }
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityComWin::GetPropertyValue(PROPERTYID id,
                                                           VARIANT* ret) {
   WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PROPERTY_VALUE);
   DVLOG(1) << "In Function: " << __func__ << " for property id: " << id;
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   V_VT(ret) = VT_EMPTY;
   if (id == UIA_ControlTypePropertyId) {
     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";
@@ skipping 716 matching lines @@
         start_offset +=
             static_cast<int>(text_win->GetOwner()->GetText().length());
       }
     }
   }
   return spelling_attributes;
 }
 
 BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetTargetFromChildID(
     const VARIANT& var_id) {
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return nullptr;
 
   if (var_id.vt != VT_I4)
     return nullptr;
 
   LONG child_id = var_id.lVal;
   if (child_id == CHILDID_SELF)
     return this;
 
   if (child_id >= 1 &&
       child_id <= static_cast<LONG>(GetOwner()->PlatformChildCount()))
     return ToBrowserAccessibilityComWin(
         GetOwner()->PlatformGetChild(child_id - 1));
 
   BrowserAccessibilityComWin* child = ToBrowserAccessibilityComWin(
       BrowserAccessibility::GetFromUniqueID(-child_id));
   if (child && child->GetOwner()->IsDescendantOf(GetOwner()))
     return child;
 
   return nullptr;
 }
 
 HRESULT BrowserAccessibilityComWin::GetStringAttributeAsBstr(
     ui::AXStringAttribute attribute,
     BSTR* value_bstr) {
   base::string16 str;
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return E_FAIL;
 
   if (!GetOwner()->GetString16Attribute(attribute, &str))
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
@@ skipping 516 matching lines @@
       return static_cast<LONG>(iterator->first);
     }
   }
 
   NOTREACHED();
   return start_offset;
 }
 
 BrowserAccessibilityComWin* BrowserAccessibilityComWin::GetFromID(
     int32_t id) const {
-  if (!GetOwner() || !GetOwner()->instance_active())
+  if (!GetOwner())
     return nullptr;
   return ToBrowserAccessibilityComWin(GetOwner()->manager()->GetFromID(id));
 }
 
 bool BrowserAccessibilityComWin::IsListBoxOptionOrMenuListOption() {
   if (!GetOwner()->PlatformGetParent())
     return false;
 
   int32_t role = GetOwner()->GetRole();
   int32_t parent_role = GetOwner()->PlatformGetParent()->GetRole();
@@ skipping 49 matching lines @@
   CComObject<BrowserAccessibilityRelation>* relation;
   HRESULT hr =
       CComObject<BrowserAccessibilityRelation>::CreateInstance(&relation);
   DCHECK(SUCCEEDED(hr));
   relation->AddRef();
   relation->Initialize(this, relation_type);
 
   for (int target_id : filtered_target_ids) {
     BrowserAccessibilityComWin* target =
         GetFromID(static_cast<int32_t>(target_id));
-    if (!target || !target->GetOwner()->instance_active())
+    if (!target || !target->GetOwner())
       continue;
     relation->AddTarget(target_id);
     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
@@ skipping 23 matching lines @@
 void BrowserAccessibilityComWin::RemoveBidirectionalRelationsOfType(
     const base::string16& relation_type,
     const base::string16& reverse_relation_type) {
   for (auto iter = relations_.begin(); iter != relations_.end();) {
     BrowserAccessibilityRelation* relation = *iter;
     DCHECK(relation);
     if (relation->get_type() == relation_type) {
       for (int target_id : relation->get_target_ids()) {
         BrowserAccessibilityComWin* target =
             GetFromID(static_cast<int32_t>(target_id));
-        if (!target || !target->GetOwner()->instance_active())
+        if (!target || !target->GetOwner())
           continue;
         DCHECK_NE(target, this);
         target->RemoveTargetFromRelation(reverse_relation_type,
                                          GetOwner()->GetId());
       }
       iter = relations_.erase(iter);
       relation->Release();
     } else {
       ++iter;
     }
@@ skipping 705 matching lines @@
 
 BrowserAccessibilityComWin* ToBrowserAccessibilityComWin(
     BrowserAccessibility* obj) {
   if (!obj || !obj->IsNative())
     return nullptr;
   auto* result = static_cast<BrowserAccessibilityWin*>(obj)->GetCOM();
   return result;
 }
 
 }  // namespace content