Attachment #445823 for bug #233804

View Details Raw Unified Return to Bug 233804



2021-12-03  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Ensure atspi wrappers have root set at construction time
        https://bugs.webkit.org/show_bug.cgi?id=233804

        Reviewed by NOBODY (OOPS!).

        Pass the AccessibilityRootAtspi as a parameter to AccessibilityObjectAtspi constructor and store it as a
        reference. A pointer to the AccessibilityRootAtspi object is now set in Page so that it can be accessed from the
        AXObjectCache. Also remove setRoot() and use m_root directly instead of root() accessor.

        * accessibility/atspi/AXObjectCacheAtspi.cpp:
        (WebCore::AXObjectCache::attachWrapper): Get the AccessibilityRootAtspi from the page and pass it to the wrapper
        constructor. Also set the parent of the dom root element wrapper to the atspi root element.
        * accessibility/atspi/AccessibilityAtspi.cpp:
        (WebCore::AccessibilityAtspi::childrenChanged):
        * accessibility/atspi/AccessibilityObjectAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::create):
        (WebCore::AccessibilityObjectAtspi::AccessibilityObjectAtspi):
        (WebCore::AccessibilityObjectAtspi::cacheDestroyed):
        (WebCore::AccessibilityObjectAtspi::elementDestroyed):
        (WebCore::AccessibilityObjectAtspi::path):
        (WebCore::AccessibilityObjectAtspi::reference):
        (WebCore::AccessibilityObjectAtspi::hyperlinkReference):
        (WebCore::AccessibilityObjectAtspi::parentReference const):
        (WebCore::AccessibilityObjectAtspi::childAt const):
        (WebCore::AccessibilityObjectAtspi::wrapperVector const):
        (WebCore::AccessibilityObjectAtspi::buildRelationSet const):
        (WebCore::AccessibilityObjectAtspi::serialize const):
        (WebCore::AccessibilityObjectAtspi::childAdded):
        (WebCore::AccessibilityObjectAtspi::childRemoved):
        (WebCore::AccessibilityObjectAtspi::stateChanged):
        (WebCore::AccessibilityObjectAtspi::setRoot): Deleted.
        (WebCore::AccessibilityObjectAtspi::root const): Deleted.
        * accessibility/atspi/AccessibilityObjectAtspi.h:
        * accessibility/atspi/AccessibilityObjectComponentAtspi.cpp:
        * accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp:
        * accessibility/atspi/AccessibilityObjectHypertextAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::hyperlink const):
        * accessibility/atspi/AccessibilityObjectSelectionAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::selectedChild const):
        (WebCore::AccessibilityObjectAtspi::selectionChanged):
        * accessibility/atspi/AccessibilityObjectTableAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::cell const):
        (WebCore::AccessibilityObjectAtspi::tableCaption const):
        (WebCore::AccessibilityObjectAtspi::rowHeader const):
        (WebCore::AccessibilityObjectAtspi::columnHeader const):
        * accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::cellRowHeaders const):
        (WebCore::AccessibilityObjectAtspi::cellColumnHeaders const):
        * accessibility/atspi/AccessibilityObjectTextAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::textInserted):
        (WebCore::AccessibilityObjectAtspi::textDeleted):
        (WebCore::AccessibilityObjectAtspi::selectionChanged):
        (WebCore::AccessibilityObjectAtspi::textAttributesChanged):
        * accessibility/atspi/AccessibilityObjectValueAtspi.cpp:
        (WebCore::AccessibilityObjectAtspi::valueChanged):
        * accessibility/atspi/AccessibilityRootAtspi.cpp:
        (WebCore::AccessibilityRootAtspi::registerObject):
        (WebCore::AccessibilityRootAtspi::unregisterObject):
        (WebCore::AccessibilityRootAtspi::child const):
        (WebCore::AccessibilityRootAtspi::focusedObject const): Deleted.
        * accessibility/atspi/AccessibilityRootAtspi.h:
        * page/Page.h:
        (WebCore::Page::accessibilityRootObject const):
        (WebCore::Page::setAccessibilityRootObject):

2021-12-02  Martin Robinson  <mrobinson@webkit.org>

        sticky th or td in table does not stops at specified top

Lines 35-46 namespace WebCore { a/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp -2 / +7 lines
35		35
36	void AXObjectCache::attachWrapper(AXCoreObject* axObject)	36	void AXObjectCache::attachWrapper(AXCoreObject* axObject)
37	{	37	{
38	auto wrapper = AccessibilityObjectAtspi::create(axObject);	38	auto* rootWrapper = document().page()->accessibilityRootObject();
		39	RELEASE_ASSERT(rootWrapper);
		40	auto wrapper = AccessibilityObjectAtspi::create(axObject, *rootWrapper);
39	axObject->setWrapper(wrapper.ptr());	41	axObject->setWrapper(wrapper.ptr());
40		42
41	auto* axParent = axObject->parentObjectUnignored();	43	auto* axParent = axObject->parentObjectUnignored();
42	if (!axParent)	44	if (!axParent) {
		45	if (axObject->isScrollView() && axObject->scrollView() == document().view())
		46	wrapper->setParent(nullptr); // nullptr parent means root.
43	return;	47	return;
		48	}
44		49
45	auto* axParentWrapper = axParent->wrapper();	50	auto* axParentWrapper = axParent->wrapper();
46	if (!axParentWrapper)	51	if (!axParentWrapper)

Lines 177-183 void AccessibilityAtspi::childrenChanged(AccessibilityObjectAtspi& atspiObject, a/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp -1 lines
177	if (!m_connection)	177	if (!m_connection)
178	return;	178	return;
179		179
180	child->setRoot(atspiObject->root());
181	g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject->path().utf8().data(), "org.a11y.atspi.Event.Object", "ChildrenChanged",	180	g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject->path().utf8().data(), "org.a11y.atspi.Event.Object", "ChildrenChanged",
182	g_variant_new("(siiv(so))", change == ChildrenChanged::Added ? "add" : "remove", child->indexInParentForChildrenChanged(change),	181	g_variant_new("(siiv(so))", change == ChildrenChanged::Added ? "add" : "remove", child->indexInParentForChildrenChanged(change),
183	0, g_variant_new("(so)", uniqueName(), child->path().utf8().data()), uniqueName(), atspiObject->path().utf8().data()), nullptr);	182	0, g_variant_new("(so)", uniqueName(), child->path().utf8().data()), uniqueName(), atspiObject->path().utf8().data()), nullptr);




namespace WebCore {

Ref<AccessibilityObjectAtspi> AccessibilityObjectAtspi::create(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
{
    return adoptRef(*new AccessibilityObjectAtspi(coreObject, root));
}

static inline bool roleIsTextType(AccessibilityRole role)

    return interfaces;
}

AccessibilityObjectAtspi::AccessibilityObjectAtspi(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
    : m_coreObject(coreObject)
    , m_interfaces(interfacesForObject(*m_coreObject))
    , m_root(root)
{
    RELEASE_ASSERT(isMainThread());
}

    if (!m_isRegistered.load())
        return;

    m_root.atspi().unregisterObject(*this);
}

void AccessibilityObjectAtspi::elementDestroyed()

    if (m_parent && *m_parent)
        m_parent.value()->childRemoved(*this);

    m_root.atspi().unregisterObject(*this);
}

static unsigned atspiRole(AccessibilityRole role)


            g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
        } else if (!g_strcmp0(methodName, "GetApplication"))
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", atspiObject->m_root.applicationReference()));
        else if (!g_strcmp0(methodName, "GetChildAtIndex")) {
            int index;
            g_variant_get(parameters, "(i)", &index);
            auto* wrapper = index >= 0 ? atspiObject->childAt(index) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "GetChildren")) {
            GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
            for (const auto& wrapper : atspiObject->children())

{
    RELEASE_ASSERT(!isMainThread());
    if (m_path.isNull()) {
        auto* atspiRoot = root();
        RELEASE_ASSERT(atspiRoot);
        m_isRegistered.store(true);

        Vector<std::pair<GDBusInterfaceInfo*, GDBusInterfaceVTable*>> interfaces;

            interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_interface), &s_tableFunctions });
        if (m_interfaces.contains(Interface::TableCell))
            interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_cell_interface), &s_tableCellFunctions });
        m_path = m_root.atspi().registerObject(*this, WTFMove(interfaces));
    }

    return m_path;

GVariant* AccessibilityObjectAtspi::reference()
{
    RELEASE_ASSERT(!isMainThread());
    return g_variant_new("(so)", m_root.atspi().uniqueName(), path().utf8().data());
}

GVariant* AccessibilityObjectAtspi::hyperlinkReference()

    RELEASE_ASSERT(!isMainThread());
    if (m_hyperlinkPath.isNull()) {
        path();
        m_hyperlinkPath = m_root.atspi().registerHyperlink(*this, { { const_cast<GDBusInterfaceInfo*>(&webkit_hyperlink_interface), &s_hyperlinkFunctions } });
    }

    return g_variant_new("(so)", m_root.atspi().uniqueName(), m_hyperlinkPath.utf8().data());
}

