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

Changeset 286116 in webkit


Ignore:
Timestamp:
Nov 22, 2021, 12:34:19 PM (5 years ago)
Author:
Chris Fleizach
Message:

AX: WebKit: need a method to get visible text and frame of an element on screen
​https://bugs.webkit.org/show_bug.cgi?id=233336

Reviewed by Andres Gonzalez.

Source/WebCore:

Implement visibleCharacterRange for static text elements so that Books can determine the visible
content on a page.

Test: accessibility/visible-character-range.html

  • accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::visibleCharacterRange const):
(WebCore::AccessibilityObject::unobscuredContentRect const):

  • accessibility/AccessibilityObject.h:
  • accessibility/AccessibilityObjectInterface.h:
  • accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:

(-[WebAccessibilityObjectWrapper accessibilityVisibleContentRect]):
(accessibleElementsForObjects):
(-[WebAccessibilityObjectWrapper accessibilityFindMatchingObjects:]):
(-[WebAccessibilityObjectWrapper positionForTextMarker:]):
(-[WebAccessibilityObjectWrapper textMarkerForPosition:]):
(-[WebAccessibilityObjectWrapper stringForRange:]):
(-[WebAccessibilityObjectWrapper frameForRange:]):
(-[WebAccessibilityObjectWrapper accessibilityMathRadicand]):
(-[WebAccessibilityObjectWrapper _convertToNSRange:]): Deleted.
(-[WebAccessibilityObjectWrapper _convertToDOMRange:]): Deleted.

  • accessibility/isolatedtree/AXIsolatedObject.cpp:

(WebCore::AXIsolatedObject::visibleCharacterRange const):
(WebCore::AXIsolatedObject::unobscuredContentRect const):

  • accessibility/isolatedtree/AXIsolatedObject.h:
  • accessibility/mac/WebAccessibilityObjectWrapperBase.h:
  • accessibility/mac/WebAccessibilityObjectWrapperBase.mm:

(makeNSArray):
(-[WebAccessibilityObjectWrapperBase accessibilityVisibleCharacterRange]):
(makeNSRange):
(makeDOMRange):
(-[WebAccessibilityObjectWrapperBase baseUpdateBackingStore]):
(-[WebAccessibilityObjectWrapperBase lineRectsAndText]):
(convertToNSArray): Deleted.

  • accessibility/mac/WebAccessibilityObjectWrapperMac.mm:

