/* * Copyright (C) 2008, 2009, 2011 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "third_party/blink/renderer/modules/accessibility/ax_object.h" #include #include #include "base/auto_reset.h" #include "base/containers/span.h" #include "base/debug/crash_logging.h" #include "base/numerics/safe_conversions.h" #include "base/strings/string_util.h" #include "build/build_config.h" #include "third_party/blink/public/common/features.h" #include "third_party/blink/public/common/input/web_keyboard_event.h" #include "third_party/blink/public/mojom/frame/user_activation_notification_type.mojom-blink.h" #include "third_party/blink/public/mojom/input/focus_type.mojom-blink.h" #include "third_party/blink/public/mojom/scroll/scroll_into_view_params.mojom-blink.h" #include "third_party/blink/renderer/bindings/core/v8/frozen_array.h" #include "third_party/blink/renderer/core/accessibility/ax_object_cache.h" #include "third_party/blink/renderer/core/accessibility/ax_utilities_generated.h" #include "third_party/blink/renderer/core/accessibility/axid.h" #include "third_party/blink/renderer/core/css/resolver/style_resolver.h" #include "third_party/blink/renderer/core/display_lock/display_lock_utilities.h" #include "third_party/blink/renderer/core/dom/dom_node_ids.h" #include "third_party/blink/renderer/core/dom/element.h" #include "third_party/blink/renderer/core/dom/events/simulated_click_options.h" #include "third_party/blink/renderer/core/dom/focus_params.h" #include "third_party/blink/renderer/core/dom/focusgroup_flags.h" #include "third_party/blink/renderer/core/dom/indexed_pseudo_element.h" #include "third_party/blink/renderer/core/dom/shadow_root.h" #include "third_party/blink/renderer/core/dom/slot_assignment_engine.h" #include "third_party/blink/renderer/core/editing/character_range_mapper.h" #include "third_party/blink/renderer/core/editing/editing_utilities.h" #include "third_party/blink/renderer/core/editing/frame_selection.h" #include "third_party/blink/renderer/core/editing/selection_template.h" #include "third_party/blink/renderer/core/events/keyboard_event.h" #include "third_party/blink/renderer/core/frame/local_frame.h" #include "third_party/blink/renderer/core/frame/local_frame_view.h" #include "third_party/blink/renderer/core/frame/settings.h" #include "third_party/blink/renderer/core/frame/visual_viewport.h" #include "third_party/blink/renderer/core/fullscreen/fullscreen.h" #include "third_party/blink/renderer/core/html/canvas/html_canvas_element.h" #include "third_party/blink/renderer/core/html/custom/element_internals.h" #include "third_party/blink/renderer/core/html/fenced_frame/html_fenced_frame_element.h" #include "third_party/blink/renderer/core/html/forms/html_button_element.h" #include "third_party/blink/renderer/core/html/forms/html_data_list_element.h" #include "third_party/blink/renderer/core/html/forms/html_form_control_element.h" #include "third_party/blink/renderer/core/html/forms/html_input_element.h" #include "third_party/blink/renderer/core/html/forms/html_label_element.h" #include "third_party/blink/renderer/core/html/forms/html_opt_group_element.h" #include "third_party/blink/renderer/core/html/forms/html_option_element.h" #include "third_party/blink/renderer/core/html/forms/html_select_element.h" #include "third_party/blink/renderer/core/html/forms/html_text_area_element.h" #include "third_party/blink/renderer/core/html/forms/text_control_element.h" #include "third_party/blink/renderer/core/html/html_area_element.h" #include "third_party/blink/renderer/core/html/html_body_element.h" #include "third_party/blink/renderer/core/html/html_dialog_element.h" #include "third_party/blink/renderer/core/html/html_element.h" #include "third_party/blink/renderer/core/html/html_embed_element.h" #include "third_party/blink/renderer/core/html/html_frame_owner_element.h" #include "third_party/blink/renderer/core/html/html_head_element.h" #include "third_party/blink/renderer/core/html/html_hr_element.h" #include "third_party/blink/renderer/core/html/html_html_element.h" #include "third_party/blink/renderer/core/html/html_image_element.h" #include "third_party/blink/renderer/core/html/html_map_element.h" #include "third_party/blink/renderer/core/html/html_menu_item_element.h" #include "third_party/blink/renderer/core/html/html_no_script_element.h" #include "third_party/blink/renderer/core/html/html_progress_element.h" #include "third_party/blink/renderer/core/html/html_script_element.h" #include "third_party/blink/renderer/core/html/html_slot_element.h" #include "third_party/blink/renderer/core/html/html_span_element.h" #include "third_party/blink/renderer/core/html/html_style_element.h" #include "third_party/blink/renderer/core/html/html_table_cell_element.h" #include "third_party/blink/renderer/core/html/html_table_element.h" #include "third_party/blink/renderer/core/html/html_table_row_element.h" #include "third_party/blink/renderer/core/html/html_table_section_element.h" #include "third_party/blink/renderer/core/html/html_title_element.h" #include "third_party/blink/renderer/core/html/media/html_media_element.h" #include "third_party/blink/renderer/core/html/parser/html_parser_idioms.h" #include "third_party/blink/renderer/core/html/shadow/shadow_element_names.h" #include "third_party/blink/renderer/core/input/context_menu_allowed_scope.h" #include "third_party/blink/renderer/core/input/event_handler.h" #include "third_party/blink/renderer/core/input_type_names.h" #include "third_party/blink/renderer/core/keywords.h" #include "third_party/blink/renderer/core/layout/layout_box.h" #include "third_party/blink/renderer/core/layout/layout_box_model_object.h" #include "third_party/blink/renderer/core/layout/layout_image.h" #include "third_party/blink/renderer/core/layout/layout_view.h" #include "third_party/blink/renderer/core/mathml_names.h" #include "third_party/blink/renderer/core/overscroll/overscroll_area_tracker.h" #include "third_party/blink/renderer/core/page/chrome_client.h" #include "third_party/blink/renderer/core/page/focus_controller.h" #include "third_party/blink/renderer/core/page/focusgroup_controller_utils.h" #include "third_party/blink/renderer/core/page/page.h" #include "third_party/blink/renderer/core/page/scrolling/top_document_root_scroller_controller.h" #include "third_party/blink/renderer/core/scroll/scroll_into_view_util.h" #include "third_party/blink/renderer/core/style/computed_style_constants.h" #include "third_party/blink/renderer/core/svg/svg_desc_element.h" #include "third_party/blink/renderer/core/svg/svg_element.h" #include "third_party/blink/renderer/core/svg/svg_g_element.h" #include "third_party/blink/renderer/core/svg/svg_style_element.h" #include "third_party/blink/renderer/core/svg/svg_title_element.h" #include "third_party/blink/renderer/modules/accessibility/aria_notification.h" #include "third_party/blink/renderer/modules/accessibility/ax_enums.h" #include "third_party/blink/renderer/modules/accessibility/ax_object-inl.h" #include "third_party/blink/renderer/modules/accessibility/ax_relation_cache.h" #include "third_party/blink/renderer/platform/wtf/text/atomic_string.h" #include "third_party/blink/renderer/platform/wtf/text/string_to_number.h" #if AX_FAIL_FAST_BUILD() #include "third_party/blink/renderer/modules/accessibility/ax_debug_utils.h" #endif #include "third_party/blink/renderer/bindings/core/v8/v8_highlight_type.h" #include "third_party/blink/renderer/core/page/page_popup_client.h" #include "third_party/blink/renderer/modules/accessibility/ax_image_map_link.h" #include "third_party/blink/renderer/modules/accessibility/ax_inline_text_box.h" #include "third_party/blink/renderer/modules/accessibility/ax_object_cache_impl.h" #include "third_party/blink/renderer/modules/accessibility/ax_range.h" #include "third_party/blink/renderer/modules/accessibility/ax_selection.h" #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h" #include "third_party/blink/renderer/platform/keyboard_codes.h" #include "third_party/blink/renderer/platform/language.h" #include "third_party/blink/renderer/platform/runtime_enabled_features.h" #include "third_party/blink/renderer/platform/text/platform_locale.h" #include "third_party/blink/renderer/platform/wtf/hash_set.h" #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h" #include "third_party/blink/renderer/platform/wtf/text/strcat.h" #include "third_party/blink/renderer/platform/wtf/text/string_builder_stream.h" #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" #include "third_party/blink/renderer/platform/wtf/wtf_size_t.h" #include "ui/accessibility/accessibility_features.h" #include "ui/accessibility/ax_action_data.h" #include "ui/accessibility/ax_common.h" #include "ui/accessibility/ax_enums.mojom-blink-forward.h" #include "ui/accessibility/ax_node_data.h" #include "ui/accessibility/ax_role_properties.h" #include "ui/accessibility/ax_tree_id.h" #include "ui/accessibility/ax_tree_source.h" #include "ui/base/mojom/menu_source_type.mojom-blink.h" #include "ui/events/keycodes/dom/dom_code.h" #include "ui/events/keycodes/dom/keycode_converter.h" #include "ui/gfx/geometry/transform.h" namespace blink { using mojom::blink::FormControlType; namespace { #if AX_FAIL_FAST_BUILD() String GetIgnoredReasonsDebugString(AXObject::IgnoredReasons& reasons) { if (reasons.size() == 0) return ""; StringBuilder string_builder; string_builder.Append("("); for (wtf_size_t count = 0; count < reasons.size(); count++) { if (count > 0) string_builder.Append(','); string_builder.Append(IgnoredReasonName(reasons[count].reason)); } string_builder.Append(")"); return string_builder.ReleaseString(); } #endif #if DCHECK_IS_ON() bool IsValidRole(ax::mojom::blink::Role role) { // Check for illegal roles that should not be assigned in Blink. switch (role) { case ax::mojom::blink::Role::kCaret: case ax::mojom::blink::Role::kClient: case ax::mojom::blink::Role::kColumn: case ax::mojom::blink::Role::kDesktop: case ax::mojom::blink::Role::kKeyboard: case ax::mojom::blink::Role::kImeCandidate: case ax::mojom::blink::Role::kListGrid: case ax::mojom::blink::Role::kMenuItemSeparator: case ax::mojom::blink::Role::kPane: case ax::mojom::blink::Role::kPdfActionableHighlight: case ax::mojom::blink::Role::kPdfRoot: case ax::mojom::blink::Role::kPreDeprecated: case ax::mojom::blink::Role::kTableHeaderContainer: case ax::mojom::blink::Role::kTitleBar: case ax::mojom::blink::Role::kUnknown: case ax::mojom::blink::Role::kWebView: case ax::mojom::blink::Role::kWindow: return false; default: return true; } } #endif void AddIntListAttributeFromObjects(ax::mojom::blink::IntListAttribute attr, const AXObject::AXObjectVector& objects, ui::AXNodeData* node_data) { DCHECK(node_data); std::vector ids; for (const auto& obj : objects) { if (!obj->IsIgnored()) { ids.push_back(obj->AXObjectID()); } } if (!ids.empty()) node_data->AddIntListAttribute(attr, ids); } // Returns true if |target| satisfies the Author MUST requirements for // aria-actions targets per the spec PR // (https://github.com/w3c/aria/pull/1805) #aria-actions. The UA drops targets // that fail these checks. Validates accessible name, click-handler // availability, and keyboard accessibility. bool IsValidAriaActionsTarget(const AXObject& target) { String name = target.ComputedName(); if (name.StripWhiteSpace().empty()) { return false; } // IsClickable() is virtually dispatched to AXNodeObject::IsClickable(), // which considers mouse-button event listeners, contenteditable, native // clickable roles, and correctly returns false for disabled elements. if (!target.IsClickable()) { return false; } // CanSetFocusAttribute() accepts elements that are either mouse-focusable // (native focusable roles, tabindex>=0, or tabindex=-1 inside a // managed-focus widget) or keyboard-focusable. It rejects disabled, // hidden, and inert elements. The const overload returns the cached // value, which has been updated by the surrounding serialization path. return target.CanSetFocusAttribute(); } // Max length for attributes such as aria-label. static constexpr uint32_t kMaxStringAttributeLength = 10000; // Max length for a static text name. // Length of War and Peace (http://www.gutenberg.org/files/2600/2600-0.txt). static constexpr uint32_t kMaxStaticTextLength = 3227574; std::string TruncateString(const String& str, uint32_t max_len = kMaxStringAttributeLength) { auto str_utf8 = str.Utf8(Utf8ConversionMode::kStrict); if (str_utf8.size() > max_len) { std::string truncated; base::TruncateUTF8ToByteSize(str_utf8, max_len, &truncated); return truncated; } return str_utf8; } bool TruncateAndAddStringAttribute( ui::AXNodeData* dst, ax::mojom::blink::StringAttribute attribute, const String& value, uint32_t max_len = kMaxStringAttributeLength) { if (!value.empty()) { std::string value_utf8 = TruncateString(value, max_len); if (!value_utf8.empty()) { dst->AddStringAttribute(attribute, value_utf8); return true; } } return false; } void AddIntAttribute(const AXObject* obj, ax::mojom::blink::IntAttribute node_data_attr, const QualifiedName& attr_name, ui::AXNodeData* node_data, int min_value = INT_MIN) { const AtomicString& value = obj->AriaAttribute(attr_name); if (!value.empty()) { int value_as_int = StringToIntLoose(value).value_or(0); if (value_as_int >= min_value) { node_data->AddIntAttribute(node_data_attr, value_as_int); } } } void AddIntListAttributeFromOffsetVector( ax::mojom::blink::IntListAttribute attr, const Vector& offsets, ui::AXNodeData* node_data) { std::vector offset_values; for (int offset : offsets) offset_values.push_back(static_cast(offset)); DCHECK(node_data); if (!offset_values.empty()) node_data->AddIntListAttribute(attr, offset_values); } const QualifiedName& DeprecatedAriaColtextAttrName() { DEFINE_STATIC_LOCAL(QualifiedName, aria_coltext_attr, (AtomicString("aria-coltext"))); return aria_coltext_attr; } const QualifiedName& DeprecatedAriaRowtextAttrName() { DEFINE_STATIC_LOCAL(QualifiedName, aria_rowtext_attr, (AtomicString("aria-rowtext"))); return aria_rowtext_attr; } const AtomicString& AriaTokenAttributeFromValue(const QualifiedName& attribute, const AtomicString& value) { DEFINE_STATIC_LOCAL(const AtomicString, undefined_value, ("undefined")); if (IsAriaTokenAttribute(attribute) || IsAriaTokenListAttribute(attribute)) { // These properties support a list of tokens, and "undefined"/"" is // equivalent to not setting the attribute. return value.empty() || value == undefined_value ? g_null_atom : value; } DCHECK(false) << "Not a token attribute. Use AriaFloatAttribute(), " "AriaIntAttribute(), AriaStringAttribute(), etc. instead."; return value; } bool IsGenericWrapper(const Element& element, const AtomicString& role_str) { if (!role_str.empty()) { return false; } return element.HasTagName(html_names::kDivTag) || element.HasTagName(html_names::kSpanTag) || element.HasTagName(html_names::kSlotTag) || element.IsCustomElement(); } } // namespace int32_t ToAXMarkerType(DocumentMarker::MarkerType marker_type) { ax::mojom::blink::MarkerType result; switch (marker_type) { case DocumentMarker::kSpelling: result = ax::mojom::blink::MarkerType::kSpelling; break; case DocumentMarker::kGrammar: result = ax::mojom::blink::MarkerType::kGrammar; break; case DocumentMarker::kTextFragment: case DocumentMarker::kTextMatch: result = ax::mojom::blink::MarkerType::kTextMatch; break; case DocumentMarker::kActiveSuggestion: result = ax::mojom::blink::MarkerType::kActiveSuggestion; break; case DocumentMarker::kSuggestion: result = ax::mojom::blink::MarkerType::kSuggestion; break; case DocumentMarker::kCustomHighlight: result = ax::mojom::blink::MarkerType::kHighlight; break; default: result = ax::mojom::blink::MarkerType::kNone; break; } return static_cast(result); } int32_t ToAXHighlightType(const V8HighlightType& highlight_type) { switch (highlight_type.AsEnum()) { case V8HighlightType::Enum::kHighlight: return static_cast(ax::mojom::blink::HighlightType::kHighlight); case V8HighlightType::Enum::kSpellingError: return static_cast( ax::mojom::blink::HighlightType::kSpellingError); case V8HighlightType::Enum::kGrammarError: return static_cast( ax::mojom::blink::HighlightType::kGrammarError); } NOTREACHED(); } const AXObject* FindAncestorWithAriaHidden(const AXObject* start) { for (const AXObject* object = start; object && !IsA(object->GetNode()); object = object->ParentObject()) { if (object->IsAriaHiddenRoot()) { return object; } } return nullptr; } // static unsigned AXObject::number_of_live_ax_objects_ = 0; AXObject::AXObject(AXObjectCacheImpl& ax_object_cache, bool is_node_object) : id_(0), parent_(nullptr), role_(ax::mojom::blink::Role::kUnknown), is_node_object_(is_node_object), cached_live_region_root_(nullptr), ax_object_cache_(&ax_object_cache) { ++number_of_live_ax_objects_; } AXObject::~AXObject() { DCHECK(IsDetached()); --number_of_live_ax_objects_; } void AXObject::SetHasDirtyDescendants(bool dirty) { CHECK(!dirty || CachedIsIncludedInTree()) << "Only included nodes can be marked as having dirty descendants: " << this; has_dirty_descendants_ = dirty; } void AXObject::SetAncestorsHaveDirtyDescendants() { CHECK(!IsDetached()); CHECK(AXObjectCache() .lifecycle() .StateAllowsAXObjectsToGainFinalizationNeededBit()) << AXObjectCache(); // Set the dirty bit for the root AX object when created. For all other // objects, this is set by a descendant needing to be updated, and // AXObjectCacheImpl::FinalizeTree() will therefore process an object // if its parent has has_dirty_descendants_ set. The root, however, has no // parent, so there is no parent to mark in order to cause the root to update // itself. Therefore this bit serves a second purpose of determining // whether AXObjectCacheImpl::FinalizeTree() needs to update the root // object. if (IsRoot()) { // Need at least the root object to be flagged in order for // FinalizeTree() to do anything. SetHasDirtyDescendants(true); return; } if (AXObjectCache().EntireDocumentIsDirty()) { // No need to walk parent chain when marking the entire document dirty, // as every node will have the bit set. In addition, attempting to repair // the parent chain while marking everything dirty is actually against // the point, because all child-parent relationships will be rebuilt // from the top down. if (CachedIsIncludedInTree()) { SetHasDirtyDescendants(true); } return; } AXObject* ancestor = this; while (true) { ancestor = ancestor->ParentObjectIfPresent(); if (!ancestor) { break; } DCHECK(!ancestor->IsDetached()); // We need to to continue setting bits through AX objects for which // IsIncludedInTree is false, since those objects are omitted // from the generated tree. However, don't set the bit on unincluded // objects, during the clearing phase in // AXObjectCacheImpl::FinalizeTree(), only included nodes are // visited. if (!ancestor->CachedIsIncludedInTree()) { continue; } if (!ancestor->has_dirty_descendants_) { ancestor->SetHasDirtyDescendants(true); } } #if AX_FAIL_FAST_BUILD() // Walk up the tree looking for dirty bits that failed to be set. If any // are found, this is a bug. for (auto* obj = ParentObjectIfPresent(); obj; obj = obj->ParentObjectIfPresent()) { if (obj->CachedIsIncludedInTree() && !obj->has_dirty_descendants_) { NOTREACHED() << "Failed to set dirty bits on some ancestors:\n" << ParentChainToStringHelper(this); } } #endif // AX_FAIL_FAST_BUILD() } void AXObject::Init(AXObject* parent) { CHECK(!parent_) << "Should not already have a cached parent:" << "\n* Child = " << GetNode() << " / " << GetLayoutObject() << "\n* Parent = " << parent_ << "\n* Equal to passed-in parent? " << (parent == parent_); // Every AXObject must have a parent unless it's the root. CHECK(parent || IsRoot()) << "The following node should have a parent: " << GetNode(); CHECK(!AXObjectCache().IsFrozen()); #if DCHECK_IS_ON() CHECK(!is_initializing_); base::AutoReset reentrancy_protector(&is_initializing_, true); #endif // DCHECK_IS_ON() // Set the parent as soon as possible, so that we can use it in computations // for the role and cached value. We will set it again at the end of the // method using SetParent(), to ensure all of the normal code paths for // setting the parent are followed. parent_ = parent; // The role must be determined immediately. // Note: in order to avoid reentrancy, the role computation cannot use the // ParentObject(), although it can use the DOM parent. role_ = DetermineRoleValue(); #if DCHECK_IS_ON() DCHECK(IsValidRole(role_)) << "Illegal " << role_ << " for\n" << GetNode() << '\n' << GetLayoutObject(); // The parent cannot have children. This object must be destroyed. DCHECK(!parent_ || parent_->CanHaveChildren()) << "Tried to set a parent that cannot have children:" << "\n* Parent = " << parent_ << "\n* Child = " << this; #endif children_dirty_ = true; UpdateCachedAttributeValuesIfNeeded(false); DCHECK(GetDocument()) << "All AXObjects must have a document: " << this; // Set the parent again, this time via SetParent(), so that all related checks // and calls occur now that we have the role and updated cached values. SetParent(parent_); } void AXObject::Detach() { #if DCHECK_IS_ON() DCHECK(!is_updating_cached_values_) << "Don't detach in the middle of updating cached values: " << this; DCHECK(!IsDetached()); #endif // Prevents LastKnown*() methods from returning the wrong values. cached_is_ignored_ = true; cached_is_ignored_but_included_in_tree_ = false; #if AX_FAIL_FAST_BUILD() SANITIZER_CHECK(ax_object_cache_); SANITIZER_CHECK(!ax_object_cache_->IsFrozen()) << "Do not detach children while the tree is frozen, in order to avoid " "an object detaching itself in the middle of computing its own " "accessibility properties."; SANITIZER_CHECK(!is_adding_children_) << this; #endif #if !defined(NDEBUG) // Facilitates debugging of detached objects by providing info on what it was. if (!ax_object_cache_->HasBeenDisposed()) { detached_object_debug_info_ = ToString(); } #endif if (AXObjectCache().HasBeenDisposed()) { // Shutting down a11y, just clear the children. children_.clear(); } else { // Clear children and call DetachFromParent() on them so that // no children are left with dangling pointers to their parent. ClearChildren(); } parent_ = nullptr; SetCachedValuesNeedUpdate(false); ax_object_cache_ = nullptr; children_dirty_ = false; child_cached_values_need_update_ = false; has_dirty_descendants_ = false; id_ = 0; } bool AXObject::IsRoot() const { return GetNode() && GetNode() == &AXObjectCache().GetDocument(); } void AXObject::SetParent(AXObject* new_parent) { CHECK(!AXObjectCache().IsFrozen()); #if DCHECK_IS_ON() if (!new_parent && !IsRoot()) { std::ostringstream message; message << "Parent cannot be null, except at the root." << "\nThis: " << this << "\nDOM parent chain , starting at |this->GetNode()|:"; int count = 0; for (Node* node = GetNode(); node; node = GetParentNodeForComputeParent(AXObjectCache(), node)) { message << "\n" << (++count) << ". " << node << "\n LayoutObject=" << node->GetLayoutObject(); if (AXObject* obj = AXObjectCache().Get(node)) message << "\n " << obj; if (!node->isConnected()) { break; } } NOTREACHED() << message.str(); } if (new_parent) { DCHECK(!new_parent->IsDetached()) << "Cannot set parent to a detached object:" << "\n* Child: " << this << "\n* New parent: " << new_parent; DCHECK(!IsAXInlineTextBox() || ui::CanHaveInlineTextBoxChildren(new_parent->RoleValue())) << "Unexpected parent of inline text box: " << new_parent->RoleValue(); } // Check to ensure that if the parent is changing from a previous parent, // that |this| is not still a child of that one. // This is similar to the IsParentUnignoredOf() check in // BlinkAXTreeSource, but closer to where the problem would occur. if (parent_ && new_parent != parent_ && !parent_->NeedsToUpdateChildren() && !parent_->IsDetached()) { for (const auto& child : parent_->ChildrenIncludingIgnored()) { // TODO(crbug.com/500774799): Investigate and convert to CHECK. DCHECK(child != this) << "Previous parent still has |this| child:\n" << this << " should be a child of " << new_parent << " not of " << parent_; } // TODO(accessibility) This should not be reached unless this method is // called on an AXObject of role kRootWebArea or when the parent's // children are dirty, aka parent_->NeedsToUpdateChildren()); // Ideally we will also ensure |this| is in the parent's children now, so // that ClearChildren() can later find the child to detach from the parent. } #endif parent_ = new_parent; if (AXObjectCache().IsUpdatingTree()) { // If updating tree, tell the newly included parent to iterate through // all of its children to look for the has dirty descendants flag. // However, we do not set the flag on higher ancestors since // they have already been walked by the tree update loop. if (AXObject* ax_included_parent = ParentObjectIncludedInTree()) { ax_included_parent->SetHasDirtyDescendants(true); } } else { SetAncestorsHaveDirtyDescendants(); } } bool AXObject::IsMissingParent() const { // This method should not be called on a detached object. if (IsDetached()) { // TODO(a11y): Upgrade to NOTREACHED once all hits of // crbug.com/337178753 have been addressed. DUMP_WILL_BE_NOTREACHED() << "Checking for parent on detached object: " << this; return false; } if (!parent_) { // Do not attempt to repair the ParentObject() of a validation message // object, because hidden ones are purposely kept around without being in // the tree, and without a parent, for potential later reuse. bool is_missing = !IsRoot(); // TODO(crbug.com/500793607): Investigate and convert to CHECK. DCHECK(!is_missing || !AXObjectCache().IsFrozen()) << "Should not have missing parent in frozen tree: " << this; return is_missing; } if (parent_->IsDetached()) { // TODO(crbug.com/500793607): Investigate and convert to CHECK. DCHECK(!AXObjectCache().IsFrozen()) << "Should not have detached parent in frozen tree: " << this; return true; } return false; } // In many cases, ComputeParent() is not called, because the parent adding // the parent adding the child will pass itself into AXObjectCacheImpl. // ComputeParent() is still necessary because some parts of the code, // especially web tests, result in AXObjects being created in the middle of // the tree before their parents are created. // TODO(accessibility) Consider forcing all ax objects to be created from // the top down, eliminating the need for ComputeParent(). AXObject* AXObject::ComputeParent() const { AXObject* ax_parent = ComputeParentOrNull(); CHECK(!ax_parent || !ax_parent->IsDetached()) << "Computed parent should never be detached:" << "\n* Child: " << this << "\n* Parent: " << ax_parent; return ax_parent; } // Same as ComputeParent, but without the extra check for valid parent in the // end. This is for use in RestoreParentOrPrune. AXObject* AXObject::ComputeParentOrNull() const { CHECK(!IsDetached()); CHECK(GetNode() || GetLayoutObject()) << "Can't compute parent on AXObjects without a backing Node or " "LayoutObject. Objects without those must set the " "parent in Init(), |this| = " << RoleValue(); AXObject* ax_parent = nullptr; if (IsAXInlineTextBox()) { NOTREACHED() << "AXInlineTextBox box tried to compute a new parent, but they are " "not allowed to exist even temporarily without a parent, as their " "existence depends on the parent text object. Parent text = " << AXObjectCache().Get(GetNode()); } else if (AXObjectCache().IsAriaOwned(this)) { ax_parent = AXObjectCache().ValidatedAriaOwner(this); } if (!ax_parent) { ax_parent = ComputeNonARIAParent(AXObjectCache(), GetNode()); } return ax_parent; } // static Node* AXObject::GetParentNodeForComputeParent(AXObjectCacheImpl& cache, Node* node) { if (!node || !node->isConnected()) { return nullptr; } // A document's parent should be the page popup owner, if any, otherwise null. if (auto* document = DynamicTo(node)) { LocalFrame* frame = document->GetFrame(); DCHECK(frame); return frame->PagePopupOwner(); } // Avoid a CHECK that disallows calling LayoutTreeBuilderTraversal::Parent() with a shadow root node. if (node->IsShadowRoot()) { return node->OwnerShadowHost(); } Node* parent = nullptr; // ::scroll-button and ::scroll-marker-group elements have a node parent that // is the originating element. However, they are constructed as siblings of // the originating element. This matches the layout relationship. So, for // these specific elements, use the layout parent's node. if ((node->IsScrollButtonPseudoElement() || node->IsScrollMarkerGroupPseudoElement()) && node->GetLayoutObject()) { LayoutObject* parent_object = node->GetLayoutObject()->Parent(); // Find the nearest non-anonymous layout object ancestor. while (parent_object && parent_object->IsAnonymous()) { parent_object = parent_object->Parent(); } if (parent_object) { parent = parent_object->GetNode(); } } // Targets of toggle-overscroll actions are reparented under their // corresponding ::-internal-overscroll-area on their overscroll container. if (Element* element = DynamicTo(node)) { if (PseudoElement* overscroll_area_parent = element->GetPseudoElement(kPseudoIdOverscrollAreaParent)) { return overscroll_area_parent; } } if (PseudoElement* pseudo_element = DynamicTo(node); pseudo_element && pseudo_element->GetPseudoId() == kPseudoIdOverscrollAreaParent) { return pseudo_element->UltimateOriginatingElement() .GetOverscrollContainer(); } // Use LayoutTreeBuilderTraversal::Parent(), which handles pseudo content. // This can return nullptr for a node that is never visited by // LayoutTreeBuilderTraversal's child traversal. For example, while an element // can be appended as a