void AccessibilityObjectAtspi::setRoot(AccessibilityRootAtspi* root)
{
    Locker locker { m_rootLock };
    m_root = root;
}

AccessibilityRootAtspi* AccessibilityObjectAtspi::root() const
{
    Locker locker { m_rootLock };
    return m_root;
}

void AccessibilityObjectAtspi::setParent(std::optional<AccessibilityObjectAtspi*> atspiParent)

    if (!axParent)
        return nullptr;

    if (auto* atspiParent = axParent->wrapper())
        atspiParent->setRoot(root());
        return atspiParent;
    }

    return std::nullopt;
}

{
    auto parentAtspi = parent();
    if (!parentAtspi)
        return m_root.atspi().nullReference();

    if (!parentAtspi.value())
        return m_root.reference();

    return parentAtspi.value()->reference();
}

    if (index >= children.size())
        return nullptr;

    return children[index]->wrapper();
    wrapper->setRoot(root());
    return wrapper;
}

Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::wrapperVector(const Vector<RefPtr<AXCoreObject>>& elements) const
{
    Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
    wrappers.reserveInitialCapacity(elements.size());
    auto* root = this->root();
    for (const auto& element : elements) {
        if (auto* wrapper = element->wrapper())
            wrapper->setRoot(root);
            wrappers.uncheckedAppend(wrapper);
        }
    }
    return wrappers;
}


    for (const auto& it : relationMap) {
        GVariantBuilder arrayBuilder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
        for (const auto& atspiObject : it.value)
            atspiObject->setRoot(root());
            g_variant_builder_add(&arrayBuilder, "@(so)", atspiObject->reference());
        }
        g_variant_builder_add(builder, "(ua(so))", it.key, &arrayBuilder);
    }
}

void AccessibilityObjectAtspi::serialize(GVariantBuilder* builder) const
{
    RELEASE_ASSERT(!isMainThread());
    g_variant_builder_add(builder, "(so)", m_root.atspi().uniqueName(), m_path.utf8().data());
    g_variant_builder_add(builder, "(so)", m_root.parentUniqueName().utf8().data(), "/org/a11y/atspi/accessible/root");
    g_variant_builder_add(builder, "(so)", atspiRoot->parentUniqueName().utf8().data(), "/org/a11y/atspi/accessible/root");
    g_variant_builder_add(builder, "@(so)", parentReference());

    g_variant_builder_add(builder, "i", indexInParent());

    RunLoop::main().dispatch([this, protectedThis = Ref { *this }, child = Ref { child }] {
        if (!m_coreObject)
            return;
        m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
    });
}


    if (!m_isRegistered.load())
        return;

    m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
}

void AccessibilityObjectAtspi::stateChanged(const char* name, bool value)

    if (!m_isRegistered.load())
        return;

    m_root.atspi().stateChanged(*this, name, value);
}

unsigned AccessibilityObjectAtspi::role() const



#include "AccessibilityObjectInterface.h"
#include "IntRect.h"
#include <wtf/Atomics.h>
#include <wtf/Lock.h>
#include <wtf/OptionSet.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/text/CString.h>


class AccessibilityObjectAtspi final : public ThreadSafeRefCounted<AccessibilityObjectAtspi> {
public:
    static Ref<AccessibilityObjectAtspi> create(AXCoreObject*, AccessibilityRootAtspi&);
    ~AccessibilityObjectAtspi() = default;

    enum class Interface : uint16_t {

    };
    const OptionSet<Interface>& interfaces() const { return m_interfaces; }

    const AccessibilityRootAtspi& root() const { return m_root; }
    WEBCORE_EXPORT AccessibilityRootAtspi* root() const;
    void setParent(std::optional<AccessibilityObjectAtspi*>);
    WEBCORE_EXPORT std::optional<AccessibilityObjectAtspi*> parent() const;
    WEBCORE_EXPORT void updateBackingStore();

    WEBCORE_EXPORT std::pair<std::optional<unsigned>, std::optional<unsigned>> cellPosition() const;

private:
    explicit AccessibilityObjectAtspi(AXCoreObject*, AccessibilityRootAtspi&);

    Vector<RefPtr<AccessibilityObjectAtspi>> wrapperVector(const Vector<RefPtr<AXCoreObject>>&) const;
    int indexInParent() const;

    AXCoreObject* m_axObject { nullptr };
    AXCoreObject* m_coreObject { nullptr };
    OptionSet<Interface> m_interfaces;
    AccessibilityRootAtspi& m_root;
    std::optional<AccessibilityObjectAtspi*> m_parent;
    Atomic<bool> m_isRegistered { false };
    String m_path;

Lines 47-53 GDBusInterfaceVTable AccessibilityObjectAtspi::s_componentFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectComponentAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectComponentAtspi.cpp -1 / +1 lines
47	uint32_t coordinateType;	47	uint32_t coordinateType;
48	g_variant_get(parameters, "(iiu)", &x, &y, &coordinateType);	48	g_variant_get(parameters, "(iiu)", &x, &y, &coordinateType);
49	auto* wrapper = atspiObject->hitTest({ x, y }, coordinateType);	49	auto* wrapper = atspiObject->hitTest({ x, y }, coordinateType);
50	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->root()->atspi().nullReference()));	50	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference()));
51	} else if (!g_strcmp0(methodName, "GetExtents")) {	51	} else if (!g_strcmp0(methodName, "GetExtents")) {
52	uint32_t coordinateType;	52	uint32_t coordinateType;
53	g_variant_get(parameters, "(u)", &coordinateType);	53	g_variant_get(parameters, "(u)", &coordinateType);

Lines 39-45 GDBusInterfaceVTable AccessibilityObjectAtspi::s_hyperlinkFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp -1 / +1 lines
39	if (!g_strcmp0(methodName, "GetObject")) {	39	if (!g_strcmp0(methodName, "GetObject")) {
40	int index;	40	int index;
41	g_variant_get(parameters, "(i)", &index);	41	g_variant_get(parameters, "(i)", &index);
42	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", !index ? atspiObject->reference() : atspiObject->root()->atspi().nullReference()));	42	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", !index ? atspiObject->reference() : atspiObject->m_root.atspi().nullReference()));
43	} else if (!g_strcmp0(methodName, "GetURI")) {	43	} else if (!g_strcmp0(methodName, "GetURI")) {
44	int index;	44	int index;
45	g_variant_get(parameters, "(i)", &index);	45	g_variant_get(parameters, "(i)", &index);



            int index;
            g_variant_get(parameters, "(i)", &index);
            auto* wrapper = index >= 0 ? atspiObject->hyperlink(index) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->hyperlinkReference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "GetLinkIndex")) {
            int offset;
            g_variant_get(parameters, "(i)", &offset);

            if (!wrapper || !wrapper->interfaces().contains(Interface::Hyperlink))
                continue;

            if (static_cast<unsigned>(++linkIndex) == index)
                wrapper->setRoot(root());
                return wrapper;
            }
        }

        return nullptr;



            int index;
            g_variant_get(parameters, "(i)", &index);
            auto* child = index >= 0 ? atspiObject->selectedChild(index) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", child ? child->reference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "SelectChild")) {
            int index;
            g_variant_get(parameters, "(i)", &index);

        return selectedItems[index]->wrapper();
    });

    if (wrapper)
        wrapper->setRoot(root());

    return wrapper;
}


    if (!m_isRegistered.load())
        return;

    m_root.atspi().selectionChanged(*this);
}

} // namespace WebCore



            int row, column;
            g_variant_get(parameters, "(ii)", &row, &column);
            auto* cell = row >= 0 && column >= 0 ? atspiObject->cell(row, column) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", cell ? cell->reference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "GetIndexAt")) {
            int row, column;
            g_variant_get(parameters, "(ii)", &row, &column);

            int row;
            g_variant_get(parameters, "(i)", &row);
            auto* header = row >= 0 ? atspiObject->rowHeader(row) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "GetColumnHeader")) {
            int column;
            g_variant_get(parameters, "(i)", &column);
            auto* header = column >= 0 ? atspiObject->columnHeader(column) : nullptr;
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
        } else if (!g_strcmp0(methodName, "GetRowColumnExtentsAtIndex")) {
            int index;
            g_variant_get(parameters, "(i)", &index);

            return g_variant_new_int32(atspiObject->columnCount());
        if (!g_strcmp0(propertyName, "Caption")) {
            auto* caption = atspiObject->tableCaption();
            return caption ? caption->reference() : atspiObject->m_root.atspi().nullReference();
        }
        if (!g_strcmp0(propertyName, "Summary"))
            return atspiObject->m_root.atspi().nullReference();
        if (!g_strcmp0(propertyName, "NSelectedRows"))
            return g_variant_new_int32(0);
        if (!g_strcmp0(propertyName, "NSelectedColumns"))

    if (!m_axObject)
        return nullptr;

    if (auto* tableCell = m_axObject->cellForColumnAndRow(column, row))
        return tableCell->wrapper();
            wrapper->setRoot(root());
            return wrapper;
        }
    }

    return nullptr;
}


            if (auto caption = downcast<HTMLTableElement>(*node).caption()) {
                if (auto* renderer = caption->renderer()) {
                    if (auto* element = AccessibilityObject::firstAccessibleObjectFromNode(renderer->element()))
                        return element->wrapper();
                            wrapper->setRoot(root());
                            return wrapper;
                        }
                    }
                }
            }
        }

    for (const auto& header : headers) {
        auto range = header->rowIndexRange();
        if (range.first <= row && row < range.first + range.second) {
            if (auto* wrapper = header->wrapper())
                wrapper->setRoot(root());
                return wrapper;
            }
        }
    }


    for (const auto& header : headers) {
        auto range = header->columnIndexRange();
        if (range.first <= column && column < range.first + range.second) {
            if (auto* wrapper = header->wrapper())
                wrapper->setRoot(root());
                return wrapper;
            }
        }
    }




        if (!g_strcmp0(propertyName, "Table")) {
            auto* axObject = atspiObject->m_axObject;
            if (!axObject || !axObject->isTableCell())
                return atspiObject->m_root.atspi().nullReference();

            AccessibilityObjectAtspi* wrapper = atspiObject.ptr();
            while (auto parent = wrapper->parent()) {

                if (axObject && axObject->isTable())
                    break;
            }
            return wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference();
        }

        g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);

    if (role() != Atspi::Role::TableCell)
        return { };

    return wrapperVector(m_axObject->rowHeaders());
    Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
    wrappers.reserveInitialCapacity(headers.size());
    auto* root = this->root();
    for (const auto& header : headers) {
        if (auto* wrapper = header->wrapper()) {
            wrapper->setRoot(root);
            wrappers.uncheckedAppend(wrapper);
        }
    }
    return wrappers;
}

Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::cellColumnHeaders() const

    if (role() != Atspi::Role::TableCell)
        return { };

    return wrapperVector(m_axObject->columnHeaders());
    Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
    wrappers.reserveInitialCapacity(headers.size());
    auto* root = this->root();
    for (const auto& header : headers) {
        if (auto* wrapper = header->wrapper()) {
            wrapper->setRoot(root);
            wrappers.uncheckedAppend(wrapper);
        }
    }
    return wrappers;
}

