⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 287876 in webkit


Ignore:
Timestamp:
Jan 11, 2022, 6:07:38 AM (5 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK][a11y] Web process crashes in some sites having SVG images
​https://bugs.webkit.org/show_bug.cgi?id=234737

Reviewed by Adrian Perez de Castro.

Source/WebCore:

Unfortunately the changes in r287388 are not enough, it can still happen that root hasn't been set to the
SVGImage page when the wrappers are created. So, we can't actually create the wrappers with a reference to the
root object as we did in r286767. In most of the cases wrappers use the root just to get AccessibilityAtspi,
which is not a singleton, but it's created and owned by the web process singleton at startup, so it can be
accessed globaly. This patch makes AccessibilityAtspi a singleton to get the global instance without having to
keep a reference in the root object.

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::remoteSVGRootElement const): Move the code to set the root in SVGImage page
before the remote svg wrapper is created.

  • accessibility/atspi/AXObjectCacheAtspi.cpp:

(WebCore::AXObjectCache::attachWrapper): Just pass the page root object to the wrapper constructor, that now
receives a pointer that might be nullptr.

  • accessibility/atspi/AccessibilityAtspi.cpp:

(WebCore::AccessibilityAtspi::AccessibilityAtspi): Just create the WorkQueue.
(WebCore::AccessibilityAtspi::singleton): Return a reference to the global instance.
(WebCore::AccessibilityAtspi::connect): Connect to the given dbus address.
(WebCore::AccessibilityAtspi::applicationReference const): This allows wrappers to get the application reference
without having to check if m_root is nullptr or not.
(WebCore::AccessibilityAtspi::parentChanged): Use AccessibilityObjectAtspi::isTreeRegistered()
(WebCore::AccessibilityAtspi::childrenChanged): Ditto.

  • accessibility/atspi/AccessibilityAtspi.h:
  • accessibility/atspi/AccessibilityObjectAtspi.cpp:

(WebCore::AccessibilityObjectAtspi::create): Receive a AccessibilityRootAtspi pointer instead of reference.
(WebCore::AccessibilityObjectAtspi::AccessibilityObjectAtspi): Ditto.
(WebCore::AccessibilityObjectAtspi::cacheDestroyed): Only call AccessibilityRootAtspi::childRemoved if parent is
the root object.
(WebCore::AccessibilityObjectAtspi::elementDestroyed): Null check m_root and use AccessibilityAtspi::singleton().
(WebCore::AccessibilityObjectAtspi::root): Get the root if already set or try to get it from the page.
(WebCore::AccessibilityObjectAtspi::isTreeRegistered const): Return try if root has been set and its tree has
been registered.
(WebCore::AccessibilityObjectAtspi::registerObject): Use AccessibilityObjectAtspi::root().
(WebCore::AccessibilityObjectAtspi::reference): Use AccessibilityAtspi::singleton().
(WebCore::AccessibilityObjectAtspi::hyperlinkReference): Ditto.
(WebCore::AccessibilityObjectAtspi::setParent): Return early also if root hasn't been set yet.
(WebCore::AccessibilityObjectAtspi::parentReference const): Use AccessibilityAtspi::singleton().
(WebCore::AccessibilityObjectAtspi::serialize const): Ditto.
(WebCore::AccessibilityObjectAtspi::childAdded): Ditto.
(WebCore::AccessibilityObjectAtspi::childRemoved): Ditto.
(WebCore::AccessibilityObjectAtspi::stateChanged): Ditto.
(WebCore::AccessibilityObjectAtspi::loadEvent): Ditto.

  • accessibility/atspi/AccessibilityObjectAtspi.h:
  • accessibility/atspi/AccessibilityObjectComponentAtspi.cpp:
  • accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp:
  • accessibility/atspi/AccessibilityObjectHypertextAtspi.cpp:
  • accessibility/atspi/AccessibilityObjectSelectionAtspi.cpp:

(WebCore::AccessibilityObjectAtspi::selectionChanged): Ditto.

  • accessibility/atspi/AccessibilityObjectTableAtspi.cpp:
  • accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp:
  • accessibility/atspi/AccessibilityObjectTextAtspi.cpp:

(WebCore::AccessibilityObjectAtspi::textInserted): Ditto.
(WebCore::AccessibilityObjectAtspi::textDeleted): Ditto.
(WebCore::AccessibilityObjectAtspi::selectionChanged): Ditto.
(WebCore::AccessibilityObjectAtspi::textAttributesChanged): Ditto.

  • accessibility/atspi/AccessibilityObjectValueAtspi.cpp:

(WebCore::AccessibilityObjectAtspi::valueChanged): Ditto.

  • accessibility/atspi/AccessibilityRootAtspi.cpp:

(WebCore::AccessibilityRootAtspi::create): Remove AccessibilityAtspi parameter.
(WebCore::AccessibilityRootAtspi::AccessibilityRootAtspi): Ditto.
(WebCore::AccessibilityRootAtspi::registerObject): Use AccessibilityAtspi::singleton().
(WebCore::AccessibilityRootAtspi::unregisterObject): Ditto
(WebCore::AccessibilityRootAtspi::embedded): Ditto.
(WebCore::AccessibilityRootAtspi::applicationReference const): Ditto.
(WebCore::AccessibilityRootAtspi::reference const): Ditto.
(WebCore::AccessibilityRootAtspi::childAdded): Ditto.
(WebCore::AccessibilityRootAtspi::childRemoved): Ditto.
(WebCore::AccessibilityRootAtspi::serialize const): Ditto.

  • accessibility/atspi/AccessibilityRootAtspi.h:

Source/WebKit:

Use AccessibilityAtspi::singleton().

  • WebProcess/WebPage/gtk/WebPageGtk.cpp:

(WebKit::WebPage::platformInitialize):

  • WebProcess/WebProcess.h:

(WebKit::WebProcess::accessibilityAtspi const): Deleted.

  • WebProcess/glib/WebProcessGLib.cpp:

(WebKit::WebProcess::platformInitializeWebProcess):

