Changeset 258673 in webkit


Ignore:
Timestamp:
Mar 18, 2020 7:09:44 PM (4 years ago)
Author:
Andres Gonzalez
Message:

Several TextMarker attributes need to run on the main thread.
​https://bugs.webkit.org/show_bug.cgi?id=209247

Reviewed by Chris Fleizach.

  • Dispatch several TextMarker parameterized attributes to the main

thread.

  • Added helper methods to return TextMarkers and TextMarkerRanges for

diffferent units of text such as word or sentence.

  • Added a helper function, retainWrapper to make code a bit more

readable in lambda definitions.

  • accessibility/mac/AXObjectCacheMac.mm:

(WebCore::textMarkerForVisiblePosition):
(WebCore::textMarkerRangeFromVisiblePositions):

  • accessibility/mac/WebAccessibilityObjectWrapperMac.mm:

(retainWrapper):
(-[WebAccessibilityObjectWrapper attachmentView]):
(-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):
(-[WebAccessibilityObjectWrapper textMarkerRangeFromVisiblePositions:endPosition:]):
(-[WebAccessibilityObjectWrapper associatedPluginParent]):
(-[WebAccessibilityObjectWrapper windowElement:]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
(-[WebAccessibilityObjectWrapper accessibilityShowContextMenu]):
(-[WebAccessibilityObjectWrapper textMarkerRangeAtTextMarker:forUnit:]):
(-[WebAccessibilityObjectWrapper lineTextMarkerRangeForTextMarker:forUnit:]):
(-[WebAccessibilityObjectWrapper textMarkerForTextMarker:atUnit:]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r258666 r258673  
     12020-03-18  Andres Gonzalez  <andresg_22@apple.com>
     2
     3        Several TextMarker attributes need to run on the main thread.
     4        https://bugs.webkit.org/show_bug.cgi?id=209247
     5
     6        Reviewed by Chris Fleizach.
     7
     8        - Dispatch several TextMarker parameterized attributes to the main
     9        thread.
     10        - Added helper methods to return TextMarkers and TextMarkerRanges for
     11        diffferent units of text such as word or sentence.
     12        - Added a helper function, retainWrapper to make code a bit more
     13        readable in lambda definitions.
     14
     15        * accessibility/mac/AXObjectCacheMac.mm:
     16        (WebCore::textMarkerForVisiblePosition):
     17        (WebCore::textMarkerRangeFromVisiblePositions):
     18        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
     19        (retainWrapper):
     20        (-[WebAccessibilityObjectWrapper attachmentView]):
     21        (-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):
     22        (-[WebAccessibilityObjectWrapper textMarkerRangeFromVisiblePositions:endPosition:]):
     23        (-[WebAccessibilityObjectWrapper associatedPluginParent]):
     24        (-[WebAccessibilityObjectWrapper windowElement:]):
     25        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
     26        (-[WebAccessibilityObjectWrapper accessibilityShowContextMenu]):
     27        (-[WebAccessibilityObjectWrapper textMarkerRangeAtTextMarker:forUnit:]):
     28        (-[WebAccessibilityObjectWrapper lineTextMarkerRangeForTextMarker:forUnit:]):
     29        (-[WebAccessibilityObjectWrapper textMarkerForTextMarker:atUnit:]):
     30        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
     31
    1322020-03-18  Zalan Bujtas  <zalan@apple.com>
    233

  • trunk/Source/WebCore/accessibility/mac/AXObjectCacheMac.mm

    r258108 r258673  
    568568id textMarkerForVisiblePosition(AXObjectCache* cache, const VisiblePosition& visiblePos)
    569569{
     570    ASSERT(isMainThread());
    570571    ASSERT(cache);
    571572    if (!cache)
    … …  
    581582id textMarkerRangeFromVisiblePositions(AXObjectCache* cache, const VisiblePosition& startPosition, const VisiblePosition& endPosition)
    582583{
     584    ASSERT(isMainThread());
    583585    if (!cache)
    584586        return nil;

  • trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm

    r258525 r258673  
    554554}
    555555
     556static inline RetainPtr<WebAccessibilityObjectWrapper> retainWrapper(WebAccessibilityObjectWrapper* wrapper)
     557{
     558    return RetainPtr<WebAccessibilityObjectWrapper>(wrapper);
     559}
     560
    556561- (id)attachmentView
    557562{
    558563    ASSERT(self.axBackingObject->isAttachment());
    559564
    560     return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     565    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    561566        auto* widget = protectedSelf.get().axBackingObject->widgetForAttachmentView();
    562567        if (!widget)
    … …  
    12481253- (NSAttributedString*)doAXAttributedStringForTextMarkerRange:(id)textMarkerRange spellCheck:(BOOL)spellCheck
    12491254{
    1250     return Accessibility::retrieveValueFromMainThread<NSAttributedString *>([&textMarkerRange, &spellCheck, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> NSAttributedString * {
     1255    return Accessibility::retrieveValueFromMainThread<NSAttributedString *>([&textMarkerRange, &spellCheck, protectedSelf = retainWrapper(self)] () -> NSAttributedString * {
    12511256        auto* backingObject = protectedSelf.get().axBackingObject;
    12521257        if (!backingObject)
    … …  
    12941299- (id)textMarkerRangeFromVisiblePositions:(const VisiblePosition&)startPosition endPosition:(const VisiblePosition&)endPosition
    12951300{
    1296     auto* backingObject = self.axBackingObject;
    1297     if (!backingObject)
    1298         return nil;
    1299 
    1300     return textMarkerRangeFromVisiblePositions(backingObject->axObjectCache(), startPosition, endPosition);
     1301    return Accessibility::retrieveValueFromMainThread<NSAttributedString *>([&startPosition, &endPosition, protectedSelf = retainWrapper(self)] () -> id {
     1302        auto* backingObject = protectedSelf.get().axBackingObject;
     1303        if (!backingObject)
     1304            return nil;
     1305
     1306        return textMarkerRangeFromVisiblePositions(backingObject->axObjectCache(), startPosition, endPosition);
     1307    });
    13011308}
    13021309
    … …  
    19131920- (id)associatedPluginParent
    19141921{
    1915     return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     1922    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    19161923        auto* backingObject = protectedSelf.get().axBackingObject;
    19171924        if (!backingObject || !backingObject->hasApplePDFAnnotationAttribute())
    … …  
    22832290- (id)windowElement:(NSString*)attributeName
    22842291{
    2285     return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([attributeName, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     2292    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([attributeName, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    22862293        id remoteParent = [protectedSelf remoteAccessibilityParentObject];
    22872294        if (remoteParent) {
    … …  
    28182825
    28192826    if ([attributeName isEqualToString:@"AXSelectedTextMarkerRange"]) {
    2820         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     2827        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    28212828            return [protectedSelf textMarkerRangeForSelection];
    28222829        });
    … …  
    28242831
    28252832    if ([attributeName isEqualToString:@"AXStartTextMarker"]) {
    2826         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     2833        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    28272834            if (auto* backingObject = protectedSelf.get().axBackingObject)
    28282835                return [protectedSelf textMarkerForVisiblePosition:startOfDocument(backingObject->document())];
    … …  
    28322839
    28332840    if ([attributeName isEqualToString:@"AXEndTextMarker"]) {
    2834         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     2841        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    28352842            if (auto* backingObject = protectedSelf.get().axBackingObject)
    28362843                return [protectedSelf textMarkerForVisiblePosition:endOfDocument(backingObject->document())];
    … …  
    34003407- (void)accessibilityShowContextMenu
    34013408{
    3402     Accessibility::performFunctionOnMainThread([protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] {
     3409    Accessibility::performFunctionOnMainThread([protectedSelf = retainWrapper(self)] {
    34033410        [protectedSelf _accessibilityShowContextMenu];
    34043411    });
    … …  
    37573764#endif
    37583765
     3766enum class TextUnit {
     3767    LeftWord = 1,
     3768    RightWord,
     3769    NextWordEnd,
     3770    PreviousWordStart,
     3771    Sentence,
     3772    NextSentenceEnd,
     3773    PreviousSentenceStart,
     3774    Paragraph,
     3775    NextParagraphEnd,
     3776    PreviousParagraphStart,
     3777    Line,
     3778    LeftLine,
     3779    RightLine,
     3780    NextLineEnd,
     3781    PreviousLineStart,
     3782};
     3783
     3784- (id)textMarkerRangeAtTextMarker:(id)textMarker forUnit:(TextUnit)textUnit
     3785{
     3786    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, &textUnit, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     3787        auto* backingObject = protectedSelf.get().axBackingObject;
     3788        if (!backingObject)
     3789            return nil;
     3790
     3791        auto* cache = backingObject->axObjectCache();
     3792        if (!cache)
     3793            return nil;
     3794
     3795        auto characterOffset = characterOffsetForTextMarker(cache, textMarker);
     3796        RefPtr<Range> range;
     3797        switch (textUnit) {
     3798        case TextUnit::LeftWord:
     3799            range = cache->leftWordRange(characterOffset);
     3800            break;
     3801        case TextUnit::RightWord:
     3802            range = cache->rightWordRange(characterOffset);
     3803            break;
     3804        case TextUnit::Sentence:
     3805            range = cache->sentenceForCharacterOffset(characterOffset);
     3806            break;
     3807        case TextUnit::Paragraph:
     3808            range = cache->paragraphForCharacterOffset(characterOffset);
     3809            break;
     3810        default:
     3811            ASSERT_NOT_REACHED();
     3812            break;
     3813        }
     3814
     3815        return textMarkerRangeFromRange(cache, range);
     3816    });
     3817}
     3818
     3819- (id)lineTextMarkerRangeForTextMarker:(id)textMarker forUnit:(TextUnit)textUnit
     3820{
     3821    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, &textUnit, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     3822        auto* backingObject = protectedSelf.get().axBackingObject;
     3823        if (!backingObject)
     3824            return nil;
     3825
     3826        auto* cache = backingObject->axObjectCache();
     3827        if (!cache)
     3828            return nil;
     3829
     3830        auto visiblePosition = visiblePositionForTextMarker(cache, textMarker);
     3831        VisiblePositionRange visiblePositionRange;
     3832        switch (textUnit) {
     3833        case TextUnit::Line:
     3834            visiblePositionRange = backingObject->lineRangeForPosition(visiblePosition);
     3835            break;
     3836        case TextUnit::LeftLine:
     3837            visiblePositionRange = backingObject->leftLineVisiblePositionRange(visiblePosition);
     3838            break;
     3839        case TextUnit::RightLine:
     3840            visiblePositionRange = backingObject->rightLineVisiblePositionRange(visiblePosition);
     3841            break;
     3842        default:
     3843            ASSERT_NOT_REACHED();
     3844            break;
     3845        }
     3846
     3847        return textMarkerRangeFromVisiblePositions(backingObject->axObjectCache(), visiblePositionRange.start, visiblePositionRange.end);
     3848    });
     3849}
     3850
     3851- (id)textMarkerForTextMarker:(id)textMarker atUnit:(TextUnit)textUnit
     3852{
     3853    return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, &textUnit, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     3854        auto* backingObject = protectedSelf.get().axBackingObject;
     3855        if (!backingObject)
     3856            return nil;
     3857
     3858        auto* cache = backingObject->axObjectCache();
     3859        if (!cache)
     3860            return nil;
     3861
     3862        CharacterOffset oldOffset = characterOffsetForTextMarker(cache, textMarker);
     3863        CharacterOffset newOffset;
     3864        switch (textUnit) {
     3865        case TextUnit::NextWordEnd:
     3866            newOffset = cache->nextWordEndCharacterOffset(oldOffset);
     3867            break;
     3868        case TextUnit::PreviousWordStart:
     3869            newOffset = cache->previousWordStartCharacterOffset(oldOffset);
     3870            break;
     3871        case TextUnit::NextSentenceEnd:
     3872            newOffset = cache->nextSentenceEndCharacterOffset(oldOffset);
     3873            break;
     3874        case TextUnit::PreviousSentenceStart:
     3875            newOffset = cache->previousSentenceStartCharacterOffset(oldOffset);
     3876            break;
     3877        case TextUnit::NextParagraphEnd:
     3878            newOffset = cache->nextParagraphEndCharacterOffset(oldOffset);
     3879            break;
     3880        case TextUnit::PreviousParagraphStart:
     3881            newOffset = cache->previousParagraphStartCharacterOffset(oldOffset);
     3882            break;
     3883        case TextUnit::NextLineEnd: {
     3884            auto visiblePosition = visiblePositionForTextMarker(cache, textMarker);
     3885            return textMarkerForVisiblePosition(cache, backingObject->nextLineEndPosition(visiblePosition));
     3886        }
     3887        case TextUnit::PreviousLineStart: {
     3888            auto visiblePosition = visiblePositionForTextMarker(cache, textMarker);
     3889            return textMarkerForVisiblePosition(cache, backingObject->previousLineStartPosition(visiblePosition));
     3890        }
     3891        default:
     3892            ASSERT_NOT_REACHED();
     3893            break;
     3894        }
     3895
     3896        return textMarkerForCharacterOffset(cache, newOffset);
     3897    });
     3898}
     3899
    37593900ALLOW_DEPRECATED_IMPLEMENTATIONS_BEGIN
    37603901- (id)accessibilityAttributeValue:(NSString*)attribute forParameter:(id)parameter
    … …  
    38123953    if ([attribute isEqualToString:NSAccessibilitySelectTextWithCriteriaParameterizedAttribute]) {
    38133954        // To be deprecated.
    3814         auto result = Accessibility::retrieveValueFromMainThread<Vector<String>>([dictionary, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> Vector<String> {
     3955        auto result = Accessibility::retrieveValueFromMainThread<Vector<String>>([dictionary, protectedSelf = retainWrapper(self)] () -> Vector<String> {
    38153956            auto* backingObject = protectedSelf.get().axBackingObject;
    38163957            if (!backingObject)
    … …  
    38303971    if ([attribute isEqualToString:NSAccessibilitySearchTextWithCriteriaParameterizedAttribute]) {
    38313972        auto criteria = accessibilitySearchTextCriteriaForParameterizedAttribute(dictionary);
    3832         return Accessibility::retrieveValueFromMainThread<NSArray *>([&criteria, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> NSArray * {
     3973        return Accessibility::retrieveAutoreleasedValueFromMainThread<NSArray *>([&criteria, protectedSelf = retainWrapper(self)] () -> RetainPtr<NSArray> {
    38333974            auto* backingObject = protectedSelf.get().axBackingObject;
    38343975            if (!backingObject)
    … …  
    38483989
    38493990    if ([attribute isEqualToString:NSAccessibilityTextOperationParameterizedAttribute]) {
    3850         auto operationResult = Accessibility::retrieveValueFromMainThread<Vector<String>>([dictionary, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> Vector<String> {
     3991        auto operationResult = Accessibility::retrieveValueFromMainThread<Vector<String>>([dictionary, protectedSelf = retainWrapper(self)] () -> Vector<String> {
    38513992            auto* backingObject = protectedSelf.get().axBackingObject;
    38523993            if (!backingObject)
    … …  
    38794020
    38804021    if ([attribute isEqualToString:NSAccessibilityEndTextMarkerForBoundsParameterizedAttribute]) {
    3881         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&rect, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    3882             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4022        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&rect, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4023            auto* backingObject = protectedSelf.get().axBackingObject;
     4024            if (!backingObject)
     4025                return nil;
     4026
     4027            auto* cache = backingObject->axObjectCache();
    38834028            if (!cache)
    38844029                return nil;
    … …  
    38914036
    38924037    if ([attribute isEqualToString:NSAccessibilityStartTextMarkerForBoundsParameterizedAttribute]) {
    3893         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&rect, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    3894             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4038        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&rect, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4039            auto* backingObject = protectedSelf.get().axBackingObject;
     4040            if (!backingObject)
     4041                return nil;
     4042
     4043            auto* cache = backingObject->axObjectCache();
    38954044            if (!cache)
    38964045                return nil;
    … …  
    39024051    }
    39034052
    3904     if ([attribute isEqualToString:NSAccessibilityLineTextMarkerRangeForTextMarkerParameterizedAttribute]) {
    3905         VisiblePosition visiblePosition = [self visiblePositionForTextMarker:textMarker];
    3906         VisiblePositionRange visiblePositionRange = backingObject->lineRangeForPosition(visiblePosition);
    3907         return [self textMarkerRangeFromVisiblePositions:visiblePositionRange.start endPosition:visiblePositionRange.end];
    3908     }
     4053    if ([attribute isEqualToString:NSAccessibilityLineTextMarkerRangeForTextMarkerParameterizedAttribute])
     4054        return [self lineTextMarkerRangeForTextMarker:textMarker forUnit:TextUnit::Line];
    39094055
    39104056    if ([attribute isEqualToString:NSAccessibilityMisspellingTextMarkerRangeParameterizedAttribute]) {
    39114057        auto criteria = accessibilityMisspellingSearchCriteriaForParameterizedAttribute(self, dictionary);
    3912         if (auto misspellingRange = backingObject->getMisspellingRange(criteria.first, criteria.second))
    3913             return [self textMarkerRangeFromRange:misspellingRange];
    3914         return nil;
     4058        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&criteria, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4059            auto* backingObject = protectedSelf.get().axBackingObject;
     4060            if (!backingObject)
     4061                return nil;
     4062
     4063            if (auto misspellingRange = backingObject->getMisspellingRange(criteria.first, criteria.second))
     4064                return [protectedSelf textMarkerRangeFromRange:misspellingRange];
     4065            return nil;
     4066        });
    39154067    }
    39164068
    39174069    if ([attribute isEqualToString:NSAccessibilityTextMarkerIsValidParameterizedAttribute]) {
    3918         VisiblePosition pos = [self visiblePositionForTextMarker:textMarker];
    3919         return [NSNumber numberWithBool:!pos.isNull()];
    3920     }
     4070        bool result = Accessibility::retrieveValueFromMainThread<bool>([&textMarker, protectedSelf = retainWrapper(self)] () -> bool {
     4071            VisiblePosition pos = [protectedSelf visiblePositionForTextMarker:textMarker];
     4072            return !pos.isNull();
     4073        });
     4074        return [NSNumber numberWithBool:result];
     4075    }
     4076
    39214077    if ([attribute isEqualToString:NSAccessibilityIndexForTextMarkerParameterizedAttribute]) {
    3922         return [NSNumber numberWithInteger:[self _indexForTextMarker:textMarker]];
    3923     }
     4078        auto result = Accessibility::retrieveValueFromMainThread<NSInteger>([&textMarker, protectedSelf = retainWrapper(self)] () -> NSInteger {
     4079            return [protectedSelf _indexForTextMarker:textMarker];
     4080        });
     4081        return [NSNumber numberWithInteger:result];
     4082    }
     4083
    39244084    if ([attribute isEqualToString:NSAccessibilityTextMarkerForIndexParameterizedAttribute]) {
    3925         return [self _textMarkerForIndex:[number integerValue]];
     4085        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&number, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4086            return [protectedSelf _textMarkerForIndex:[number integerValue]];
     4087        });
    39264088    }
    39274089
    39284090    if ([attribute isEqualToString:@"AXUIElementForTextMarker"]) {
    3929         AccessibilityObject* axObject = [self accessibilityObjectForTextMarker:textMarker];
    3930         if (!axObject)
    3931             return nil;
    3932         if (axObject->isAttachment() && [axObject->wrapper() attachmentView])
    3933             return [axObject->wrapper() attachmentView];
    3934         return axObject->wrapper();
     4091        // FIXME: we need to return an IsolatedObject if this is called on the AX thread.
     4092        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4093            auto* axObject = [protectedSelf accessibilityObjectForTextMarker:textMarker];
     4094            if (!axObject)
     4095                return nil;
     4096            if (axObject->isAttachment() && [axObject->wrapper() attachmentView])
     4097                return [axObject->wrapper() attachmentView];
     4098            return axObject->wrapper();
     4099        });
    39354100    }
    39364101
    39374102    if ([attribute isEqualToString:@"AXTextMarkerRangeForUIElement"]) {
    3938         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&uiElement, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
     4103        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&uiElement, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
    39394104            RefPtr<Range> range = uiElement.get()->elementRange();
    39404105            return [protectedSelf textMarkerRangeFromRange:range];
    … …  
    39434108
    39444109    if ([attribute isEqualToString:@"AXLineForTextMarker"]) {
    3945         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    3946         return [NSNumber numberWithUnsignedInt:backingObject->lineForPosition(visiblePos)];
     4110        int result = Accessibility::retrieveValueFromMainThread<int>([&textMarker, protectedSelf = retainWrapper(self)] () -> int {
     4111            auto* backingObject = protectedSelf.get().axBackingObject;
     4112            if (!backingObject)
     4113                return -1;
     4114
     4115            VisiblePosition visiblePos = [protectedSelf visiblePositionForTextMarker:textMarker];
     4116            return backingObject->lineForPosition(visiblePos);
     4117        });
     4118        return [NSNumber numberWithInt:result];
    39474119    }
    39484120
    39494121    if ([attribute isEqualToString:@"AXTextMarkerRangeForLine"]) {
    3950         VisiblePositionRange vpRange;
    3951         if ([number unsignedIntegerValue] != NSNotFound)
    3952             vpRange = backingObject->visiblePositionRangeForLine([number unsignedIntValue]);
    3953         return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
     4122        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&number, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4123            auto* backingObject = protectedSelf.get().axBackingObject;
     4124            VisiblePositionRange vpRange;
     4125            if (backingObject && [number unsignedIntegerValue] != NSNotFound)
     4126                vpRange = backingObject->visiblePositionRangeForLine([number unsignedIntValue]);
     4127            return [protectedSelf textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
     4128        });
    39544129    }
    39554130
    39564131    if ([attribute isEqualToString:@"AXStringForTextMarkerRange"]) {
    3957         return Accessibility::retrieveValueFromMainThread<String>([&textMarkerRange, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> String {
     4132        return Accessibility::retrieveValueFromMainThread<String>([&textMarkerRange, protectedSelf = retainWrapper(self)] () -> String {
    39584133            RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
    39594134            auto* backingObject = protectedSelf.get().axBackingObject;
    … …  
    39674142            return nil;
    39684143
    3969         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&webCorePoint, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    3970             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4144        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&webCorePoint, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4145            auto* backingObject = protectedSelf.get().axBackingObject;
     4146            if (!backingObject)
     4147                return nil;
     4148
     4149            auto* cache = backingObject->axObjectCache();
    39714150            if (!cache)
    39724151                return nil;
    39734152
    3974             CharacterOffset characterOffset = cache->characterOffsetForPoint(webCorePoint, protectedSelf.get().axBackingObject);
     4153            CharacterOffset characterOffset = cache->characterOffsetForPoint(webCorePoint, backingObject);
    39754154            return [protectedSelf textMarkerForCharacterOffset:characterOffset];
    39764155        });
    … …  
    39784157
    39794158    if ([attribute isEqualToString:@"AXBoundsForTextMarkerRange"]) {
    3980         RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
    3981         auto bounds = FloatRect(backingObject->boundsForRange(range));
    3982         NSRect rect = [self convertRectToSpace:bounds space:AccessibilityConversionSpace::Screen];
     4159        NSRect rect = Accessibility::retrieveValueFromMainThread<NSRect>([&textMarkerRange, protectedSelf = retainWrapper(self)] () -> NSRect {
     4160            auto* backingObject = protectedSelf.get().axBackingObject;
     4161            if (!backingObject)
     4162                return CGRectZero;
     4163
     4164            RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
     4165            auto bounds = FloatRect(backingObject->boundsForRange(range));
     4166            return [protectedSelf convertRectToSpace:bounds space:AccessibilityConversionSpace::Screen];
     4167        });
    39834168        return [NSValue valueWithRect:rect];
    39844169    }
    39854170
    39864171    if ([attribute isEqualToString:NSAccessibilityBoundsForRangeParameterizedAttribute]) {
    3987         NSRect rect = Accessibility::retrieveValueFromMainThread<NSRect>([&range, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> NSRect {
     4172        NSRect rect = Accessibility::retrieveValueFromMainThread<NSRect>([&range, protectedSelf = retainWrapper(self)] () -> NSRect {
    39884173            auto* backingObject = protectedSelf.get().axBackingObject;
    39894174            if (!backingObject)
    … …  
    40124197        }
    40134198
    4014         return Accessibility::retrieveValueFromMainThread<NSString *>([&range, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> NSString * {
    4015             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4199        return Accessibility::retrieveValueFromMainThread<String>([&range, protectedSelf = retainWrapper(self)] () -> String {
     4200            auto* backingObject = protectedSelf.get().axBackingObject;
     4201            if (!backingObject)
     4202                return String();
     4203
     4204            auto* cache = backingObject->axObjectCache();
    40164205            if (!cache)
    4017                 return nil;
    4018 
    4019             CharacterOffset start = cache->characterOffsetForIndex(range.location, protectedSelf.get().axBackingObject);
    4020             CharacterOffset end = cache->characterOffsetForIndex(range.location + range.length, protectedSelf.get().axBackingObject);
     4206                return String();
     4207
     4208            CharacterOffset start = cache->characterOffsetForIndex(range.location, backingObject);
     4209            CharacterOffset end = cache->characterOffsetForIndex(range.location + range.length, backingObject);
    40214210            if (start.isNull() || end.isNull())
    4022                 return nil;
     4211                return String();
    40234212
    40244213            RefPtr<Range> range = cache->rangeForUnorderedCharacterOffsets(start, end);
    4025             return protectedSelf.get().axBackingObject->stringForRange(range);
     4214            return backingObject->stringForRange(range);
    40264215        });
    40274216    }
    … …  
    40564245            return nil;
    40574246
    4058         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker1, textMarker2, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4059             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4247        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker1, &textMarker2, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4248            auto* backingObject = protectedSelf.get().axBackingObject;
     4249            if (!backingObject)
     4250                return nil;
     4251
     4252            auto* cache = backingObject->axObjectCache();
    40604253            if (!cache)
    40614254                return nil;
    … …  
    40694262
    40704263    if ([attribute isEqualToString:@"AXNextTextMarkerForTextMarker"]) {
    4071         CharacterOffset characterOffset = [self characterOffsetForTextMarker:textMarker];
    4072         return [self nextTextMarkerForCharacterOffset:characterOffset];
     4264        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4265            CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
     4266            return [protectedSelf nextTextMarkerForCharacterOffset:characterOffset];
     4267        });
    40734268    }
    40744269
    40754270    if ([attribute isEqualToString:@"AXPreviousTextMarkerForTextMarker"]) {
    4076         CharacterOffset characterOffset = [self characterOffsetForTextMarker:textMarker];
    4077         return [self previousTextMarkerForCharacterOffset:characterOffset];
    4078     }
    4079 
    4080     if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"]) {
    4081         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4082             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
     4271        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4272            CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
     4273            return [protectedSelf previousTextMarkerForCharacterOffset:characterOffset];
     4274        });
     4275    }
     4276
     4277    if ([attribute isEqualToString:@"AXLeftWordTextMarkerRangeForTextMarker"])
     4278        return [self textMarkerRangeAtTextMarker:textMarker forUnit:TextUnit::LeftWord];
     4279
     4280    if ([attribute isEqualToString:@"AXRightWordTextMarkerRangeForTextMarker"])
     4281        return [self textMarkerRangeAtTextMarker:textMarker forUnit:TextUnit::RightWord];
     4282
     4283    if ([attribute isEqualToString:@"AXLeftLineTextMarkerRangeForTextMarker"])
     4284        return [self lineTextMarkerRangeForTextMarker:textMarker forUnit:TextUnit::LeftLine];
     4285
     4286    if ([attribute isEqualToString:@"AXRightLineTextMarkerRangeForTextMarker"])
     4287        return [self lineTextMarkerRangeForTextMarker:textMarker forUnit:TextUnit::RightLine];
     4288
     4289    if ([attribute isEqualToString:@"AXSentenceTextMarkerRangeForTextMarker"])
     4290        return [self textMarkerRangeAtTextMarker:textMarker forUnit:TextUnit::Sentence];
     4291
     4292    if ([attribute isEqualToString:@"AXParagraphTextMarkerRangeForTextMarker"])
     4293        return [self textMarkerRangeAtTextMarker:textMarker forUnit:TextUnit::Paragraph];
     4294
     4295    if ([attribute isEqualToString:@"AXNextWordEndTextMarkerForTextMarker"])
     4296        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::NextWordEnd];
     4297
     4298    if ([attribute isEqualToString:@"AXPreviousWordStartTextMarkerForTextMarker"])
     4299        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::PreviousWordStart];
     4300
     4301    if ([attribute isEqualToString:@"AXNextLineEndTextMarkerForTextMarker"])
     4302        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::NextLineEnd];
     4303
     4304    if ([attribute isEqualToString:@"AXPreviousLineStartTextMarkerForTextMarker"])
     4305        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::PreviousLineStart];
     4306
     4307    if ([attribute isEqualToString:@"AXNextSentenceEndTextMarkerForTextMarker"])
     4308        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::NextSentenceEnd];
     4309
     4310    if ([attribute isEqualToString:@"AXPreviousSentenceStartTextMarkerForTextMarker"])
     4311        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::PreviousSentenceStart];
     4312
     4313    if ([attribute isEqualToString:@"AXNextParagraphEndTextMarkerForTextMarker"])
     4314        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::NextParagraphEnd];
     4315
     4316    if ([attribute isEqualToString:@"AXPreviousParagraphStartTextMarkerForTextMarker"])
     4317        return [self textMarkerForTextMarker:textMarker atUnit:TextUnit::PreviousParagraphStart];
     4318
     4319    if ([attribute isEqualToString:@"AXStyleTextMarkerRangeForTextMarker"]) {
     4320        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarker, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4321            auto* backingObject = protectedSelf.get().axBackingObject;
     4322            if (!backingObject)
     4323                return nil;
     4324
     4325            auto* cache = backingObject->axObjectCache();
    40834326            if (!cache)
    40844327                return nil;
    40854328
    4086             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4087             RefPtr<Range> range = cache->leftWordRange(characterOffset);
    4088             return [protectedSelf textMarkerRangeFromRange:range];
     4329        VisiblePosition visiblePos = visiblePositionForTextMarker(cache, textMarker);
     4330        VisiblePositionRange vpRange = backingObject->styleRangeForPosition(visiblePos);
     4331        return [protectedSelf textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
    40894332        });
    40904333    }
    40914334
    4092     if ([attribute isEqualToString:@"AXRightWordTextMarkerRangeForTextMarker"]) {
    4093         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4094             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4095             if (!cache)
    4096                 return nil;
    4097 
    4098             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4099             RefPtr<Range> range = cache->rightWordRange(characterOffset);
    4100             return [protectedSelf textMarkerRangeFromRange:range];
     4335    if ([attribute isEqualToString:@"AXLengthForTextMarkerRange"]) {
     4336        int length = Accessibility::retrieveValueFromMainThread<int>([&textMarkerRange, protectedSelf = retainWrapper(self)] () -> int {
     4337            auto* backingObject = protectedSelf.get().axBackingObject;
     4338            if (!backingObject)
     4339                return 0;
     4340
     4341            RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
     4342            return AXObjectCache::lengthForRange(range.get());
    41014343        });
    4102     }
    4103 
    4104     if ([attribute isEqualToString:@"AXLeftLineTextMarkerRangeForTextMarker"]) {
    4105         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    4106         VisiblePositionRange vpRange = backingObject->leftLineVisiblePositionRange(visiblePos);
    4107         return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
    4108     }
    4109 
    4110     if ([attribute isEqualToString:@"AXRightLineTextMarkerRangeForTextMarker"]) {
    4111         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    4112         VisiblePositionRange vpRange = backingObject->rightLineVisiblePositionRange(visiblePos);
    4113         return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
    4114     }
    4115 
    4116     if ([attribute isEqualToString:@"AXSentenceTextMarkerRangeForTextMarker"]) {
    4117         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4118             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4119             if (!cache)
    4120                 return nil;
    4121 
    4122             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4123             RefPtr<Range> range = cache->sentenceForCharacterOffset(characterOffset);
    4124             return [protectedSelf textMarkerRangeFromRange:range];
    4125         });
    4126     }
    4127 
    4128     if ([attribute isEqualToString:@"AXParagraphTextMarkerRangeForTextMarker"]) {
    4129         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4130             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4131             if (!cache)
    4132                 return nil;
    4133 
    4134             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4135             RefPtr<Range> range = cache->paragraphForCharacterOffset(characterOffset);
    4136             return [protectedSelf textMarkerRangeFromRange:range];
    4137         });
    4138     }
    4139 
    4140     if ([attribute isEqualToString:@"AXNextWordEndTextMarkerForTextMarker"]) {
    4141         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4142             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4143             if (!cache)
    4144                 return nil;
    4145 
    4146             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4147             CharacterOffset nextEnd = cache->nextWordEndCharacterOffset(characterOffset);
    4148             return [protectedSelf textMarkerForCharacterOffset:nextEnd];
    4149         });
    4150     }
    4151 
    4152     if ([attribute isEqualToString:@"AXPreviousWordStartTextMarkerForTextMarker"]) {
    4153         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4154             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4155             if (!cache)
    4156                 return nil;
    4157 
    4158             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4159             CharacterOffset previousStart = cache->previousWordStartCharacterOffset(characterOffset);
    4160             return [protectedSelf textMarkerForCharacterOffset:previousStart];
    4161         });
    4162     }
    4163 
    4164     if ([attribute isEqualToString:@"AXNextLineEndTextMarkerForTextMarker"]) {
    4165         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    4166         return [self textMarkerForVisiblePosition:backingObject->nextLineEndPosition(visiblePos)];
    4167     }
    4168 
    4169     if ([attribute isEqualToString:@"AXPreviousLineStartTextMarkerForTextMarker"]) {
    4170         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    4171         return [self textMarkerForVisiblePosition:backingObject->previousLineStartPosition(visiblePos)];
    4172     }
    4173 
    4174     if ([attribute isEqualToString:@"AXNextSentenceEndTextMarkerForTextMarker"]) {
    4175         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4176             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4177             if (!cache)
    4178                 return nil;
    4179 
    4180             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4181             CharacterOffset nextEnd = cache->nextSentenceEndCharacterOffset(characterOffset);
    4182             return [protectedSelf textMarkerForCharacterOffset:nextEnd];
    4183         });
    4184     }
    4185 
    4186     if ([attribute isEqualToString:@"AXPreviousSentenceStartTextMarkerForTextMarker"]) {
    4187         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4188             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4189             if (!cache)
    4190                 return nil;
    4191 
    4192             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4193             CharacterOffset previousStart = cache->previousSentenceStartCharacterOffset(characterOffset);
    4194             return [protectedSelf textMarkerForCharacterOffset:previousStart];
    4195         });
    4196     }
    4197 
    4198     if ([attribute isEqualToString:@"AXNextParagraphEndTextMarkerForTextMarker"]) {
    4199         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4200             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4201             if (!cache)
    4202                 return nil;
    4203 
    4204             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4205             CharacterOffset nextEnd = cache->nextParagraphEndCharacterOffset(characterOffset);
    4206             return [protectedSelf textMarkerForCharacterOffset:nextEnd];
    4207         });
    4208     }
    4209 
    4210     if ([attribute isEqualToString:@"AXPreviousParagraphStartTextMarkerForTextMarker"]) {
    4211         return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([textMarker, protectedSelf = RetainPtr<WebAccessibilityObjectWrapper>(self)] () -> RetainPtr<id> {
    4212             auto* cache = protectedSelf.get().axBackingObject->axObjectCache();
    4213             if (!cache)
    4214                 return nil;
    4215 
    4216             CharacterOffset characterOffset = [protectedSelf characterOffsetForTextMarker:textMarker];
    4217             CharacterOffset previousStart = cache->previousParagraphStartCharacterOffset(characterOffset);
    4218             return [protectedSelf textMarkerForCharacterOffset:previousStart];
    4219         });
    4220     }
    4221 
    4222     if ([attribute isEqualToString:@"AXStyleTextMarkerRangeForTextMarker"]) {
    4223         VisiblePosition visiblePos = [self visiblePositionForTextMarker:(textMarker)];
    4224         VisiblePositionRange vpRange = backingObject->styleRangeForPosition(visiblePos);
    4225         return [self textMarkerRangeFromVisiblePositions:vpRange.start endPosition:vpRange.end];
    4226     }
    4227 
    4228     if ([attribute isEqualToString:@"AXLengthForTextMarkerRange"]) {
    4229         RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
    4230         int length = AXObjectCache::lengthForRange(range.get());
    42314344        if (length < 0)
    42324345            return nil;
    … …  
    42364349    // Used only by DumpRenderTree (so far).
    42374350    if ([attribute isEqualToString:@"AXStartTextMarkerForTextMarkerRange"]) {
    4238         RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
    4239         return [self startOrEndTextMarkerForRange:range isStart:YES];
     4351        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarkerRange, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4352            RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
     4353            return [protectedSelf startOrEndTextMarkerForRange:range isStart:YES];
     4354        });
    42404355    }
    42414356
    42424357    if ([attribute isEqualToString:@"AXEndTextMarkerForTextMarkerRange"]) {
    4243         RefPtr<Range> range = [self rangeForTextMarkerRange:textMarkerRange];
    4244         return [self startOrEndTextMarkerForRange:range isStart:NO];
     4358        return Accessibility::retrieveAutoreleasedValueFromMainThread<id>([&textMarkerRange, protectedSelf = retainWrapper(self)] () -> RetainPtr<id> {
     4359            RefPtr<Range> range = [protectedSelf rangeForTextMarkerRange:textMarkerRange];
     4360            return [protectedSelf startOrEndTextMarkerForRange:range isStart:NO];
     4361        });
    42454362    }
    42464363
Note: See TracChangeset for help on using the changeset viewer.