unsigned AccessibilityObjectAtspi::rowSpan() const



    auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);
    auto utf8InsertedText = insertedText.utf8();
    auto insertedTextLength = g_utf8_strlen(utf8InsertedText.data(), -1);
    m_root.atspi().textChanged(*this, "insert", WTFMove(utf8InsertedText), offset - insertedTextLength, insertedTextLength);
}

void AccessibilityObjectAtspi::textDeleted(const String& deletedText, const VisiblePosition& position)

    auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);
    auto utf8DeletedText = deletedText.utf8();
    auto deletedTextLength = g_utf8_strlen(utf8DeletedText.data(), -1);
    m_root.atspi().textChanged(*this, "delete", WTFMove(utf8DeletedText), offset, deletedTextLength);
}

IntPoint AccessibilityObjectAtspi::boundaryOffset(unsigned utf16Offset, TextGranularity granularity) const

    auto mapping = offsetMapping(utf16Text);
    auto caretOffset = UTF16OffsetToUTF8(mapping, bounds.y());
    if (caretOffset <= length)
        m_root.atspi().textCaretMoved(*this, caretOffset);

    if (selection.isRange())
        m_root.atspi().textSelectionChanged(*this);
}

AccessibilityObjectAtspi::TextAttributes AccessibilityObjectAtspi::textAttributes(std::optional<unsigned> utf16Offset, bool includeDefault) const

    if (!m_interfaces.contains(Interface::Text))
        return;

    m_root.atspi().textAttributesChanged(*this);
}

bool AccessibilityObjectAtspi::scrollToMakeVisible(int startOffset, int endOffset, uint32_t scrollType) const

Lines 137-143 void AccessibilityObjectAtspi::valueChanged(double value) a/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp -1 / +1 lines
137	if (!m_isRegistered.load())	137	if (!m_isRegistered.load())
138	return;	138	return;
139		139
140	root()->atspi().valueChanged(*this, value);	140	m_root.atspi().valueChanged(*this, value);
141	}	141	}
142		142
143	} // namespace WebCore	143	} // namespace WebCore

Lines 157-162 GDBusInterfaceVTable AccessibilityRootAtspi::s_accessibleFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp -44 / +8 lines
157	void AccessibilityRootAtspi::registerObject(CompletionHandler<void(const String&)>&& completionHandler)	157	void AccessibilityRootAtspi::registerObject(CompletionHandler<void(const String&)>&& completionHandler)
158	{	158	{
159	RELEASE_ASSERT(isMainThread());	159	RELEASE_ASSERT(isMainThread());
		160	if (m_page)
		161	m_page->setAccessibilityRootObject(this);
		162
160	Vector<std::pair<GDBusInterfaceInfo, GDBusInterfaceVTable>> interfaces;	163	Vector<std::pair<GDBusInterfaceInfo, GDBusInterfaceVTable>> interfaces;
161	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_accessible_interface), &s_accessibleFunctions });	164	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_accessible_interface), &s_accessibleFunctions });
162	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_component_interface), &s_componentFunctions });	165	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_component_interface), &s_componentFunctions });
Lines 167-172 void AccessibilityRootAtspi::unregisterObject() a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp_sec2
167	{	170	{
168	RELEASE_ASSERT(isMainThread());	171	RELEASE_ASSERT(isMainThread());
169	m_atspi.unregisterRoot(*this);	172	m_atspi.unregisterRoot(*this);
		173
		174	if (m_page)
		175	m_page->setAccessibilityRootObject(nullptr);
170	}	176	}
171		177
172	void AccessibilityRootAtspi::setPath(String&& path)	178	void AccessibilityRootAtspi::setPath(String&& path)
Lines 198-206 GVariant* AccessibilityRootAtspi::reference() const a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp_sec3
198	AccessibilityObjectAtspi* AccessibilityRootAtspi::child() const	204	AccessibilityObjectAtspi* AccessibilityRootAtspi::child() const
199	{	205	{
200	RELEASE_ASSERT(isMainThread());	206	RELEASE_ASSERT(isMainThread());
201	if (!AXObjectCache::accessibilityEnabled())
202	AXObjectCache::enableAccessibility();
203
204	if (!m_page)	207	if (!m_page)
205	return nullptr;	208	return nullptr;
206		209
Lines 208-259 AccessibilityObjectAtspi* AccessibilityRootAtspi::child() const a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp_sec4
208	if (!frame.document())	211	if (!frame.document())
209	return nullptr;	212	return nullptr;
210		213
		214	AXObjectCache::enableAccessibility();
211	AXObjectCache* cache = frame.document()->axObjectCache();	215	AXObjectCache* cache = frame.document()->axObjectCache();
212	if (!cache)	216	if (!cache)
213	return nullptr;	217	return nullptr;
214		218
215	AXCoreObject* rootObject = cache->rootObject();	219	AXCoreObject* rootObject = cache->rootObject();
216	if (!rootObject)	220	return rootObject ? rootObject->wrapper() : nullptr;
217	return nullptr;
218
219	auto* wrapper = rootObject->wrapper();
220	if (!wrapper)
221	return nullptr;
222
223	wrapper->setRoot(const_cast<AccessibilityRootAtspi*>(this));
224	wrapper->setParent(nullptr); // nullptr parent means root.
225
226	return wrapper;
227	}
228
229	AccessibilityObjectAtspi* AccessibilityRootAtspi::focusedObject() const
230	{
231	RELEASE_ASSERT(isMainThread());
232	if (!AXObjectCache::accessibilityEnabled())
233	AXObjectCache::enableAccessibility();
234
235	if (!m_page)
236	return nullptr;
237
238	auto* focusedDocument = m_page->focusController().focusedOrMainFrame().document();
239	if (!focusedDocument)
240	return nullptr;
241
242	auto* cache = focusedDocument->axObjectCache();
243	if (!cache)
244	return nullptr;
245
246	auto* focusedObject = cache->focusedObjectForPage(m_page.get());
247	if (!focusedObject)
248	return nullptr;
249
250	auto* wrapper = focusedObject->wrapper();
251	if (!wrapper)
252	return nullptr;
253
254	wrapper->setRoot(const_cast<AccessibilityRootAtspi*>(this));
255
256	return wrapper;
257	}	221	}
258		222
259	void AccessibilityRootAtspi::serialize(GVariantBuilder* builder) const	223	void AccessibilityRootAtspi::serialize(GVariantBuilder* builder) const