(-[WebAccessibilityObjectWrapper childrenVectorArray]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
(-[WebAccessibilityObjectWrapper _indexForTextMarker:]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
(-[WebAccessibilityObjectWrapper _convertToNSRange:]): Deleted.

LayoutTests:

  • accessibility/ios-simulator/visible-character-range-expected.txt: Added.
  • accessibility/visible-character-range-expected.txt: Added.
  • accessibility/visible-character-range.html: Added.
  • platform/ios/TestExpectations:
  • platform/mac-wk1/TestExpectations:
  • platform/win/TestExpectations:
Location:
trunk
Files:
3 added
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r286113 r286116  
     12021-11-22  Chris Fleizach  <cfleizach@apple.com>
     2
     3        AX: WebKit: need a method to get visible text and frame of an element on screen
     4        https://bugs.webkit.org/show_bug.cgi?id=233336
     5
     6        Reviewed by Andres Gonzalez.
     7
     8        * accessibility/ios-simulator/visible-character-range-expected.txt: Added.
     9        * accessibility/visible-character-range-expected.txt: Added.
     10        * accessibility/visible-character-range.html: Added.
     11        * platform/ios/TestExpectations:
     12        * platform/mac-wk1/TestExpectations:
     13        * platform/win/TestExpectations:
     14
    1152021-11-22  Antti Koivisto  <antti@apple.com>
    216

  • trunk/LayoutTests/platform/ios/TestExpectations

    r286063 r286116  
    21192119
    21202120accessibility/video-element-url-attribute.html [ Pass ]
    2121 
     2121accessibility/visible-character-range.html [ Pass ]
    21222122accessibility/ancestor-computation.html [ Pass ]
    21232123

  • trunk/LayoutTests/platform/mac-wk1/TestExpectations

    r285993 r286116  
    602602editing/spelling/spelling-unified-emulation.html [ Failure ]
    603603
     604# Skip due to lack of DumpRenderTree `AccessibilityUIElement::stringDescriptionOfAttributeValue` implementation.
     605accessibility/visible-character-range.html [ Skip ]
     606
    604607# <rdar://problem/26050923> The result is probably still a pass, but we don't have a way
    605608# to have platform specific results that are different between WK1 and WK2.

  • trunk/LayoutTests/platform/win/TestExpectations

    r285998 r286116  
    279279accessibility/embedded-image-description.html [ Skip ]
    280280accessibility/img-no-alt-not-ignored-with-title.html [ Skip ]
     281accessibility/visible-character-range.html [ Skip ]
    281282
    282283# Need to implement AccessibilityUIElement::hasDocumentRoleAncestor(), AccessibilityUIElement::hasWebApplicationAncestor(),

  • trunk/Source/WebCore/ChangeLog

    r286115 r286116  
     12021-11-22  Chris Fleizach  <cfleizach@apple.com>
     2
     3        AX: WebKit: need a method to get visible text and frame of an element on screen
     4        https://bugs.webkit.org/show_bug.cgi?id=233336
     5
     6        Reviewed by Andres Gonzalez.
     7
     8        Implement visibleCharacterRange for static text elements so that Books can determine the visible
     9        content on a page.
     10
     11        Test: accessibility/visible-character-range.html
     12
     13        * accessibility/AccessibilityObject.cpp:
     14        (WebCore::AccessibilityObject::visibleCharacterRange const):
     15        (WebCore::AccessibilityObject::unobscuredContentRect const):
     16        * accessibility/AccessibilityObject.h:
     17        * accessibility/AccessibilityObjectInterface.h:
     18        * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
     19        (-[WebAccessibilityObjectWrapper accessibilityVisibleContentRect]):
     20        (accessibleElementsForObjects):
     21        (-[WebAccessibilityObjectWrapper accessibilityFindMatchingObjects:]):
     22        (-[WebAccessibilityObjectWrapper positionForTextMarker:]):
     23        (-[WebAccessibilityObjectWrapper textMarkerForPosition:]):
     24        (-[WebAccessibilityObjectWrapper stringForRange:]):
     25        (-[WebAccessibilityObjectWrapper frameForRange:]):
     26        (-[WebAccessibilityObjectWrapper accessibilityMathRadicand]):
     27        (-[WebAccessibilityObjectWrapper _convertToNSRange:]): Deleted.
     28        (-[WebAccessibilityObjectWrapper _convertToDOMRange:]): Deleted.
     29        * accessibility/isolatedtree/AXIsolatedObject.cpp:
     30        (WebCore::AXIsolatedObject::visibleCharacterRange const):
     31        (WebCore::AXIsolatedObject::unobscuredContentRect const):
     32        * accessibility/isolatedtree/AXIsolatedObject.h:
     33        * accessibility/mac/WebAccessibilityObjectWrapperBase.h:
     34        * accessibility/mac/WebAccessibilityObjectWrapperBase.mm:
     35        (makeNSArray):
     36        (-[WebAccessibilityObjectWrapperBase accessibilityVisibleCharacterRange]):
     37        (makeNSRange):
     38        (makeDOMRange):
     39        (-[WebAccessibilityObjectWrapperBase baseUpdateBackingStore]):
     40        (-[WebAccessibilityObjectWrapperBase lineRectsAndText]):
     41        (convertToNSArray): Deleted.
     42        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
     43        (-[WebAccessibilityObjectWrapper childrenVectorArray]):
     44        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
     45        (-[WebAccessibilityObjectWrapper _indexForTextMarker:]):
     46        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
     47        (-[WebAccessibilityObjectWrapper _convertToNSRange:]): Deleted.
     48
    1492021-11-20  Simon Fraser  <simon.fraser@apple.com>
    250

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

    r285632 r286116  
    703703        return { };
    704704    return AXObjectCache::rangeForNodeContents(*node);
     705}
     706
     707std::optional<SimpleRange> AccessibilityObject::visibleCharacterRange() const
     708{
     709    auto range = elementRange();
     710    if (!range)
     711        return std::nullopt;
     712
     713    auto contentRect = unobscuredContentRect();
     714    auto elementRect = snappedIntRect(this->elementRect());
     715    if (!contentRect.intersects(elementRect))
     716        return std::nullopt;
     717
     718    std::optional<BoundaryPoint> startBoundary = range->start;
     719    std::optional<BoundaryPoint> endBoundary = range->end;
     720
     721    // Origin isn't contained in visible rect, start moving forward by line.
     722    while (!contentRect.contains(elementRect.location())) {
     723        auto nextLinePosition = nextLineEndPosition(VisiblePosition(makeContainerOffsetPosition(*startBoundary)));
     724        std::optional<BoundaryPoint> testStartBoundary = makeBoundaryPoint(nextLinePosition);
     725        if (!testStartBoundary || !contains(*range, *testStartBoundary))
     726            break;
     727       
     728        startBoundary = testStartBoundary;
     729        elementRect = boundsForRange(SimpleRange(*startBoundary, range->end));
     730        if (elementRect.isEmpty())
     731            break;
     732    }
     733
     734    // End isn't contained in visible rect, start moving backwards by line.
     735    while (!contentRect.contains(elementRect.location() + elementRect.size())) {
     736        auto previousLinePosition = previousLineStartPosition(VisiblePosition(makeContainerOffsetPosition(*endBoundary)));
     737        std::optional<BoundaryPoint> testEndBoundary = makeBoundaryPoint(previousLinePosition);
     738        if (!testEndBoundary || !contains(*range, *testEndBoundary))
     739            break;
     740       
     741        endBoundary = testEndBoundary;
     742        elementRect = boundsForRange({ *startBoundary, *endBoundary });
     743        if (elementRect.isEmpty())
     744            break;
     745    }
     746
     747    if (!startBoundary || !endBoundary)
     748        return std::nullopt;
     749   
     750    return {{ *startBoundary, *endBoundary }};
    705751}
    706752
    … …  
    31833229}
    31843230
     3231FloatRect AccessibilityObject::unobscuredContentRect() const
     3232{
     3233    auto document = this->document();
     3234    if (!document || !document->view())
     3235        return { };
     3236    return FloatRect(snappedIntRect(document->view()->unobscuredContentRect()));
     3237}
     3238
    31853239void AccessibilityObject::scrollToGlobalPoint(const IntPoint& globalPoint) const
    31863240{

  • trunk/Source/WebCore/accessibility/AccessibilityObject.h

    r285991 r286116  
    809809    void ariaElementsReferencedByAttribute(AccessibilityChildrenVector&, const QualifiedName&) const;
    810810    virtual bool exposesTitleUIElement() const { return true; }
    811 
     811    FloatRect unobscuredContentRect() const override;
    812812    AccessibilityObject* radioGroupAncestor() const;
    813813
    … …  
    822822    std::optional<SimpleRange> selectionRange() const;
    823823    std::optional<SimpleRange> findTextRange(const Vector<String>& searchStrings, const SimpleRange& start, AccessibilitySearchTextDirection) const;
     824    std::optional<SimpleRange> visibleCharacterRange() const override;
    824825
    825826protected: // FIXME: Make the data members private.

  • trunk/Source/WebCore/accessibility/AccessibilityObjectInterface.h

    r285991 r286116  
    989989    virtual FloatRect relativeFrame() const = 0;
    990990    virtual FloatRect convertFrameToSpace(const FloatRect&, AccessibilityConversionSpace) const = 0;
     991    virtual FloatRect unobscuredContentRect() const = 0;
    991992    virtual bool supportsCheckedState() const = 0;
    992993   
    … …  
    998999    virtual bool hasMisspelling() const = 0;
    9991000    virtual std::optional<SimpleRange> misspellingRange(const SimpleRange& start, AccessibilitySearchDirection) const = 0;
     1001    virtual std::optional<SimpleRange> visibleCharacterRange() const = 0;
    10001002    virtual bool hasPlainText() const = 0;
    10011003    virtual bool hasSameFont(const AXCoreObject&) const = 0;

  • trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm

    r285589 r286116  
    5353#import "SVGNames.h"
    5454#import "SelectionGeometry.h"
     55#import "SimpleRange.h"
    5556#import "TextIterator.h"
    5657#import "WAKScrollView.h"
    … …  
    16951696    if (![self _prepareAccessibilityCall])
    16961697        return CGRectZero;
    1697    
    1698     auto document = self.axBackingObject->document();
    1699     if (!document || !document->view())
    1700         return CGRectZero;
    1701     auto rect = FloatRect(snappedIntRect(document->view()->unobscuredContentRect()));
    1702     return [self convertRectToSpace:rect space:AccessibilityConversionSpace::Screen];
     1698    return [self convertRectToSpace:self.axBackingObject->unobscuredContentRect() space:AccessibilityConversionSpace::Screen];
    17031699}
    17041700
    … …  
    19161912    }
    19171913
    1918     return convertToNSArray(accessibleElements);
     1914    return makeNSArray(accessibleElements);
    19191915}
    19201916
    … …  
    21052101    AccessibilityObject::AccessibilityChildrenVector results;
    21062102    self.axBackingObject->findMatchingObjects(&criteria, results);
    2107     return convertToNSArray(results);
     2103    return makeNSArray(results);
    21082104}
    21092105
    … …  
    22102206}
    22112207
    2212 // FIXME: No reason for this to be a method instead of a function.
    2213 - (NSRange)_convertToNSRange:(const SimpleRange&)range
    2214 {
    2215     auto& document = range.start.document();
    2216     auto* frame = document.frame();
    2217     if (!frame)
    2218         return NSMakeRange(NSNotFound, 0);
    2219 
    2220     auto* rootEditableElement = frame->selection().selection().rootEditableElement();
    2221     auto* scope = rootEditableElement ? rootEditableElement : document.documentElement();
    2222     if (!scope)
    2223         return NSMakeRange(NSNotFound, 0);
    2224 
    2225     // Mouse events may cause TSM to attempt to create an NSRange for a portion of the view
    2226     // that is not inside the current editable region. These checks ensure we don't produce
    2227     // potentially invalid data when responding to such requests.
    2228     if (!scope->contains(range.start.container.ptr()) || !scope->contains(range.end.container.ptr()))
    2229         return NSMakeRange(NSNotFound, 0);
    2230 
    2231     return NSMakeRange(characterCount({ { *scope, 0 }, range.start }), characterCount(range));
    2232 }
    2233 
    2234 - (std::optional<SimpleRange>)_convertToDOMRange:(NSRange)range
    2235 {
    2236     if (range.location == NSNotFound)
    2237         return std::nullopt;
    2238 
    2239     // our critical assumption is that we are only called by input methods that
    2240     // concentrate on a given area containing the selection
    2241     // We have to do this because of text fields and textareas. The DOM for those is not
    2242     // directly in the document DOM, so serialization is problematic. Our solution is
    2243     // to use the root editable element of the selection start as the positional base.
    2244     // That fits with AppKit's idea of an input context.
    2245     auto document = self.axBackingObject->document();
    2246     auto selectionRoot = document->frame()->selection().selection().rootEditableElement();
    2247     auto scope = selectionRoot ? selectionRoot : document->documentElement();
    2248     if (!scope)
    2249         return std::nullopt;
    2250 
    2251     return resolveCharacterRange(makeRangeSelectingNodeContents(*scope), range);
    2252 }
    22532208
    22542209// This method is intended to take a text marker representing a VisiblePosition and convert it
    … …  
    22682223        if (!range)
    22692224            return NSNotFound;
    2270         return [self _convertToNSRange:*range].location;
     2225        return makeNSRange(range).location;
    22712226    }
    22722227    return NSNotFound;
    … …  
    23472302        return nil;
    23482303
    2349     auto range = [self _convertToDOMRange:NSMakeRange(position, 0)];
     2304    auto range = makeDOMRange(self.axBackingObject->document(), NSMakeRange(position, 0));
    23502305    if (!range)
    23512306        return nil;
    … …  
    24152370    if (![self _prepareAccessibilityCall])
    24162371        return nil;
    2417     auto webRange = [self _convertToDOMRange:range];
     2372    auto webRange = makeDOMRange(self.axBackingObject->document(), range);
    24182373    if (!webRange)
    24192374        return nil;
    … …  
    25992554    CharacterOffset start = [marker characterOffset];
    26002555    return [self previousMarkerForCharacterOffset:start];
     2556}
     2557
     2558- (CGRect)frameForRange:(NSRange)range
     2559{
     2560    if (![self _prepareAccessibilityCall])
     2561        return CGRectZero;
     2562    auto webRange = makeDOMRange(self.axBackingObject->document(), range);
     2563    if (!webRange)
     2564        return CGRectZero;
     2565    auto rect = self.axBackingObject->boundsForRange(*webRange);
     2566    return [self convertRectToSpace:rect space:AccessibilityConversionSpace::Screen];
    26012567}
    26022568
    … …  
    29322898
    29332899    auto radicand = self.axBackingObject->mathRadicand();
    2934     return radicand ? convertToNSArray(*radicand) : nil;
     2900    return radicand ? makeNSArray(*radicand) : nil;
    29352901}
    29362902

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.cpp

    r285991 r286116  
    993993}
    994994
     995std::optional<SimpleRange> AXIsolatedObject::visibleCharacterRange() const
     996{
     997    ASSERT(isMainThread());
     998    auto* axObject = associatedAXObject();
     999    return axObject ? axObject->visibleCharacterRange() : std::nullopt;
     1000}
     1001
    9951002std::optional<SimpleRange> AXIsolatedObject::rangeForPlainTextRange(const PlainTextRange& axRange) const
    9961003{
    … …  
    14691476    if (auto* object = associatedAXObject())
    14701477        object->setSelectedVisiblePositionRange(visiblePositionRange);
     1478}
     1479
     1480FloatRect AXIsolatedObject::unobscuredContentRect() const
     1481{
     1482    return Accessibility::retrieveValueFromMainThread<FloatRect>([this] () -> FloatRect {
     1483        if (auto* object = associatedAXObject())
     1484            return object->unobscuredContentRect();
     1485        return { };
     1486    });
    14711487}
    14721488

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedObject.h

    r285991 r286116  
    442442    int lineForPosition(const VisiblePosition&) const override;
    443443    PlainTextRange plainTextRangeForVisiblePositionRange(const VisiblePositionRange&) const override;
     444    std::optional<SimpleRange> visibleCharacterRange() const override;
    444445    int index(const VisiblePosition&) const override;
    445446    void lineBreaks(Vector<int>&) const override;
    446 
     447    FloatRect unobscuredContentRect() const override;
     448   
    447449    // Attribute setters.
    448450    void setARIAGrabbed(bool) override;

  • trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperBase.h

    r284213 r286116  
    3535namespace WebCore {
    3636struct AccessibilitySearchCriteria;
     37class Document;
    3738class IntRect;
    3839class FloatPoint;
    … …  
    112113- (NSArray *)accessibilityMathPrescriptPairs;
    113114
     115- (NSRange)accessibilityVisibleCharacterRange;
     116
    114117- (NSDictionary<NSString *, id> *)baseAccessibilityResolvedEditingStyles;
    115118
    116119extern WebCore::AccessibilitySearchCriteria accessibilitySearchCriteriaForSearchPredicateParameterizedAttribute(const NSDictionary *);
    117120
    118 extern NSArray *convertToNSArray(const WebCore::AXCoreObject::AccessibilityChildrenVector&);
     121extern NSArray *makeNSArray(const WebCore::AXCoreObject::AccessibilityChildrenVector&);
     122extern NSRange makeNSRange(std::optional<WebCore::SimpleRange>);
     123extern std::optional<WebCore::SimpleRange> makeDOMRange(WebCore::Document*, NSRange);
    119124
    120125#if PLATFORM(IOS_FAMILY)

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

    r285991 r286116  
    262262}
    263263
    264 NSArray *convertToNSArray(const WebCore::AXCoreObject::AccessibilityChildrenVector& children)
     264NSArray *makeNSArray(const WebCore::AXCoreObject::AccessibilityChildrenVector& children)
    265265{
    266266    return createNSArray(children, [] (const auto& child) -> id {
    … …  
    461461    });
    462462    return convertedPath.autorelease();
     463}
     464
     465// Determine the visible range by checking intersection of unobscuredContentRect and a range of text by
     466// advancing forward by line from top and backwards by line from the bottom, until we have a visible range.
     467- (NSRange)accessibilityVisibleCharacterRange
     468{
     469    return Accessibility::retrieveValueFromMainThread<NSRange>([protectedSelf = retainPtr(self)] () -> NSRange {
     470        auto backingObject = protectedSelf.get().baseUpdateBackingStore;
     471        if (!backingObject)
     472            return NSMakeRange(NSNotFound, 0);
     473
     474        auto elementRange = makeNSRange(backingObject->elementRange());
     475        if (elementRange.location == NSNotFound)
     476            return elementRange;
     477       
     478        auto visibleRange = makeNSRange(backingObject->visibleCharacterRange());
     479        if (visibleRange.location == NSNotFound)
     480            return visibleRange;
     481
     482        return NSMakeRange(visibleRange.location - elementRange.location, visibleRange.length);
     483    });
    463484}
    464485
    … …  
    624645}
    625646
     647NSRange makeNSRange(std::optional<SimpleRange> range)
     648{
     649    if (!range)
     650        return NSMakeRange(NSNotFound, 0);
     651   
     652    auto& document = range->start.document();
     653    auto* frame = document.frame();
     654    if (!frame)
     655        return NSMakeRange(NSNotFound, 0);
     656
     657    auto* rootEditableElement = frame->selection().selection().rootEditableElement();
     658    auto* scope = rootEditableElement ? rootEditableElement : document.documentElement();
     659    if (!scope)
     660        return NSMakeRange(NSNotFound, 0);
     661
     662    // Mouse events may cause TSM to attempt to create an NSRange for a portion of the view
     663    // that is not inside the current editable region. These checks ensure we don't produce
     664    // potentially invalid data when responding to such requests.
     665    if (!scope->contains(range->start.container.ptr()) || !scope->contains(range->end.container.ptr()))
     666        return NSMakeRange(NSNotFound, 0);
     667
     668    return NSMakeRange(characterCount({ { *scope, 0 }, range->start }), characterCount(*range));
     669}
     670
     671std::optional<SimpleRange> makeDOMRange(Document* document, NSRange range)
     672{
     673    if (range.location == NSNotFound)
     674        return std::nullopt;
     675
     676    // our critical assumption is that we are only called by input methods that
     677    // concentrate on a given area containing the selection
     678    // We have to do this because of text fields and textareas. The DOM for those is not
     679    // directly in the document DOM, so serialization is problematic. Our solution is
     680    // to use the root editable element of the selection start as the positional base.
     681    // That fits with AppKit's idea of an input context.
     682    auto selectionRoot = document->frame()->selection().selection().rootEditableElement();
     683    auto scope = selectionRoot ? selectionRoot : document->documentElement();
     684    if (!scope)
     685        return std::nullopt;
     686
     687    return resolveCharacterRange(makeRangeSelectingNodeContents(*scope), range);
     688}
     689
    626690// Returns an array of strings and AXObject wrappers corresponding to the text
    627691// runs and replacement nodes included in the given range.
    … …  
    677741}
    678742
    679 - (NSArray<NSDictionary *> *)lineRectsAndText
     743- (WebCore::AXCoreObject*)baseUpdateBackingStore
    680744{
    681745#if PLATFORM(MAC)
    682746    auto* backingObject = self.updateObjectBackingStore;
    683747    if (!backingObject)
    684         return nil;
     748        return nullptr;
    685749#else
    686750    if (![self _prepareAccessibilityCall])
     751        return nullptr;
     752    auto* backingObject = self.axBackingObject;
     753#endif
     754    return backingObject;
     755}
     756
     757- (NSArray<NSDictionary *> *)lineRectsAndText
     758{
     759    auto backingObject = self.baseUpdateBackingStore;
     760    if (!backingObject)
    687761        return nil;
    688     auto* backingObject = self.axBackingObject;
    689 #endif
    690 
     762   
    691763    auto range = backingObject->elementRange();
    692764    if (!range)

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

    r285904 r286116  
    17961796- (NSArray<WebAccessibilityObjectWrapper *> *)childrenVectorArray
    17971797{
    1798     return convertToNSArray(self.axBackingObject->children());
     1798    return makeNSArray(self.axBackingObject->children());
    17991799}
    18001800
    … …  
    22042204            AccessibilityObject::AccessibilityChildrenVector contentCopy;
    22052205            backingObject->ariaTreeItemContent(contentCopy);
    2206             return convertToNSArray(contentCopy);
     2206            return makeNSArray(contentCopy);
    22072207        }
    22082208
    … …  
    22142214            AccessibilityObject::AccessibilityChildrenVector selectedChildrenCopy;
    22152215            backingObject->selectedChildren(selectedChildrenCopy);
    2216             return convertToNSArray(selectedChildrenCopy);
     2216            return makeNSArray(selectedChildrenCopy);
    22172217        }
    22182218        return nil;
    … …  
    22232223            AccessibilityObject::AccessibilityChildrenVector visibleChildrenCopy;
    22242224            backingObject->visibleChildren(visibleChildrenCopy);
    2225             return convertToNSArray(visibleChildrenCopy);
     2225            return makeNSArray(visibleChildrenCopy);
    22262226        }
    22272227
    … …  
    22352235    if (backingObject->isWebArea()) {
    22362236        if ([attributeName isEqualToString:@"AXLinkUIElements"])
    2237             return convertToNSArray(backingObject->documentLinks());
     2237            return makeNSArray(backingObject->documentLinks());
    22382238
    22392239        if ([attributeName isEqualToString:@"AXLoaded"])
    … …  
    22682268            return [NSValue valueWithRange:NSMakeRange(textRange.start, textRange.length)];
    22692269        }
    2270         // TODO: Get actual visible range. <rdar://problem/4712101>
    2271         if ([attributeName isEqualToString: NSAccessibilityVisibleCharacterRangeAttribute])
    2272             return backingObject->isPasswordField() ? nil : [NSValue valueWithRange: NSMakeRange(0, backingObject->textLength())];
    2273 
    22742270        if ([attributeName isEqualToString:NSAccessibilityInsertionPointLineNumberAttribute]) {
    22752271            int lineNumber = backingObject->insertionPointLineNumber();
    22762272            return lineNumber >= 0 ? @(lineNumber) : nil;
    22772273        }
     2274    }
     2275
     2276    if ([attributeName isEqualToString: NSAccessibilityVisibleCharacterRangeAttribute]) {
     2277        if (backingObject->isPasswordField())
     2278            return nil;
     2279        // TODO: Get actual visible range. <rdar://problem/4712101>
     2280        if (backingObject->isTextControl())
     2281            return [NSValue valueWithRange:NSMakeRange(0, backingObject->textLength())];
     2282        return [NSValue valueWithRange:[self accessibilityVisibleCharacterRange]];
    22782283    }
    22792284
    … …  
    23812386    if ([attributeName isEqualToString:NSAccessibilityImageOverlayElementsAttribute]) {
    23822387        auto imageOverlayElements = backingObject->imageOverlayElements();
    2383         return imageOverlayElements ? convertToNSArray(*imageOverlayElements) : nil;
     2388        return imageOverlayElements ? makeNSArray(*imageOverlayElements) : nil;
    23842389    }
    23852390
    … …  
    24052410            AccessibilityObject::AccessibilityChildrenVector tabsChildren;
    24062411            backingObject->tabChildren(tabsChildren);
    2407             return convertToNSArray(tabsChildren);
     2412            return makeNSArray(tabsChildren);
    24082413        }
    24092414    }
    24102415
    24112416    if ([attributeName isEqualToString:NSAccessibilityContentsAttribute])
    2412         return convertToNSArray(backingObject->contents());
     2417        return makeNSArray(backingObject->contents());
    24132418
    24142419    if (backingObject->isTable() && backingObject->isExposable()) {
    24152420        if ([attributeName isEqualToString:NSAccessibilityRowsAttribute])
    2416             return convertToNSArray(backingObject->rows());
     2421            return makeNSArray(backingObject->rows());
    24172422
    24182423        if ([attributeName isEqualToString:NSAccessibilityVisibleRowsAttribute])
    2419             return convertToNSArray(backingObject->visibleRows());
     2424            return makeNSArray(backingObject->visibleRows());
    24202425
    24212426        // TODO: distinguish between visible and non-visible columns
    24222427        if ([attributeName isEqualToString:NSAccessibilityColumnsAttribute]
    24232428            || [attributeName isEqualToString:NSAccessibilityVisibleColumnsAttribute])
    2424             return convertToNSArray(backingObject->columns());
     2429            return makeNSArray(backingObject->columns());
    24252430
    24262431        if ([attributeName isEqualToString:NSAccessibilitySelectedRowsAttribute]) {
    24272432            AccessibilityObject::AccessibilityChildrenVector selectedChildrenCopy;
    24282433            backingObject->selectedChildren(selectedChildrenCopy);
    2429             return convertToNSArray(selectedChildrenCopy);
     2434            return makeNSArray(selectedChildrenCopy);
    24302435        }
    24312436
    … …  
    24362441
    24372442        if ([attributeName isEqualToString:NSAccessibilityColumnHeaderUIElementsAttribute])
    2438             return convertToNSArray(backingObject->columnHeaders());
     2443            return makeNSArray(backingObject->columnHeaders());
    24392444
    24402445        if ([attributeName isEqualToString:NSAccessibilityHeaderAttribute]) {
    … …  
    24442449
    24452450        if ([attributeName isEqualToString:NSAccessibilityRowHeaderUIElementsAttribute])
    2446             return convertToNSArray(backingObject->rowHeaders());
     2451            return makeNSArray(backingObject->rowHeaders());
    24472452
    24482453        if ([attributeName isEqualToString:NSAccessibilityVisibleCellsAttribute])
    2449             return convertToNSArray(backingObject->cells());
     2454            return makeNSArray(backingObject->cells());
    24502455
    24512456        if ([attributeName isEqualToString:NSAccessibilityColumnCountAttribute])
    … …  
    24692474        if ([attributeName isEqualToString:NSAccessibilityRowsAttribute]
    24702475            || [attributeName isEqualToString:NSAccessibilityVisibleRowsAttribute])
    2471             return convertToNSArray(backingObject->children());
     2476            return makeNSArray(backingObject->children());
    24722477
    24732478        if ([attributeName isEqualToString:NSAccessibilityHeaderAttribute]) {
    … …  
    24892494
    24902495        if ([attributeName isEqualToString:NSAccessibilityColumnHeaderUIElementsAttribute])
    2491             return convertToNSArray(backingObject->columnHeaders());
     2496            return makeNSArray(backingObject->columnHeaders());
    24922497
    24932498        if ([attributeName isEqualToString:NSAccessibilityRowHeaderUIElementsAttribute])
    2494             return convertToNSArray(backingObject->rowHeaders());
     2499            return makeNSArray(backingObject->rowHeaders());
    24952500
    24962501        if ([attributeName isEqualToString:NSAccessibilityARIAColumnIndexAttribute])
    … …  
    25052510            AccessibilityObject::AccessibilityChildrenVector selectedChildrenCopy;
    25062511            backingObject->selectedChildren(selectedChildrenCopy);
    2507             return convertToNSArray(selectedChildrenCopy);
     2512            return makeNSArray(selectedChildrenCopy);
    25082513        }
    25092514        if ([attributeName isEqualToString:NSAccessibilityRowsAttribute]) {
    25102515            AccessibilityObject::AccessibilityChildrenVector rowsCopy;
    25112516            backingObject->ariaTreeRows(rowsCopy);
    2512             return convertToNSArray(rowsCopy);
     2517            return makeNSArray(rowsCopy);
    25132518        }
    25142519
    … …  
    25452550    if ([attributeName isEqualToString:NSAccessibilityDisclosedRowsAttribute]) {
    25462551        if (backingObject->isTreeItem() || backingObject->isARIATreeGridRow())
    2547             return convertToNSArray(backingObject->disclosedRows());
     2552            return makeNSArray(backingObject->disclosedRows());
    25482553    }
    25492554
    … …  
    26132618        AccessibilityObject::AccessibilityChildrenVector linkedUIElements;
    26142619        backingObject->linkedUIElements(linkedUIElements);
    2615         return convertToNSArray(linkedUIElements);
     2620        return makeNSArray(linkedUIElements);
    26162621    }
    26172622
    … …  
    26862691        AccessibilityObject::AccessibilityChildrenVector ariaOwns;
    26872692        backingObject->ariaOwnsElements(ariaOwns);
    2688         return convertToNSArray(ariaOwns);
     2693        return makeNSArray(ariaOwns);
    26892694    }
    26902695
    … …  
    27522757        if ([attributeName isEqualToString:NSAccessibilityMathRootRadicandAttribute]) {
    27532758            auto radicand = backingObject->mathRadicand();
    2754             return radicand ? convertToNSArray(*radicand) : nil;
     2759            return radicand ? makeNSArray(*radicand) : nil;
    27552760        }
    27562761
    … …  
    28462851        AccessibilityObject::AccessibilityChildrenVector details;
    28472852        backingObject->ariaDetailsElements(details);
    2848         return convertToNSArray(details);
     2853        return makeNSArray(details);
    28492854    }
    28502855
    … …  
    28612866        AccessibilityObject::AccessibilityChildrenVector errorMessages;
    28622867        backingObject->ariaErrorMessageElements(errorMessages);
    2863         return convertToNSArray(errorMessages);
     2868        return makeNSArray(errorMessages);
    28642869    }
    28652870
    … …  
    28792884        AccessibilityObject::AccessibilityChildrenVector ariaControls;
    28802885        backingObject->ariaControlsElements(ariaControls);
    2881         return convertToNSArray(ariaControls);
     2886        return makeNSArray(ariaControls);
    28822887    }
    28832888
    … …  
    34293434}
    34303435
    3431 // FIXME: No reason for this to be a method instead of a function; can get document from range.
    3432 - (NSRange)_convertToNSRange:(const SimpleRange&)range
    3433 {
    3434     ASSERT(isMainThread());
    3435    
    3436     auto document = self.axBackingObject->document();
    3437     if (!document)
    3438         return NSMakeRange(NSNotFound, 0);
    3439 
    3440     auto documentElement = document->documentElement();
    3441     if (!documentElement)
    3442         return NSMakeRange(NSNotFound, 0);
    3443 
    3444     return characterRange(makeBoundaryPointBeforeNodeContents(*documentElement), range);
    3445 }
    3446 
    34473436- (NSInteger)_indexForTextMarker:(AXTextMarkerRef)marker
    34483437{
    … …  
    34613450                return NSNotFound;
    34623451
    3463             return [protectedSelf _convertToNSRange:*range].location;
     3452            return makeNSRange(range).location;
    34643453        }
    34653454
    … …  
    38363825        backingObject->findMatchingObjects(&criteria, results);
    38373826        if (widgetChildren)
    3838             return [widgetChildren arrayByAddingObjectsFromArray:convertToNSArray(results)];
    3839         return convertToNSArray(results);
     3827            return [widgetChildren arrayByAddingObjectsFromArray:makeNSArray(results)];
     3828        return makeNSArray(results);
    38403829    }
    38413830

  • trunk/Tools/WebKitTestRunner/InjectedBundle/ios/AccessibilityUIElementIOS.mm

    r285859 r286116  
    109109- (id)_accessibilityPhotoDescription;
    110110- (NSArray *)accessibilityImageOverlayElements;
     111- (NSRange)accessibilityVisibleCharacterRange;
    111112
    112113// TextMarker related
    … …  
    395396JSRetainPtr<JSStringRef> AccessibilityUIElement::stringDescriptionOfAttributeValue(JSStringRef attribute)
    396397{
     398    if (JSStringIsEqualToUTF8CString(attribute, "AXVisibleCharacterRange"))
     399        return [NSStringFromRange([m_element accessibilityVisibleCharacterRange]) createJSStringRef];
     400
    397401    return createJSString();
    398402}
Note: See TracChangeset for help on using the changeset viewer.