Tools:

Use AccessibilityAtspi::singleton().

  • WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:

(WTR::AccessibilityController::axRunLoop):

  • WebKitTestRunner/InjectedBundle/atspi/AccessibilityNotificationHandler.cpp:

(WTR::AccessibilityNotificationHandler::AccessibilityNotificationHandler):
(WTR::AccessibilityNotificationHandler::~AccessibilityNotificationHandler):

Location:
trunk
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r287875 r287876  
     12022-01-11  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Web process crashes in some sites having SVG images
     4        https://bugs.webkit.org/show_bug.cgi?id=234737
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        Unfortunately the changes in r287388 are not enough, it can still happen that root hasn't been set to the
     9        SVGImage page when the wrappers are created. So, we can't actually create the wrappers with a reference to the
     10        root object as we did in r286767. In most of the cases wrappers use the root just to get AccessibilityAtspi,
     11        which is not a singleton, but it's created and owned by the web process singleton at startup, so it can be
     12        accessed globaly. This patch makes AccessibilityAtspi a singleton to get the global instance without having to
     13        keep a reference in the root object.
     14
     15        * accessibility/AccessibilityRenderObject.cpp:
     16        (WebCore::AccessibilityRenderObject::remoteSVGRootElement const): Move the code to set the root in SVGImage page
     17        before the remote svg wrapper is created.
     18        * accessibility/atspi/AXObjectCacheAtspi.cpp:
     19        (WebCore::AXObjectCache::attachWrapper): Just pass the page root object to the wrapper constructor, that now
     20        receives a pointer that might be nullptr.
     21        * accessibility/atspi/AccessibilityAtspi.cpp:
     22        (WebCore::AccessibilityAtspi::AccessibilityAtspi): Just create the WorkQueue.
     23        (WebCore::AccessibilityAtspi::singleton): Return a reference to the global instance.
     24        (WebCore::AccessibilityAtspi::connect): Connect to the given dbus address.
     25        (WebCore::AccessibilityAtspi::applicationReference const): This allows wrappers to get the application reference
     26        without having to check if m_root is nullptr or not.
     27        (WebCore::AccessibilityAtspi::parentChanged): Use AccessibilityObjectAtspi::isTreeRegistered()
     28        (WebCore::AccessibilityAtspi::childrenChanged): Ditto.
     29        * accessibility/atspi/AccessibilityAtspi.h:
     30        * accessibility/atspi/AccessibilityObjectAtspi.cpp:
     31        (WebCore::AccessibilityObjectAtspi::create): Receive a AccessibilityRootAtspi pointer instead of reference.
     32        (WebCore::AccessibilityObjectAtspi::AccessibilityObjectAtspi): Ditto.
     33        (WebCore::AccessibilityObjectAtspi::cacheDestroyed): Only call AccessibilityRootAtspi::childRemoved if parent is
     34        the root object.
     35        (WebCore::AccessibilityObjectAtspi::elementDestroyed): Null check m_root and use AccessibilityAtspi::singleton().
     36        (WebCore::AccessibilityObjectAtspi::root): Get the root if already set or try to get it from the page.
     37        (WebCore::AccessibilityObjectAtspi::isTreeRegistered const): Return try if root has been set and its tree has
     38        been registered.
     39        (WebCore::AccessibilityObjectAtspi::registerObject): Use AccessibilityObjectAtspi::root().
     40        (WebCore::AccessibilityObjectAtspi::reference): Use AccessibilityAtspi::singleton().
     41        (WebCore::AccessibilityObjectAtspi::hyperlinkReference): Ditto.
     42        (WebCore::AccessibilityObjectAtspi::setParent): Return early also if root hasn't been set yet.
     43        (WebCore::AccessibilityObjectAtspi::parentReference const): Use AccessibilityAtspi::singleton().
     44        (WebCore::AccessibilityObjectAtspi::serialize const): Ditto.
     45        (WebCore::AccessibilityObjectAtspi::childAdded): Ditto.
     46        (WebCore::AccessibilityObjectAtspi::childRemoved): Ditto.
     47        (WebCore::AccessibilityObjectAtspi::stateChanged): Ditto.
     48        (WebCore::AccessibilityObjectAtspi::loadEvent): Ditto.
     49        * accessibility/atspi/AccessibilityObjectAtspi.h:
     50        * accessibility/atspi/AccessibilityObjectComponentAtspi.cpp:
     51        * accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp:
     52        * accessibility/atspi/AccessibilityObjectHypertextAtspi.cpp:
     53        * accessibility/atspi/AccessibilityObjectSelectionAtspi.cpp:
     54        (WebCore::AccessibilityObjectAtspi::selectionChanged): Ditto.
     55        * accessibility/atspi/AccessibilityObjectTableAtspi.cpp:
     56        * accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp:
     57        * accessibility/atspi/AccessibilityObjectTextAtspi.cpp:
     58        (WebCore::AccessibilityObjectAtspi::textInserted): Ditto.
     59        (WebCore::AccessibilityObjectAtspi::textDeleted): Ditto.
     60        (WebCore::AccessibilityObjectAtspi::selectionChanged): Ditto.
     61        (WebCore::AccessibilityObjectAtspi::textAttributesChanged): Ditto.
     62        * accessibility/atspi/AccessibilityObjectValueAtspi.cpp:
     63        (WebCore::AccessibilityObjectAtspi::valueChanged): Ditto.
     64        * accessibility/atspi/AccessibilityRootAtspi.cpp:
     65        (WebCore::AccessibilityRootAtspi::create): Remove AccessibilityAtspi parameter.
     66        (WebCore::AccessibilityRootAtspi::AccessibilityRootAtspi): Ditto.
     67        (WebCore::AccessibilityRootAtspi::registerObject): Use AccessibilityAtspi::singleton().
     68        (WebCore::AccessibilityRootAtspi::unregisterObject): Ditto
     69        (WebCore::AccessibilityRootAtspi::embedded): Ditto.
     70        (WebCore::AccessibilityRootAtspi::applicationReference const): Ditto.
     71        (WebCore::AccessibilityRootAtspi::reference const): Ditto.
     72        (WebCore::AccessibilityRootAtspi::childAdded): Ditto.
     73        (WebCore::AccessibilityRootAtspi::childRemoved): Ditto.
     74        (WebCore::AccessibilityRootAtspi::serialize const): Ditto.
     75        * accessibility/atspi/AccessibilityRootAtspi.h:
     76
    1772022-01-11  Martin Robinson  <mrobinson@webkit.org>
    278

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r287832 r287876  
    34033403    if (!cache)
    34043404        return nullptr;
    3405     AccessibilityObject* rootSVGObject = createIfNecessary == Create ? cache->getOrCreate(rendererRoot) : cache->get(rendererRoot);
    3406 
    3407     ASSERT(!createIfNecessary || rootSVGObject);
    3408     if (!is<AccessibilitySVGRoot>(rootSVGObject))
    3409         return nullptr;
    34103405
    34113406#if USE(ATSPI)
    … …  
    34133408        page->setAccessibilityRootObject(createIfNecessary == Create ? axObjectCache()->document().page()->accessibilityRootObject() : nullptr);
    34143409#endif
     3410
     3411    AccessibilityObject* rootSVGObject = createIfNecessary == Create ? cache->getOrCreate(rendererRoot) : cache->get(rendererRoot);
     3412
     3413    ASSERT(!createIfNecessary || rootSVGObject);
     3414    if (!is<AccessibilitySVGRoot>(rootSVGObject))
     3415        return nullptr;
    34153416
    34163417    return downcast<AccessibilitySVGRoot>(rootSVGObject);

  • trunk/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp

    r287871 r287876  
    3636void AXObjectCache::attachWrapper(AXCoreObject* axObject)
    3737{
    38     auto* rootWrapper = document().page()->accessibilityRootObject();
    39     if (!rootWrapper)
    40         return;
    41 
    42     auto wrapper = AccessibilityObjectAtspi::create(axObject, *rootWrapper);
     38    auto wrapper = AccessibilityObjectAtspi::create(axObject, document().page()->accessibilityRootObject());
    4339    axObject->setWrapper(wrapper.ptr());
    4440

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp

    r287456 r287876  
    2727#include <glib/gi18n-lib.h>
    2828#include <wtf/MainThread.h>
     29#include <wtf/NeverDestroyed.h>
    2930#include <wtf/SetForScope.h>
    3031#include <wtf/SortedArrayMap.h>
    … …  
    3334namespace WebCore {
    3435
    35 AccessibilityAtspi::AccessibilityAtspi(const String& busAddress)
     36AccessibilityAtspi& AccessibilityAtspi::singleton()
     37{
     38    static NeverDestroyed<AccessibilityAtspi> atspi;
     39    return atspi;
     40}
     41
     42AccessibilityAtspi::AccessibilityAtspi()
    3643    : m_queue(WorkQueue::create("org.webkit.a11y"))
    3744{
    3845    RELEASE_ASSERT(isMainThread());
     46}
     47
     48void AccessibilityAtspi::connect(const String& busAddress)
     49{
     50    RELEASE_ASSERT(isMainThread());
    3951    if (busAddress.isEmpty())
    4052        return;
     53
    4154    m_queue->dispatch([this, busAddress = busAddress.isolatedCopy()] {
    4255        GUniqueOutPtr<GError> error;
    … …  
    5063            g_warning("Can't connect to a11y bus: %s", error->message);
    5164    });
    52 }
    53 
    54 AccessibilityAtspi::~AccessibilityAtspi()
    55 {
    56     if (m_registry)
    57         g_signal_handlers_disconnect_by_data(m_registry.get(), this);
    5865}
    5966
    … …  
    217224    RELEASE_ASSERT(!isMainThread());
    218225    return g_variant_new("(so)", uniqueName(), "/org/a11y/atspi/null");
     226}
     227
     228GVariant* AccessibilityAtspi::applicationReference() const
     229{
     230    RELEASE_ASSERT(!isMainThread());
     231
     232    // The application is the same for all root objects, so just use the first root object that is already embedded.
     233    for (auto* rootObject : m_rootObjects.keys()) {
     234        if (!rootObject->path().isNull())
     235            return rootObject->applicationReference();
     236    }
     237
     238    return nullReference();
    219239}
    220240
    … …  
    330350
    331351        // Always emit parentChanged when the tree is registered because the atspi cache always consumes it.
    332         if (!atspiObject->root().isTreeRegistered())
     352        if (!atspiObject->isTreeRegistered())
    333353            return;
    334354
    … …  
    366386
    367387        // Always emit ChildrenChanged when the tree is registered because the atspi cache always consumes it.
    368         if (!atspiObject->root().isTreeRegistered())
     388        if (!atspiObject->isTreeRegistered())
    369389            return;
    370390

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.h

    r287456 r287876  
    4141
    4242class AccessibilityAtspi {
    43     WTF_MAKE_FAST_ALLOCATED;
     43    WTF_MAKE_NONCOPYABLE(AccessibilityAtspi); WTF_MAKE_FAST_ALLOCATED;
     44    friend NeverDestroyed<AccessibilityAtspi>;
    4445public:
    45     AccessibilityAtspi(const String&);
    46     ~AccessibilityAtspi();
     46    WEBCORE_EXPORT static AccessibilityAtspi& singleton();
     47
     48    void connect(const String&);
    4749
    4850    WEBCORE_EXPORT RunLoop& runLoop() const;
    … …  
    5052    const char* uniqueName() const;
    5153    GVariant* nullReference() const;
     54    GVariant* applicationReference() const;
    5255    bool hasEventListeners() const { return !m_eventListeners.isEmpty(); }
    5356
    … …  
    8992
    9093private:
     94    AccessibilityAtspi();
     95
    9196    void registerTrees() const;
    9297    void initializeRegistry();

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp

    r287871 r287876  
    3838namespace WebCore {
    3939
    40 Ref<AccessibilityObjectAtspi> AccessibilityObjectAtspi::create(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
     40Ref<AccessibilityObjectAtspi> AccessibilityObjectAtspi::create(AXCoreObject* coreObject, AccessibilityRootAtspi* root)
    4141{
    4242    return adoptRef(*new AccessibilityObjectAtspi(coreObject, root));
    … …  
    111111}
    112112
    113 AccessibilityObjectAtspi::AccessibilityObjectAtspi(AXCoreObject* coreObject, AccessibilityRootAtspi& root)
     113AccessibilityObjectAtspi::AccessibilityObjectAtspi(AXCoreObject* coreObject, AccessibilityRootAtspi* root)
    114114    : m_coreObject(coreObject)
    115115    , m_interfaces(interfacesForObject(*m_coreObject))
    … …  
    137137        return;
    138138
    139     m_root.childRemoved(*this);
    140     m_root.atspi().unregisterObject(*this);
     139    if (m_parent && !*m_parent && m_root)
     140        m_root->childRemoved(*this);
     141
     142    AccessibilityAtspi::singleton().unregisterObject(*this);
    141143}
    142144
    … …  
    151153        if (*m_parent)
    152154            m_parent.value()->childRemoved(*this);
    153         else
    154             m_root.childRemoved(*this);
    155     }
    156 
    157     m_root.atspi().unregisterObject(*this);
     155        else if (m_root)
     156            m_root->childRemoved(*this);
     157    }
     158
     159    AccessibilityAtspi::singleton().unregisterObject(*this);
    158160}
    159161
    … …  
    433435            g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
    434436        } else if (!g_strcmp0(methodName, "GetApplication"))
    435             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", atspiObject->m_root.applicationReference()));
     437            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", AccessibilityAtspi::singleton().applicationReference()));
    436438        else if (!g_strcmp0(methodName, "GetChildAtIndex")) {
    437439            int index;
    438440            g_variant_get(parameters, "(i)", &index);
    439441            auto* wrapper = index >= 0 ? atspiObject->childAt(index) : nullptr;
    440             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference()));
     442            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : AccessibilityAtspi::singleton().nullReference()));
    441443        } else if (!g_strcmp0(methodName, "GetChildren")) {
    442444            GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
    … …  
    483485    nullptr
    484486};
     487
     488AccessibilityRootAtspi* AccessibilityObjectAtspi::root()
     489{
     490    RELEASE_ASSERT(isMainThread());
     491    RELEASE_ASSERT(m_coreObject);
     492
     493    if (!m_root) {
     494        if (auto* document = m_coreObject->document())
     495            m_root = document->page()->accessibilityRootObject();
     496    }
     497    return m_root;
     498}
     499
     500bool AccessibilityObjectAtspi::isTreeRegistered() const
     501{
     502    return m_root ? m_root->isTreeRegistered() : false;
     503}
    485504
    486505bool AccessibilityObjectAtspi::registerObject()
    … …  
    520539        // to create it before registering the object.
    521540        Accessibility::performFunctionOnMainThread([this] {
    522             m_root.child();
     541            if (!m_coreObject)
     542                return;
     543
     544            if (auto* atspiRoot = root())
     545                atspiRoot->child();
    523546        });
    524547    }
    525     m_path = m_root.atspi().registerObject(*this, WTFMove(interfaces));
    526     m_root.atspi().addAccessible(*this);
     548
     549    m_path = AccessibilityAtspi::singleton().registerObject(*this, WTFMove(interfaces));
     550    AccessibilityAtspi::singleton().addAccessible(*this);
    527551
    528552    return true;
    … …  
    539563{
    540564    RELEASE_ASSERT(!isMainThread());
    541     return g_variant_new("(so)", m_root.atspi().uniqueName(), path().utf8().data());
     565    return g_variant_new("(so)", AccessibilityAtspi::singleton().uniqueName(), path().utf8().data());
    542566}
    543567
    … …  
    547571    if (m_hyperlinkPath.isNull()) {
    548572        registerObject();
    549         m_hyperlinkPath = m_root.atspi().registerHyperlink(*this, { { const_cast<GDBusInterfaceInfo*>(&webkit_hyperlink_interface), &s_hyperlinkFunctions } });
    550     }
    551 
    552     return g_variant_new("(so)", m_root.atspi().uniqueName(), m_hyperlinkPath.utf8().data());
     573        m_hyperlinkPath = AccessibilityAtspi::singleton().registerHyperlink(*this, { { const_cast<GDBusInterfaceInfo*>(&webkit_hyperlink_interface), &s_hyperlinkFunctions } });
     574    }
     575
     576    return g_variant_new("(so)", AccessibilityAtspi::singleton().uniqueName(), m_hyperlinkPath.utf8().data());
    553577}
    554578
    … …  
    560584
    561585    m_parent = atspiParent;
    562     if (!m_coreObject || m_coreObject->accessibilityIsIgnored())
     586    if (!m_coreObject || m_coreObject->accessibilityIsIgnored() || !root())
    563587        return;
    564588
    565     m_root.atspi().parentChanged(*this);
     589    AccessibilityAtspi::singleton().parentChanged(*this);
    566590    if (m_parent) {
    567591        if (*m_parent)
    568592            m_parent.value()->childAdded(*this);
    569         else
    570             m_root.childAdded(*this);
     593        else if (m_root)
     594            m_root->childAdded(*this);
    571595    }
    572596}
    … …  
    590614GVariant* AccessibilityObjectAtspi::parentReference() const
    591615{
    592     if (!m_parent)
    593         return m_root.atspi().nullReference();
    594 
    595     if (!m_parent.value())
    596         return m_root.reference();
    597 
    598     return m_parent.value()->reference();
     616    if (m_parent) {
     617        if (*m_parent)
     618            return m_parent.value()->reference();
     619
     620        if (m_root)
     621            return m_root->reference();
     622    }
     623
     624    return AccessibilityAtspi::singleton().nullReference();
    599625}
    600626
    … …  
    12231249{
    12241250    RELEASE_ASSERT(!isMainThread());
    1225     g_variant_builder_add(builder, "(so)", m_root.atspi().uniqueName(), m_path.utf8().data());
    1226     g_variant_builder_add(builder, "@(so)", m_root.applicationReference());
     1251    g_variant_builder_add(builder, "(so)", AccessibilityAtspi::singleton().uniqueName(), m_path.utf8().data());
     1252    g_variant_builder_add(builder, "@(so)", AccessibilityAtspi::singleton().applicationReference());
    12271253    g_variant_builder_add(builder, "@(so)", parentReference());
    12281254
    … …  
    12561282        return;
    12571283
    1258     m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
     1284    AccessibilityAtspi::singleton().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
    12591285}
    12601286
    … …  
    12681294        return;
    12691295
    1270     m_root.atspi().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
     1296    AccessibilityAtspi::singleton().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
    12711297}
    12721298
    … …  
    12741300{
    12751301    RELEASE_ASSERT(isMainThread());
    1276     m_root.atspi().stateChanged(*this, name, value);
     1302    AccessibilityAtspi::singleton().stateChanged(*this, name, value);
    12771303}
    12781304
    … …  
    12801306{
    12811307    RELEASE_ASSERT(isMainThread());
    1282     m_root.atspi().loadEvent(*this, event);
     1308    AccessibilityAtspi::singleton().loadEvent(*this, event);
    12831309}
    12841310

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h

    r287565 r287876  
    3939class AccessibilityObjectAtspi final : public ThreadSafeRefCounted<AccessibilityObjectAtspi, WTF::DestructionThread::Main> {
    4040public:
    41     static Ref<AccessibilityObjectAtspi> create(AXCoreObject*, AccessibilityRootAtspi&);
     41    static Ref<AccessibilityObjectAtspi> create(AXCoreObject*, AccessibilityRootAtspi*);
    4242    ~AccessibilityObjectAtspi() = default;
    4343
    4444    bool registerObject();
     45    bool isTreeRegistered() const;
    4546
    4647    enum class Interface : uint16_t {
    … …  
    6061    const OptionSet<Interface>& interfaces() const { return m_interfaces; }
    6162
    62     const AccessibilityRootAtspi& root() const { return m_root; }
    6363    void setParent(std::optional<AccessibilityObjectAtspi*>);
    6464    WEBCORE_EXPORT std::optional<AccessibilityObjectAtspi*> parent() const;
    … …  
    159159
    160160private:
    161     explicit AccessibilityObjectAtspi(AXCoreObject*, AccessibilityRootAtspi&);
     161    AccessibilityObjectAtspi(AXCoreObject*, AccessibilityRootAtspi*);
     162
     163    AccessibilityRootAtspi* root();
    162164
    163165    Vector<RefPtr<AccessibilityObjectAtspi>> wrapperVector(const Vector<RefPtr<AXCoreObject>>&) const;
    … …  
    242244    AXCoreObject* m_coreObject { nullptr };
    243245    OptionSet<Interface> m_interfaces;
    244     AccessibilityRootAtspi& m_root;
     246    AccessibilityRootAtspi* m_root { nullptr };
    245247    std::optional<AccessibilityObjectAtspi*> m_parent;
    246248    Atomic<bool> m_isRegistered { false };
    … …  
    250252    mutable std::atomic<bool> m_hasListMarkerAtStart;
    251253    mutable int m_indexInParent { -1 };
    252     mutable Lock m_rootLock;
    253254};
    254255

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectComponentAtspi.cpp

    r286767 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424#include "AXIsolatedObject.h"
     25#include "AccessibilityAtspi.h"
    2526#include "AccessibilityAtspiEnums.h"
    2627#include "AccessibilityObjectInterface.h"
    … …  
    4849            g_variant_get(parameters, "(iiu)", &x, &y, &coordinateType);
    4950            auto* wrapper = atspiObject->hitTest({ x, y }, coordinateType);
    50             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference()));
     51            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->reference() : AccessibilityAtspi::singleton().nullReference()));
    5152        } else if (!g_strcmp0(methodName, "GetExtents")) {
    5253            uint32_t coordinateType;

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectHyperlinkAtspi.cpp

    r286767 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
    25 #include "AccessibilityRootAtspi.h"
     25#include "AccessibilityAtspi.h"
    2626#include <gio/gio.h>
    2727#include <wtf/URL.h>
    … …  
    4040            int index;
    4141            g_variant_get(parameters, "(i)", &index);
    42             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", !index ? atspiObject->reference() : atspiObject->m_root.atspi().nullReference()));
     42            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", !index ? atspiObject->reference() : AccessibilityAtspi::singleton().nullReference()));
    4343        } else if (!g_strcmp0(methodName, "GetURI")) {
    4444            int index;

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectHypertextAtspi.cpp

    r286767 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
    25 #include "AccessibilityRootAtspi.h"
     25#include "AccessibilityAtspi.h"
    2626#include <gio/gio.h>
    2727#include <wtf/unicode/CharacterNames.h>
    … …  
    4242            g_variant_get(parameters, "(i)", &index);
    4343            auto* wrapper = index >= 0 ? atspiObject->hyperlink(index) : nullptr;
    44             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->hyperlinkReference() : atspiObject->m_root.atspi().nullReference()));
     44            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", wrapper ? wrapper->hyperlinkReference() : AccessibilityAtspi::singleton().nullReference()));
    4545        } else if (!g_strcmp0(methodName, "GetLinkIndex")) {
    4646            int offset;

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectSelectionAtspi.cpp

    r287455 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
    25 #include "AccessibilityRootAtspi.h"
     25#include "AccessibilityAtspi.h"
    2626
    2727namespace WebCore {
    … …  
    3838            g_variant_get(parameters, "(i)", &index);
    3939            auto* child = index >= 0 ? atspiObject->selectedChild(index) : nullptr;
    40             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", child ? child->reference() : atspiObject->m_root.atspi().nullReference()));
     40            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", child ? child->reference() : AccessibilityAtspi::singleton().nullReference()));
    4141        } else if (!g_strcmp0(methodName, "SelectChild")) {
    4242            int index;
    … …  
    234234
    235235    m_lastSelectionChangedTime = sourceTime;
    236     m_root.atspi().selectionChanged(*this);
     236    AccessibilityAtspi::singleton().selectionChanged(*this);
    237237}
    238238

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectTableAtspi.cpp

    r286767 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
    25 #include "AccessibilityRootAtspi.h"
     25#include "AccessibilityAtspi.h"
    2626#include "HTMLTableCaptionElement.h"
    2727#include "HTMLTableElement.h"
    … …  
    4343            g_variant_get(parameters, "(ii)", &row, &column);
    4444            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->m_root.atspi().nullReference()));
     45            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", cell ? cell->reference() : AccessibilityAtspi::singleton().nullReference()));
    4646        } else if (!g_strcmp0(methodName, "GetIndexAt")) {
    4747            int row, column;
    … …  
    7676            g_variant_get(parameters, "(i)", &row);
    7777            auto* header = row >= 0 ? atspiObject->rowHeader(row) : nullptr;
    78             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
     78            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : AccessibilityAtspi::singleton().nullReference()));
    7979        } else if (!g_strcmp0(methodName, "GetColumnHeader")) {
    8080            int column;
    8181            g_variant_get(parameters, "(i)", &column);
    8282            auto* header = column >= 0 ? atspiObject->columnHeader(column) : nullptr;
    83             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : atspiObject->m_root.atspi().nullReference()));
     83            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", header ? header->reference() : AccessibilityAtspi::singleton().nullReference()));
    8484        } else if (!g_strcmp0(methodName, "GetRowColumnExtentsAtIndex")) {
    8585            int index;
    … …  
    119119        if (!g_strcmp0(propertyName, "Caption")) {
    120120            auto* caption = atspiObject->tableCaption();
    121             return caption ? caption->reference() : atspiObject->m_root.atspi().nullReference();
     121            return caption ? caption->reference() : AccessibilityAtspi::singleton().nullReference();
    122122        }
    123123        if (!g_strcmp0(propertyName, "Summary"))
    124             return atspiObject->m_root.atspi().nullReference();
     124            return AccessibilityAtspi::singleton().nullReference();
    125125        if (!g_strcmp0(propertyName, "NSelectedRows"))
    126126            return g_variant_new_int32(0);

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectTableCellAtspi.cpp

    r286767 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
     25#include "AccessibilityAtspi.h"
    2526#include "AccessibilityAtspiEnums.h"
    26 #include "AccessibilityRootAtspi.h"
    2727#include <gio/gio.h>
    2828
    … …  
    6868            auto* axObject = atspiObject->m_axObject;
    6969            if (!axObject || !axObject->isTableCell())
    70                 return atspiObject->m_root.atspi().nullReference();
     70                return AccessibilityAtspi::singleton().nullReference();
    7171
    7272            AccessibilityObjectAtspi* wrapper = atspiObject.ptr();
    … …  
    8181                    break;
    8282            }
    83             return wrapper ? wrapper->reference() : atspiObject->m_root.atspi().nullReference();
     83            return wrapper ? wrapper->reference() : AccessibilityAtspi::singleton().nullReference();
    8484        }
    8585

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectTextAtspi.cpp

    r287552 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424#include "AXObjectCache.h"
     25#include "AccessibilityAtspi.h"
    2526#include "AccessibilityAtspiEnums.h"
    2627#include "AccessibilityObject.h"
    2728#include "AccessibilityObjectInterface.h"
    28 #include "AccessibilityRootAtspi.h"
    2929#include "Editing.h"
    3030#include "PlatformScreen.h"
    … …  
    382382    auto utf8InsertedText = insertedText.utf8();
    383383    auto insertedTextLength = g_utf8_strlen(utf8InsertedText.data(), -1);
    384     m_root.atspi().textChanged(*this, "insert", WTFMove(utf8InsertedText), offset - insertedTextLength, insertedTextLength);
     384    AccessibilityAtspi::singleton().textChanged(*this, "insert", WTFMove(utf8InsertedText), offset - insertedTextLength, insertedTextLength);
    385385}
    386386
    … …  
    398398    auto utf8DeletedText = deletedText.utf8();
    399399    auto deletedTextLength = g_utf8_strlen(utf8DeletedText.data(), -1);
    400     m_root.atspi().textChanged(*this, "delete", WTFMove(utf8DeletedText), offset, deletedTextLength);
     400    AccessibilityAtspi::singleton().textChanged(*this, "delete", WTFMove(utf8DeletedText), offset, deletedTextLength);
    401401}
    402402
    … …  
    799799    auto caretOffset = UTF16OffsetToUTF8(mapping, bounds.y());
    800800    if (caretOffset <= length)
    801         m_root.atspi().textCaretMoved(*this, caretOffset);
     801        AccessibilityAtspi::singleton().textCaretMoved(*this, caretOffset);
    802802
    803803    if (selection.isRange())
    804         m_root.atspi().textSelectionChanged(*this);
     804        AccessibilityAtspi::singleton().textSelectionChanged(*this);
    805805}
    806806
    … …  
    991991        return;
    992992
    993     m_root.atspi().textAttributesChanged(*this);
     993    AccessibilityAtspi::singleton().textAttributesChanged(*this);
    994994}
    995995

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp

    r287070 r287876  
    2323#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    2424
     25#include "AccessibilityAtspi.h"
    2526#include "AccessibilityObject.h"
    26 #include "AccessibilityRootAtspi.h"
    2727#include <gio/gio.h>
    2828
    … …  
    135135{
    136136    RELEASE_ASSERT(isMainThread());
    137     m_root.atspi().valueChanged(*this, value);
     137    AccessibilityAtspi::singleton().valueChanged(*this, value);
    138138}
    139139

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp

    r287456 r287876  
    3535namespace WebCore {
    3636
    37 Ref<AccessibilityRootAtspi> AccessibilityRootAtspi::create(Page& page, AccessibilityAtspi& atspi)
    38 {
    39     return adoptRef(*new AccessibilityRootAtspi(page, atspi));
    40 }
    41 
    42 AccessibilityRootAtspi::AccessibilityRootAtspi(Page& page, AccessibilityAtspi& atspi)
    43     : m_atspi(atspi)
    44     , m_page(page)
     37Ref<AccessibilityRootAtspi> AccessibilityRootAtspi::create(Page& page)
     38{
     39    return adoptRef(*new AccessibilityRootAtspi(page));
     40}
     41
     42AccessibilityRootAtspi::AccessibilityRootAtspi(Page& page)
     43    : m_page(page)
    4544{
    4645    RELEASE_ASSERT(isMainThread());
    … …  
    9392                }
    9493            }
    95             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", rootObject.atspi().nullReference()));
     94            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@(so))", AccessibilityAtspi::singleton().nullReference()));
    9695        } else if (!g_strcmp0(methodName, "GetChildren")) {
    9796            GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("a(so)"));
    … …  
    175174    interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_socket_interface), &s_socketFunctions });
    176175    interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_component_interface), &s_componentFunctions });
    177     m_atspi.registerRoot(*this, WTFMove(interfaces), WTFMove(completionHandler));
     176    AccessibilityAtspi::singleton().registerRoot(*this, WTFMove(interfaces), WTFMove(completionHandler));
    178177}
    179178
    … …  
    181180{
    182181    RELEASE_ASSERT(isMainThread());
    183     m_atspi.unregisterRoot(*this);
     182    AccessibilityAtspi::singleton().unregisterRoot(*this);
    184183
    185184    if (m_page)
    … …  
    223222    m_parentUniqueName = parentUniqueName;
    224223    m_parentPath = parentPath;
    225     m_atspi.parentChanged(*this);
    226     if (!m_isTreeRegistered.load() && m_atspi.hasEventListeners())
     224    AccessibilityAtspi::singleton().parentChanged(*this);
     225    if (!m_isTreeRegistered.load() && AccessibilityAtspi::singleton().hasEventListeners())
    227226        registerTree();
    228227}
    … …  
    232231    RELEASE_ASSERT(!isMainThread());
    233232    if (m_parentUniqueName.isNull())
    234         return m_atspi.nullReference();
     233        return AccessibilityAtspi::singleton().nullReference();
    235234    return g_variant_new("(so)", m_parentUniqueName.utf8().data(), "/org/a11y/atspi/accessible/root");
    236235}
    … …  
    239238{
    240239    RELEASE_ASSERT(!isMainThread());
    241     return g_variant_new("(so)", m_atspi.uniqueName(), m_path.utf8().data());
     240    return g_variant_new("(so)", AccessibilityAtspi::singleton().uniqueName(), m_path.utf8().data());
    242241}
    243242
    … …  
    269268void AccessibilityRootAtspi::childAdded(AccessibilityObjectAtspi& child)
    270269{
    271     m_atspi.childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
     270    AccessibilityAtspi::singleton().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Added);
    272271}
    273272
    274273void AccessibilityRootAtspi::childRemoved(AccessibilityObjectAtspi& child)
    275274{
    276     m_atspi.childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
     275    AccessibilityAtspi::singleton().childrenChanged(*this, child, AccessibilityAtspi::ChildrenChanged::Removed);
    277276}
    278277
    … …  
    280279{
    281280    RELEASE_ASSERT(!isMainThread());
    282     g_variant_builder_add(builder, "(so)", m_atspi.uniqueName(), m_path.utf8().data());
     281    g_variant_builder_add(builder, "(so)", AccessibilityAtspi::singleton().uniqueName(), m_path.utf8().data());
    283282    g_variant_builder_add(builder, "@(so)", applicationReference());
    284283    g_variant_builder_add(builder, "@(so)", parentReference());

  • trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.h

    r287565 r287876  
    2121
    2222#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
    23 #include "AccessibilityAtspi.h"
    2423#include "IntRect.h"
    2524#include <wtf/Atomics.h>
    … …  
    2827#include <wtf/WeakPtr.h>
    2928
     29typedef struct _GDBusInterfaceVTable GDBusInterfaceVTable;
    3030typedef struct _GVariant GVariant;
    3131
    … …  
    3737    WTF_MAKE_FAST_ALLOCATED;
    3838public:
    39     static Ref<AccessibilityRootAtspi> create(Page&, AccessibilityAtspi&);
     39    static Ref<AccessibilityRootAtspi> create(Page&);
    4040    ~AccessibilityRootAtspi() = default;
    4141
    … …  
    5050    GVariant* parentReference() const;
    5151    GVariant* applicationReference() const;
    52     AccessibilityAtspi& atspi() const { return m_atspi; }
    5352    AccessibilityObjectAtspi* child() const;
    5453    void childAdded(AccessibilityObjectAtspi&);
    … …  
    5857
    5958private:
    60     AccessibilityRootAtspi(Page&, AccessibilityAtspi&);
     59    explicit AccessibilityRootAtspi(Page&);
    6160
    6261    void embedded(const char* parentUniqueName, const char* parentPath);
    … …  
    6766    static GDBusInterfaceVTable s_componentFunctions;
    6867
    69     AccessibilityAtspi& m_atspi;
    7068    WeakPtr<Page> m_page;
    7169    String m_path;

  • trunk/Source/WebKit/ChangeLog

    r287866 r287876  
     12022-01-11  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Web process crashes in some sites having SVG images
     4        https://bugs.webkit.org/show_bug.cgi?id=234737
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        Use AccessibilityAtspi::singleton().
     9
     10        * WebProcess/WebPage/gtk/WebPageGtk.cpp:
     11        (WebKit::WebPage::platformInitialize):
     12        * WebProcess/WebProcess.h:
     13        (WebKit::WebProcess::accessibilityAtspi const): Deleted.
     14        * WebProcess/glib/WebProcessGLib.cpp:
     15        (WebKit::WebProcess::platformInitializeWebProcess):
     16
    1172022-01-10  Wenson Hsieh  <wenson_hsieh@apple.com>
    218

  • trunk/Source/WebKit/WebProcess/WebPage/gtk/WebPageGtk.cpp

    r287014 r287876  
    7171#else
    7272    if (auto* page = corePage()) {
    73         m_accessibilityRootObject = AccessibilityRootAtspi::create(*page, WebProcess::singleton().accessibilityAtspi());
     73        m_accessibilityRootObject = AccessibilityRootAtspi::create(*page);
    7474        m_accessibilityRootObject->registerObject([&](const String& plugID) {
    7575            send(Messages::WebPageProxy::BindAccessibilityTree(plugID));

  • trunk/Source/WebKit/WebProcess/WebProcess.h

    r287808 r287876  
    7474#if HAVE(MEDIA_ACCESSIBILITY_FRAMEWORK)
    7575#include <WebCore/CaptionUserPreferences.h>
    76 #endif
    77 
    78 #if USE(ATSPI)
    79 #include <WebCore/AccessibilityAtspi.h>
    8076#endif
    8177
    … …  
    400396#endif
    401397
    402 #if USE(ATSPI)
    403     WebCore::AccessibilityAtspi& accessibilityAtspi() const { return *m_accessibility; }
    404 #endif
    405 
    406398    bool isCaptivePortalModeEnabled() const { return m_isCaptivePortalModeEnabled; }
    407399
    … …  
    779771    std::unique_ptr<SpeechRecognitionRealtimeMediaSourceManager> m_speechRecognitionRealtimeMediaSourceManager;
    780772#endif
    781 
    782 #if USE(ATSPI)
    783     std::unique_ptr<WebCore::AccessibilityAtspi> m_accessibility;
    784 #endif
    785773};
    786774

  • trunk/Source/WebKit/WebProcess/glib/WebProcessGLib.cpp

    r284525 r287876  
    5858#if OS(LINUX)
    5959#include <wtf/linux/RealTimeThreads.h>
     60#endif
     61
     62#if USE(ATSPI)
     63#include <WebCore/AccessibilityAtspi.h>
    6064#endif
    6165
    … …  
    130134
    131135#if USE(ATSPI)
    132     m_accessibility = makeUnique<AccessibilityAtspi>(parameters.accessibilityBusAddress);
     136    AccessibilityAtspi::singleton().connect(parameters.accessibilityBusAddress);
    133137#endif
    134138}

  • trunk/Tools/ChangeLog

    r287872 r287876  
     12022-01-11  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][a11y] Web process crashes in some sites having SVG images
     4        https://bugs.webkit.org/show_bug.cgi?id=234737
     5
     6        Reviewed by Adrian Perez de Castro.
     7
     8        Use AccessibilityAtspi::singleton().
     9
     10        * WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp:
     11        (WTR::AccessibilityController::axRunLoop):
     12        * WebKitTestRunner/InjectedBundle/atspi/AccessibilityNotificationHandler.cpp:
     13        (WTR::AccessibilityNotificationHandler::AccessibilityNotificationHandler):
     14        (WTR::AccessibilityNotificationHandler::~AccessibilityNotificationHandler):
     15
    1162022-01-11  Carlos Garcia Campos  <cgarcia@igalia.com>
    217

  • trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityControllerAtspi.cpp

    r287872 r287876  
    139139        auto* element = static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page));
    140140        RELEASE_ASSERT(element);
    141         m_axRunLoop = &element->root().atspi().runLoop();
     141        m_axRunLoop = &WebCore::AccessibilityAtspi::singleton().runLoop();
    142142    }
    143143

  • trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityNotificationHandler.cpp

    r287387 r287876  
    3434#include <JavaScriptCore/OpaqueJSString.h>
    3535#include <WebCore/AccessibilityObjectAtspi.h>
    36 #include <WebCore/AccessibilityRootAtspi.h>
    3736#include <WebKit/WKBundleFrame.h>
    3837#include <WebKit/WKBundlePage.h>
    … …  
    4544    , m_element(element)
    4645{
    47     WKBundlePageRef page = InjectedBundle::singleton().page()->page();
    48     WKBundleFrameRef mainFrame = WKBundlePageGetMainFrame(page);
     46    WKBundleFrameRef mainFrame = WKBundlePageGetMainFrame(InjectedBundle::singleton().page()->page());
    4947    JSContextRef jsContext = WKBundleFrameGetJavaScriptContext(mainFrame);
    5048    JSValueProtect(jsContext, m_callback);
    5149
    52     auto& atspi = m_element ? m_element->root().atspi() : static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page))->root().atspi();
    53     atspi.addNotificationObserver(this, [this](WebCore::AccessibilityObjectAtspi& element, const char* notificationName, WebCore::AccessibilityAtspi::NotificationObserverParameter parameter) {
     50    WebCore::AccessibilityAtspi::singleton().addNotificationObserver(this, [this](WebCore::AccessibilityObjectAtspi& element, const char* notificationName, WebCore::AccessibilityAtspi::NotificationObserverParameter parameter) {
    5451        if (m_element && m_element.get() != &element)
    5552            return;
    … …  
    9693AccessibilityNotificationHandler::~AccessibilityNotificationHandler()
    9794{
    98     WKBundlePageRef page = InjectedBundle::singleton().page()->page();
    99     auto& atspi = m_element ? m_element->root().atspi() : static_cast<WebCore::AccessibilityObjectAtspi*>(WKAccessibilityRootObject(page))->root().atspi();
    100     atspi.removeNotificationObserver(this);
     95    WebCore::AccessibilityAtspi::singleton().removeNotificationObserver(this);
    10196
    102     WKBundleFrameRef mainFrame = WKBundlePageGetMainFrame(page);
     97    WKBundleFrameRef mainFrame = WKBundlePageGetMainFrame(InjectedBundle::singleton().page()->page());
    10398    JSContextRef jsContext = WKBundleFrameGetJavaScriptContext(mainFrame);
    10499    JSValueUnprotect(jsContext, m_callback);
Note: See TracChangeset for help on using the changeset viewer.