Lines 49-55 public: a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.h_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.h -1 lines
49	GVariant* applicationReference() const;	49	GVariant* applicationReference() const;
50	AccessibilityAtspi& atspi() const { return m_atspi; }	50	AccessibilityAtspi& atspi() const { return m_atspi; }
51	AccessibilityObjectAtspi* child() const;	51	AccessibilityObjectAtspi* child() const;
52	AccessibilityObjectAtspi* focusedObject() const;
53		52
54	void serialize(GVariantBuilder*) const;	53	void serialize(GVariantBuilder*) const;
55		54

Lines 91-96 namespace IDBClient { a/Source/WebCore/page/Page.h_sec1
- a/Source/WebCore/page/Page.h +10 lines
91	class IDBConnectionToServer;	91	class IDBConnectionToServer;
92	}	92	}
93		93
		94	class AccessibilityRootAtspi;
94	class ApplePayAMSUIPaymentHandler;	95	class ApplePayAMSUIPaymentHandler;
95	class ActivityStateChangeObserver;	96	class ActivityStateChangeObserver;
96	class AlternativeTextClient;	97	class AlternativeTextClient;
Lines 913-918 public: a/Source/WebCore/page/Page.h_sec2
913		914
914	ModelPlayerProvider& modelPlayerProvider();	915	ModelPlayerProvider& modelPlayerProvider();
915		916
		917	#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
		918	AccessibilityRootAtspi* accessibilityRootObject() const { return m_accessibilityRootObject; }
		919	void setAccessibilityRootObject(AccessibilityRootAtspi* rootObject) { m_accessibilityRootObject = rootObject; }
		920	#endif
		921
916	private:	922	private:
917	struct Navigation {	923	struct Navigation {
918	RegistrableDomain domain;	924	RegistrableDomain domain;
Lines 1259-1264 private: a/Source/WebCore/page/Page.h_sec3
1259	using CachedTextRecognitionResult = std::pair<TextRecognitionResult, IntRect>;	1265	using CachedTextRecognitionResult = std::pair<TextRecognitionResult, IntRect>;
1260	WeakHashMap<HTMLElement, CachedTextRecognitionResult> m_textRecognitionResults;	1266	WeakHashMap<HTMLElement, CachedTextRecognitionResult> m_textRecognitionResults;
1261	#endif	1267	#endif
		1268
		1269	#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
		1270	AccessibilityRootAtspi* m_accessibilityRootObject { nullptr };
		1271	#endif
1262	};	1272	};
1263		1273
1264	inline PageGroup& Page::group()	1274	inline PageGroup& Page::group()



2021-12-03  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Ensure atspi wrappers have root set at construction time
        https://bugs.webkit.org/show_bug.cgi?id=233804

        Reviewed by NOBODY (OOPS!).

        * WebProcess/InjectedBundle/API/c/WKBundlePage.cpp:
        (WKAccessibilityRootObject): Remove ATSPI specific code.
        (WKAccessibilityFocusedObject): Ditto.
        * WebProcess/WebPage/WebPage.h:
        (WebKit::WebPage::accessibilityRootObject const): Deleted.

2021-12-01  Sihui Liu  <sihui_liu@apple.com>

        FileSystemSyncAccessHandle should be invalidated when network process crashes



    if (!pageRef)
        return 0;

#if USE(ATSPI)
    return WebKit::toImpl(pageRef)->accessibilityRootObject().child();
#endif

    WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();
    if (!page)
        return 0;

    if (!pageRef)
        return 0;

#if USE(ATSPI)
    return WebKit::toImpl(pageRef)->accessibilityRootObject().focusedObject();
#endif

    WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();
    if (!page)
        return 0;




    void prepareToRunModalJavaScriptDialog();

#if USE(ATSPI)
    const WebCore::AccessibilityRootAtspi& accessibilityRootObject() const { return *m_accessibilityRootObject; }
#endif

#if ENABLE(ARKIT_INLINE_PREVIEW)
    bool useARKitForModel() const { return m_useARKitForModel; };
#endif



2021-12-03  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Ensure atspi wrappers have root set at construction time
        https://bugs.webkit.org/show_bug.cgi?id=233804

        Reviewed by NOBODY (OOPS!).

        * WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:
        (WTR::AccessibilityController::axRunLoop):

2021-12-02  Carlos Garcia Campos  <cgarcia@igalia.com>

        Unreviewed. [GTK] Use nullptr instead of 0 in JSStringCreateWithCharacters()

Lines 123-129 RunLoop& AccessibilityController::axRunLoop() a/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp_sec1
- a/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp -1 / +1 lines
123	WKBundlePageRef page = InjectedBundle::singleton().page()->page();	123	WKBundlePageRef page = InjectedBundle::singleton().page()->page();
124	auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));	124	auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));
125	RELEASE_ASSERT(element);	125	RELEASE_ASSERT(element);
126	m_axRunLoop = &element->root()->atspi().runLoop();	126	m_axRunLoop = &element->root().atspi().runLoop();
127	}	127	}
128		128
129	return *m_axRunLoop;	129	return *m_axRunLoop;

Return to Bug 233804

