ax_tree_manager.cc | Explore in Territory

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/accessibility/ax_tree_manager.h"

#include "base/lazy_instance.h"
#include "base/no_destructor.h"
#include "ui/accessibility/ax_common.h"
#include "ui/accessibility/ax_export.h"
#include "ui/accessibility/ax_node.h"
#include "ui/accessibility/ax_tree_id.h"
#include "ui/accessibility/ax_tree_manager_map.h"
#include "ui/accessibility/ax_tree_observer.h"

namespace ui {

// A flag to ensure that accessibility fatal errors crash immediately.
bool AXTreeManager::is_fail_fast_mode_ = …;

// static
AXTreeManagerMap& AXTreeManager::GetMap() { … }

// static
AXTreeManager* AXTreeManager::FromID(const AXTreeID& ax_tree_id) { … }

// static
AXTreeManager* AXTreeManager::ForChildTree(const AXNode& parent_node) { … }

// static
base::RepeatingClosure& AXTreeManager::GetFocusChangeCallbackForTesting() { … }

void AXTreeManager::SetFocusChangeCallbackForTesting(
    base::RepeatingClosure callback) { … }

AXTreeManager::AXTreeManager()
    : … { … }

AXTreeManager::AXTreeManager(std::unique_ptr<AXTree> tree)
    : … { … }

void AXTreeManager::FireFocusEvent(AXNode* node) { … }

AXNode* AXTreeManager::RetargetForEvents(AXNode* node,
                                         RetargetEventType type) const { … }

bool AXTreeManager::CanFireEvents() const { … }

bool AXTreeManager::IsView() const { … }

AXNode* AXTreeManager::GetNodeFromTree(const AXTreeID& tree_id,
                                       const AXNodeID node_id) const { … }

void AXTreeManager::Initialize(const AXTreeUpdate& initial_tree) { … }

AXNode* AXTreeManager::GetNode(const AXNodeID node_id) const { … }

const AXTreeData& AXTreeManager::GetTreeData() const { … }

AXTreeID AXTreeManager::GetParentTreeID() const { … }

bool AXTreeManager::IsPlatformTreeManager() const { … }

AXNode* AXTreeManager::GetRoot() const { … }

void AXTreeManager::WillBeRemovedFromMap() { … }

// static
std::optional<AXNodeID> AXTreeManager::last_focused_node_id_ = …;

// static
std::optional<AXTreeID> AXTreeManager::last_focused_node_tree_id_ = …;

// static
void AXTreeManager::SetLastFocusedNode(AXNode* node) { … }

// static
AXNode* AXTreeManager::GetLastFocusedNode() { … }

AXTreeManager::~AXTreeManager() { … }

std::unique_ptr<AXTree> AXTreeManager::SetTree(std::unique_ptr<AXTree> tree) { … }

std::unique_ptr<AXTree> AXTreeManager::SetTree(
    const AXTreeUpdate& initial_state) { … }

void AXTreeManager::OnTreeDataChanged(AXTree* tree,
                                      const AXTreeData& old_data,
                                      const AXTreeData& new_data) { … }

void AXTreeManager::OnNodeWillBeDeleted(AXTree* tree, AXNode* node) { … }

void AXTreeManager::OnAtomicUpdateFinished(
    AXTree* tree,
    bool root_changed,
    const std::vector<AXTreeObserver::Change>& changes) { … }

AXTreeManager* AXTreeManager::GetParentManager() const { … }

bool AXTreeManager::IsRoot() const { … }

AXTreeManager* AXTreeManager::GetRootManager() const { … }

AXNode* AXTreeManager::GetParentNodeFromParentTree() const { … }

void AXTreeManager::ParentConnectionChanged(AXNode* parent) { … }

void AXTreeManager::EnsureParentConnectionIfNotRootManager() { … }

}  // namespace ui
chromium/ui/accessibility/ax_tree_manager.cc
