Changeset 243970 in webkit


Ignore:
Timestamp:
Apr 8, 2019 1:11:19 AM (5 years ago)
Author:
Carlos Garcia Campos
Message:

[ATK] Cleanup accessible wrapper base class
https://bugs.webkit.org/show_bug.cgi?id=196601

Reviewed by Mario Sanchez Prada.

Cleanups:

  • Rename WebKitAccessibleWrapperAtk cpp and header as WebKitAccessible for consistency with the class name.
  • Use WEBKIT_DEFINE_TYPE instead of custom type registration. This ensures that all CStrings used in private struct are no longer leaked.
  • Move core object pointer to the private struct.
  • Remove confusing core() function and simply get the core object from the private struct.
  • Use nullptr instead of 0 and other coding style issues.
  • Rename cacheAndReturnAtkProperty as webkitAccessibleCacheAndReturnAtkProperty and use WebKitAccessible as instance parameter.
  • Make webkitAccessibleGetAccessibilityObject() return a reference, since we use a fallback object on detach it never returns nullptr.
  • Move objectFocusedAndCaretOffsetUnignored() to WebKitAccessibleUtil.
  • SourcesGTK.txt:
  • accessibility/atk/AXObjectCacheAtk.cpp:
  • accessibility/atk/WebKitAccessible.cpp: Renamed from Source/WebCore/accessibility/atk/WebKitAccessibleWrapperAtk.cpp.

(webkitAccessibleGetName):
(webkitAccessibleGetDescription):
(setAtkRelationSetFromCoreObject):
(isRootObject):
(webkitAccessibleGetParent):
(webkitAccessibleGetNChildren):
(webkitAccessibleRefChild):
(webkitAccessibleGetIndexInParent):
(webkitAccessibleGetAttributes):
(atkRole):
(webkitAccessibleGetRole):
(webkitAccessibleRefStateSet):
(webkitAccessibleRefRelationSet):
(webkitAccessibleInit):
(webkitAccessibleGetObjectLocale):
(webkit_accessible_class_init):
(interfaceMaskFromObject):
(uniqueAccessibilityTypeName):
(accessibilityTypeFromObject):
(webkitAccessibleNew):
(webkitAccessibleGetAccessibilityObject):
(webkitAccessibleDetach):
(webkitAccessibleIsDetached):
(webkitAccessibleCacheAndReturnAtkProperty):

  • accessibility/atk/WebKitAccessible.h: Renamed from Source/WebCore/accessibility/atk/WebKitAccessibleWrapperAtk.h.
  • accessibility/atk/WebKitAccessibleHyperlink.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceAction.cpp:

(core):
(webkitAccessibleActionGetKeybinding):
(webkitAccessibleActionGetName):

  • accessibility/atk/WebKitAccessibleInterfaceComponent.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceDocument.cpp:

(core):
(documentAttributeValue):

  • accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceImage.cpp:

(core):
(webkitAccessibleImageGetImageDescription):

  • accessibility/atk/WebKitAccessibleInterfaceSelection.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceTable.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceText.cpp:

(core):

  • accessibility/atk/WebKitAccessibleInterfaceValue.cpp:

(core):

  • accessibility/atk/WebKitAccessibleUtil.cpp:

(objectFocusedAndCaretOffsetUnignored):

  • accessibility/atk/WebKitAccessibleUtil.h:
  • editing/atk/FrameSelectionAtk.cpp:
Location:
trunk/Source/WebCore
Files:
18 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r243962 r243970  
     12019-04-08  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [ATK] Cleanup accessible wrapper base class
     4        https://bugs.webkit.org/show_bug.cgi?id=196601
     5
     6        Reviewed by Mario Sanchez Prada.
     7
     8        Cleanups:
     9
     10         - Rename WebKitAccessibleWrapperAtk cpp and header as WebKitAccessible for consistency with the class name.
     11         - Use WEBKIT_DEFINE_TYPE instead of custom type registration. This ensures that all CStrings used in private
     12           struct are no longer leaked.
     13         - Move core object pointer to the private struct.
     14         - Remove confusing core() function and simply get the core object from the private struct.
     15         - Use nullptr instead of 0 and other coding style issues.
     16         - Rename cacheAndReturnAtkProperty as webkitAccessibleCacheAndReturnAtkProperty and use WebKitAccessible as
     17           instance parameter.
     18         - Make webkitAccessibleGetAccessibilityObject() return a reference, since we use a fallback object on detach it
     19           never returns nullptr.
     20         - Move objectFocusedAndCaretOffsetUnignored() to WebKitAccessibleUtil.
     21
     22        * SourcesGTK.txt:
     23        * accessibility/atk/AXObjectCacheAtk.cpp:
     24        * accessibility/atk/WebKitAccessible.cpp: Renamed from Source/WebCore/accessibility/atk/WebKitAccessibleWrapperAtk.cpp.
     25        (webkitAccessibleGetName):
     26        (webkitAccessibleGetDescription):
     27        (setAtkRelationSetFromCoreObject):
     28        (isRootObject):
     29        (webkitAccessibleGetParent):
     30        (webkitAccessibleGetNChildren):
     31        (webkitAccessibleRefChild):
     32        (webkitAccessibleGetIndexInParent):
     33        (webkitAccessibleGetAttributes):
     34        (atkRole):
     35        (webkitAccessibleGetRole):
     36        (webkitAccessibleRefStateSet):
     37        (webkitAccessibleRefRelationSet):
     38        (webkitAccessibleInit):
     39        (webkitAccessibleGetObjectLocale):
     40        (webkit_accessible_class_init):
     41        (interfaceMaskFromObject):
     42        (uniqueAccessibilityTypeName):
     43        (accessibilityTypeFromObject):
     44        (webkitAccessibleNew):
     45        (webkitAccessibleGetAccessibilityObject):
     46        (webkitAccessibleDetach):
     47        (webkitAccessibleIsDetached):
     48        (webkitAccessibleCacheAndReturnAtkProperty):
     49        * accessibility/atk/WebKitAccessible.h: Renamed from Source/WebCore/accessibility/atk/WebKitAccessibleWrapperAtk.h.
     50        * accessibility/atk/WebKitAccessibleHyperlink.cpp:
     51        (core):
     52        * accessibility/atk/WebKitAccessibleInterfaceAction.cpp:
     53        (core):
     54        (webkitAccessibleActionGetKeybinding):
     55        (webkitAccessibleActionGetName):
     56        * accessibility/atk/WebKitAccessibleInterfaceComponent.cpp:
     57        (core):
     58        * accessibility/atk/WebKitAccessibleInterfaceDocument.cpp:
     59        (core):
     60        (documentAttributeValue):
     61        * accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp:
     62        (core):
     63        * accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp:
     64        (core):
     65        * accessibility/atk/WebKitAccessibleInterfaceImage.cpp:
     66        (core):
     67        (webkitAccessibleImageGetImageDescription):
     68        * accessibility/atk/WebKitAccessibleInterfaceSelection.cpp:
     69        (core):
     70        * accessibility/atk/WebKitAccessibleInterfaceTable.cpp:
     71        (core):
     72        * accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp:
     73        (core):
     74        * accessibility/atk/WebKitAccessibleInterfaceText.cpp:
     75        (core):
     76        * accessibility/atk/WebKitAccessibleInterfaceValue.cpp:
     77        (core):
     78        * accessibility/atk/WebKitAccessibleUtil.cpp:
     79        (objectFocusedAndCaretOffsetUnignored):
     80        * accessibility/atk/WebKitAccessibleUtil.h:
     81        * editing/atk/FrameSelectionAtk.cpp:
     82
    1832019-04-06  Antti Koivisto  <antti@apple.com>
    284
  • trunk/Source/WebCore/SourcesGTK.txt

    r243409 r243970  
    2424accessibility/atk/AXObjectCacheAtk.cpp
    2525accessibility/atk/AccessibilityObjectAtk.cpp
     26accessibility/atk/WebKitAccessible.cpp
    2627accessibility/atk/WebKitAccessibleHyperlink.cpp
    2728accessibility/atk/WebKitAccessibleInterfaceAction.cpp @no-unify
     
    3839accessibility/atk/WebKitAccessibleInterfaceValue.cpp
    3940accessibility/atk/WebKitAccessibleUtil.cpp
    40 accessibility/atk/WebKitAccessibleWrapperAtk.cpp
    4141
    4242editing/atk/FrameSelectionAtk.cpp
  • trunk/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp

    r243928 r243970  
    3030#include "Range.h"
    3131#include "TextIterator.h"
    32 #include "WebKitAccessibleWrapperAtk.h"
     32#include "WebKitAccessible.h"
    3333#include <wtf/NeverDestroyed.h>
    3434#include <wtf/glib/GRefPtr.h>
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessible.cpp

    r243969 r243970  
    22 * Copyright (C) 2008 Nuanti Ltd.
    33 * Copyright (C) 2009 Jan Alonzo
    4  * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
     4 * Copyright (C) 2009, 2010, 2011, 2012, 2019 Igalia S.L.
    55 * Copyright (C) 2013 Samsung Electronics
    66 *
     
    3131
    3232#include "config.h"
    33 #include "WebKitAccessibleWrapperAtk.h"
     33#include "WebKitAccessible.h"
    3434
    3535#if HAVE(ACCESSIBILITY)
     
    7070#include "WebKitAccessibleUtil.h"
    7171#include <glib/gprintf.h>
     72#include <wtf/glib/WTFGType.h>
    7273#include <wtf/text/CString.h>
    7374
     
    7576
    7677struct _WebKitAccessiblePrivate {
     78    AccessibilityObject* object;
     79
    7780    // Cached data for AtkObject.
    7881    CString accessibleName;
     
    9396};
    9497
    95 #define WEBKIT_ACCESSIBLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessiblePrivate))
     98WEBKIT_DEFINE_TYPE(WebKitAccessible, webkit_accessible, ATK_TYPE_OBJECT)
    9699
    97100static AccessibilityObject* fallbackObject()
     
    101104}
    102105
    103 static AccessibilityObject* core(AtkObject* object)
    104 {
    105     if (!WEBKIT_IS_ACCESSIBLE(object))
    106         return 0;
    107 
    108     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(object));
    109 }
    110 
    111106static const gchar* webkitAccessibleGetName(AtkObject* object)
    112107{
    113     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    114     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
     108    auto* accessible = WEBKIT_ACCESSIBLE(object);
     109    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    115110
    116111    Vector<AccessibilityText> textOrder;
    117     core(object)->accessibilityText(textOrder);
     112    accessible->priv->object->accessibilityText(textOrder);
    118113
    119114    for (const auto& text : textOrder) {
     
    128123        // does not expose via the AtkObject description.
    129124        if (text.textSource != AccessibilityTextSource::Help && text.textSource != AccessibilityTextSource::Summary)
    130             return cacheAndReturnAtkProperty(object, AtkCachedAccessibleName, text.text);
    131     }
    132 
    133     return cacheAndReturnAtkProperty(object, AtkCachedAccessibleName, "");
     125            return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleName, text.text.utf8());
     126    }
     127
     128    return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleName, "");
    134129}
    135130
    136131static const gchar* webkitAccessibleGetDescription(AtkObject* object)
    137132{
    138     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    139     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
     133    auto* accessible = WEBKIT_ACCESSIBLE(object);
     134    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    140135
    141136    Vector<AccessibilityText> textOrder;
    142     core(object)->accessibilityText(textOrder);
     137    accessible->priv->object->accessibilityText(textOrder);
    143138
    144139    bool nameTextAvailable = false;
     
    148143        // does not expose via the AtkObject name.
    149144        if (text.textSource == AccessibilityTextSource::Help || text.textSource == AccessibilityTextSource::Summary)
    150             return cacheAndReturnAtkProperty(object, AtkCachedAccessibleDescription, text.text);
     145            return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, text.text.utf8());
    151146
    152147        // If there is no other text alternative, the title tag contents will have been
    153148        // used for the AtkObject name. We don't want to duplicate it here.
    154149        if (text.textSource == AccessibilityTextSource::TitleTag && nameTextAvailable)
    155             return cacheAndReturnAtkProperty(object, AtkCachedAccessibleDescription, text.text);
     150            return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, text.text.utf8());
    156151
    157152        nameTextAvailable = true;
    158153    }
    159154
    160     return cacheAndReturnAtkProperty(object, AtkCachedAccessibleDescription, "");
     155    return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedAccessibleDescription, "");
    161156}
    162157
     
    193188            }
    194189        }
    195     } else if (AccessibilityObject* control = coreObject->correspondingControlForLabelElement()) {
     190    } else if (AccessibilityObject* control = coreObject->correspondingControlForLabelElement())
    196191        atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABEL_FOR, ATK_OBJECT(control->wrapper()));
    197     } else {
     192    else {
    198193        AccessibilityObject::AccessibilityChildrenVector ariaLabelledByElements;
    199194        coreObject->ariaLabelledByElements(ariaLabelledByElements);
     
    295290}
    296291
    297 static gpointer webkitAccessibleParentClass = nullptr;
    298 
    299292static bool isRootObject(AccessibilityObject* coreObject)
    300293{
     
    305298
    306299    AccessibilityObject* firstChild = coreObject->firstChild();
    307     if (!firstChild || !firstChild->isWebArea())
    308         return false;
    309 
    310     return true;
    311 }
    312 
    313 static AtkObject* atkParentOfRootObject(AtkObject* object)
    314 {
    315     AccessibilityObject* coreObject = core(object);
    316     AccessibilityObject* coreParent = coreObject->parentObjectUnignored();
    317 
    318     // The top level object claims to not have a parent. This makes it
    319     // impossible for assistive technologies to ascend the accessible
    320     // hierarchy all the way to the application. (Bug 30489)
    321     if (!coreParent && isRootObject(coreObject)) {
    322         Document* document = coreObject->document();
    323         if (!document)
    324             return 0;
    325     }
    326 
    327     return coreParent ? ATK_OBJECT(coreParent->wrapper()) : nullptr;
     300    return firstChild && firstChild->isWebArea();
    328301}
    329302
    330303static AtkObject* webkitAccessibleGetParent(AtkObject* object)
    331304{
    332     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    333     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
     305    auto* accessible = WEBKIT_ACCESSIBLE(object);
     306    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    334307
    335308    // Check first if the parent has been already set.
    336     AtkObject* accessibleParent = ATK_OBJECT_CLASS(webkitAccessibleParentClass)->get_parent(object);
     309    AtkObject* accessibleParent = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->get_parent(object);
    337310    if (accessibleParent)
    338311        return accessibleParent;
    339312
    340313    // Parent not set yet, so try to find it in the hierarchy.
    341     AccessibilityObject* coreObject = core(object);
    342     if (!coreObject)
    343         return 0;
    344 
    345     AccessibilityObject* coreParent = coreObject->parentObjectUnignored();
    346 
    347     if (!coreParent && isRootObject(coreObject))
    348         return atkParentOfRootObject(object);
     314    auto* coreObject = accessible->priv->object;
     315    auto* coreParent = coreObject->parentObjectUnignored();
     316    if (!coreParent && isRootObject(coreObject)) {
     317        // The top level object claims to not have a parent. This makes it
     318        // impossible for assistive technologies to ascend the accessible
     319        // hierarchy all the way to the application. (Bug 30489)
     320        if (!coreObject->document())
     321            return nullptr;
     322    }
    349323
    350324    return coreParent ? ATK_OBJECT(coreParent->wrapper()) : nullptr;
     
    353327static gint webkitAccessibleGetNChildren(AtkObject* object)
    354328{
    355     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    356     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
    357 
    358     AccessibilityObject* coreObject = core(object);
    359 
    360     return coreObject->children().size();
     329    auto* accessible = WEBKIT_ACCESSIBLE(object);
     330    returnValIfWebKitAccessibleIsInvalid(accessible, 0);
     331
     332    return accessible->priv->object->children().size();
    361333}
    362334
    363335static AtkObject* webkitAccessibleRefChild(AtkObject* object, gint index)
    364336{
    365     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    366     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
     337    auto* accessible = WEBKIT_ACCESSIBLE(object);
     338    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    367339
    368340    if (index < 0)
    369         return 0;
    370 
    371     AccessibilityObject* coreObject = core(object);
    372     AccessibilityObject* coreChild = nullptr;
    373 
    374     const AccessibilityObject::AccessibilityChildrenVector& children = coreObject->children();
     341        return nullptr;
     342
     343    const auto& children = accessible->priv->object->children();
    375344    if (static_cast<size_t>(index) >= children.size())
    376         return 0;
    377     coreChild = children.at(index).get();
    378 
     345        return nullptr;
     346
     347    auto& coreChild = children[index];
    379348    if (!coreChild)
    380         return 0;
     349        return nullptr;
    381350
    382351    auto* child = ATK_OBJECT(coreChild->wrapper());
     
    389358static gint webkitAccessibleGetIndexInParent(AtkObject* object)
    390359{
    391     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), -1);
    392     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), -1);
    393 
    394     AccessibilityObject* coreObject = core(object);
    395     AccessibilityObject* parent = coreObject->parentObjectUnignored();
    396 
     360    auto* accessible = WEBKIT_ACCESSIBLE(object);
     361    returnValIfWebKitAccessibleIsInvalid(accessible, -1);
     362
     363    auto* coreObject = accessible->priv->object;
     364    auto* parent = coreObject->parentObjectUnignored();
    397365    if (!parent && isRootObject(coreObject)) {
    398         AtkObject* atkParent = atkParentOfRootObject(object);
     366        if (!coreObject->document())
     367            return -1;
     368
     369        auto* atkParent = parent ? ATK_OBJECT(parent->wrapper()) : nullptr;
    399370        if (!atkParent)
    400371            return -1;
     
    402373        unsigned count = atk_object_get_n_accessible_children(atkParent);
    403374        for (unsigned i = 0; i < count; ++i) {
    404             AtkObject* child = atk_object_ref_accessible_child(atkParent, i);
    405             bool childIsObject = child == object;
    406             g_object_unref(child);
    407             if (childIsObject)
     375            GRefPtr<AtkObject> child = adoptGRef(atk_object_ref_accessible_child(atkParent, i));
     376            if (child.get() == object)
    408377                return i;
    409378        }
     
    419388static AtkAttributeSet* webkitAccessibleGetAttributes(AtkObject* object)
    420389{
    421     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    422     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
     390    auto* accessible = WEBKIT_ACCESSIBLE(object);
     391    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    423392
    424393    AtkAttributeSet* attributeSet = nullptr;
     
    427396#endif
    428397
    429     AccessibilityObject* coreObject = core(object);
    430     if (!coreObject)
    431         return attributeSet;
     398    auto* coreObject = accessible->priv->object;
    432399
    433400    // Hack needed for WebKit2 tests because obtaining an element by its ID
     
    606573static AtkRole atkRole(AccessibilityObject* coreObject)
    607574{
    608     AccessibilityRole role = coreObject->roleValue();
    609     switch (role) {
     575    switch (coreObject->roleValue()) {
    610576    case AccessibilityRole::ApplicationAlert:
    611577        return ATK_ROLE_ALERT;
     
    877843    // ATK_ROLE_UNKNOWN should only be applied in cases where there is a valid
    878844    // WebCore accessible object for which the platform role mapping is unknown.
    879     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), ATK_ROLE_INVALID);
    880     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), ATK_ROLE_INVALID);
    881 
    882     AccessibilityObject* coreObject = core(object);
    883 
    884     if (!coreObject)
    885         return ATK_ROLE_INVALID;
     845    auto* accessible = WEBKIT_ACCESSIBLE(object);
     846    returnValIfWebKitAccessibleIsInvalid(accessible, ATK_ROLE_INVALID);
    886847
    887848    // Note: Why doesn't WebCore have a password field for this
    888     if (coreObject->isPasswordField())
     849    if (accessible->priv->object->isPasswordField())
    889850        return ATK_ROLE_PASSWORD_TEXT;
    890851
    891     return atkRole(coreObject);
     852    return atkRole(accessible->priv->object);
    892853}
    893854
     
    10541015static AtkStateSet* webkitAccessibleRefStateSet(AtkObject* object)
    10551016{
    1056     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    1057 
    1058     AtkStateSet* stateSet = ATK_OBJECT_CLASS(webkitAccessibleParentClass)->ref_state_set(object);
    1059     AccessibilityObject* coreObject = core(object);
     1017    auto* accessible = WEBKIT_ACCESSIBLE(object);
     1018    AtkStateSet* stateSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_state_set(object);
    10601019
    10611020    // Make sure the layout is updated to really know whether the object
    10621021    // is defunct or not, so we can return the proper state.
    1063     coreObject->updateBackingStore();
    1064 
    1065     if (coreObject == fallbackObject()) {
     1022    accessible->priv->object->updateBackingStore();
     1023
     1024    if (accessible->priv->object == fallbackObject()) {
    10661025        atk_state_set_add_state(stateSet, ATK_STATE_DEFUNCT);
    10671026        return stateSet;
     
    10731032        atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);
    10741033
    1075     setAtkStateSetFromCoreObject(coreObject, stateSet);
     1034    setAtkStateSetFromCoreObject(accessible->priv->object, stateSet);
    10761035    return stateSet;
    10771036}
     
    10791038static AtkRelationSet* webkitAccessibleRefRelationSet(AtkObject* object)
    10801039{
    1081     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    1082     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
    1083 
    1084     AtkRelationSet* relationSet = ATK_OBJECT_CLASS(webkitAccessibleParentClass)->ref_relation_set(object);
    1085     AccessibilityObject* coreObject = core(object);
    1086 
    1087     setAtkRelationSetFromCoreObject(coreObject, relationSet);
    1088 
     1040    auto* accessible = WEBKIT_ACCESSIBLE(object);
     1041    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
     1042
     1043    AtkRelationSet* relationSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_relation_set(object);
     1044    setAtkRelationSetFromCoreObject(accessible->priv->object, relationSet);
    10891045    return relationSet;
    10901046}
     
    10921048static void webkitAccessibleInit(AtkObject* object, gpointer data)
    10931049{
    1094     if (ATK_OBJECT_CLASS(webkitAccessibleParentClass)->initialize)
    1095         ATK_OBJECT_CLASS(webkitAccessibleParentClass)->initialize(object, data);
     1050    if (ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize)
     1051        ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize(object, data);
    10961052
    10971053    WebKitAccessible* accessible = WEBKIT_ACCESSIBLE(object);
    1098     accessible->m_object = reinterpret_cast<AccessibilityObject*>(data);
    1099     accessible->priv = WEBKIT_ACCESSIBLE_GET_PRIVATE(accessible);
     1054    accessible->priv->object = reinterpret_cast<AccessibilityObject*>(data);
    11001055}
    11011056
    11021057static const gchar* webkitAccessibleGetObjectLocale(AtkObject* object)
    11031058{
    1104     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE(object), 0);
    1105     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(object), 0);
    1106 
    1107     AccessibilityObject* coreObject = core(object);
    1108     if (!coreObject)
    1109         return 0;
     1059    auto* accessible = WEBKIT_ACCESSIBLE(object);
     1060    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    11101061
    11111062    if (ATK_IS_DOCUMENT(object)) {
    11121063        // TODO: Should we fall back on lang xml:lang when the following comes up empty?
    1113         String language = coreObject->language();
     1064        String language = accessible->priv->object->language();
    11141065        if (!language.isEmpty())
    1115             return cacheAndReturnAtkProperty(object, AtkCachedDocumentLocale, language);
     1066            return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedDocumentLocale, language.utf8());
    11161067
    11171068    } else if (ATK_IS_TEXT(object)) {
     
    11191070
    11201071        AtkAttributeSet* textAttributes = atk_text_get_default_attributes(ATK_TEXT(object));
    1121         for (AtkAttributeSet* attributes = textAttributes; attributes; attributes = attributes->next) {
    1122             AtkAttribute* atkAttribute = static_cast<AtkAttribute*>(attributes->data);
     1072        for (auto* attributes = textAttributes; attributes; attributes = attributes->next) {
     1073            auto* atkAttribute = static_cast<AtkAttribute*>(attributes->data);
    11231074            if (!strcmp(atkAttribute->name, atk_text_attribute_get_name(ATK_TEXT_ATTR_LANGUAGE))) {
    1124                 locale = cacheAndReturnAtkProperty(object, AtkCachedDocumentLocale, String::fromUTF8(atkAttribute->value));
     1075                locale = webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedDocumentLocale, atkAttribute->value);
    11251076                break;
    11261077            }
     
    11311082    }
    11321083
    1133     return 0;
    1134 }
    1135 
    1136 static void webkitAccessibleFinalize(GObject* object)
    1137 {
    1138     G_OBJECT_CLASS(webkitAccessibleParentClass)->finalize(object);
    1139 }
    1140 
    1141 static void webkitAccessibleClassInit(AtkObjectClass* klass)
    1142 {
    1143     GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);
    1144 
    1145     webkitAccessibleParentClass = g_type_class_peek_parent(klass);
    1146 
    1147     gobjectClass->finalize = webkitAccessibleFinalize;
    1148 
    1149     klass->initialize = webkitAccessibleInit;
    1150     klass->get_name = webkitAccessibleGetName;
    1151     klass->get_description = webkitAccessibleGetDescription;
    1152     klass->get_parent = webkitAccessibleGetParent;
    1153     klass->get_n_children = webkitAccessibleGetNChildren;
    1154     klass->ref_child = webkitAccessibleRefChild;
    1155     klass->get_role = webkitAccessibleGetRole;
    1156     klass->ref_state_set = webkitAccessibleRefStateSet;
    1157     klass->get_index_in_parent = webkitAccessibleGetIndexInParent;
    1158     klass->get_attributes = webkitAccessibleGetAttributes;
    1159     klass->ref_relation_set = webkitAccessibleRefRelationSet;
    1160     klass->get_object_locale = webkitAccessibleGetObjectLocale;
    1161 
    1162     g_type_class_add_private(klass, sizeof(WebKitAccessiblePrivate));
    1163 }
    1164 
    1165 GType
    1166 webkitAccessibleGetType(void)
    1167 {
    1168     static volatile gsize typeVolatile = 0;
    1169 
    1170     if (g_once_init_enter(&typeVolatile)) {
    1171         static const GTypeInfo tinfo = {
    1172             sizeof(WebKitAccessibleClass),
    1173             (GBaseInitFunc) 0,
    1174             (GBaseFinalizeFunc) 0,
    1175             (GClassInitFunc)(GCallback) webkitAccessibleClassInit,
    1176             (GClassFinalizeFunc) 0,
    1177             0, /* class data */
    1178             sizeof(WebKitAccessible), /* instance size */
    1179             0, /* nb preallocs */
    1180             (GInstanceInitFunc) 0,
    1181             0 /* value table */
    1182         };
    1183 
    1184         GType type = g_type_register_static(ATK_TYPE_OBJECT, "WebKitAccessible", &tinfo, GTypeFlags(0));
    1185         g_once_init_leave(&typeVolatile, type);
    1186     }
    1187 
    1188     return typeVolatile;
    1189 }
    1190 
    1191 static const GInterfaceInfo AtkInterfacesInitFunctions[] = {
    1192     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleActionInterfaceInit)), 0, 0},
    1193     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleSelectionInterfaceInit)), 0, 0},
    1194     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleEditableTextInterfaceInit)), 0, 0},
    1195     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTextInterfaceInit)), 0, 0},
    1196     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleComponentInterfaceInit)), 0, 0},
    1197     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleImageInterfaceInit)), 0, 0},
    1198     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableInterfaceInit)), 0, 0},
     1084    return nullptr;
     1085}
     1086
     1087static void webkit_accessible_class_init(WebKitAccessibleClass* klass)
     1088{
     1089    auto* atkObjectClass = ATK_OBJECT_CLASS(klass);
     1090    atkObjectClass->initialize = webkitAccessibleInit;
     1091    atkObjectClass->get_name = webkitAccessibleGetName;
     1092    atkObjectClass->get_description = webkitAccessibleGetDescription;
     1093    atkObjectClass->get_parent = webkitAccessibleGetParent;
     1094    atkObjectClass->get_n_children = webkitAccessibleGetNChildren;
     1095    atkObjectClass->ref_child = webkitAccessibleRefChild;
     1096    atkObjectClass->get_role = webkitAccessibleGetRole;
     1097    atkObjectClass->ref_state_set = webkitAccessibleRefStateSet;
     1098    atkObjectClass->get_index_in_parent = webkitAccessibleGetIndexInParent;
     1099    atkObjectClass->get_attributes = webkitAccessibleGetAttributes;
     1100    atkObjectClass->ref_relation_set = webkitAccessibleRefRelationSet;
     1101    atkObjectClass->get_object_locale = webkitAccessibleGetObjectLocale;
     1102}
     1103
     1104static const GInterfaceInfo atkInterfacesInitFunctions[] = {
     1105    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleActionInterfaceInit)), nullptr, nullptr},
     1106    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleSelectionInterfaceInit)), nullptr, nullptr},
     1107    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleEditableTextInterfaceInit)), nullptr, nullptr},
     1108    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTextInterfaceInit)), nullptr, nullptr},
     1109    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleComponentInterfaceInit)), nullptr, nullptr},
     1110    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleImageInterfaceInit)), nullptr, nullptr},
     1111    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableInterfaceInit)), nullptr, nullptr},
    11991112#if ATK_CHECK_VERSION(2,11,90)
    1200     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableCellInterfaceInit)), 0, 0},
    1201 #endif
    1202     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHypertextInterfaceInit)), 0, 0},
    1203     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHyperlinkImplInterfaceInit)), 0, 0},
    1204     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleDocumentInterfaceInit)), 0, 0},
    1205     {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleValueInterfaceInit)), 0, 0}
     1113    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleTableCellInterfaceInit)), nullptr, nullptr},
     1114#endif
     1115    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHypertextInterfaceInit)), nullptr, nullptr},
     1116    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleHyperlinkImplInterfaceInit)), nullptr, nullptr},
     1117    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleDocumentInterfaceInit)), nullptr, nullptr},
     1118    {reinterpret_cast<GInterfaceInitFunc>(reinterpret_cast<GCallback>(webkitAccessibleValueInterfaceInit)), nullptr, nullptr}
    12061119};
    12071120
     
    12231136};
    12241137
    1225 static GType GetAtkInterfaceTypeFromWAIType(WAIType type)
     1138static GType atkInterfaceTypeFromWAIType(WAIType type)
    12261139{
    12271140    switch (type) {
     
    12721185}
    12731186
    1274 static guint16 getInterfaceMaskFromObject(AccessibilityObject* coreObject)
     1187static guint16 interfaceMaskFromObject(AccessibilityObject* coreObject)
    12751188{
    12761189    guint16 interfaceMask = 0;
     
    13191232        // first accessible child has a text renderer
    13201233        if (role == AccessibilityRole::ListItem) {
    1321             const AccessibilityObject::AccessibilityChildrenVector& children = coreObject->children();
    1322             if (children.size()) {
    1323                 AccessibilityObject* axRenderChild = children.at(0).get();
    1324                 interfaceMask |= getInterfaceMaskFromObject(axRenderChild);
    1325             }
     1234            const auto& children = coreObject->children();
     1235            if (!children.isEmpty())
     1236                interfaceMask |= interfaceMaskFromObject(children[0].get());
    13261237        }
    13271238    }
     
    13571268}
    13581269
    1359 static const char* getUniqueAccessibilityTypeName(guint16 interfaceMask)
    1360 {
    1361 #define WAI_TYPE_NAME_LEN (30) /* Enough for prefix + 5 hex characters (max) */
     1270static const char* uniqueAccessibilityTypeName(guint16 interfaceMask)
     1271{
     1272#define WAI_TYPE_NAME_LEN (30) // Enough for prefix + 5 hex characters (max).
    13621273    static char name[WAI_TYPE_NAME_LEN + 1];
    13631274
     
    13681279}
    13691280
    1370 static GType getAccessibilityTypeFromObject(AccessibilityObject* coreObject)
     1281static GType accessibilityTypeFromObject(AccessibilityObject* coreObject)
    13711282{
    13721283    static const GTypeInfo typeInfo = {
    13731284        sizeof(WebKitAccessibleClass),
    1374         (GBaseInitFunc) 0,
    1375         (GBaseFinalizeFunc) 0,
    1376         (GClassInitFunc) 0,
    1377         (GClassFinalizeFunc) 0,
    1378         0, /* class data */
    1379         sizeof(WebKitAccessible), /* instance size */
    1380         0, /* nb preallocs */
    1381         (GInstanceInitFunc) 0,
    1382         0 /* value table */
     1285        nullptr, // GBaseInitFunc
     1286        nullptr, // GBaseFinalizeFunc
     1287        nullptr, // GClassInitFunc
     1288        nullptr, // GClassFinalizeFunc
     1289        nullptr, // class data
     1290        sizeof(WebKitAccessible), // instance size
     1291        0, // nb preallocs
     1292        nullptr, // GInstanceInitFunc
     1293        nullptr // value table
    13831294    };
    13841295
    1385     guint16 interfaceMask = getInterfaceMaskFromObject(coreObject);
    1386     const char* atkTypeName = getUniqueAccessibilityTypeName(interfaceMask);
    1387     GType type = g_type_from_name(atkTypeName);
    1388     if (type)
     1296    guint16 interfaceMask = interfaceMaskFromObject(coreObject);
     1297    const char* atkTypeName = uniqueAccessibilityTypeName(interfaceMask);
     1298    if (GType type = g_type_from_name(atkTypeName))
    13891299        return type;
    13901300
    1391     type = g_type_register_static(WEBKIT_TYPE_ACCESSIBLE, atkTypeName, &typeInfo, GTypeFlags(0));
    1392     for (guint i = 0; i < G_N_ELEMENTS(AtkInterfacesInitFunctions); i++) {
    1393         if (interfaceMask & (1 << i))
     1301    GType type = g_type_register_static(WEBKIT_TYPE_ACCESSIBLE, atkTypeName, &typeInfo, static_cast<GTypeFlags>(0));
     1302    for (unsigned i = 0; i < G_N_ELEMENTS(atkInterfacesInitFunctions); ++i) {
     1303        if (interfaceMask & (1 << i)) {
    13941304            g_type_add_interface_static(type,
    1395                 GetAtkInterfaceTypeFromWAIType(static_cast<WAIType>(i)),
    1396                 &AtkInterfacesInitFunctions[i]);
     1305                atkInterfaceTypeFromWAIType(static_cast<WAIType>(i)),
     1306                &atkInterfacesInitFunctions[i]);
     1307        }
    13971308    }
    13981309
     
    14021313WebKitAccessible* webkitAccessibleNew(AccessibilityObject* coreObject)
    14031314{
    1404     GType type = getAccessibilityTypeFromObject(coreObject);
    1405     AtkObject* object = static_cast<AtkObject*>(g_object_new(type, 0));
    1406 
     1315    auto* object = ATK_OBJECT(g_object_new(accessibilityTypeFromObject(coreObject), nullptr));
    14071316    atk_object_initialize(object, coreObject);
    1408 
    14091317    return WEBKIT_ACCESSIBLE(object);
    14101318}
    14111319
    1412 AccessibilityObject* webkitAccessibleGetAccessibilityObject(WebKitAccessible* accessible)
    1413 {
    1414     return accessible->m_object;
     1320AccessibilityObject& webkitAccessibleGetAccessibilityObject(WebKitAccessible* accessible)
     1321{
     1322    ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
     1323    return *accessible->priv->object;
    14151324}
    14161325
    14171326void webkitAccessibleDetach(WebKitAccessible* accessible)
    14181327{
    1419     ASSERT(accessible->m_object);
    1420 
    1421     if (accessible->m_object->roleValue() == AccessibilityRole::WebArea)
    1422         atk_object_notify_state_change(ATK_OBJECT(accessible), ATK_STATE_DEFUNCT, true);
     1328    ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
     1329    ASSERT(accessible->priv->object != fallbackObject());
     1330
     1331    if (accessible->priv->object->roleValue() == AccessibilityRole::WebArea)
     1332        atk_object_notify_state_change(ATK_OBJECT(accessible), ATK_STATE_DEFUNCT, TRUE);
    14231333
    14241334    // We replace the WebCore AccessibilityObject with a fallback object that
    14251335    // provides default implementations to avoid repetitive null-checking after
    14261336    // detachment.
    1427     accessible->m_object = fallbackObject();
     1337    accessible->priv->object = fallbackObject();
    14281338}
    14291339
    14301340bool webkitAccessibleIsDetached(WebKitAccessible* accessible)
    14311341{
    1432     ASSERT(accessible->m_object);
    1433     return accessible->m_object == fallbackObject();
    1434 }
    1435 
    1436 AccessibilityObject* objectFocusedAndCaretOffsetUnignored(AccessibilityObject* referenceObject, int& offset)
    1437 {
    1438     // Indication that something bogus has transpired.
    1439     offset = -1;
    1440 
    1441     Document* document = referenceObject->document();
    1442     if (!document)
    1443         return 0;
    1444 
    1445     Node* focusedNode = referenceObject->selection().end().containerNode();
    1446     if (!focusedNode)
    1447         return 0;
    1448 
    1449     RenderObject* focusedRenderer = focusedNode->renderer();
    1450     if (!focusedRenderer)
    1451         return 0;
    1452 
    1453     AccessibilityObject* focusedObject = document->axObjectCache()->getOrCreate(focusedRenderer);
    1454     if (!focusedObject)
    1455         return 0;
    1456 
    1457     // Look for the actual (not ignoring accessibility) selected object.
    1458     AccessibilityObject* firstUnignoredParent = focusedObject;
    1459     if (firstUnignoredParent->accessibilityIsIgnored())
    1460         firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
    1461     if (!firstUnignoredParent)
    1462         return 0;
    1463 
    1464     // Don't ignore links if the offset is being requested for a link
    1465     // or if the link is a block.
    1466     if (!referenceObject->isLink() && firstUnignoredParent->isLink()
    1467         && !(firstUnignoredParent->renderer() && !firstUnignoredParent->renderer()->isInline()))
    1468         firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
    1469     if (!firstUnignoredParent)
    1470         return 0;
    1471 
    1472     // The reference object must either coincide with the focused
    1473     // object being considered, or be a descendant of it.
    1474     if (referenceObject->isDescendantOfObject(firstUnignoredParent))
    1475         referenceObject = firstUnignoredParent;
    1476 
    1477     Node* startNode = nullptr;
    1478     if (firstUnignoredParent != referenceObject || firstUnignoredParent->isTextControl()) {
    1479         // We need to use the first child's node of the reference
    1480         // object as the start point to calculate the caret offset
    1481         // because we want it to be relative to the object of
    1482         // reference, not just to the focused object (which could have
    1483         // previous siblings which should be taken into account too).
    1484         AccessibilityObject* axFirstChild = referenceObject->firstChild();
    1485         if (axFirstChild)
    1486             startNode = axFirstChild->node();
    1487     }
    1488     // Getting the Position of a PseudoElement now triggers an assertion.
    1489     // This can occur when clicking on empty space in a render block.
    1490     if (!startNode || startNode->isPseudoElement())
    1491         startNode = firstUnignoredParent->node();
    1492 
    1493     // Check if the node for the first parent object not ignoring
    1494     // accessibility is null again before using it. This might happen
    1495     // with certain kind of accessibility objects, such as the root
    1496     // one (the scroller containing the webArea object).
    1497     if (!startNode)
    1498         return 0;
    1499 
    1500     VisiblePosition startPosition = VisiblePosition(positionBeforeNode(startNode), DOWNSTREAM);
    1501     VisiblePosition endPosition = firstUnignoredParent->selection().visibleEnd();
    1502 
    1503     if (startPosition == endPosition)
    1504         offset = 0;
    1505     else if (!isStartOfLine(endPosition)) {
    1506         RefPtr<Range> range = makeRange(startPosition, endPosition.previous());
    1507         offset = TextIterator::rangeLength(range.get(), true) + 1;
    1508     } else {
    1509         RefPtr<Range> range = makeRange(startPosition, endPosition);
    1510         offset = TextIterator::rangeLength(range.get(), true);
    1511     }
    1512 
    1513     return firstUnignoredParent;
    1514 }
    1515 
    1516 const char* cacheAndReturnAtkProperty(AtkObject* object, AtkCachedProperty property, String value)
    1517 {
    1518     WebKitAccessiblePrivate* priv = WEBKIT_ACCESSIBLE(object)->priv;
     1342    ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
     1343    return accessible->priv->object == fallbackObject();
     1344}
     1345
     1346const char* webkitAccessibleCacheAndReturnAtkProperty(WebKitAccessible* accessible, AtkCachedProperty property, CString&& value)
     1347{
     1348    ASSERT(WEBKIT_IS_ACCESSIBLE(accessible));
     1349
     1350    WebKitAccessiblePrivate* priv = accessible->priv;
    15191351    CString* propertyPtr = nullptr;
    15201352
     
    15231355        propertyPtr = &priv->accessibleName;
    15241356        break;
    1525 
    15261357    case AtkCachedAccessibleDescription:
    15271358        propertyPtr = &priv->accessibleDescription;
    15281359        break;
    1529 
    15301360    case AtkCachedActionName:
    15311361        propertyPtr = &priv->actionName;
    15321362        break;
    1533 
    15341363    case AtkCachedActionKeyBinding:
    15351364        propertyPtr = &priv->actionKeyBinding;
    15361365        break;
    1537 
    15381366    case AtkCachedDocumentLocale:
    15391367        propertyPtr = &priv->documentLocale;
    15401368        break;
    1541 
    15421369    case AtkCachedDocumentType:
    15431370        propertyPtr = &priv->documentType;
    15441371        break;
    1545 
    15461372    case AtkCachedDocumentEncoding:
    15471373        propertyPtr = &priv->documentEncoding;
    15481374        break;
    1549 
    15501375    case AtkCachedDocumentURI:
    15511376        propertyPtr = &priv->documentURI;
    15521377        break;
    1553 
    15541378    case AtkCachedImageDescription:
    15551379        propertyPtr = &priv->imageDescription;
    15561380        break;
    1557 
    15581381    default:
    15591382        ASSERT_NOT_REACHED();
     
    15621385    // Don't invalidate old memory if not stricly needed, since other
    15631386    // callers might be still holding on to it.
    1564     if (*propertyPtr != value.utf8())
    1565         *propertyPtr = value.utf8();
     1387    if (*propertyPtr != value)
     1388        *propertyPtr = WTFMove(value);
    15661389
    15671390    return (*propertyPtr).data();
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessible.h

    r243969 r243970  
    22 * Copyright (C) 2008 Nuanti Ltd.
    33 * Copyright (C) 2009 Jan Alonzo
    4  * Copyright (C) 2009, 2010, 2011, 2012 Igalia S.L.
     4 * Copyright (C) 2009, 2010, 2011, 2012, 2019 Igalia S.L.
    55 * Copyright (C) 2013 Samsung Electronics
    66 *
     
    3434G_BEGIN_DECLS
    3535
    36 #define WEBKIT_TYPE_ACCESSIBLE                  (webkitAccessibleGetType ())
    37 #define WEBKIT_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessible))
    38 #define WEBKIT_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
    39 #define WEBKIT_IS_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEBKIT_TYPE_ACCESSIBLE))
    40 #define WEBKIT_IS_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), WEBKIT_TYPE_ACCESSIBLE))
    41 #define WEBKIT_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
     36#define WEBKIT_TYPE_ACCESSIBLE            (webkit_accessible_get_type())
     37#define WEBKIT_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessible))
     38#define WEBKIT_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
     39#define WEBKIT_IS_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_ACCESSIBLE))
     40#define WEBKIT_IS_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), WEBKIT_TYPE_ACCESSIBLE))
     41#define WEBKIT_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass))
    4242
    43 typedef struct _WebKitAccessible                WebKitAccessible;
    44 typedef struct _WebKitAccessibleClass           WebKitAccessibleClass;
    45 typedef struct _WebKitAccessiblePrivate         WebKitAccessiblePrivate;
     43typedef struct _WebKitAccessible        WebKitAccessible;
     44typedef struct _WebKitAccessibleClass   WebKitAccessibleClass;
     45typedef struct _WebKitAccessiblePrivate WebKitAccessiblePrivate;
    4646
    4747
    4848struct _WebKitAccessible {
    4949    AtkObject parent;
    50     WebCore::AccessibilityObject* m_object;
    5150
    5251    WebKitAccessiblePrivate *priv;
     
    6968};
    7069
    71 GType webkitAccessibleGetType(void) G_GNUC_CONST;
     70GType webkit_accessible_get_type(void);
    7271
    7372WebKitAccessible* webkitAccessibleNew(WebCore::AccessibilityObject*);
    7473
    75 WebCore::AccessibilityObject* webkitAccessibleGetAccessibilityObject(WebKitAccessible*);
     74WebCore::AccessibilityObject& webkitAccessibleGetAccessibilityObject(WebKitAccessible*);
    7675
    7776void webkitAccessibleDetach(WebKitAccessible*);
     
    7978bool webkitAccessibleIsDetached(WebKitAccessible*);
    8079
    81 WebCore::AccessibilityObject* objectFocusedAndCaretOffsetUnignored(WebCore::AccessibilityObject*, int& offset);
    82 
    83 const char* cacheAndReturnAtkProperty(AtkObject*, AtkCachedProperty, String value);
     80const char* webkitAccessibleCacheAndReturnAtkProperty(WebKitAccessible*, AtkCachedProperty, CString&&);
    8481
    8582G_END_DECLS
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleHyperlink.cpp

    r239535 r243970  
    3333#include "RenderObject.h"
    3434#include "TextIterator.h"
     35#include "WebKitAccessible.h"
    3536#include "WebKitAccessibleUtil.h"
    36 #include "WebKitAccessibleWrapperAtk.h"
    3737#include <wtf/text/CString.h>
    3838
     
    6565        return 0;
    6666
    67     return webkitAccessibleGetAccessibilityObject(accessible);
     67    return &webkitAccessibleGetAccessibilityObject(accessible);
    6868}
    6969
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceAction.cpp

    r156532 r243970  
    3737#include "AccessibilityObject.h"
    3838#include "NotImplemented.h"
     39#include "WebKitAccessible.h"
    3940#include "WebKitAccessibleUtil.h"
    40 #include "WebKitAccessibleWrapperAtk.h"
    4141
    4242using namespace WebCore;
     
    4747        return 0;
    4848
    49     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(action));
     49    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(action));
    5050}
    5151
     
    7878}
    7979
    80 static const gchar* webkitAccessibleActionGetKeybinding(AtkAction* action, gint index)
     80static const gchar* webkitAccessibleActionGetKeybinding(AtkAction* action, gint)
    8181{
    82     g_return_val_if_fail(ATK_IS_ACTION(action), 0);
    83     g_return_val_if_fail(!index, 0);
    84     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(action), 0);
     82    auto* accessible = WEBKIT_ACCESSIBLE(action);
     83    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    8584
    8685    // FIXME: Construct a proper keybinding string.
    87     return cacheAndReturnAtkProperty(ATK_OBJECT(action), AtkCachedActionKeyBinding, core(action)->accessKey().string());
     86    return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedActionKeyBinding, core(action)->accessKey().string().utf8());
    8887}
    8988
    90 static const gchar* webkitAccessibleActionGetName(AtkAction* action, gint index)
     89static const gchar* webkitAccessibleActionGetName(AtkAction* action, gint)
    9190{
    92     g_return_val_if_fail(ATK_IS_ACTION(action), 0);
    93     g_return_val_if_fail(!index, 0);
    94     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(action), 0);
     91    auto* accessible = WEBKIT_ACCESSIBLE(action);
     92    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    9593
    96     return cacheAndReturnAtkProperty(ATK_OBJECT(action), AtkCachedActionName, core(action)->actionVerb());
     94    return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedActionName, core(action)->actionVerb().utf8());
    9795}
    9896
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceComponent.cpp

    r243928 r243970  
    3737#include "FrameView.h"
    3838#include "IntRect.h"
     39#include "WebKitAccessible.h"
    3940#include "WebKitAccessibleUtil.h"
    40 #include "WebKitAccessibleWrapperAtk.h"
    4141
    4242using namespace WebCore;
     
    4747        return 0;
    4848
    49     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(component));
     49    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(component));
    5050}
    5151
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceDocument.cpp

    r184979 r243970  
    3838#include "Document.h"
    3939#include "DocumentType.h"
     40#include "WebKitAccessible.h"
    4041#include "WebKitAccessibleUtil.h"
    41 #include "WebKitAccessibleWrapperAtk.h"
    4242
    4343using namespace WebCore;
     
    4848        return 0;
    4949
    50     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(document));
     50    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(document));
    5151}
    5252
     
    5757        return 0;
    5858
    59     String value = String();
     59    String value;
    6060    AtkCachedProperty atkCachedProperty;
    6161
     
    7272
    7373    if (!value.isEmpty())
    74         return cacheAndReturnAtkProperty(ATK_OBJECT(document), atkCachedProperty, value);
     74        return webkitAccessibleCacheAndReturnAtkProperty(WEBKIT_ACCESSIBLE(document), atkCachedProperty, value.utf8());
    7575
    7676    return 0;
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceEditableText.cpp

    r156532 r243970  
    3939#include "Frame.h"
    4040#include "NotImplemented.h"
     41#include "WebKitAccessible.h"
    4142#include "WebKitAccessibleUtil.h"
    42 #include "WebKitAccessibleWrapperAtk.h"
    4343
    4444using namespace WebCore;
     
    4949        return 0;
    5050
    51     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
     51    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
    5252}
    5353
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceHypertext.cpp

    r243928 r243970  
    2424
    2525#include "AccessibilityObject.h"
     26#include "WebKitAccessible.h"
    2627#include "WebKitAccessibleUtil.h"
    27 #include "WebKitAccessibleWrapperAtk.h"
    2828
    2929using namespace WebCore;
     
    3434        return 0;
    3535
    36     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(hypertext));
     36    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(hypertext));
    3737}
    3838
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceImage.cpp

    r188433 r243970  
    3737#include "AccessibilityObject.h"
    3838#include "IntRect.h"
     39#include "WebKitAccessible.h"
    3940#include "WebKitAccessibleUtil.h"
    40 #include "WebKitAccessibleWrapperAtk.h"
    4141
    4242using namespace WebCore;
     
    4747        return 0;
    4848
    49     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(image));
     49    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(image));
    5050}
    5151
     
    6161static const gchar* webkitAccessibleImageGetImageDescription(AtkImage* image)
    6262{
    63     g_return_val_if_fail(ATK_IMAGE(image), 0);
    64     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE(image), 0);
     63    auto* accessible = WEBKIT_ACCESSIBLE(image);
     64    returnValIfWebKitAccessibleIsInvalid(accessible, nullptr);
    6565
    66     return cacheAndReturnAtkProperty(ATK_OBJECT(image), AtkCachedImageDescription, accessibilityDescription(core(image)));
     66    return webkitAccessibleCacheAndReturnAtkProperty(accessible, AtkCachedImageDescription, accessibilityDescription(core(image)).utf8());
    6767}
    6868
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceSelection.cpp

    r243928 r243970  
    3838#include "HTMLSelectElement.h"
    3939#include "RenderObject.h"
     40#include "WebKitAccessible.h"
    4041#include "WebKitAccessibleUtil.h"
    41 #include "WebKitAccessibleWrapperAtk.h"
    4242
    4343using namespace WebCore;
     
    4848        return nullptr;
    4949
    50     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(selection));
     50    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(selection));
    5151}
    5252
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTable.cpp

    r243928 r243970  
    4141#include "HTMLTableElement.h"
    4242#include "RenderElement.h"
     43#include "WebKitAccessible.h"
    4344#include "WebKitAccessibleInterfaceText.h"
    4445#include "WebKitAccessibleUtil.h"
    45 #include "WebKitAccessibleWrapperAtk.h"
    4646
    4747using namespace WebCore;
     
    5252        return nullptr;
    5353
    54     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(table));
     54    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(table));
    5555}
    5656
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceTableCell.cpp

    r243928 r243970  
    2626#include "AccessibilityTable.h"
    2727#include "AccessibilityTableCell.h"
     28#include "WebKitAccessible.h"
    2829#include "WebKitAccessibleUtil.h"
    29 #include "WebKitAccessibleWrapperAtk.h"
    3030
    3131using namespace WebCore;
     
    4646        return nullptr;
    4747
    48     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(cell));
     48    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(cell));
    4949}
    5050
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp

    r243928 r243970  
    5050#include "TextIterator.h"
    5151#include "VisibleUnits.h"
     52#include "WebKitAccessible.h"
    5253#include "WebKitAccessibleUtil.h"
    53 #include "WebKitAccessibleWrapperAtk.h"
    5454#include <wtf/glib/GUniquePtr.h>
    5555#include <wtf/text/CString.h>
     
    6767        return 0;
    6868
    69     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
     69    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(text));
    7070}
    7171
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceValue.cpp

    r176163 r243970  
    2525#include "AccessibilityObject.h"
    2626#include "HTMLNames.h"
     27#include "WebKitAccessible.h"
    2728#include "WebKitAccessibleUtil.h"
    28 #include "WebKitAccessibleWrapperAtk.h"
    2929#include <wtf/text/CString.h>
    3030
     
    3636        return 0;
    3737
    38     return webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(value));
     38    return &webkitAccessibleGetAccessibilityObject(WEBKIT_ACCESSIBLE(value));
    3939}
    4040
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.cpp

    r238082 r243970  
    3434#if HAVE(ACCESSIBILITY)
    3535
     36#include "AXObjectCache.h"
    3637#include "AccessibilityObject.h"
    3738#include "FrameView.h"
     
    3940#include "Node.h"
    4041#include "Range.h"
     42#include "RenderObject.h"
     43#include "TextIterator.h"
    4144#include "VisibleSelection.h"
    4245
     
    174177}
    175178
     179AccessibilityObject* objectFocusedAndCaretOffsetUnignored(AccessibilityObject* referenceObject, int& offset)
     180{
     181    // Indication that something bogus has transpired.
     182    offset = -1;
     183
     184    Document* document = referenceObject->document();
     185    if (!document)
     186        return nullptr;
     187
     188    Node* focusedNode = referenceObject->selection().end().containerNode();
     189    if (!focusedNode)
     190        return nullptr;
     191
     192    RenderObject* focusedRenderer = focusedNode->renderer();
     193    if (!focusedRenderer)
     194        return nullptr;
     195
     196    AccessibilityObject* focusedObject = document->axObjectCache()->getOrCreate(focusedRenderer);
     197    if (!focusedObject)
     198        return nullptr;
     199
     200    // Look for the actual (not ignoring accessibility) selected object.
     201    AccessibilityObject* firstUnignoredParent = focusedObject;
     202    if (firstUnignoredParent->accessibilityIsIgnored())
     203        firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
     204    if (!firstUnignoredParent)
     205        return nullptr;
     206
     207    // Don't ignore links if the offset is being requested for a link
     208    // or if the link is a block.
     209    if (!referenceObject->isLink() && firstUnignoredParent->isLink()
     210        && !(firstUnignoredParent->renderer() && !firstUnignoredParent->renderer()->isInline()))
     211        firstUnignoredParent = firstUnignoredParent->parentObjectUnignored();
     212    if (!firstUnignoredParent)
     213        return nullptr;
     214
     215    // The reference object must either coincide with the focused
     216    // object being considered, or be a descendant of it.
     217    if (referenceObject->isDescendantOfObject(firstUnignoredParent))
     218        referenceObject = firstUnignoredParent;
     219
     220    Node* startNode = nullptr;
     221    if (firstUnignoredParent != referenceObject || firstUnignoredParent->isTextControl()) {
     222        // We need to use the first child's node of the reference
     223        // object as the start point to calculate the caret offset
     224        // because we want it to be relative to the object of
     225        // reference, not just to the focused object (which could have
     226        // previous siblings which should be taken into account too).
     227        AccessibilityObject* axFirstChild = referenceObject->firstChild();
     228        if (axFirstChild)
     229            startNode = axFirstChild->node();
     230    }
     231    // Getting the Position of a PseudoElement now triggers an assertion.
     232    // This can occur when clicking on empty space in a render block.
     233    if (!startNode || startNode->isPseudoElement())
     234        startNode = firstUnignoredParent->node();
     235
     236    // Check if the node for the first parent object not ignoring
     237    // accessibility is null again before using it. This might happen
     238    // with certain kind of accessibility objects, such as the root
     239    // one (the scroller containing the webArea object).
     240    if (!startNode)
     241        return nullptr;
     242
     243    VisiblePosition startPosition = VisiblePosition(positionBeforeNode(startNode), DOWNSTREAM);
     244    VisiblePosition endPosition = firstUnignoredParent->selection().visibleEnd();
     245
     246    if (startPosition == endPosition)
     247        offset = 0;
     248    else if (!isStartOfLine(endPosition)) {
     249        RefPtr<Range> range = makeRange(startPosition, endPosition.previous());
     250        offset = TextIterator::rangeLength(range.get(), true) + 1;
     251    } else {
     252        RefPtr<Range> range = makeRange(startPosition, endPosition);
     253        offset = TextIterator::rangeLength(range.get(), true);
     254    }
     255
     256    return firstUnignoredParent;
     257}
     258
    176259#endif
  • trunk/Source/WebCore/accessibility/atk/WebKitAccessibleUtil.h

    r208179 r243970  
    3636// detached or if it's not but just updating the layout will detach it anyway.
    3737#define returnIfWebKitAccessibleIsInvalid(webkitAccessible) G_STMT_START { \
    38     if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) { \
     38    if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) \
    3939        return; \
    40     } else { \
    41         AccessibilityObject* coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
    42         if (!coreObject || !coreObject->document()) \
    43             return; \
    44         coreObject->updateBackingStore(); \
    45         if (webkitAccessibleIsDetached(webkitAccessible)) \
    46             return; \
    47     }; } G_STMT_END
     40    auto& coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
     41    if (!coreObject.document())                                         \
     42        return;                                                         \
     43    coreObject.updateBackingStore();                                    \
     44    if (webkitAccessibleIsDetached(webkitAccessible))                   \
     45        return;                                                         \
     46    ; } G_STMT_END
    4847
    4948#define returnValIfWebKitAccessibleIsInvalid(webkitAccessible, val) G_STMT_START { \
    50     if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) { \
    51         return (val); \
    52     } else { \
    53         AccessibilityObject* coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
    54         if (!coreObject || !coreObject->document()) \
    55             return (val); \
    56         coreObject->updateBackingStore(); \
    57         if (webkitAccessibleIsDetached(webkitAccessible)) \
    58             return (val); \
    59     }; } G_STMT_END
     49    if (!webkitAccessible || webkitAccessibleIsDetached(webkitAccessible)) \
     50        return (val);                                                   \
     51    auto& coreObject = webkitAccessibleGetAccessibilityObject(webkitAccessible); \
     52    if (!coreObject.document())                                         \
     53        return (val);                                                   \
     54    coreObject.updateBackingStore();                                    \
     55    if (webkitAccessibleIsDetached(webkitAccessible))                   \
     56        return (val);                                                   \
     57    ; } G_STMT_END
    6058
    6159AtkAttributeSet* addToAtkAttributeSet(AtkAttributeSet*, const char* name, const char* value);
     
    6967bool selectionBelongsToObject(WebCore::AccessibilityObject*, WebCore::VisibleSelection&);
    7068
     69WebCore::AccessibilityObject* objectFocusedAndCaretOffsetUnignored(WebCore::AccessibilityObject*, int& offset);
     70
    7171#endif // HAVE(ACCESSIBILITY)
  • trunk/Source/WebCore/editing/atk/FrameSelectionAtk.cpp

    r243928 r243970  
    2727#include "Frame.h"
    2828#include "RenderListItem.h"
    29 #include "WebKitAccessibleWrapperAtk.h"
     29#include "WebKitAccessible.h"
     30#include "WebKitAccessibleUtil.h"
    3031#include <glib.h>
    3132#include <wtf/NeverDestroyed.h>
Note: See TracChangeset for help on using the changeset viewer.