Lines 37-45 a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp -46 / +23 lines
37		37
38	namespace WebCore {	38	namespace WebCore {
39		39
40	Ref<AccessibilityObjectAtspi> AccessibilityObjectAtspi::create(AXCoreObject* coreObject)	40	Ref<AccessibilityObjectAtspi> AccessibilityObjectAtspi::create(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
41	{	41	{
42	return adoptRef(*new AccessibilityObjectAtspi(coreObject));	42	return adoptRef(*new AccessibilityObjectAtspi(coreObject, root));
43	}	43	}
44		44
45	static inline bool roleIsTextType(AccessibilityRole role)	45	static inline bool roleIsTextType(AccessibilityRole role)
Lines 112-120 OptionSet<AccessibilityObjectAtspi::Interface> AccessibilityObjectAtspi::interfa a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec2
112	return interfaces;	112	return interfaces;
113	}	113	}
114		114
115	AccessibilityObjectAtspi::AccessibilityObjectAtspi(AXCoreObject* coreObject)	115	AccessibilityObjectAtspi::AccessibilityObjectAtspi(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
116	: m_coreObject(coreObject)	116	: m_coreObject(coreObject)
117	, m_interfaces(interfacesForObject(*m_coreObject))	117	, m_interfaces(interfacesForObject(*m_coreObject))
		118	, m_root(root)
118	{	119	{
119	RELEASE_ASSERT(isMainThread());	120	RELEASE_ASSERT(isMainThread());
120	}	121	}
Lines 137-143 void AccessibilityObjectAtspi::cacheDestroyed() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec3
137	if (!m_isRegistered.load())	138	if (!m_isRegistered.load())
138	return;	139	return;
139		140
140	root()->atspi().unregisterObject(*this);	141	m_root.atspi().unregisterObject(*this);
141	}	142	}
142		143
143	void AccessibilityObjectAtspi::elementDestroyed()	144	void AccessibilityObjectAtspi::elementDestroyed()
Lines 150-156 void AccessibilityObjectAtspi::elementDestroyed() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec4
150	if (m_parent && *m_parent)	151	if (m_parent && *m_parent)
151	m_parent.value()->childRemoved(*this);	152	m_parent.value()->childRemoved(*this);
152		153
153	root()->atspi().unregisterObject(*this);	154	m_root.atspi().unregisterObject(*this);
154	}	155	}
155		156
156	static unsigned atspiRole(AccessibilityRole role)	157	static unsigned atspiRole(AccessibilityRole role)
Lines 429-440 GDBusInterfaceVTable AccessibilityObjectAtspi::s_accessibleFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec5
429		430
430	g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));	431	g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
431	} else if (!g_strcmp0(methodName, "GetApplication"))	432	} else if (!g_strcmp0(methodName, "GetApplication"))
432	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", atspiObject->root()->applicationReference()));	433	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", atspiObject->m_root.applicationReference()));
433	else if (!g_strcmp0(methodName, "GetChildAtIndex")) {	434	else if (!g_strcmp0(methodName, "GetChildAtIndex")) {
434	int index;	435	int index;
435	g_variant_get(parameters, "(i)", &index);	436	g_variant_get(parameters, "(i)", &index);
436	auto* wrapper = index >= 0 ? atspiObject->childAt(index) : nullptr;	437	auto* wrapper = index >= 0 ? atspiObject->childAt(index) : nullptr;
437	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->root()->atspi().nullReference()));	438	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference()));
438	} else if (!g_strcmp0(methodName, "GetChildren")) {	439	} else if (!g_strcmp0(methodName, "GetChildren")) {
439	GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));	440	GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
440	for (const auto& wrapper : atspiObject->children())	441	for (const auto& wrapper : atspiObject->children())
Lines 484-491 const String& AccessibilityObjectAtspi::path() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec6
484	{	485	{
485	RELEASE_ASSERT(!isMainThread());	486	RELEASE_ASSERT(!isMainThread());
486	if (m_path.isNull()) {	487	if (m_path.isNull()) {
487	auto* atspiRoot = root();
488	RELEASE_ASSERT(atspiRoot);
489	m_isRegistered.store(true);	488	m_isRegistered.store(true);
490		489
491	Vector<std::pair<GDBusInterfaceInfo, GDBusInterfaceVTable>> interfaces;	490	Vector<std::pair<GDBusInterfaceInfo, GDBusInterfaceVTable>> interfaces;
Lines 513-519 const String& AccessibilityObjectAtspi::path() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec7
513	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_interface), &s_tableFunctions });	512	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_interface), &s_tableFunctions });
514	if (m_interfaces.contains(Interface::TableCell))	513	if (m_interfaces.contains(Interface::TableCell))
515	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_cell_interface), &s_tableCellFunctions });	514	interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_table_cell_interface), &s_tableCellFunctions });
516	m_path = atspiRoot->atspi().registerObject(*this, WTFMove(interfaces));	515	m_path = m_root.atspi().registerObject(*this, WTFMove(interfaces));
517	}	516	}
518		517
519	return m_path;	518	return m_path;
Lines 522-528 const String& AccessibilityObjectAtspi::path() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec8
522	GVariant* AccessibilityObjectAtspi::reference()	521	GVariant* AccessibilityObjectAtspi::reference()
523	{	522	{
524	RELEASE_ASSERT(!isMainThread());	523	RELEASE_ASSERT(!isMainThread());
525	return g_variant_new("(so)", root()->atspi().uniqueName(), path().utf8().data());	524	return g_variant_new("(so)", m_root.atspi().uniqueName(), path().utf8().data());
526	}	525	}
527		526
528	GVariant* AccessibilityObjectAtspi::hyperlinkReference()	527	GVariant* AccessibilityObjectAtspi::hyperlinkReference()
Lines 530-551 GVariant* AccessibilityObjectAtspi::hyperlinkReference() a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec9
530	RELEASE_ASSERT(!isMainThread());	529	RELEASE_ASSERT(!isMainThread());
531	if (m_hyperlinkPath.isNull()) {	530	if (m_hyperlinkPath.isNull()) {
532	path();	531	path();
533	m_hyperlinkPath = root()->atspi().registerHyperlink(this, { { const_cast<GDBusInterfaceInfo>(&webkit_hyperlink_interface), &s_hyperlinkFunctions } });	532	m_hyperlinkPath = m_root.atspi().registerHyperlink(this, { { const_cast<GDBusInterfaceInfo>(&webkit_hyperlink_interface), &s_hyperlinkFunctions } });
534	}	533	}
535		534
536	return g_variant_new("(so)", root()->atspi().uniqueName(), m_hyperlinkPath.utf8().data());	535	return g_variant_new("(so)", m_root.atspi().uniqueName(), m_hyperlinkPath.utf8().data());
537	}
538
539	void AccessibilityObjectAtspi::setRoot(AccessibilityRootAtspi* root)
540	{
541	Locker locker { m_rootLock };
542	m_root = root;
543	}
544
545	AccessibilityRootAtspi* AccessibilityObjectAtspi::root() const
546	{
547	Locker locker { m_rootLock };
548	return m_root;
549	}	536	}
550		537
551	void AccessibilityObjectAtspi::setParent(std::optional<AccessibilityObjectAtspi*> atspiParent)	538	void AccessibilityObjectAtspi::setParent(std::optional<AccessibilityObjectAtspi*> atspiParent)
Lines 569-578 std::optional<AccessibilityObjectAtspi*> AccessibilityObjectAtspi::parent() cons a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec10
569	if (!axParent)	556	if (!axParent)
570	return nullptr;	557	return nullptr;
571		558
572	if (auto* atspiParent = axParent->wrapper()) {	559	if (auto* atspiParent = axParent->wrapper())
573	atspiParent->setRoot(root());
574	return atspiParent;	560	return atspiParent;
575	}
576		561
577	return std::nullopt;	562	return std::nullopt;
578	}	563	}
Lines 581-590 GVariant* AccessibilityObjectAtspi::parentReference() const a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec11
581	{	566	{
582	auto parentAtspi = parent();	567	auto parentAtspi = parent();
583	if (!parentAtspi)	568	if (!parentAtspi)
584	return root()->atspi().nullReference();	569	return m_root.atspi().nullReference();
585		570
586	if (!parentAtspi.value())	571	if (!parentAtspi.value())
587	return root()->reference();	572	return m_root.reference();
588		573
589	return parentAtspi.value()->reference();	574	return parentAtspi.value()->reference();
590	}	575	}
Lines 608-628 AccessibilityObjectAtspi* AccessibilityObjectAtspi::childAt(unsigned index) cons a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec12
608	if (index >= children.size())	593	if (index >= children.size())
609	return nullptr;	594	return nullptr;
610		595
611	auto* wrapper = children[index]->wrapper();	596	return children[index]->wrapper();
612	wrapper->setRoot(root());
613	return wrapper;
614	}	597	}
615		598
616	Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::wrapperVector(const Vector<RefPtr<AXCoreObject>>& elements) const	599	Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::wrapperVector(const Vector<RefPtr<AXCoreObject>>& elements) const
617	{	600	{
618	Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;	601	Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
619	wrappers.reserveInitialCapacity(elements.size());	602	wrappers.reserveInitialCapacity(elements.size());
620	auto* root = this->root();
621	for (const auto& element : elements) {	603	for (const auto& element : elements) {
622	if (auto* wrapper = element->wrapper()) {	604	if (auto* wrapper = element->wrapper())
623	wrapper->setRoot(root);
624	wrappers.uncheckedAppend(wrapper);	605	wrappers.uncheckedAppend(wrapper);
625	}
626	}	606	}
627	return wrappers;	607	return wrappers;
628	}	608	}
Lines 1140-1149 void AccessibilityObjectAtspi::buildRelationSet(GVariantBuilder* builder) const a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec13
1140		1120
1141	for (const auto& it : relationMap) {	1121	for (const auto& it : relationMap) {
1142	GVariantBuilder arrayBuilder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));	1122	GVariantBuilder arrayBuilder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
1143	for (const auto& atspiObject : it.value) {	1123	for (const auto& atspiObject : it.value)
1144	atspiObject->setRoot(root());
1145	g_variant_builder_add(&arrayBuilder, "@(so)", atspiObject->reference());	1124	g_variant_builder_add(&arrayBuilder, "@(so)", atspiObject->reference());
1146	}
1147	g_variant_builder_add(builder, "(ua(so))", it.key, &arrayBuilder);	1125	g_variant_builder_add(builder, "(ua(so))", it.key, &arrayBuilder);
1148	}	1126	}
1149	}	1127	}
Lines 1180-1188 void AccessibilityObjectAtspi::buildInterfaces(GVariantBuilder* builder) const a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec14
1180	void AccessibilityObjectAtspi::serialize(GVariantBuilder* builder) const	1158	void AccessibilityObjectAtspi::serialize(GVariantBuilder* builder) const
1181	{	1159	{
1182	RELEASE_ASSERT(!isMainThread());	1160	RELEASE_ASSERT(!isMainThread());
1183	auto* atspiRoot = root();	1161	g_variant_builder_add(builder, "(so)", m_root.atspi().uniqueName(), m_path.utf8().data());
1184	g_variant_builder_add(builder, "(so)", atspiRoot->atspi().uniqueName(), m_path.utf8().data());	1162	g_variant_builder_add(builder, "(so)", m_root.parentUniqueName().utf8().data(), "/org/a11y/atspi/accessible/root");
1185	g_variant_builder_add(builder, "(so)", atspiRoot->parentUniqueName().utf8().data(), "/org/a11y/atspi/accessible/root");
1186	g_variant_builder_add(builder, "@(so)", parentReference());	1163	g_variant_builder_add(builder, "@(so)", parentReference());
1187		1164
1188	g_variant_builder_add(builder, "i", indexInParent());	1165	g_variant_builder_add(builder, "i", indexInParent());
Lines 1214-1220 void AccessibilityObjectAtspi::childAdded(AccessibilityObjectAtspi& child) a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec15
1214	RunLoop::main().dispatch([this, protectedThis = Ref { *this }, child = Ref { child }] {	1191	RunLoop::main().dispatch([this, protectedThis = Ref { *this }, child = Ref { child }] {
1215	if (!m_coreObject)	1192	if (!m_coreObject)
1216	return;	1193	return;
1217	root()->atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);	1194	m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
1218	});	1195	});
1219	}	1196	}
1220		1197
Lines 1224-1230 void AccessibilityObjectAtspi::childRemoved(AccessibilityObjectAtspi& child) a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec16
1224	if (!m_isRegistered.load())	1201	if (!m_isRegistered.load())
1225	return;	1202	return;
1226		1203
1227	root()->atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);	1204	m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
1228	}	1205	}
1229		1206
1230	void AccessibilityObjectAtspi::stateChanged(const char* name, bool value)	1207	void AccessibilityObjectAtspi::stateChanged(const char* name, bool value)
Lines 1233-1239 void AccessibilityObjectAtspi::stateChanged(const char* name, bool value) a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp_sec17
1233	if (!m_isRegistered.load())	1210	if (!m_isRegistered.load())
1234	return;	1211	return;
1235		1212
1236	root()->atspi().stateChanged(*this, name, value);	1213	m_root.atspi().stateChanged(*this, name, value);
1237	}	1214	}
1238		1215
1239	unsigned AccessibilityObjectAtspi::role() const	1216	unsigned AccessibilityObjectAtspi::role() const

