71a2214eaf192df2ab9e1ca85e386ac701ff487f
[WebKit-https.git] / Source / WebCore / accessibility / AXObjectCache.cpp
1 /*
2  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30
31 #if HAVE(ACCESSIBILITY)
32
33 #include "AXObjectCache.h"
34
35 #include "AccessibilityARIAGrid.h"
36 #include "AccessibilityARIAGridCell.h"
37 #include "AccessibilityARIAGridRow.h"
38 #include "AccessibilityImageMapLink.h"
39 #include "AccessibilityList.h"
40 #include "AccessibilityListBox.h"
41 #include "AccessibilityListBoxOption.h"
42 #include "AccessibilityMediaControls.h"
43 #include "AccessibilityMenuList.h"
44 #include "AccessibilityMenuListOption.h"
45 #include "AccessibilityMenuListPopup.h"
46 #include "AccessibilityProgressIndicator.h"
47 #include "AccessibilityRenderObject.h"
48 #include "AccessibilityScrollView.h"
49 #include "AccessibilityScrollbar.h"
50 #include "AccessibilitySlider.h"
51 #include "AccessibilitySpinButton.h"
52 #include "AccessibilityTable.h"
53 #include "AccessibilityTableCell.h"
54 #include "AccessibilityTableColumn.h"
55 #include "AccessibilityTableHeaderContainer.h"
56 #include "AccessibilityTableRow.h"
57 #include "Document.h"
58 #include "FocusController.h"
59 #include "Frame.h"
60 #include "HTMLAreaElement.h"
61 #include "HTMLImageElement.h"
62 #include "HTMLInputElement.h"
63 #include "HTMLNames.h"
64 #if ENABLE(VIDEO)
65 #include "MediaControlElements.h"
66 #endif
67 #include "Page.h"
68 #include "RenderListBox.h"
69 #include "RenderMenuList.h"
70 #include "RenderProgress.h"
71 #include "RenderSlider.h"
72 #include "RenderTable.h"
73 #include "RenderTableCell.h"
74 #include "RenderTableRow.h"
75 #include "RenderView.h"
76 #include "ScrollView.h"
77
78 #include <wtf/PassRefPtr.h>
79
80 namespace WebCore {
81
82 using namespace HTMLNames;
83     
84 bool AXObjectCache::gAccessibilityEnabled = false;
85 bool AXObjectCache::gAccessibilityEnhancedUserInterfaceEnabled = false;
86
87 AXObjectCache::AXObjectCache(const Document* doc)
88     : m_notificationPostTimer(this, &AXObjectCache::notificationPostTimerFired)
89 {
90     m_document = const_cast<Document*>(doc);
91 }
92
93 AXObjectCache::~AXObjectCache()
94 {
95     HashMap<AXID, RefPtr<AccessibilityObject> >::iterator end = m_objects.end();
96     for (HashMap<AXID, RefPtr<AccessibilityObject> >::iterator it = m_objects.begin(); it != end; ++it) {
97         AccessibilityObject* obj = (*it).second.get();
98         detachWrapper(obj);
99         obj->detach();
100         removeAXID(obj);
101     }
102 }
103
104 AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement* areaElement)
105 {
106     // Find the corresponding accessibility object for the HTMLAreaElement. This should be
107     // in the list of children for its corresponding image.
108     if (!areaElement)
109         return 0;
110     
111     HTMLImageElement* imageElement = areaElement->imageElement();
112     if (!imageElement)
113         return 0;
114     
115     AccessibilityObject* axRenderImage = areaElement->document()->axObjectCache()->getOrCreate(imageElement->renderer());
116     if (!axRenderImage)
117         return 0;
118     
119     AccessibilityObject::AccessibilityChildrenVector imageChildren = axRenderImage->children();
120     unsigned count = imageChildren.size();
121     for (unsigned k = 0; k < count; ++k) {
122         AccessibilityObject* child = imageChildren[k].get();
123         if (!child->isImageMapLink())
124             continue;
125         
126         if (static_cast<AccessibilityImageMapLink*>(child)->areaElement() == areaElement)
127             return child;
128     }    
129     
130     return 0;
131 }
132     
133 AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
134 {
135     if (!gAccessibilityEnabled)
136         return 0;
137
138     // get the focused node in the page
139     Document* focusedDocument = page->focusController()->focusedOrMainFrame()->document();
140     Node* focusedNode = focusedDocument->focusedNode();
141     if (!focusedNode)
142         focusedNode = focusedDocument;
143
144     if (focusedNode->hasTagName(areaTag))
145         return focusedImageMapUIElement(static_cast<HTMLAreaElement*>(focusedNode));
146     
147     RenderObject* focusedNodeRenderer = focusedNode->renderer();
148     if (!focusedNodeRenderer)
149         return 0;
150
151     AccessibilityObject* obj = focusedNodeRenderer->document()->axObjectCache()->getOrCreate(focusedNodeRenderer);
152
153     if (obj->shouldFocusActiveDescendant()) {
154         if (AccessibilityObject* descendant = obj->activeDescendant())
155             obj = descendant;
156     }
157
158     // the HTML element, for example, is focusable but has an AX object that is ignored
159     if (obj->accessibilityIsIgnored())
160         obj = obj->parentObjectUnignored();
161
162     return obj;
163 }
164
165 AccessibilityObject* AXObjectCache::get(Widget* widget)
166 {
167     if (!widget)
168         return 0;
169         
170     AXID axID = m_widgetObjectMapping.get(widget);
171     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
172     if (!axID)
173         return 0;
174     
175     return m_objects.get(axID).get();    
176 }
177     
178 AccessibilityObject* AXObjectCache::get(RenderObject* renderer)
179 {
180     if (!renderer)
181         return 0;
182     
183     AXID axID = m_renderObjectMapping.get(renderer);
184     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
185     if (!axID)
186         return 0;
187
188     return m_objects.get(axID).get();    
189 }
190
191 // FIXME: This probably belongs on Node.
192 // FIXME: This should take a const char*, but one caller passes nullAtom.
193 bool nodeHasRole(Node* node, const String& role)
194 {
195     if (!node || !node->isElementNode())
196         return false;
197
198     return equalIgnoringCase(static_cast<Element*>(node)->getAttribute(roleAttr), role);
199 }
200
201 static PassRefPtr<AccessibilityObject> createFromRenderer(RenderObject* renderer)
202 {
203     // FIXME: How could renderer->node() ever not be an Element?
204     Node* node = renderer->node();
205
206     // If the node is aria role="list" or the aria role is empty and its a
207     // ul/ol/dl type (it shouldn't be a list if aria says otherwise).
208     if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
209                       || (nodeHasRole(node, nullAtom) && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))))
210         return AccessibilityList::create(renderer);
211
212     // aria tables
213     if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
214         return AccessibilityARIAGrid::create(renderer);
215     if (nodeHasRole(node, "row"))
216         return AccessibilityARIAGridRow::create(renderer);
217     if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
218         return AccessibilityARIAGridCell::create(renderer);
219
220 #if ENABLE(VIDEO)
221     // media controls
222     if (node && node->isMediaControlElement())
223         return AccessibilityMediaControl::create(renderer);
224 #endif
225
226     if (renderer->isBoxModelObject()) {
227         RenderBoxModelObject* cssBox = toRenderBoxModelObject(renderer);
228         if (cssBox->isListBox())
229             return AccessibilityListBox::create(toRenderListBox(cssBox));
230         if (cssBox->isMenuList())
231             return AccessibilityMenuList::create(toRenderMenuList(cssBox));
232
233         // standard tables
234         if (cssBox->isTable())
235             return AccessibilityTable::create(toRenderTable(cssBox));
236         if (cssBox->isTableRow())
237             return AccessibilityTableRow::create(toRenderTableRow(cssBox));
238         if (cssBox->isTableCell())
239             return AccessibilityTableCell::create(toRenderTableCell(cssBox));
240
241 #if ENABLE(PROGRESS_TAG)
242         // progress bar
243         if (cssBox->isProgress())
244             return AccessibilityProgressIndicator::create(toRenderProgress(cssBox));
245 #endif
246
247         // input type=range
248         if (cssBox->isSlider())
249             return AccessibilitySlider::create(toRenderSlider(cssBox));
250     }
251
252     return AccessibilityRenderObject::create(renderer);
253 }
254
255 AccessibilityObject* AXObjectCache::getOrCreate(Widget* widget)
256 {
257     if (!widget)
258         return 0;
259
260     if (AccessibilityObject* obj = get(widget))
261         return obj;
262     
263     RefPtr<AccessibilityObject> newObj = 0;
264     if (widget->isFrameView())
265         newObj = AccessibilityScrollView::create(static_cast<ScrollView*>(widget));
266     else if (widget->isScrollbar())
267         newObj = AccessibilityScrollbar::create(static_cast<Scrollbar*>(widget));
268         
269     getAXID(newObj.get());
270     
271     m_widgetObjectMapping.set(widget, newObj->axObjectID());
272     m_objects.set(newObj->axObjectID(), newObj);    
273     attachWrapper(newObj.get());
274     return newObj.get();
275 }
276     
277 AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
278 {
279     if (!renderer)
280         return 0;
281
282     if (AccessibilityObject* obj = get(renderer))
283         return obj;
284
285     RefPtr<AccessibilityObject> newObj = createFromRenderer(renderer);
286
287     getAXID(newObj.get());
288
289     m_renderObjectMapping.set(renderer, newObj->axObjectID());
290     m_objects.set(newObj->axObjectID(), newObj);
291     attachWrapper(newObj.get());
292     return newObj.get();
293 }
294     
295 AccessibilityObject* AXObjectCache::rootObject()
296 {
297     if (!gAccessibilityEnabled)
298         return 0;
299     
300     return getOrCreate(m_document->view());
301 }
302
303 AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame* frame)
304 {
305     if (!gAccessibilityEnabled)
306         return 0;
307
308     if (!frame)
309         return 0;
310     return getOrCreate(frame->view());
311 }    
312     
313 AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole role)
314 {
315     RefPtr<AccessibilityObject> obj = 0;
316     
317     // will be filled in...
318     switch (role) {
319     case ListBoxOptionRole:
320         obj = AccessibilityListBoxOption::create();
321         break;
322     case ImageMapLinkRole:
323         obj = AccessibilityImageMapLink::create();
324         break;
325     case ColumnRole:
326         obj = AccessibilityTableColumn::create();
327         break;            
328     case TableHeaderContainerRole:
329         obj = AccessibilityTableHeaderContainer::create();
330         break;   
331     case SliderThumbRole:
332         obj = AccessibilitySliderThumb::create();
333         break;
334     case MenuListPopupRole:
335         obj = AccessibilityMenuListPopup::create();
336         break;
337     case MenuListOptionRole:
338         obj = AccessibilityMenuListOption::create();
339         break;
340     case SpinButtonRole:
341         obj = AccessibilitySpinButton::create();
342         break;
343     case SpinButtonPartRole:
344         obj = AccessibilitySpinButtonPart::create();
345         break;
346     default:
347         obj = 0;
348     }
349     
350     if (obj)
351         getAXID(obj.get());
352     else
353         return 0;
354
355     m_objects.set(obj->axObjectID(), obj);    
356     attachWrapper(obj.get());
357     return obj.get();
358 }
359
360 void AXObjectCache::remove(AXID axID)
361 {
362     if (!axID)
363         return;
364     
365     // first fetch object to operate some cleanup functions on it 
366     AccessibilityObject* obj = m_objects.get(axID).get();
367     if (!obj)
368         return;
369     
370     detachWrapper(obj);
371     obj->detach();
372     removeAXID(obj);
373     
374     // finally remove the object
375     if (!m_objects.take(axID))
376         return;
377     
378     ASSERT(m_objects.size() >= m_idsInUse.size());    
379 }
380     
381 void AXObjectCache::remove(RenderObject* renderer)
382 {
383     if (!renderer)
384         return;
385     
386     AXID axID = m_renderObjectMapping.get(renderer);
387     remove(axID);
388     m_renderObjectMapping.remove(renderer);
389 }
390
391 void AXObjectCache::remove(Widget* view)
392 {
393     if (!view)
394         return;
395         
396     AXID axID = m_widgetObjectMapping.get(view);
397     remove(axID);
398     m_widgetObjectMapping.remove(view);
399 }
400     
401     
402 #if !PLATFORM(WIN) || OS(WINCE)
403 AXID AXObjectCache::platformGenerateAXID() const
404 {
405     static AXID lastUsedID = 0;
406
407     // Generate a new ID.
408     AXID objID = lastUsedID;
409     do {
410         ++objID;
411     } while (!objID || HashTraits<AXID>::isDeletedValue(objID) || m_idsInUse.contains(objID));
412
413     lastUsedID = objID;
414
415     return objID;
416 }
417 #endif
418
419 AXID AXObjectCache::getAXID(AccessibilityObject* obj)
420 {
421     // check for already-assigned ID
422     AXID objID = obj->axObjectID();
423     if (objID) {
424         ASSERT(m_idsInUse.contains(objID));
425         return objID;
426     }
427
428     objID = platformGenerateAXID();
429
430     m_idsInUse.add(objID);
431     obj->setAXObjectID(objID);
432     
433     return objID;
434 }
435
436 void AXObjectCache::removeAXID(AccessibilityObject* object)
437 {
438     if (!object)
439         return;
440     
441     AXID objID = object->axObjectID();
442     if (!objID)
443         return;
444     ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
445     ASSERT(m_idsInUse.contains(objID));
446     object->setAXObjectID(0);
447     m_idsInUse.remove(objID);
448 }
449
450 void AXObjectCache::contentChanged(RenderObject* renderer)
451 {
452     AccessibilityObject* object = getOrCreate(renderer);
453     if (object)
454         object->contentChanged(); 
455 }
456
457 void AXObjectCache::childrenChanged(RenderObject* renderer)
458 {
459     if (!renderer)
460         return;
461  
462     AXID axID = m_renderObjectMapping.get(renderer);
463     if (!axID)
464         return;
465     
466     AccessibilityObject* obj = m_objects.get(axID).get();
467     if (obj)
468         obj->childrenChanged();
469 }
470     
471 void AXObjectCache::notificationPostTimerFired(Timer<AXObjectCache>*)
472 {
473     m_notificationPostTimer.stop();
474
475     unsigned i = 0, count = m_notificationsToPost.size();
476     for (i = 0; i < count; ++i) {
477         AccessibilityObject* obj = m_notificationsToPost[i].first.get();
478 #ifndef NDEBUG
479         // Make sure none of the render views are in the process of being layed out.
480         // Notifications should only be sent after the renderer has finished
481         if (obj->isAccessibilityRenderObject()) {
482             AccessibilityRenderObject* renderObj = static_cast<AccessibilityRenderObject*>(obj);
483             RenderObject* renderer = renderObj->renderer();
484             if (renderer && renderer->view())
485                 ASSERT(!renderer->view()->layoutState());
486         }
487 #endif
488         
489         postPlatformNotification(obj, m_notificationsToPost[i].second);
490     }
491     
492     m_notificationsToPost.clear();
493 }
494     
495 void AXObjectCache::postNotification(RenderObject* renderer, AXNotification notification, bool postToElement, PostType postType)
496 {
497     // Notifications for text input objects are sent to that object.
498     // All others are sent to the top WebArea.
499     if (!renderer)
500         return;
501     
502     // Get an accessibility object that already exists. One should not be created here
503     // because a render update may be in progress and creating an AX object can re-trigger a layout
504     RefPtr<AccessibilityObject> object = get(renderer);
505     while (!object && renderer) {
506         renderer = renderer->parent();
507         object = get(renderer); 
508     }
509     
510     if (!renderer)
511         return;
512     
513     postNotification(object.get(), renderer->document(), notification, postToElement, postType);
514 }
515
516 void AXObjectCache::postNotification(AccessibilityObject* object, Document* document, AXNotification notification, bool postToElement, PostType postType)
517 {
518     if (object && !postToElement)
519         object = object->observableObject();
520
521     if (!object && document)
522         object = get(document->renderer());
523
524     if (!object)
525         return;
526
527     if (postType == PostAsynchronously) {
528         m_notificationsToPost.append(std::make_pair(object, notification));
529         if (!m_notificationPostTimer.isActive())
530             m_notificationPostTimer.startOneShot(0);
531     } else
532         postPlatformNotification(object, notification);
533 }
534
535 void AXObjectCache::checkedStateChanged(RenderObject* renderer)
536 {
537     postNotification(renderer, AXObjectCache::AXCheckedStateChanged, true);
538 }
539
540 void AXObjectCache::selectedChildrenChanged(RenderObject* renderer)
541 {
542     // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
543     // to find the container which should send out the notification.
544     postNotification(renderer, AXSelectedChildrenChanged, false);
545 }
546
547 void AXObjectCache::nodeTextChangeNotification(RenderObject* renderer, AXTextChange textChange, unsigned offset, const String& text)
548 {
549     if (!renderer)
550         return;
551
552     // Delegate on the right platform
553     AccessibilityObject* obj = getOrCreate(renderer);
554     nodeTextChangePlatformNotification(obj, textChange, offset, text);
555 }
556
557 void AXObjectCache::frameLoadingEventNotification(Frame* frame, AXLoadingEvent loadingEvent)
558 {
559     if (!frame)
560         return;
561
562     // Delegate on the right platform
563     RenderView* contentRenderer = frame->contentRenderer();
564     if (!contentRenderer)
565         return;
566
567     AccessibilityObject* obj = getOrCreate(contentRenderer);
568     frameLoadingEventPlatformNotification(obj, loadingEvent);
569 }
570
571 void AXObjectCache::handleScrollbarUpdate(ScrollView* view)
572 {
573     if (!view)
574         return;
575     
576     // We don't want to create a scroll view from this method, only update an existing one.
577     AccessibilityObject* scrollViewObject = get(view);
578     if (scrollViewObject)
579         scrollViewObject->updateChildrenIfNecessary();
580 }
581     
582 void AXObjectCache::handleAriaExpandedChange(RenderObject *renderer)
583 {
584     if (!renderer)
585         return;
586     AccessibilityObject* obj = getOrCreate(renderer);
587     if (obj)
588         obj->handleAriaExpandedChanged();
589 }
590     
591 void AXObjectCache::handleActiveDescendantChanged(RenderObject* renderer)
592 {
593     if (!renderer)
594         return;
595     AccessibilityObject* obj = getOrCreate(renderer);
596     if (obj)
597         obj->handleActiveDescendantChanged();
598 }
599
600 void AXObjectCache::handleAriaRoleChanged(RenderObject* renderer)
601 {
602     if (!renderer)
603         return;
604     AccessibilityObject* obj = getOrCreate(renderer);
605     if (obj && obj->isAccessibilityRenderObject())
606         static_cast<AccessibilityRenderObject*>(obj)->updateAccessibilityRole();
607 }
608
609 VisiblePosition AXObjectCache::visiblePositionForTextMarkerData(TextMarkerData& textMarkerData)
610 {
611     if (!isNodeInUse(textMarkerData.node))
612         return VisiblePosition();
613     
614     // FIXME: Accessability should make it clear these are DOM-compliant offsets or store Position objects.
615     VisiblePosition visiblePos = VisiblePosition(createLegacyEditingPosition(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
616     Position deepPos = visiblePos.deepEquivalent();
617     if (deepPos.isNull())
618         return VisiblePosition();
619     
620     RenderObject* renderer = deepPos.deprecatedNode()->renderer();
621     if (!renderer)
622         return VisiblePosition();
623     
624     AXObjectCache* cache = renderer->document()->axObjectCache();
625     if (!cache->isIDinUse(textMarkerData.axID))
626         return VisiblePosition();
627     
628     if (deepPos.deprecatedNode() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
629         return VisiblePosition();
630     
631     return visiblePos;
632 }
633
634 void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos)
635 {
636     // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence.
637     // This also allows callers to check for failure by looking at textMarkerData upon return.
638     memset(&textMarkerData, 0, sizeof(TextMarkerData));
639     
640     if (visiblePos.isNull())
641         return;
642     
643     Position deepPos = visiblePos.deepEquivalent();
644     Node* domNode = deepPos.deprecatedNode();
645     ASSERT(domNode);
646     if (!domNode)
647         return;
648     
649     if (domNode->isHTMLElement()) {
650         HTMLInputElement* inputElement = domNode->toInputElement();
651         if (inputElement && inputElement->isPasswordField())
652             return;
653     }
654     
655     // locate the renderer, which must exist for a visible dom node
656     RenderObject* renderer = domNode->renderer();
657     ASSERT(renderer);
658     
659     // find or create an accessibility object for this renderer
660     AXObjectCache* cache = renderer->document()->axObjectCache();
661     RefPtr<AccessibilityObject> obj = cache->getOrCreate(renderer);
662     
663     textMarkerData.axID = obj.get()->axObjectID();
664     textMarkerData.node = domNode;
665     textMarkerData.offset = deepPos.deprecatedEditingOffset();
666     textMarkerData.affinity = visiblePos.affinity();   
667     
668     cache->setNodeInUse(domNode);
669 }
670
671 const Element* AXObjectCache::rootAXEditableElement(const Node* node)
672 {
673     const Element* result = node->rootEditableElement();
674     const Element* element = node->isElementNode() ? toElement(node) : node->parentElement();
675
676     for (; element; element = element->parentElement()) {
677         if (nodeIsTextControl(element))
678             result = element;
679     }
680
681     return result;
682 }
683
684 bool AXObjectCache::nodeIsTextControl(const Node* node)
685 {
686     if (!node)
687         return false;
688
689     const AccessibilityObject* axObject = getOrCreate(node->renderer());
690     return axObject && axObject->isTextControl();
691 }
692
693 } // namespace WebCore
694
695 #endif // HAVE(ACCESSIBILITY)