Lines 1494-1503 public: a/Source/WebKit/WebProcess/WebPage/WebPage.h_sec1
- a/Source/WebKit/WebProcess/WebPage/WebPage.h -4 lines
1494		1494
1495	void prepareToRunModalJavaScriptDialog();	1495	void prepareToRunModalJavaScriptDialog();
1496		1496
1497	#if USE(ATSPI)
1498	const WebCore::AccessibilityRootAtspi& accessibilityRootObject() const { return *m_accessibilityRootObject; }
1499	#endif
1500
1501	#if ENABLE(ARKIT_INLINE_PREVIEW)	1497	#if ENABLE(ARKIT_INLINE_PREVIEW)
1502	bool useARKitForModel() const { return m_useARKitForModel; };	1498	bool useARKitForModel() const { return m_useARKitForModel; };
1503	#endif	1499	#endif

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +67 lines
		1	2021-12-03 Carlos Garcia Campos <cgarcia@igalia.com>
		2
		3	[GTK][a11y] Ensure atspi wrappers have root set at construction time
		4	https://bugs.webkit.org/show_bug.cgi?id=233804
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Pass the AccessibilityRootAtspi as a parameter to AccessibilityObjectAtspi constructor and store it as a
		9	reference. A pointer to the AccessibilityRootAtspi object is now set in Page so that it can be accessed from the
		10	AXObjectCache. Also remove setRoot() and use m_root directly instead of root() accessor.
		11
		12	* accessibility/atspi/AXObjectCacheAtspi.cpp:
		13	(WebCore::AXObjectCache::attachWrapper): Get the AccessibilityRootAtspi from the page and pass it to the wrapper
		14	constructor. Also set the parent of the dom root element wrapper to the atspi root element.
		15	* accessibility/atspi/AccessibilityAtspi.cpp:
		16	(WebCore::AccessibilityAtspi::childrenChanged):
		17	* accessibility/atspi/AccessibilityObjectAtspi.cpp:
		18	(WebCore::AccessibilityObjectAtspi::create):
		19	(WebCore::AccessibilityObjectAtspi::AccessibilityObjectAtspi):
		20	(WebCore::AccessibilityObjectAtspi::cacheDestroyed):
		21	(WebCore::AccessibilityObjectAtspi::elementDestroyed):
		22	(WebCore::AccessibilityObjectAtspi::path):
		23	(WebCore::AccessibilityObjectAtspi::reference):
		24	(WebCore::AccessibilityObjectAtspi::hyperlinkReference):
		25	(WebCore::AccessibilityObjectAtspi::parentReference const):
		26	(WebCore::AccessibilityObjectAtspi::childAt const):
		27	(WebCore::AccessibilityObjectAtspi::wrapperVector const):
		28	(WebCore::AccessibilityObjectAtspi::buildRelationSet const):
		29	(WebCore::AccessibilityObjectAtspi::serialize const):
		30	(WebCore::AccessibilityObjectAtspi::childAdded):
		31	(WebCore::AccessibilityObjectAtspi::childRemoved):
		32	(WebCore::AccessibilityObjectAtspi::stateChanged):
		33	(WebCore::AccessibilityObjectAtspi::setRoot): Deleted.
		34	(WebCore::AccessibilityObjectAtspi::root const): Deleted.
		35	* accessibility/atspi/AccessibilityObjectAtspi.h:
		36	* accessibility/atspi/AccessibilityObjectComponentAtspi.cpp:
		37	* accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp:
		38	* accessibility/atspi/AccessibilityObjectHypertextAtspi.cpp:
		39	(WebCore::AccessibilityObjectAtspi::hyperlink const):
		40	* accessibility/atspi/AccessibilityObjectSelectionAtspi.cpp:
		41	(WebCore::AccessibilityObjectAtspi::selectedChild const):
		42	(WebCore::AccessibilityObjectAtspi::selectionChanged):
		43	* accessibility/atspi/AccessibilityObjectTableAtspi.cpp:
		44	(WebCore::AccessibilityObjectAtspi::cell const):
		45	(WebCore::AccessibilityObjectAtspi::tableCaption const):
		46	(WebCore::AccessibilityObjectAtspi::rowHeader const):
		47	(WebCore::AccessibilityObjectAtspi::columnHeader const):
		48	* accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp:
		49	(WebCore::AccessibilityObjectAtspi::cellRowHeaders const):
		50	(WebCore::AccessibilityObjectAtspi::cellColumnHeaders const):
		51	* accessibility/atspi/AccessibilityObjectTextAtspi.cpp:
		52	(WebCore::AccessibilityObjectAtspi::textInserted):
		53	(WebCore::AccessibilityObjectAtspi::textDeleted):
		54	(WebCore::AccessibilityObjectAtspi::selectionChanged):
		55	(WebCore::AccessibilityObjectAtspi::textAttributesChanged):
		56	* accessibility/atspi/AccessibilityObjectValueAtspi.cpp:
		57	(WebCore::AccessibilityObjectAtspi::valueChanged):
		58	* accessibility/atspi/AccessibilityRootAtspi.cpp:
		59	(WebCore::AccessibilityRootAtspi::registerObject):
		60	(WebCore::AccessibilityRootAtspi::unregisterObject):
		61	(WebCore::AccessibilityRootAtspi::child const):
		62	(WebCore::AccessibilityRootAtspi::focusedObject const): Deleted.
		63	* accessibility/atspi/AccessibilityRootAtspi.h:
		64	* page/Page.h:
65	(WebCore::Page::accessibilityRootObject const):
66	(WebCore::Page::setAccessibilityRootObject):
67
1	2021-12-02 Martin Robinson <mrobinson@webkit.org>	68	2021-12-02 Martin Robinson <mrobinson@webkit.org>
2		69
3	sticky th or td in table does not stops at specified top	70	sticky th or td in table does not stops at specified top

Lines 24-30 a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h -6 / +4 lines
24	#include "AccessibilityObjectInterface.h"	24	#include "AccessibilityObjectInterface.h"
25	#include "IntRect.h"	25	#include "IntRect.h"
26	#include <wtf/Atomics.h>	26	#include <wtf/Atomics.h>
27	#include <wtf/Lock.h>
28	#include <wtf/OptionSet.h>	27	#include <wtf/OptionSet.h>
29	#include <wtf/ThreadSafeRefCounted.h>	28	#include <wtf/ThreadSafeRefCounted.h>
30	#include <wtf/text/CString.h>	29	#include <wtf/text/CString.h>
Lines 39-45 class AccessibilityRootAtspi; a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h_sec2
39		38
40	class AccessibilityObjectAtspi final : public ThreadSafeRefCounted<AccessibilityObjectAtspi> {	39	class AccessibilityObjectAtspi final : public ThreadSafeRefCounted<AccessibilityObjectAtspi> {
41	public:	40	public:
42	static Ref<AccessibilityObjectAtspi> create(AXCoreObject*);	41	static Ref<AccessibilityObjectAtspi> create(AXCoreObject*, AccessibilityRootAtspi&);
43	~AccessibilityObjectAtspi() = default;	42	~AccessibilityObjectAtspi() = default;
44		43
45	enum class Interface : uint16_t {	44	enum class Interface : uint16_t {
Lines 58-65 public: a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h_sec3
58	};	57	};
59	const OptionSet<Interface>& interfaces() const { return m_interfaces; }	58	const OptionSet<Interface>& interfaces() const { return m_interfaces; }
60		59
61	void setRoot(AccessibilityRootAtspi*);	60	const AccessibilityRootAtspi& root() const { return m_root; }
62	WEBCORE_EXPORT AccessibilityRootAtspi* root() const;
63	void setParent(std::optional<AccessibilityObjectAtspi*>);	61	void setParent(std::optional<AccessibilityObjectAtspi*>);
64	WEBCORE_EXPORT std::optional<AccessibilityObjectAtspi*> parent() const;	62	WEBCORE_EXPORT std::optional<AccessibilityObjectAtspi*> parent() const;
65	WEBCORE_EXPORT void updateBackingStore();	63	WEBCORE_EXPORT void updateBackingStore();
Lines 155-161 public: a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h_sec4
155	WEBCORE_EXPORT std::pair<std::optional<unsigned>, std::optional<unsigned>> cellPosition() const;	153	WEBCORE_EXPORT std::pair<std::optional<unsigned>, std::optional<unsigned>> cellPosition() const;
156		154
157	private:	155	private:
158	explicit AccessibilityObjectAtspi(AXCoreObject*);	156	explicit AccessibilityObjectAtspi(AXCoreObject*, AccessibilityRootAtspi&);
159		157
160	Vector<RefPtr<AccessibilityObjectAtspi>> wrapperVector(const Vector<RefPtr<AXCoreObject>>&) const;	158	Vector<RefPtr<AccessibilityObjectAtspi>> wrapperVector(const Vector<RefPtr<AXCoreObject>>&) const;
161	int indexInParent() const;	159	int indexInParent() const;
Lines 236-242 private: a/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h_sec5
236	AXCoreObject* m_axObject { nullptr };	234	AXCoreObject* m_axObject { nullptr };
237	AXCoreObject* m_coreObject { nullptr };	235	AXCoreObject* m_coreObject { nullptr };
238	OptionSet<Interface> m_interfaces;	236	OptionSet<Interface> m_interfaces;
239	AccessibilityRootAtspi* m_root WTF_GUARDED_BY_LOCK(m_rootLock) { nullptr };	237	AccessibilityRootAtspi& m_root;
240	std::optional<AccessibilityObjectAtspi*> m_parent;	238	std::optional<AccessibilityObjectAtspi*> m_parent;
241	Atomic<bool> m_isRegistered { false };	239	Atomic<bool> m_isRegistered { false };
242	String m_path;	240	String m_path;

Lines 42-48 GDBusInterfaceVTable AccessibilityObjectAtspi::s_tableFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp -23 / +11 lines
42	int row, column;	42	int row, column;
43	g_variant_get(parameters, "(ii)", &row, &column);	43	g_variant_get(parameters, "(ii)", &row, &column);
44	auto* cell = row >= 0 && column >= 0 ? atspiObject->cell(row, column) : nullptr;	44	auto* cell = row >= 0 && column >= 0 ? atspiObject->cell(row, column) : nullptr;
45	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", cell ? cell->reference() : atspiObject->root()->atspi().nullReference()));	45	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", cell ? cell->reference() : atspiObject->m_root.atspi().nullReference()));
46	} else if (!g_strcmp0(methodName, "GetIndexAt")) {	46	} else if (!g_strcmp0(methodName, "GetIndexAt")) {
47	int row, column;	47	int row, column;
48	g_variant_get(parameters, "(ii)", &row, &column);	48	g_variant_get(parameters, "(ii)", &row, &column);
Lines 75-86 GDBusInterfaceVTable AccessibilityObjectAtspi::s_tableFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec2
75	int row;	75	int row;
76	g_variant_get(parameters, "(i)", &row);	76	g_variant_get(parameters, "(i)", &row);
77	auto* header = row >= 0 ? atspiObject->rowHeader(row) : nullptr;	77	auto* header = row >= 0 ? atspiObject->rowHeader(row) : nullptr;
78	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->root()->atspi().nullReference()));	78	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
79	} else if (!g_strcmp0(methodName, "GetColumnHeader")) {	79	} else if (!g_strcmp0(methodName, "GetColumnHeader")) {
80	int column;	80	int column;
81	g_variant_get(parameters, "(i)", &column);	81	g_variant_get(parameters, "(i)", &column);
82	auto* header = column >= 0 ? atspiObject->columnHeader(column) : nullptr;	82	auto* header = column >= 0 ? atspiObject->columnHeader(column) : nullptr;
83	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->root()->atspi().nullReference()));	83	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
84	} else if (!g_strcmp0(methodName, "GetRowColumnExtentsAtIndex")) {	84	} else if (!g_strcmp0(methodName, "GetRowColumnExtentsAtIndex")) {
85	int index;	85	int index;
86	g_variant_get(parameters, "(i)", &index);	86	g_variant_get(parameters, "(i)", &index);
Lines 118-127 GDBusInterfaceVTable AccessibilityObjectAtspi::s_tableFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec3
118	return g_variant_new_int32(atspiObject->columnCount());	118	return g_variant_new_int32(atspiObject->columnCount());
119	if (!g_strcmp0(propertyName, "Caption")) {	119	if (!g_strcmp0(propertyName, "Caption")) {
120	auto* caption = atspiObject->tableCaption();	120	auto* caption = atspiObject->tableCaption();
121	return caption ? caption->reference() : atspiObject->root()->atspi().nullReference();	121	return caption ? caption->reference() : atspiObject->m_root.atspi().nullReference();
122	}	122	}
123	if (!g_strcmp0(propertyName, "Summary"))	123	if (!g_strcmp0(propertyName, "Summary"))
124	return atspiObject->root()->atspi().nullReference();	124	return atspiObject->m_root.atspi().nullReference();
125	if (!g_strcmp0(propertyName, "NSelectedRows"))	125	if (!g_strcmp0(propertyName, "NSelectedRows"))
126	return g_variant_new_int32(0);	126	return g_variant_new_int32(0);
127	if (!g_strcmp0(propertyName, "NSelectedColumns"))	127	if (!g_strcmp0(propertyName, "NSelectedColumns"))
Lines 160-171 AccessibilityObjectAtspi* AccessibilityObjectAtspi::cell(unsigned row, unsigned a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec4
160	if (!m_axObject)	160	if (!m_axObject)
161	return nullptr;	161	return nullptr;
162		162
163	if (auto* tableCell = m_axObject->cellForColumnAndRow(column, row)) {	163	if (auto* tableCell = m_axObject->cellForColumnAndRow(column, row))
164	if (auto* wrapper = tableCell->wrapper()) {	164	return tableCell->wrapper();
165	wrapper->setRoot(root());
166	return wrapper;
167	}
168	}
169		165
170	return nullptr;	166	return nullptr;
171	}	167	}
Lines 185-196 AccessibilityObjectAtspi* AccessibilityObjectAtspi::tableCaption() const a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec5
185		181
186	if (auto caption = downcast<HTMLTableElement>(*node).caption()) {	182	if (auto caption = downcast<HTMLTableElement>(*node).caption()) {
187	if (auto* renderer = caption->renderer()) {	183	if (auto* renderer = caption->renderer()) {
188	if (auto* element = AccessibilityObject::firstAccessibleObjectFromNode(renderer->element())) {	184	if (auto* element = AccessibilityObject::firstAccessibleObjectFromNode(renderer->element()))
189	if (auto* wrapper = element->wrapper()) {	185	return element->wrapper();
190	wrapper->setRoot(root());
191	return wrapper;
192	}
193	}
194	}	186	}
195	}	187	}
196	}	188	}
Lines 253-262 AccessibilityObjectAtspi* AccessibilityObjectAtspi::rowHeader(unsigned row) cons a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec6
253	for (const auto& header : headers) {	245	for (const auto& header : headers) {
254	auto range = header->rowIndexRange();	246	auto range = header->rowIndexRange();
255	if (range.first <= row && row < range.first + range.second) {	247	if (range.first <= row && row < range.first + range.second) {
256	if (auto* wrapper = header->wrapper()) {	248	if (auto* wrapper = header->wrapper())
257	wrapper->setRoot(root());
258	return wrapper;	249	return wrapper;
259	}
260	}	250	}
261	}	251	}
262		252
Lines 273-282 AccessibilityObjectAtspi* AccessibilityObjectAtspi::columnHeader(unsigned column a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp_sec7
273	for (const auto& header : headers) {	263	for (const auto& header : headers) {
274	auto range = header->columnIndexRange();	264	auto range = header->columnIndexRange();
275	if (range.first <= column && column < range.first + range.second) {	265	if (range.first <= column && column < range.first + range.second) {
276	if (auto* wrapper = header->wrapper()) {	266	if (auto* wrapper = header->wrapper())
277	wrapper->setRoot(root());
278	return wrapper;	267	return wrapper;
279	}
280	}	268	}
281	}	269	}
282		270

Lines 67-73 GDBusInterfaceVTable AccessibilityObjectAtspi::s_tableCellFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp -24 / +4 lines
67	if (!g_strcmp0(propertyName, "Table")) {	67	if (!g_strcmp0(propertyName, "Table")) {
68	auto* axObject = atspiObject->m_axObject;	68	auto* axObject = atspiObject->m_axObject;
69	if (!axObject \|\| !axObject->isTableCell())	69	if (!axObject \|\| !axObject->isTableCell())
70	return atspiObject->root()->atspi().nullReference();	70	return atspiObject->m_root.atspi().nullReference();
71		71
72	AccessibilityObjectAtspi* wrapper = atspiObject.ptr();	72	AccessibilityObjectAtspi* wrapper = atspiObject.ptr();
73	while (auto parent = wrapper->parent()) {	73	while (auto parent = wrapper->parent()) {
Lines 80-86 GDBusInterfaceVTable AccessibilityObjectAtspi::s_tableCellFunctions = { a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp_sec2
80	if (axObject && axObject->isTable())	80	if (axObject && axObject->isTable())
81	break;	81	break;
82	}	82	}
83	return wrapper ? wrapper->reference() : atspiObject->root()->atspi().nullReference();	83	return wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference();
84	}	84	}
85		85
86	g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);	86	g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);
Lines 102-118 Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::cellRowHeader a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp_sec3
102	if (role() != Atspi::Role::TableCell)	102	if (role() != Atspi::Role::TableCell)
103	return { };	103	return { };
104		104
105	auto headers = m_axObject->rowHeaders();	105	return wrapperVector(m_axObject->rowHeaders());
106	Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
107	wrappers.reserveInitialCapacity(headers.size());
108	auto* root = this->root();
109	for (const auto& header : headers) {
110	if (auto* wrapper = header->wrapper()) {
111	wrapper->setRoot(root);
112	wrappers.uncheckedAppend(wrapper);
113	}
114	}
115	return wrappers;
116	}	106	}
117		107
118	Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::cellColumnHeaders() const	108	Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::cellColumnHeaders() const
Lines 125-141 Vector<RefPtr<AccessibilityObjectAtspi>> AccessibilityObjectAtspi::cellColumnHea a/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp_sec4
125	if (role() != Atspi::Role::TableCell)	115	if (role() != Atspi::Role::TableCell)
126	return { };	116	return { };
127		117
128	auto headers = m_axObject->columnHeaders();	118	return wrapperVector(m_axObject->columnHeaders());
129	Vector<RefPtr<AccessibilityObjectAtspi>> wrappers;
130	wrappers.reserveInitialCapacity(headers.size());
131	auto* root = this->root();
132	for (const auto& header : headers) {
133	if (auto* wrapper = header->wrapper()) {
134	wrapper->setRoot(root);
135	wrappers.uncheckedAppend(wrapper);
136	}
137	}
138	return wrappers;
139	}	119	}
140		120
141	unsigned AccessibilityObjectAtspi::rowSpan() const	121	unsigned AccessibilityObjectAtspi::rowSpan() const

Lines 361-367 void AccessibilityObjectAtspi::textInserted(const String& insertedText, const Vi a/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp_sec1
- a/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp -5 / +5 lines
361	auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);	361	auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);
362	auto utf8InsertedText = insertedText.utf8();	362	auto utf8InsertedText = insertedText.utf8();
363	auto insertedTextLength = g_utf8_strlen(utf8InsertedText.data(), -1);	363	auto insertedTextLength = g_utf8_strlen(utf8InsertedText.data(), -1);
364	root()->atspi().textChanged(*this, "insert", WTFMove(utf8InsertedText), offset - insertedTextLength, insertedTextLength);	364	m_root.atspi().textChanged(*this, "insert", WTFMove(utf8InsertedText), offset - insertedTextLength, insertedTextLength);
365	}	365	}
366		366
367	void AccessibilityObjectAtspi::textDeleted(const String& deletedText, const VisiblePosition& position)	367	void AccessibilityObjectAtspi::textDeleted(const String& deletedText, const VisiblePosition& position)
Lines 380-386 void AccessibilityObjectAtspi::textDeleted(const String& deletedText, const Visi a/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp_sec2
380	auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);	380	auto offset = UTF16OffsetToUTF8(mapping, utf16Offset);
381	auto utf8DeletedText = deletedText.utf8();	381	auto utf8DeletedText = deletedText.utf8();
382	auto deletedTextLength = g_utf8_strlen(utf8DeletedText.data(), -1);	382	auto deletedTextLength = g_utf8_strlen(utf8DeletedText.data(), -1);
383	root()->atspi().textChanged(*this, "delete", WTFMove(utf8DeletedText), offset, deletedTextLength);	383	m_root.atspi().textChanged(*this, "delete", WTFMove(utf8DeletedText), offset, deletedTextLength);
384	}	384	}
385		385
386	IntPoint AccessibilityObjectAtspi::boundaryOffset(unsigned utf16Offset, TextGranularity granularity) const	386	IntPoint AccessibilityObjectAtspi::boundaryOffset(unsigned utf16Offset, TextGranularity granularity) const
Lines 773-782 void AccessibilityObjectAtspi::selectionChanged(const VisibleSelection& selectio a/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp_sec3
773	auto mapping = offsetMapping(utf16Text);	773	auto mapping = offsetMapping(utf16Text);
774	auto caretOffset = UTF16OffsetToUTF8(mapping, bounds.y());	774	auto caretOffset = UTF16OffsetToUTF8(mapping, bounds.y());
775	if (caretOffset <= length)	775	if (caretOffset <= length)
776	root()->atspi().textCaretMoved(*this, caretOffset);	776	m_root.atspi().textCaretMoved(*this, caretOffset);
777		777
778	if (selection.isRange())	778	if (selection.isRange())
779	root()->atspi().textSelectionChanged(*this);	779	m_root.atspi().textSelectionChanged(*this);
780	}	780	}
781		781
782	AccessibilityObjectAtspi::TextAttributes AccessibilityObjectAtspi::textAttributes(std::optional<unsigned> utf16Offset, bool includeDefault) const	782	AccessibilityObjectAtspi::TextAttributes AccessibilityObjectAtspi::textAttributes(std::optional<unsigned> utf16Offset, bool includeDefault) const
Lines 949-955 void AccessibilityObjectAtspi::textAttributesChanged() a/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp_sec4
949	if (!m_interfaces.contains(Interface::Text))	949	if (!m_interfaces.contains(Interface::Text))
950	return;	950	return;
951		951
952	root()->atspi().textAttributesChanged(*this);	952	m_root.atspi().textAttributesChanged(*this);
953	}	953	}
954		954
955	bool AccessibilityObjectAtspi::scrollToMakeVisible(int startOffset, int endOffset, uint32_t scrollType) const	955	bool AccessibilityObjectAtspi::scrollToMakeVisible(int startOffset, int endOffset, uint32_t scrollType) const

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +13 lines
		1	2021-12-03 Carlos Garcia Campos <cgarcia@igalia.com>
		2
		3	[GTK][a11y] Ensure atspi wrappers have root set at construction time
		4	https://bugs.webkit.org/show_bug.cgi?id=233804
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* WebProcess/InjectedBundle/API/c/WKBundlePage.cpp:
		9	(WKAccessibilityRootObject): Remove ATSPI specific code.
		10	(WKAccessibilityFocusedObject): Ditto.
		11	* WebProcess/WebPage/WebPage.h:
		12	(WebKit::WebPage::accessibilityRootObject const): Deleted.
		13
1	2021-12-01 Sihui Liu <sihui_liu@apple.com>	14	2021-12-01 Sihui Liu <sihui_liu@apple.com>
2		15
3	FileSystemSyncAccessHandle should be invalidated when network process crashes	16	FileSystemSyncAccessHandle should be invalidated when network process crashes

Lines 247-256 void* WKAccessibilityRootObject(WKBundlePageRef pageRef) a/Source/WebKit/WebProcess/InjectedBundle/API/c/WKBundlePage.cpp_sec1
- a/Source/WebKit/WebProcess/InjectedBundle/API/c/WKBundlePage.cpp -8 lines
247	if (!pageRef)	247	if (!pageRef)
248	return 0;	248	return 0;
249		249
250	#if USE(ATSPI)
251	return WebKit::toImpl(pageRef)->accessibilityRootObject().child();
252	#endif
253
254	WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();	250	WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();
255	if (!page)	251	if (!page)
256	return 0;	252	return 0;
Lines 278-287 void* WKAccessibilityFocusedObject(WKBundlePageRef pageRef) a/Source/WebKit/WebProcess/InjectedBundle/API/c/WKBundlePage.cpp_sec2
278	if (!pageRef)	274	if (!pageRef)
279	return 0;	275	return 0;
280		276
281	#if USE(ATSPI)
282	return WebKit::toImpl(pageRef)->accessibilityRootObject().focusedObject();
283	#endif
284
285	WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();	277	WebCore::Page* page = WebKit::toImpl(pageRef)->corePage();
286	if (!page)	278	if (!page)
287	return 0;	279	return 0;

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +10 lines
		1	2021-12-03 Carlos Garcia Campos <cgarcia@igalia.com>
		2
		3	[GTK][a11y] Ensure atspi wrappers have root set at construction time
		4	https://bugs.webkit.org/show_bug.cgi?id=233804
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:
		9	(WTR::AccessibilityController::axRunLoop):
		10
1	2021-12-02 Carlos Garcia Campos <cgarcia@igalia.com>	11	2021-12-02 Carlos Garcia Campos <cgarcia@igalia.com>
2		12
3	Unreviewed. [GTK] Use nullptr instead of 0 in JSStringCreateWithCharacters()	13	Unreviewed. [GTK] Use nullptr instead of 0 in JSStringCreateWithCharacters()