b402ead76cb9033d77b6d3d6b6fd3eed10bccf25
[WebKit-https.git] / Source / WebCore / accessibility / AccessibilityRenderObject.cpp
1 /*
2 * Copyright (C) 2008 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 #include "AccessibilityRenderObject.h"
31
32 #include "AXObjectCache.h"
33 #include "AccessibilityImageMapLink.h"
34 #include "AccessibilityListBox.h"
35 #include "AccessibilitySpinButton.h"
36 #include "EventNames.h"
37 #include "FloatRect.h"
38 #include "Frame.h"
39 #include "FrameLoader.h"
40 #include "FrameSelection.h"
41 #include "HTMLAreaElement.h"
42 #include "HTMLFormElement.h"
43 #include "HTMLFrameElementBase.h"
44 #include "HTMLImageElement.h"
45 #include "HTMLInputElement.h"
46 #include "HTMLLabelElement.h"
47 #include "HTMLMapElement.h"
48 #include "HTMLNames.h"
49 #include "HTMLOptGroupElement.h"
50 #include "HTMLOptionElement.h"
51 #include "HTMLOptionsCollection.h"
52 #include "HTMLSelectElement.h"
53 #include "HTMLTextAreaElement.h"
54 #include "HitTestRequest.h"
55 #include "HitTestResult.h"
56 #include "LocalizedStrings.h"
57 #include "MathMLNames.h"
58 #include "NodeList.h"
59 #include "Page.h"
60 #include "ProgressTracker.h"
61 #include "RenderButton.h"
62 #include "RenderFieldset.h"
63 #include "RenderFileUploadControl.h"
64 #include "RenderHTMLCanvas.h"
65 #include "RenderImage.h"
66 #include "RenderInline.h"
67 #include "RenderLayer.h"
68 #include "RenderListBox.h"
69 #include "RenderListMarker.h"
70 #include "RenderMenuList.h"
71 #include "RenderText.h"
72 #include "RenderTextControl.h"
73 #include "RenderTextControlSingleLine.h"
74 #include "RenderTextFragment.h"
75 #include "RenderTheme.h"
76 #include "RenderView.h"
77 #include "RenderWidget.h"
78 #include "RenderedPosition.h"
79 #include "Text.h"
80 #include "TextControlInnerElements.h"
81 #include "TextIterator.h"
82 #include "htmlediting.h"
83 #include "visible_units.h"
84 #include <wtf/StdLibExtras.h>
85 #include <wtf/text/StringBuilder.h>
86 #include <wtf/unicode/CharacterNames.h>
87
88 using namespace std;
89
90 namespace WebCore {
91
92 using namespace HTMLNames;
93
94 AccessibilityRenderObject::AccessibilityRenderObject(RenderObject* renderer)
95     : AccessibilityObject()
96     , m_renderer(renderer)
97     , m_ariaRole(UnknownRole)
98     , m_childrenDirty(false)
99     , m_roleForMSAA(UnknownRole)
100 {
101     m_role = determineAccessibilityRole();
102
103 #ifndef NDEBUG
104     m_renderer->setHasAXObject(true);
105 #endif
106 }
107
108 AccessibilityRenderObject::~AccessibilityRenderObject()
109 {
110     ASSERT(isDetached());
111 }
112
113 PassRefPtr<AccessibilityRenderObject> AccessibilityRenderObject::create(RenderObject* renderer)
114 {
115     return adoptRef(new AccessibilityRenderObject(renderer));
116 }
117
118 void AccessibilityRenderObject::detach()
119 {
120     clearChildren();
121     AccessibilityObject::detach();
122     
123 #ifndef NDEBUG
124     if (m_renderer)
125         m_renderer->setHasAXObject(false);
126 #endif
127     m_renderer = 0;    
128 }
129
130 RenderBoxModelObject* AccessibilityRenderObject::renderBoxModelObject() const
131 {
132     if (!m_renderer || !m_renderer->isBoxModelObject())
133         return 0;
134     return toRenderBoxModelObject(m_renderer);
135 }
136
137 static inline bool isInlineWithContinuation(RenderObject* object)
138 {
139     if (!object->isBoxModelObject())
140         return false;
141
142     RenderBoxModelObject* renderer = toRenderBoxModelObject(object);
143     if (!renderer->isRenderInline())
144         return false;
145
146     return toRenderInline(renderer)->continuation();
147 }
148
149 static inline RenderObject* firstChildInContinuation(RenderObject* renderer)
150 {
151     RenderObject* r = toRenderInline(renderer)->continuation();
152
153     while (r) {
154         if (r->isRenderBlock())
155             return r;
156         if (RenderObject* child = r->firstChild())
157             return child;
158         r = toRenderInline(r)->continuation(); 
159     }
160
161     return 0;
162 }
163
164 static inline RenderObject* firstChildConsideringContinuation(RenderObject* renderer)
165 {
166     RenderObject* firstChild = renderer->firstChild();
167
168     if (!firstChild && isInlineWithContinuation(renderer))
169         firstChild = firstChildInContinuation(renderer);
170
171     return firstChild;
172 }
173
174
175 static inline RenderObject* lastChildConsideringContinuation(RenderObject* renderer)
176 {
177     RenderObject* lastChild = renderer->lastChild();
178     RenderObject* prev;
179     RenderObject* cur = renderer;
180
181     if (!cur->isRenderInline() && !cur->isRenderBlock())
182         return renderer;
183
184     while (cur) {
185         prev = cur;
186
187         if (RenderObject* lc = cur->lastChild())
188             lastChild = lc;
189
190         if (cur->isRenderInline()) {
191             cur = toRenderInline(cur)->inlineElementContinuation();
192             ASSERT_UNUSED(prev, cur || !toRenderInline(prev)->continuation());
193         } else
194             cur = toRenderBlock(cur)->inlineElementContinuation();
195     }
196
197     return lastChild;
198 }
199
200 AccessibilityObject* AccessibilityRenderObject::firstChild() const
201 {
202     if (!m_renderer)
203         return 0;
204     
205     RenderObject* firstChild = firstChildConsideringContinuation(m_renderer);
206
207     if (!firstChild)
208         return 0;
209     
210     return axObjectCache()->getOrCreate(firstChild);
211 }
212
213 AccessibilityObject* AccessibilityRenderObject::lastChild() const
214 {
215     if (!m_renderer)
216         return 0;
217
218     RenderObject* lastChild = lastChildConsideringContinuation(m_renderer);
219
220     if (!lastChild)
221         return 0;
222     
223     return axObjectCache()->getOrCreate(lastChild);
224 }
225
226 static inline RenderInline* startOfContinuations(RenderObject* r)
227 {
228     if (r->isInlineElementContinuation())
229         return toRenderInline(r->node()->renderer());
230
231     // Blocks with a previous continuation always have a next continuation
232     if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())
233         return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->node()->renderer());
234
235     return 0;
236 }
237
238 static inline RenderObject* endOfContinuations(RenderObject* renderer)
239 {
240     RenderObject* prev = renderer;
241     RenderObject* cur = renderer;
242
243     if (!cur->isRenderInline() && !cur->isRenderBlock())
244         return renderer;
245
246     while (cur) {
247         prev = cur;
248         if (cur->isRenderInline()) {
249             cur = toRenderInline(cur)->inlineElementContinuation();
250             ASSERT(cur || !toRenderInline(prev)->continuation());
251         } else 
252             cur = toRenderBlock(cur)->inlineElementContinuation();
253     }
254
255     return prev;
256 }
257
258
259 static inline RenderObject* childBeforeConsideringContinuations(RenderInline* r, RenderObject* child)
260 {
261     RenderBoxModelObject* curContainer = r;
262     RenderObject* cur = 0;
263     RenderObject* prev = 0;
264
265     while (curContainer) {
266         if (curContainer->isRenderInline()) {
267             cur = curContainer->firstChild();
268             while (cur) {
269                 if (cur == child)
270                     return prev;
271                 prev = cur;
272                 cur = cur->nextSibling();
273             }
274
275             curContainer = toRenderInline(curContainer)->continuation();
276         } else if (curContainer->isRenderBlock()) {
277             if (curContainer == child)
278                 return prev;
279
280             prev = curContainer;
281             curContainer = toRenderBlock(curContainer)->inlineElementContinuation();
282         }
283     }
284
285     ASSERT_NOT_REACHED();
286
287     return 0;
288 }
289
290 static inline bool firstChildIsInlineContinuation(RenderObject* renderer)
291 {
292     return renderer->firstChild() && renderer->firstChild()->isInlineElementContinuation();
293 }
294
295 AccessibilityObject* AccessibilityRenderObject::previousSibling() const
296 {
297     if (!m_renderer)
298         return 0;
299
300     RenderObject* previousSibling = 0;
301
302     // Case 1: The node is a block and is an inline's continuation. In that case, the inline's
303     // last child is our previous sibling (or further back in the continuation chain)
304     RenderInline* startOfConts;
305     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))
306         previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer);
307
308     // Case 2: Anonymous block parent of the end of a continuation - skip all the way to before
309     // the parent of the start, since everything in between will be linked up via the continuation.
310     else if (m_renderer->isAnonymousBlock() && firstChildIsInlineContinuation(m_renderer)) {
311         RenderObject* firstParent = startOfContinuations(m_renderer->firstChild())->parent();
312         while (firstChildIsInlineContinuation(firstParent))
313             firstParent = startOfContinuations(firstParent->firstChild())->parent();
314         previousSibling = firstParent->previousSibling();
315     }
316
317     // Case 3: The node has an actual previous sibling
318     else if (RenderObject* ps = m_renderer->previousSibling())
319         previousSibling = ps;
320
321     // Case 4: This node has no previous siblings, but its parent is an inline,
322     // and is another node's inline continutation. Follow the continuation chain.
323     else if (m_renderer->parent()->isRenderInline() && (startOfConts = startOfContinuations(m_renderer->parent())))
324         previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer->parent()->firstChild());
325
326     if (!previousSibling)
327         return 0;
328     
329     return axObjectCache()->getOrCreate(previousSibling);
330 }
331
332 static inline bool lastChildHasContinuation(RenderObject* renderer)
333 {
334     return renderer->lastChild() && isInlineWithContinuation(renderer->lastChild());
335 }
336
337 AccessibilityObject* AccessibilityRenderObject::nextSibling() const
338 {
339     if (!m_renderer)
340         return 0;
341
342     RenderObject* nextSibling = 0;
343
344     // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's
345     // first child.
346     RenderInline* inlineContinuation;
347     if (m_renderer->isRenderBlock() && (inlineContinuation = toRenderBlock(m_renderer)->inlineElementContinuation()))
348         nextSibling = firstChildConsideringContinuation(inlineContinuation);
349
350     // Case 2: Anonymous block parent of the start of a continuation - skip all the way to
351     // after the parent of the end, since everything in between will be linked up via the continuation.
352     else if (m_renderer->isAnonymousBlock() && lastChildHasContinuation(m_renderer)) {
353         RenderObject* lastParent = endOfContinuations(m_renderer->lastChild())->parent();
354         while (lastChildHasContinuation(lastParent))
355             lastParent = endOfContinuations(lastParent->lastChild())->parent();
356         nextSibling = lastParent->nextSibling();
357     }
358
359     // Case 3: node has an actual next sibling
360     else if (RenderObject* ns = m_renderer->nextSibling())
361         nextSibling = ns;
362
363     // Case 4: node is an inline with a continuation. Next sibling is the next sibling of the end 
364     // of the continuation chain.
365     else if (isInlineWithContinuation(m_renderer))
366         nextSibling = endOfContinuations(m_renderer)->nextSibling();
367
368     // Case 5: node has no next sibling, and its parent is an inline with a continuation.
369     else if (isInlineWithContinuation(m_renderer->parent())) {
370         RenderObject* continuation = toRenderInline(m_renderer->parent())->continuation();
371         
372         // Case 5a: continuation is a block - in this case the block itself is the next sibling.
373         if (continuation->isRenderBlock())
374             nextSibling = continuation;
375         // Case 5b: continuation is an inline - in this case the inline's first child is the next sibling
376         else
377             nextSibling = firstChildConsideringContinuation(continuation);
378     }
379
380     if (!nextSibling)
381         return 0;
382     
383     return axObjectCache()->getOrCreate(nextSibling);
384 }
385
386 static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
387 {
388     ASSERT(renderer);
389     if (renderer->isRenderInline() && !renderer->isReplaced())
390         return toRenderInline(renderer)->continuation();
391     if (renderer->isRenderBlock())
392         return toRenderBlock(renderer)->inlineElementContinuation();
393     return 0;
394 }
395     
396 RenderObject* AccessibilityRenderObject::renderParentObject() const
397 {
398     if (!m_renderer)
399         return 0;
400
401     RenderObject* parent = m_renderer->parent();
402
403     // Case 1: node is a block and is an inline's continuation. Parent
404     // is the start of the continuation chain.
405     RenderObject* startOfConts = 0;
406     RenderObject* firstChild = 0;
407     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))
408         parent = startOfConts;
409
410     // Case 2: node's parent is an inline which is some node's continuation; parent is 
411     // the earliest node in the continuation chain.
412     else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent)))
413         parent = startOfConts;
414     
415     // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
416     else if (parent && (firstChild = parent->firstChild()) && firstChild->node()) {
417         // Get the node's renderer and follow that continuation chain until the first child is found
418         RenderObject* nodeRenderFirstChild = firstChild->node()->renderer();
419         while (nodeRenderFirstChild != firstChild) {
420             for (RenderObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
421                 if (contsTest == firstChild) {
422                     parent = nodeRenderFirstChild->parent();
423                     break;
424                 }
425             }
426             if (firstChild == parent->firstChild())
427                 break;
428             firstChild = parent->firstChild();
429             nodeRenderFirstChild = firstChild->node()->renderer();
430         }
431     }
432         
433     return parent;
434 }
435     
436 AccessibilityObject* AccessibilityRenderObject::parentObjectIfExists() const
437 {
438     return axObjectCache()->get(renderParentObject());
439 }
440     
441 AccessibilityObject* AccessibilityRenderObject::parentObject() const
442 {
443     if (!m_renderer)
444         return 0;
445     
446     if (ariaRoleAttribute() == MenuBarRole)
447         return axObjectCache()->getOrCreate(m_renderer->parent());
448
449     // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
450     if (ariaRoleAttribute() == MenuRole) {
451         AccessibilityObject* parent = menuButtonForMenu();
452         if (parent)
453             return parent;
454     }
455     
456     RenderObject* parentObj = renderParentObject();
457     if (parentObj)
458         return axObjectCache()->getOrCreate(parentObj);
459     
460     // WebArea's parent should be the scroll view containing it.
461     if (isWebArea())
462         return axObjectCache()->getOrCreate(m_renderer->frame()->view());
463     
464     return 0;
465 }
466
467 bool AccessibilityRenderObject::isWebArea() const
468 {
469     return roleValue() == WebAreaRole;
470 }
471
472 bool AccessibilityRenderObject::isImageButton() const
473 {
474     return isNativeImage() && roleValue() == ButtonRole;
475 }
476
477 bool AccessibilityRenderObject::isAnchor() const
478 {
479     return !isNativeImage() && isLink();
480 }
481
482 bool AccessibilityRenderObject::isNativeTextControl() const
483 {
484     return m_renderer->isTextControl();
485 }
486     
487 bool AccessibilityRenderObject::isNativeImage() const
488 {
489     return m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isImage();
490 }    
491     
492 bool AccessibilityRenderObject::isImage() const
493 {
494     return roleValue() == ImageRole;
495 }
496
497 bool AccessibilityRenderObject::isAttachment() const
498 {
499     RenderBoxModelObject* renderer = renderBoxModelObject();
500     if (!renderer)
501         return false;
502     // Widgets are the replaced elements that we represent to AX as attachments
503     bool isWidget = renderer->isWidget();
504     ASSERT(!isWidget || (renderer->isReplaced() && !isImage()));
505     return isWidget && ariaRoleAttribute() == UnknownRole;
506 }
507
508 bool AccessibilityRenderObject::isPasswordField() const
509 {
510     ASSERT(m_renderer);
511     if (!m_renderer->node() || !m_renderer->node()->isHTMLElement())
512         return false;
513     if (ariaRoleAttribute() != UnknownRole)
514         return false;
515
516     HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
517     if (!inputElement)
518         return false;
519
520     return inputElement->isPasswordField();
521 }
522     
523 bool AccessibilityRenderObject::isFileUploadButton() const
524 {
525     if (m_renderer && m_renderer->node() && m_renderer->node()->hasTagName(inputTag)) {
526         HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());
527         return input->isFileUpload();
528     }
529     
530     return false;
531 }
532     
533 bool AccessibilityRenderObject::isInputImage() const
534 {
535     Node* elementNode = node();
536     if (roleValue() == ButtonRole && elementNode && elementNode->hasTagName(inputTag)) {
537         HTMLInputElement* input = static_cast<HTMLInputElement*>(elementNode);
538         return input->isImageButton();
539     }
540     
541     return false;
542 }
543
544 bool AccessibilityRenderObject::isProgressIndicator() const
545 {
546     return roleValue() == ProgressIndicatorRole;
547 }
548
549 bool AccessibilityRenderObject::isSlider() const
550 {
551     return roleValue() == SliderRole;
552 }
553
554 bool AccessibilityRenderObject::isMenuRelated() const
555 {
556     AccessibilityRole role = roleValue();
557     return role == MenuRole 
558         || role == MenuBarRole
559         || role == MenuButtonRole
560         || role == MenuItemRole;
561 }    
562
563 bool AccessibilityRenderObject::isMenu() const
564 {
565     return roleValue() == MenuRole;
566 }
567
568 bool AccessibilityRenderObject::isMenuBar() const
569 {
570     return roleValue() == MenuBarRole;
571 }
572
573 bool AccessibilityRenderObject::isMenuButton() const
574 {
575     return roleValue() == MenuButtonRole;
576 }
577
578 bool AccessibilityRenderObject::isMenuItem() const
579 {
580     return roleValue() == MenuItemRole;
581 }
582      
583 bool AccessibilityRenderObject::isPressed() const
584 {
585     ASSERT(m_renderer);
586     if (roleValue() != ButtonRole)
587         return false;
588
589     Node* node = m_renderer->node();
590     if (!node)
591         return false;
592
593     // If this is an ARIA button, check the aria-pressed attribute rather than node()->active()
594     if (ariaRoleAttribute() == ButtonRole) {
595         if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true"))
596             return true;
597         return false;
598     }
599
600     return node->active();
601 }
602
603 bool AccessibilityRenderObject::isIndeterminate() const
604 {
605     ASSERT(m_renderer);
606     if (!m_renderer->node())
607         return false;
608
609     HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
610     if (!inputElement)
611         return false;
612
613     return inputElement->isIndeterminate();
614 }
615
616 bool AccessibilityRenderObject::isNativeCheckboxOrRadio() const
617 {
618     Node* elementNode = node();
619     if (elementNode) {
620         HTMLInputElement* input = elementNode->toInputElement();
621         if (input)
622             return input->isCheckbox() || input->isRadioButton();
623     }
624     
625     return false;
626 }
627     
628 bool AccessibilityRenderObject::isChecked() const
629 {
630     ASSERT(m_renderer);
631     if (!m_renderer->node())
632         return false;
633
634     // First test for native checkedness semantics
635     HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
636     if (inputElement)
637         return inputElement->shouldAppearChecked();
638
639     // Else, if this is an ARIA checkbox or radio, respect the aria-checked attribute
640     AccessibilityRole ariaRole = ariaRoleAttribute();
641     if (ariaRole == RadioButtonRole || ariaRole == CheckBoxRole) {
642         if (equalIgnoringCase(getAttribute(aria_checkedAttr), "true"))
643             return true;
644         return false;
645     }
646
647     // Otherwise it's not checked
648     return false;
649 }
650
651 bool AccessibilityRenderObject::isHovered() const
652 {
653     ASSERT(m_renderer);
654     return m_renderer->node() && m_renderer->node()->hovered();
655 }
656
657 bool AccessibilityRenderObject::isMultiSelectable() const
658 {
659     ASSERT(m_renderer);
660     
661     const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
662     if (equalIgnoringCase(ariaMultiSelectable, "true"))
663         return true;
664     if (equalIgnoringCase(ariaMultiSelectable, "false"))
665         return false;
666     
667     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isListBox())
668         return false;
669     return m_renderer->node() && toHTMLSelectElement(m_renderer->node())->multiple();
670 }
671
672 bool AccessibilityRenderObject::isReadOnly() const
673 {
674     ASSERT(m_renderer);
675     
676     if (isWebArea()) {
677         Document* document = m_renderer->document();
678         if (!document)
679             return true;
680         
681         HTMLElement* body = document->body();
682         if (body && body->isContentEditable())
683             return false;
684
685         return !document->rendererIsEditable();
686     }
687
688     if (m_renderer->isBoxModelObject()) {
689         RenderBoxModelObject* box = toRenderBoxModelObject(m_renderer);
690         if (box->isTextField())
691             return static_cast<HTMLInputElement*>(box->node())->readOnly();
692         if (box->isTextArea())
693             return static_cast<HTMLTextAreaElement*>(box->node())->readOnly();
694     }
695
696     return !m_renderer->node() || !m_renderer->node()->rendererIsEditable();
697 }
698
699 bool AccessibilityRenderObject::isOffScreen() const
700 {
701     ASSERT(m_renderer);
702     LayoutRect contentRect = m_renderer->absoluteClippedOverflowRect();
703     FrameView* view = m_renderer->frame()->view();
704     FloatRect viewRect = view->visibleContentRect();
705     viewRect.intersect(contentRect);
706     return viewRect.isEmpty();
707 }
708
709 int AccessibilityRenderObject::headingLevel() const
710 {
711     // headings can be in block flow and non-block flow
712     Node* element = node();
713     if (!element)
714         return 0;
715
716     if (ariaRoleAttribute() == HeadingRole)
717         return getAttribute(aria_levelAttr).toInt();
718
719     if (element->hasTagName(h1Tag))
720         return 1;
721     
722     if (element->hasTagName(h2Tag))
723         return 2;
724     
725     if (element->hasTagName(h3Tag))
726         return 3;
727     
728     if (element->hasTagName(h4Tag))
729         return 4;
730     
731     if (element->hasTagName(h5Tag))
732         return 5;
733     
734     if (element->hasTagName(h6Tag))
735         return 6;
736     
737     return 0;
738 }
739
740 bool AccessibilityRenderObject::isHeading() const
741 {
742     return roleValue() == HeadingRole;
743 }
744     
745 bool AccessibilityRenderObject::isLink() const
746 {
747     return roleValue() == WebCoreLinkRole;
748 }    
749     
750 bool AccessibilityRenderObject::isControl() const
751 {
752     if (!m_renderer)
753         return false;
754     
755     Node* node = m_renderer->node();
756     return node && ((node->isElementNode() && static_cast<Element*>(node)->isFormControlElement())
757                     || AccessibilityObject::isARIAControl(ariaRoleAttribute()));
758 }
759
760 bool AccessibilityRenderObject::isFieldset() const
761 {
762     RenderBoxModelObject* renderer = renderBoxModelObject();
763     if (!renderer)
764         return false;
765     return renderer->isFieldset();
766 }
767   
768 bool AccessibilityRenderObject::isGroup() const
769 {
770     return roleValue() == GroupRole;
771 }
772
773 AccessibilityObject* AccessibilityRenderObject::selectedRadioButton()
774 {
775     if (!isRadioGroup())
776         return 0;
777     
778     // Find the child radio button that is selected (ie. the intValue == 1).
779     int count = m_children.size();
780     for (int i = 0; i < count; ++i) {
781         AccessibilityObject* object = m_children[i].get();
782         if (object->roleValue() == RadioButtonRole && object->checkboxOrRadioValue() == ButtonStateOn)
783             return object;
784     }
785     return 0;
786 }
787
788 AccessibilityObject* AccessibilityRenderObject::selectedTabItem()
789 {
790     if (!isTabList())
791         return 0;
792     
793     // Find the child tab item that is selected (ie. the intValue == 1).
794     AccessibilityObject::AccessibilityChildrenVector tabs;
795     tabChildren(tabs);
796     
797     int count = tabs.size();
798     for (int i = 0; i < count; ++i) {
799         AccessibilityObject* object = m_children[i].get();
800         if (object->isTabItem() && object->isChecked())
801             return object;
802     }
803     return 0;
804 }
805
806 Element* AccessibilityRenderObject::anchorElement() const
807 {
808     if (!m_renderer)
809         return 0;
810     
811     AXObjectCache* cache = axObjectCache();
812     RenderObject* currRenderer;
813     
814     // Search up the render tree for a RenderObject with a DOM node.  Defer to an earlier continuation, though.
815     for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent()) {
816         if (currRenderer->isAnonymousBlock()) {
817             RenderObject* continuation = toRenderBlock(currRenderer)->continuation();
818             if (continuation)
819                 return cache->getOrCreate(continuation)->anchorElement();
820         }
821     }
822     
823     // bail if none found
824     if (!currRenderer)
825         return 0;
826     
827     // search up the DOM tree for an anchor element
828     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
829     Node* node = currRenderer->node();
830     for ( ; node; node = node->parentNode()) {
831         if (node->hasTagName(aTag) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
832             return static_cast<Element*>(node);
833     }
834     
835     return 0;
836 }
837
838 Element* AccessibilityRenderObject::actionElement() const
839 {
840     if (!m_renderer)
841         return 0;
842     
843     Node* node = m_renderer->node();
844     if (node) {
845         if (node->hasTagName(inputTag)) {
846             HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
847             if (!input->disabled() && (isCheckboxOrRadio() || input->isTextButton()))
848                 return input;
849         } else if (node->hasTagName(buttonTag))
850             return static_cast<Element*>(node);
851     }
852
853     if (isFileUploadButton())
854         return static_cast<Element*>(m_renderer->node());
855             
856     if (AccessibilityObject::isARIAInput(ariaRoleAttribute()))
857         return static_cast<Element*>(m_renderer->node());
858
859     if (isImageButton())
860         return static_cast<Element*>(m_renderer->node());
861     
862     if (m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isMenuList())
863         return static_cast<Element*>(m_renderer->node());
864
865     AccessibilityRole role = roleValue();
866     if (role == ButtonRole || role == PopUpButtonRole)
867         return static_cast<Element*>(m_renderer->node()); 
868     
869     Element* elt = anchorElement();
870     if (!elt)
871         elt = mouseButtonListener();
872     return elt;
873 }
874
875 Element* AccessibilityRenderObject::mouseButtonListener() const
876 {
877     Node* node = m_renderer->node();
878     if (!node)
879         return 0;
880     
881     // check if our parent is a mouse button listener
882     while (node && !node->isElementNode())
883         node = node->parentNode();
884
885     if (!node)
886         return 0;
887
888     // FIXME: Do the continuation search like anchorElement does
889     for (Element* element = static_cast<Element*>(node); element; element = element->parentElement()) {
890         if (element->getAttributeEventListener(eventNames().clickEvent) || element->getAttributeEventListener(eventNames().mousedownEvent) || element->getAttributeEventListener(eventNames().mouseupEvent))
891             return element;
892     }
893
894     return 0;
895 }
896
897 void AccessibilityRenderObject::alterSliderValue(bool increase)
898 {
899     if (roleValue() != SliderRole)
900         return;
901
902     if (!getAttribute(stepAttr).isEmpty())
903         changeValueByStep(increase);
904     else
905         changeValueByPercent(increase ? 5 : -5);
906 }
907     
908 void AccessibilityRenderObject::increment()
909 {
910     alterSliderValue(true);
911 }
912
913 void AccessibilityRenderObject::decrement()
914 {
915     alterSliderValue(false);
916 }
917
918 static Element* siblingWithAriaRole(String role, Node* node)
919 {
920     Node* sibling = node->parentNode()->firstChild();
921     while (sibling) {
922         if (sibling->isElementNode()) {
923             const AtomicString& siblingAriaRole = static_cast<Element*>(sibling)->getAttribute(roleAttr);
924             if (equalIgnoringCase(siblingAriaRole, role))
925                 return static_cast<Element*>(sibling);
926         }
927         sibling = sibling->nextSibling();
928     }
929     
930     return 0;
931 }
932
933 Element* AccessibilityRenderObject::menuElementForMenuButton() const
934 {
935     if (ariaRoleAttribute() != MenuButtonRole)
936         return 0;
937
938     return siblingWithAriaRole("menu", renderer()->node());
939 }
940
941 AccessibilityObject* AccessibilityRenderObject::menuForMenuButton() const
942 {
943     Element* menu = menuElementForMenuButton();
944     if (menu && menu->renderer())
945         return axObjectCache()->getOrCreate(menu->renderer());
946     return 0;
947 }
948
949 Element* AccessibilityRenderObject::menuItemElementForMenu() const
950 {
951     if (ariaRoleAttribute() != MenuRole)
952         return 0;
953     
954     return siblingWithAriaRole("menuitem", renderer()->node());    
955 }
956
957 AccessibilityObject* AccessibilityRenderObject::menuButtonForMenu() const
958 {
959     Element* menuItem = menuItemElementForMenu();
960
961     if (menuItem && menuItem->renderer()) {
962         // ARIA just has generic menu items.  AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
963         AccessibilityObject* menuItemAX = axObjectCache()->getOrCreate(menuItem->renderer());
964         if (menuItemAX->isMenuButton())
965             return menuItemAX;
966     }
967     return 0;
968 }
969
970 String AccessibilityRenderObject::helpText() const
971 {
972     if (!m_renderer)
973         return String();
974     
975     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
976     if (!ariaHelp.isEmpty())
977         return ariaHelp;
978     
979     for (RenderObject* curr = m_renderer; curr; curr = curr->parent()) {
980         if (curr->node() && curr->node()->isHTMLElement()) {
981             const AtomicString& summary = static_cast<Element*>(curr->node())->getAttribute(summaryAttr);
982             if (!summary.isEmpty())
983                 return summary;
984             const AtomicString& title = static_cast<Element*>(curr->node())->getAttribute(titleAttr);
985             if (!title.isEmpty())
986                 return title;
987         }
988         
989         // Only take help text from an ancestor element if its a group or an unknown role. If help was 
990         // added to those kinds of elements, it is likely it was meant for a child element.
991         AccessibilityObject* axObj = axObjectCache()->getOrCreate(curr);
992         if (axObj) {
993             AccessibilityRole role = axObj->roleValue();
994             if (role != GroupRole && role != UnknownRole)
995                 break;
996         }
997     }
998     
999     return String();
1000 }
1001     
1002 unsigned AccessibilityRenderObject::hierarchicalLevel() const
1003 {
1004     if (!m_renderer)
1005         return 0;
1006
1007     Node* node = m_renderer->node();
1008     if (!node || !node->isElementNode())
1009         return 0;
1010     Element* element = static_cast<Element*>(node);
1011     String ariaLevel = element->getAttribute(aria_levelAttr);
1012     if (!ariaLevel.isEmpty())
1013         return ariaLevel.toInt();
1014     
1015     // Only tree item will calculate its level through the DOM currently.
1016     if (roleValue() != TreeItemRole)
1017         return 0;
1018     
1019     // Hierarchy leveling starts at 0.
1020     // We measure tree hierarchy by the number of groups that the item is within.
1021     unsigned level = 0;
1022     AccessibilityObject* parent = parentObject();
1023     while (parent) {
1024         AccessibilityRole parentRole = parent->roleValue();
1025         if (parentRole == GroupRole)
1026             level++;
1027         else if (parentRole == TreeRole)
1028             break;
1029         
1030         parent = parent->parentObject();
1031     }
1032     
1033     return level;
1034 }
1035
1036 static TextIteratorBehavior textIteratorBehaviorForTextRange()
1037 {
1038     TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility;
1039
1040 #if PLATFORM(GTK)
1041     // We need to emit replaced elements for GTK, and present
1042     // them with the 'object replacement character' (0xFFFC).
1043     behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters);
1044 #endif
1045
1046     return behavior;
1047 }
1048
1049 String AccessibilityRenderObject::textUnderElement() const
1050 {
1051     if (!m_renderer)
1052         return String();
1053     
1054     if (isFileUploadButton())
1055         return toRenderFileUploadControl(m_renderer)->buttonValue();
1056     
1057     Node* node = m_renderer->node();
1058     if (node) {
1059         if (Frame* frame = node->document()->frame()) {
1060             // catch stale WebCoreAXObject (see <rdar://problem/3960196>)
1061             if (frame->document() != node->document())
1062                 return String();
1063
1064             return plainText(rangeOfContents(node).get(), textIteratorBehaviorForTextRange());
1065         }
1066     }
1067     
1068     // Sometimes text fragments don't have Node's associated with them (like when
1069     // CSS content is used to insert text).
1070     if (m_renderer->isText()) {
1071         RenderText* renderTextObject = toRenderText(m_renderer);
1072         if (renderTextObject->isTextFragment())
1073             return String(static_cast<RenderTextFragment*>(m_renderer)->contentString());
1074     }
1075     
1076     // return the null string for anonymous text because it is non-trivial to get
1077     // the actual text and, so far, that is not needed
1078     return String();
1079 }
1080
1081 Node* AccessibilityRenderObject::node() const
1082
1083     return m_renderer ? m_renderer->node() : 0; 
1084 }    
1085     
1086 AccessibilityButtonState AccessibilityRenderObject::checkboxOrRadioValue() const
1087 {
1088     if (isNativeCheckboxOrRadio())
1089         return isChecked() ? ButtonStateOn : ButtonStateOff;
1090     
1091     return AccessibilityObject::checkboxOrRadioValue();
1092 }
1093
1094 String AccessibilityRenderObject::valueDescription() const
1095 {
1096     // Only sliders and progress bars support value descriptions currently.
1097     if (!isProgressIndicator() && !isSlider())
1098         return String();
1099     
1100     return getAttribute(aria_valuetextAttr).string();
1101 }
1102     
1103 float AccessibilityRenderObject::stepValueForRange() const
1104 {
1105     return getAttribute(stepAttr).toFloat();
1106 }
1107     
1108 float AccessibilityRenderObject::valueForRange() const
1109 {
1110     if (!isProgressIndicator() && !isSlider() && !isScrollbar())
1111         return 0.0f;
1112
1113     return getAttribute(aria_valuenowAttr).toFloat();
1114 }
1115
1116 float AccessibilityRenderObject::maxValueForRange() const
1117 {
1118     if (!isProgressIndicator() && !isSlider())
1119         return 0.0f;
1120
1121     return getAttribute(aria_valuemaxAttr).toFloat();
1122 }
1123
1124 float AccessibilityRenderObject::minValueForRange() const
1125 {
1126     if (!isProgressIndicator() && !isSlider())
1127         return 0.0f;
1128
1129     return getAttribute(aria_valueminAttr).toFloat();
1130 }
1131
1132 String AccessibilityRenderObject::stringValue() const
1133 {
1134     if (!m_renderer || isPasswordField())
1135         return String();
1136
1137     RenderBoxModelObject* cssBox = renderBoxModelObject();
1138
1139     if (ariaRoleAttribute() == StaticTextRole) {
1140         String staticText = text();
1141         if (!staticText.length())
1142             staticText = textUnderElement();
1143         return staticText;
1144     }
1145         
1146     if (m_renderer->isText())
1147         return textUnderElement();
1148     
1149     if (cssBox && cssBox->isMenuList()) {
1150         // RenderMenuList will go straight to the text() of its selected item.
1151         // This has to be overridden in the case where the selected item has an ARIA label.
1152         HTMLSelectElement* selectElement = toHTMLSelectElement(m_renderer->node());
1153         int selectedIndex = selectElement->selectedIndex();
1154         const Vector<HTMLElement*> listItems = selectElement->listItems();
1155         if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
1156             const AtomicString& overriddenDescription = listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
1157             if (!overriddenDescription.isNull())
1158                 return overriddenDescription;
1159         }
1160         return toRenderMenuList(m_renderer)->text();
1161     }
1162     
1163     if (m_renderer->isListMarker())
1164         return toRenderListMarker(m_renderer)->text();
1165     
1166     if (isWebArea()) {
1167         // FIXME: Why would a renderer exist when the Document isn't attached to a frame?
1168         if (m_renderer->frame())
1169             return String();
1170
1171         ASSERT_NOT_REACHED();
1172     }
1173     
1174     if (isTextControl())
1175         return text();
1176     
1177     if (isFileUploadButton())
1178         return toRenderFileUploadControl(m_renderer)->fileTextValue();
1179     
1180     // FIXME: We might need to implement a value here for more types
1181     // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
1182     // this would require subclassing or making accessibilityAttributeNames do something other than return a
1183     // single static array.
1184     return String();
1185 }
1186
1187 // This function implements the ARIA accessible name as described by the Mozilla
1188 // ARIA Implementer's Guide.
1189 static String accessibleNameForNode(Node* node)
1190 {
1191     if (node->isTextNode())
1192         return static_cast<Text*>(node)->data();
1193
1194     if (node->hasTagName(inputTag))
1195         return static_cast<HTMLInputElement*>(node)->value();
1196
1197     if (node->isHTMLElement()) {
1198         const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
1199         if (!alt.isEmpty())
1200             return alt;
1201     }
1202
1203     return String();
1204 }
1205
1206 String AccessibilityRenderObject::accessibilityDescriptionForElements(Vector<Element*> &elements) const
1207 {
1208     StringBuilder builder;
1209     unsigned size = elements.size();
1210     for (unsigned i = 0; i < size; ++i) {
1211         Element* idElement = elements[i];
1212
1213         builder.append(accessibleNameForNode(idElement));
1214         for (Node* n = idElement->firstChild(); n; n = n->traverseNextNode(idElement))
1215             builder.append(accessibleNameForNode(n));
1216
1217         if (i != size - 1)
1218             builder.append(' ');
1219     }
1220     return builder.toString();
1221 }
1222
1223 void AccessibilityRenderObject::elementsFromAttribute(Vector<Element*>& elements, const QualifiedName& attribute) const
1224 {
1225     Node* node = m_renderer->node();
1226     if (!node || !node->isElementNode())
1227         return;
1228
1229     TreeScope* scope = node->treeScope();
1230     if (!scope)
1231         return;
1232     
1233     String idList = getAttribute(attribute).string();
1234     if (idList.isEmpty())
1235         return;
1236     
1237     idList.replace('\n', ' ');
1238     Vector<String> idVector;
1239     idList.split(' ', idVector);
1240     
1241     unsigned size = idVector.size();
1242     for (unsigned i = 0; i < size; ++i) {
1243         AtomicString idName(idVector[i]);
1244         Element* idElement = scope->getElementById(idName);
1245         if (idElement)
1246             elements.append(idElement);
1247     }
1248 }
1249     
1250 void AccessibilityRenderObject::ariaLabeledByElements(Vector<Element*>& elements) const
1251 {
1252     elementsFromAttribute(elements, aria_labeledbyAttr);
1253     if (!elements.size())
1254         elementsFromAttribute(elements, aria_labelledbyAttr);
1255 }
1256    
1257 String AccessibilityRenderObject::ariaLabeledByAttribute() const
1258 {
1259     Vector<Element*> elements;
1260     ariaLabeledByElements(elements);
1261     
1262     return accessibilityDescriptionForElements(elements);
1263 }
1264
1265 static HTMLLabelElement* labelForElement(Element* element)
1266 {
1267     RefPtr<NodeList> list = element->document()->getElementsByTagName("label");
1268     unsigned len = list->length();
1269     for (unsigned i = 0; i < len; i++) {
1270         if (list->item(i)->hasTagName(labelTag)) {
1271             HTMLLabelElement* label = static_cast<HTMLLabelElement*>(list->item(i));
1272             if (label->control() == element)
1273                 return label;
1274         }
1275     }
1276     
1277     return 0;
1278 }
1279     
1280 HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
1281 {
1282     if (!m_renderer)
1283         return 0;
1284
1285     // the control element should not be considered part of the label
1286     if (isControl())
1287         return 0;
1288     
1289     // find if this has a parent that is a label
1290     for (Node* parentNode = m_renderer->node(); parentNode; parentNode = parentNode->parentNode()) {
1291         if (parentNode->hasTagName(labelTag))
1292             return static_cast<HTMLLabelElement*>(parentNode);
1293     }
1294     
1295     return 0;
1296 }
1297
1298 String AccessibilityRenderObject::title() const
1299 {
1300     AccessibilityRole role = roleValue();
1301     
1302     if (!m_renderer)
1303         return String();
1304
1305     Node* node = m_renderer->node();
1306     if (!node)
1307         return String();
1308     
1309     const AtomicString& title = getAttribute(titleAttr);
1310     if (!title.isEmpty())
1311         return title;
1312     
1313     bool isInputTag = node->hasTagName(inputTag);
1314     if (isInputTag) {
1315         HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
1316         if (input->isTextButton())
1317             return input->value();
1318     }
1319     
1320     if (isInputTag || AccessibilityObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
1321         HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
1322         if (label && !titleUIElement())
1323             return label->innerText();
1324     }
1325     
1326     switch (role) {
1327     case ButtonRole:
1328     case ListBoxOptionRole:
1329     case MenuItemRole:
1330     case MenuButtonRole:
1331     case RadioButtonRole:
1332     case CheckBoxRole:
1333     case TabRole:
1334     case PopUpButtonRole:
1335         return textUnderElement();
1336     default:
1337         break;
1338     }
1339     
1340     if (isHeading() || isLink())
1341         return textUnderElement();
1342     
1343     return String();
1344 }
1345
1346 String AccessibilityRenderObject::ariaDescribedByAttribute() const
1347 {
1348     Vector<Element*> elements;
1349     elementsFromAttribute(elements, aria_describedbyAttr);
1350     
1351     return accessibilityDescriptionForElements(elements);
1352 }
1353     
1354 String AccessibilityRenderObject::ariaAccessibilityDescription() const
1355 {
1356     String ariaLabeledBy = ariaLabeledByAttribute();
1357     if (!ariaLabeledBy.isEmpty())
1358         return ariaLabeledBy;
1359
1360     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
1361     if (!ariaLabel.isEmpty())
1362         return ariaLabel;
1363     
1364     String ariaDescription = ariaDescribedByAttribute();
1365     if (!ariaDescription.isEmpty())
1366         return ariaDescription;
1367     
1368     return String();
1369 }
1370
1371 String AccessibilityRenderObject::accessibilityDescription() const
1372 {
1373     if (!m_renderer)
1374         return String();
1375
1376     // Static text should not have a description, it should only have a stringValue.
1377     if (roleValue() == StaticTextRole)
1378         return String();
1379     
1380     String ariaDescription = ariaAccessibilityDescription();
1381     if (!ariaDescription.isEmpty())
1382         return ariaDescription;
1383     
1384     Node* node = m_renderer->node();
1385     if (isImage() || isInputImage() || isNativeImage()) {
1386         if (node && node->isHTMLElement()) {
1387             const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
1388             if (alt.isEmpty())
1389                 return String();
1390             return alt;
1391         }
1392     }
1393     
1394 #if ENABLE(MATHML)
1395     if (node && node->isElementNode() && static_cast<Element*>(node)->isMathMLElement())
1396         return getAttribute(MathMLNames::alttextAttr);
1397 #endif
1398     
1399     if (isWebArea()) {
1400         Document* document = m_renderer->document();
1401         
1402         // Check if the HTML element has an aria-label for the webpage.
1403         Element* documentElement = document->documentElement();
1404         if (documentElement) {
1405             const AtomicString& ariaLabel = documentElement->getAttribute(aria_labelAttr);
1406             if (!ariaLabel.isEmpty())
1407                 return ariaLabel;
1408         }
1409         
1410         Node* owner = document->ownerElement();
1411         if (owner) {
1412             if (owner->hasTagName(frameTag) || owner->hasTagName(iframeTag)) {
1413                 const AtomicString& title = static_cast<HTMLFrameElementBase*>(owner)->getAttribute(titleAttr);
1414                 if (!title.isEmpty())
1415                     return title;
1416                 return static_cast<HTMLFrameElementBase*>(owner)->getAttribute(nameAttr);
1417             }
1418             if (owner->isHTMLElement())
1419                 return toHTMLElement(owner)->getAttribute(nameAttr);
1420         }
1421         owner = document->body();
1422         if (owner && owner->isHTMLElement())
1423             return toHTMLElement(owner)->getAttribute(nameAttr);
1424     }
1425
1426     return String();
1427 }
1428
1429 LayoutRect AccessibilityRenderObject::boundingBoxRect() const
1430 {
1431     RenderObject* obj = m_renderer;
1432     
1433     if (!obj)
1434         return LayoutRect();
1435     
1436     if (obj->node()) // If we are a continuation, we want to make sure to use the primary renderer.
1437         obj = obj->node()->renderer();
1438     
1439     // absoluteFocusRingQuads will query the hierarchy below this element, which for large webpages can be very slow.
1440     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
1441     Vector<FloatQuad> quads;
1442     if (obj->isText())
1443         toRenderText(obj)->absoluteQuads(quads, 0, RenderText::ClipToEllipsis);
1444     else if (isWebArea())
1445         obj->absoluteQuads(quads);
1446     else
1447         obj->absoluteFocusRingQuads(quads);
1448     
1449     LayoutRect result = boundingBoxForQuads(obj, quads);
1450
1451     // The size of the web area should be the content size, not the clipped size.
1452     if (isWebArea() && obj->frame()->view())
1453         result.setSize(obj->frame()->view()->contentsSize());
1454     
1455     return result;
1456 }
1457     
1458 LayoutRect AccessibilityRenderObject::checkboxOrRadioRect() const
1459 {
1460     if (!m_renderer)
1461         return LayoutRect();
1462     
1463     HTMLLabelElement* label = labelForElement(static_cast<Element*>(m_renderer->node()));
1464     if (!label || !label->renderer())
1465         return boundingBoxRect();
1466     
1467     LayoutRect labelRect = axObjectCache()->getOrCreate(label->renderer())->elementRect();
1468     labelRect.unite(boundingBoxRect());
1469     return labelRect;
1470 }
1471
1472 LayoutRect AccessibilityRenderObject::elementRect() const
1473 {
1474     // a checkbox or radio button should encompass its label
1475     if (isCheckboxOrRadio())
1476         return checkboxOrRadioRect();
1477     
1478     return boundingBoxRect();
1479 }
1480
1481 LayoutSize AccessibilityRenderObject::size() const
1482 {
1483     LayoutRect rect = elementRect();
1484     return rect.size();
1485 }
1486
1487 LayoutPoint AccessibilityRenderObject::clickPoint()
1488 {
1489     // Headings are usually much wider than their textual content. If the mid point is used, often it can be wrong.
1490     if (isHeading() && children().size() == 1)
1491         return children()[0]->clickPoint();
1492
1493     // use the default position unless this is an editable web area, in which case we use the selection bounds.
1494     if (!isWebArea() || isReadOnly())
1495         return AccessibilityObject::clickPoint();
1496     
1497     VisibleSelection visSelection = selection();
1498     VisiblePositionRange range = VisiblePositionRange(visSelection.visibleStart(), visSelection.visibleEnd());
1499     LayoutRect bounds = boundsForVisiblePositionRange(range);
1500 #if PLATFORM(MAC)
1501     bounds.setLocation(m_renderer->document()->view()->screenToContents(bounds.location()));
1502 #endif        
1503     return LayoutPoint(bounds.x() + (bounds.width() / 2), bounds.y() - (bounds.height() / 2));
1504 }
1505     
1506 AccessibilityObject* AccessibilityRenderObject::internalLinkElement() const
1507 {
1508     Element* element = anchorElement();
1509     if (!element)
1510         return 0;
1511     
1512     // Right now, we do not support ARIA links as internal link elements
1513     if (!element->hasTagName(aTag))
1514         return 0;
1515     HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(element);
1516     
1517     KURL linkURL = anchor->href();
1518     String fragmentIdentifier = linkURL.fragmentIdentifier();
1519     if (fragmentIdentifier.isEmpty())
1520         return 0;
1521     
1522     // check if URL is the same as current URL
1523     KURL documentURL = m_renderer->document()->url();
1524     if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
1525         return 0;
1526     
1527     Node* linkedNode = m_renderer->document()->findAnchor(fragmentIdentifier);
1528     if (!linkedNode)
1529         return 0;
1530     
1531     // The element we find may not be accessible, so find the first accessible object.
1532     return firstAccessibleObjectFromNode(linkedNode);
1533 }
1534
1535 ESpeak AccessibilityRenderObject::speakProperty() const
1536 {
1537     if (!m_renderer)
1538         return AccessibilityObject::speakProperty();
1539     
1540     return m_renderer->style()->speak();
1541 }
1542     
1543 void AccessibilityRenderObject::addRadioButtonGroupMembers(AccessibilityChildrenVector& linkedUIElements) const
1544 {
1545     if (!m_renderer || roleValue() != RadioButtonRole)
1546         return;
1547     
1548     Node* node = m_renderer->node();
1549     if (!node || !node->hasTagName(inputTag))
1550         return;
1551     
1552     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
1553     // if there's a form, then this is easy
1554     if (input->form()) {
1555         Vector<RefPtr<Node> > formElements;
1556         input->form()->getNamedElements(input->name(), formElements);
1557         
1558         unsigned len = formElements.size();
1559         for (unsigned i = 0; i < len; ++i) {
1560             Node* associateElement = formElements[i].get();
1561             if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement->renderer()))
1562                 linkedUIElements.append(object);        
1563         } 
1564     } else {
1565         RefPtr<NodeList> list = node->document()->getElementsByTagName("input");
1566         unsigned len = list->length();
1567         for (unsigned i = 0; i < len; ++i) {
1568             if (list->item(i)->hasTagName(inputTag)) {
1569                 HTMLInputElement* associateElement = static_cast<HTMLInputElement*>(list->item(i));
1570                 if (associateElement->isRadioButton() && associateElement->name() == input->name()) {
1571                     if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement->renderer()))
1572                         linkedUIElements.append(object);
1573                 }
1574             }
1575         }
1576     }
1577 }
1578     
1579 // linked ui elements could be all the related radio buttons in a group
1580 // or an internal anchor connection
1581 void AccessibilityRenderObject::linkedUIElements(AccessibilityChildrenVector& linkedUIElements) const
1582 {
1583     ariaFlowToElements(linkedUIElements);
1584
1585     if (isAnchor()) {
1586         AccessibilityObject* linkedAXElement = internalLinkElement();
1587         if (linkedAXElement)
1588             linkedUIElements.append(linkedAXElement);
1589     }
1590
1591     if (roleValue() == RadioButtonRole)
1592         addRadioButtonGroupMembers(linkedUIElements);
1593 }
1594
1595 bool AccessibilityRenderObject::hasTextAlternative() const
1596 {
1597     // ARIA: section 2A, bullet #3 says if aria-labeledby or aria-label appears, it should
1598     // override the "label" element association.
1599     if (!ariaLabeledByAttribute().isEmpty() || !getAttribute(aria_labelAttr).isEmpty())
1600         return true;
1601         
1602     return false;   
1603 }
1604     
1605 bool AccessibilityRenderObject::ariaHasPopup() const
1606 {
1607     return elementAttributeValue(aria_haspopupAttr);
1608 }
1609     
1610 bool AccessibilityRenderObject::supportsARIAFlowTo() const
1611 {
1612     return !getAttribute(aria_flowtoAttr).isEmpty();
1613 }
1614     
1615 void AccessibilityRenderObject::ariaFlowToElements(AccessibilityChildrenVector& flowTo) const
1616 {
1617     Vector<Element*> elements;
1618     elementsFromAttribute(elements, aria_flowtoAttr);
1619     
1620     AXObjectCache* cache = axObjectCache();
1621     unsigned count = elements.size();
1622     for (unsigned k = 0; k < count; ++k) {
1623         Element* element = elements[k];
1624         AccessibilityObject* flowToElement = cache->getOrCreate(element->renderer());
1625         if (flowToElement)
1626             flowTo.append(flowToElement);
1627     }
1628         
1629 }
1630     
1631 bool AccessibilityRenderObject::supportsARIADropping() const 
1632 {
1633     const AtomicString& dropEffect = getAttribute(aria_dropeffectAttr);
1634     return !dropEffect.isEmpty();
1635 }
1636
1637 bool AccessibilityRenderObject::supportsARIADragging() const
1638 {
1639     const AtomicString& grabbed = getAttribute(aria_grabbedAttr);
1640     return equalIgnoringCase(grabbed, "true") || equalIgnoringCase(grabbed, "false");   
1641 }
1642
1643 bool AccessibilityRenderObject::isARIAGrabbed()
1644 {
1645     return elementAttributeValue(aria_grabbedAttr);
1646 }
1647
1648 void AccessibilityRenderObject::determineARIADropEffects(Vector<String>& effects)
1649 {
1650     const AtomicString& dropEffects = getAttribute(aria_dropeffectAttr);
1651     if (dropEffects.isEmpty()) {
1652         effects.clear();
1653         return;
1654     }
1655     
1656     String dropEffectsString = dropEffects.string();
1657     dropEffectsString.replace('\n', ' ');
1658     dropEffectsString.split(' ', effects);
1659 }
1660     
1661 bool AccessibilityRenderObject::exposesTitleUIElement() const
1662 {
1663     if (!isControl())
1664         return false;
1665
1666     // If this control is ignored (because it's invisible), 
1667     // then the label needs to be exposed so it can be visible to accessibility.
1668     if (accessibilityIsIgnored())
1669         return true;
1670     
1671     // checkbox or radio buttons don't expose the title ui element unless it has a title already
1672     if (isCheckboxOrRadio() && getAttribute(titleAttr).isEmpty())
1673         return false;
1674     
1675     if (hasTextAlternative())
1676         return false;
1677     
1678     return true;
1679 }
1680     
1681 AccessibilityObject* AccessibilityRenderObject::titleUIElement() const
1682 {
1683     if (!m_renderer)
1684         return 0;
1685     
1686     // if isFieldset is true, the renderer is guaranteed to be a RenderFieldset
1687     if (isFieldset())
1688         return axObjectCache()->getOrCreate(toRenderFieldset(m_renderer)->findLegend());
1689     
1690     if (!exposesTitleUIElement())
1691         return 0;
1692     
1693     Node* element = m_renderer->node();
1694     HTMLLabelElement* label = labelForElement(static_cast<Element*>(element));
1695     if (label && label->renderer())
1696         return axObjectCache()->getOrCreate(label->renderer());
1697
1698     return 0;   
1699 }
1700     
1701 bool AccessibilityRenderObject::ariaIsHidden() const
1702 {
1703     if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "true"))
1704         return true;
1705     
1706     // aria-hidden hides this object and any children
1707     AccessibilityObject* object = parentObject();
1708     while (object) {
1709         if (equalIgnoringCase(object->getAttribute(aria_hiddenAttr), "true"))
1710             return true;
1711         object = object->parentObject();
1712     }
1713
1714     return false;
1715 }
1716
1717 bool AccessibilityRenderObject::isDescendantOfBarrenParent() const
1718 {
1719     for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
1720         if (!object->canHaveChildren())
1721             return true;
1722     }
1723     
1724     return false;
1725 }
1726     
1727 bool AccessibilityRenderObject::isAllowedChildOfTree() const
1728 {
1729     // Determine if this is in a tree. If so, we apply special behavior to make it work like an AXOutline.
1730     AccessibilityObject* axObj = parentObject();
1731     bool isInTree = false;
1732     while (axObj) {
1733         if (axObj->isTree()) {
1734             isInTree = true;
1735             break;
1736         }
1737         axObj = axObj->parentObject();
1738     }
1739     
1740     // If the object is in a tree, only tree items should be exposed (and the children of tree items).
1741     if (isInTree) {
1742         AccessibilityRole role = roleValue();
1743         if (role != TreeItemRole && role != StaticTextRole)
1744             return false;
1745     }
1746     return true;
1747 }
1748     
1749 AccessibilityObjectInclusion AccessibilityRenderObject::accessibilityIsIgnoredBase() const
1750 {
1751     // The following cases can apply to any element that's a subclass of AccessibilityRenderObject.
1752     
1753     // Ignore invisible elements.
1754     if (!m_renderer || m_renderer->style()->visibility() != VISIBLE)
1755         return IgnoreObject;
1756
1757     // Anything marked as aria-hidden or a child of something aria-hidden must be hidden.
1758     if (ariaIsHidden())
1759         return IgnoreObject;
1760     
1761     // Anything that is a presentational role must be hidden.
1762     if (isPresentationalChildOfAriaRole())
1763         return IgnoreObject;
1764
1765     // Allow the platform to make a decision.
1766     AccessibilityObjectInclusion decision = accessibilityPlatformIncludesObject();
1767     if (decision == IncludeObject)
1768         return IncludeObject;
1769     if (decision == IgnoreObject)
1770         return IgnoreObject;
1771         
1772     return DefaultBehavior;
1773 }  
1774  
1775 bool AccessibilityRenderObject::accessibilityIsIgnored() const
1776 {
1777     // Check first if any of the common reasons cause this element to be ignored.
1778     // Then process other use cases that need to be applied to all the various roles
1779     // that AccessibilityRenderObjects take on.
1780     AccessibilityObjectInclusion decision = accessibilityIsIgnoredBase();
1781     if (decision == IncludeObject)
1782         return false;
1783     if (decision == IgnoreObject)
1784         return true;
1785     
1786     // If this element is within a parent that cannot have children, it should not be exposed.
1787     if (isDescendantOfBarrenParent())
1788         return true;    
1789     
1790     if (roleValue() == IgnoredRole)
1791         return true;
1792     
1793     if (roleValue() == PresentationalRole || inheritsPresentationalRole())
1794         return true;
1795     
1796     // An ARIA tree can only have tree items and static text as children.
1797     if (!isAllowedChildOfTree())
1798         return true;
1799
1800     // Allow the platform to decide if the attachment is ignored or not.
1801     if (isAttachment())
1802         return accessibilityIgnoreAttachment();
1803     
1804     // ignore popup menu items because AppKit does
1805     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
1806         if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
1807             return true;
1808     }
1809
1810     // find out if this element is inside of a label element.
1811     // if so, it may be ignored because it's the label for a checkbox or radio button
1812     AccessibilityObject* controlObject = correspondingControlForLabelElement();
1813     if (controlObject && !controlObject->exposesTitleUIElement() && controlObject->isCheckboxOrRadio())
1814         return true;
1815         
1816     // NOTE: BRs always have text boxes now, so the text box check here can be removed
1817     if (m_renderer->isText()) {
1818         // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level
1819         if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole
1820             || parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole)
1821             return true;
1822         RenderText* renderText = toRenderText(m_renderer);
1823         if (m_renderer->isBR() || !renderText->firstTextBox())
1824             return true;
1825
1826         // static text beneath TextControls is reported along with the text control text so it's ignored.
1827         for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) { 
1828             if (parent->roleValue() == TextFieldRole)
1829                 return true;
1830         }
1831
1832         // text elements that are just empty whitespace should not be returned
1833         return renderText->text()->containsOnlyWhitespace();
1834     }
1835     
1836     if (isHeading())
1837         return false;
1838     
1839     if (isLink())
1840         return false;
1841     
1842     // all controls are accessible
1843     if (isControl())
1844         return false;
1845     
1846     if (ariaRoleAttribute() != UnknownRole)
1847         return false;
1848
1849     // don't ignore labels, because they serve as TitleUIElements
1850     Node* node = m_renderer->node();
1851     if (node && node->hasTagName(labelTag))
1852         return false;
1853     
1854     // Anything that is content editable should not be ignored.
1855     // However, one cannot just call node->rendererIsEditable() since that will ask if its parents
1856     // are also editable. Only the top level content editable region should be exposed.
1857     if (node && node->isElementNode()) {
1858         Element* element = static_cast<Element*>(node);
1859         const AtomicString& contentEditable = element->getAttribute(contenteditableAttr);
1860         if (equalIgnoringCase(contentEditable, "true"))
1861             return false;
1862     }
1863     
1864     // List items play an important role in defining the structure of lists. They should not be ignored.
1865     if (roleValue() == ListItemRole)
1866         return false;
1867     
1868     // if this element has aria attributes on it, it should not be ignored.
1869     if (supportsARIAAttributes())
1870         return false;
1871     
1872     if (m_renderer->isBlockFlow() && m_renderer->childrenInline())
1873         return !toRenderBlock(m_renderer)->firstLineBox() && !mouseButtonListener();
1874     
1875     // ignore images seemingly used as spacers
1876     if (isImage()) {
1877         if (node && node->isElementNode()) {
1878             Element* elt = static_cast<Element*>(node);
1879             const AtomicString& alt = elt->getAttribute(altAttr);
1880             // don't ignore an image that has an alt tag
1881             if (!alt.isEmpty())
1882                 return false;
1883             // informal standard is to ignore images with zero-length alt strings
1884             if (!alt.isNull())
1885                 return true;
1886         }
1887         
1888         if (node && node->hasTagName(canvasTag)) {
1889             RenderHTMLCanvas* canvas = toRenderHTMLCanvas(m_renderer);
1890             if (canvas->height() <= 1 || canvas->width() <= 1)
1891                 return true;
1892             return false;
1893         }
1894         
1895         if (isNativeImage()) {
1896             // check for one-dimensional image
1897             RenderImage* image = toRenderImage(m_renderer);
1898             if (image->height() <= 1 || image->width() <= 1)
1899                 return true;
1900             
1901             // check whether rendered image was stretched from one-dimensional file image
1902             if (image->cachedImage()) {
1903                 LayoutSize imageSize = image->cachedImage()->imageSizeForRenderer(m_renderer, image->view()->zoomFactor());
1904                 return imageSize.height() <= 1 || imageSize.width() <= 1;
1905             }
1906         }
1907         return false;
1908     }
1909     
1910     if (isWebArea() || m_renderer->isListMarker())
1911         return false;
1912     
1913     // Using the help text to decide an element's visibility is not as definitive
1914     // as previous checks, so this should remain as one of the last.
1915     if (!helpText().isEmpty())
1916         return false;
1917     
1918     // By default, objects should be ignored so that the AX hierarchy is not 
1919     // filled with unnecessary items.
1920     return true;
1921 }
1922
1923 bool AccessibilityRenderObject::isLoaded() const
1924 {
1925     return !m_renderer->document()->parser();
1926 }
1927
1928 double AccessibilityRenderObject::estimatedLoadingProgress() const
1929 {
1930     if (!m_renderer)
1931         return 0;
1932     
1933     if (isLoaded())
1934         return 1.0;
1935     
1936     Page* page = m_renderer->document()->page();
1937     if (!page)
1938         return 0;
1939     
1940     return page->progress()->estimatedProgress();
1941 }
1942     
1943 int AccessibilityRenderObject::layoutCount() const
1944 {
1945     if (!m_renderer->isRenderView())
1946         return 0;
1947     return toRenderView(m_renderer)->frameView()->layoutCount();
1948 }
1949
1950 String AccessibilityRenderObject::text() const
1951 {
1952     // If this is a user defined static text, use the accessible name computation.
1953     if (ariaRoleAttribute() == StaticTextRole)
1954         return ariaAccessibilityDescription();
1955     
1956     if (!isTextControl() || isPasswordField())
1957         return String();
1958
1959     Node* node = m_renderer->node();
1960     if (!node)
1961         return String();
1962
1963     if (isNativeTextControl())
1964         return toRenderTextControl(m_renderer)->textFormControlElement()->value();
1965
1966     if (!node->isElementNode())
1967         return String();
1968     
1969     return static_cast<Element*>(node)->innerText();
1970 }
1971     
1972 int AccessibilityRenderObject::textLength() const
1973 {
1974     ASSERT(isTextControl());
1975     
1976     if (isPasswordField())
1977         return -1; // need to return something distinct from 0
1978     
1979     return text().length();
1980 }
1981
1982 PlainTextRange AccessibilityRenderObject::ariaSelectedTextRange() const
1983 {
1984     Node* node = m_renderer->node();
1985     if (!node)
1986         return PlainTextRange();
1987     
1988     ExceptionCode ec = 0;
1989     VisibleSelection visibleSelection = selection();
1990     RefPtr<Range> currentSelectionRange = visibleSelection.toNormalizedRange();
1991     if (!currentSelectionRange || !currentSelectionRange->intersectsNode(node, ec))
1992         return PlainTextRange();
1993     
1994     int start = indexForVisiblePosition(visibleSelection.start());
1995     int end = indexForVisiblePosition(visibleSelection.end());
1996     
1997     return PlainTextRange(start, end - start);
1998 }
1999
2000 String AccessibilityRenderObject::selectedText() const
2001 {
2002     ASSERT(isTextControl());
2003     
2004     if (isPasswordField())
2005         return String(); // need to return something distinct from empty string
2006     
2007     if (isNativeTextControl()) {
2008         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2009         return textControl->selectedText();
2010     }
2011     
2012     if (ariaRoleAttribute() == UnknownRole)
2013         return String();
2014     
2015     return doAXStringForRange(ariaSelectedTextRange());
2016 }
2017
2018 const AtomicString& AccessibilityRenderObject::accessKey() const
2019 {
2020     Node* node = m_renderer->node();
2021     if (!node)
2022         return nullAtom;
2023     if (!node->isElementNode())
2024         return nullAtom;
2025     return static_cast<Element*>(node)->getAttribute(accesskeyAttr);
2026 }
2027
2028 VisibleSelection AccessibilityRenderObject::selection() const
2029 {
2030     return m_renderer->frame()->selection()->selection();
2031 }
2032
2033 PlainTextRange AccessibilityRenderObject::selectedTextRange() const
2034 {
2035     ASSERT(isTextControl());
2036     
2037     if (isPasswordField())
2038         return PlainTextRange();
2039     
2040     AccessibilityRole ariaRole = ariaRoleAttribute();
2041     if (isNativeTextControl() && ariaRole == UnknownRole) {
2042         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2043         return PlainTextRange(textControl->selectionStart(), textControl->selectionEnd() - textControl->selectionStart());
2044     }
2045     
2046     if (ariaRole == UnknownRole)
2047         return PlainTextRange();
2048     
2049     return ariaSelectedTextRange();
2050 }
2051
2052 void AccessibilityRenderObject::setSelectedTextRange(const PlainTextRange& range)
2053 {
2054     if (isNativeTextControl()) {
2055         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2056         textControl->setSelectionRange(range.start, range.start + range.length);
2057         return;
2058     }
2059
2060     Document* document = m_renderer->document();
2061     if (!document)
2062         return;
2063     Frame* frame = document->frame();
2064     if (!frame)
2065         return;
2066     Node* node = m_renderer->node();
2067     frame->selection()->setSelection(VisibleSelection(Position(node, range.start, Position::PositionIsOffsetInAnchor),
2068         Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
2069 }
2070
2071 KURL AccessibilityRenderObject::url() const
2072 {
2073     if (isAnchor() && m_renderer->node()->hasTagName(aTag)) {
2074         if (HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(anchorElement()))
2075             return anchor->href();
2076     }
2077     
2078     if (isWebArea())
2079         return m_renderer->document()->url();
2080     
2081     if (isImage() && m_renderer->node() && m_renderer->node()->hasTagName(imgTag))
2082         return static_cast<HTMLImageElement*>(m_renderer->node())->src();
2083     
2084     if (isInputImage())
2085         return static_cast<HTMLInputElement*>(m_renderer->node())->src();
2086     
2087     return KURL();
2088 }
2089
2090 bool AccessibilityRenderObject::isUnvisited() const
2091 {
2092     // FIXME: Is it a privacy violation to expose unvisited information to accessibility APIs?
2093     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideUnvisitedLink;
2094 }
2095
2096 bool AccessibilityRenderObject::isVisited() const
2097 {
2098     // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
2099     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideVisitedLink;
2100 }
2101
2102 void AccessibilityRenderObject::setElementAttributeValue(const QualifiedName& attributeName, bool value)
2103 {
2104     if (!m_renderer)
2105         return;
2106     
2107     Node* node = m_renderer->node();
2108     if (!node || !node->isElementNode())
2109         return;
2110     
2111     Element* element = static_cast<Element*>(node);
2112     element->setAttribute(attributeName, (value) ? "true" : "false");        
2113 }
2114     
2115 bool AccessibilityRenderObject::elementAttributeValue(const QualifiedName& attributeName) const
2116 {
2117     if (!m_renderer)
2118         return false;
2119     
2120     return equalIgnoringCase(getAttribute(attributeName), "true");
2121 }
2122     
2123 bool AccessibilityRenderObject::isRequired() const
2124 {
2125     if (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
2126         return true;
2127     
2128     Node* n = node();
2129     if (n && (n->isElementNode() && static_cast<Element*>(n)->isFormControlElement()))
2130         return static_cast<HTMLFormControlElement*>(n)->required();
2131     
2132     return false;
2133 }
2134
2135 bool AccessibilityRenderObject::isSelected() const
2136 {
2137     if (!m_renderer)
2138         return false;
2139     
2140     Node* node = m_renderer->node();
2141     if (!node)
2142         return false;
2143     
2144     const AtomicString& ariaSelected = getAttribute(aria_selectedAttr);
2145     if (equalIgnoringCase(ariaSelected, "true"))
2146         return true;    
2147     
2148     if (isTabItem() && isTabItemSelected())
2149         return true;
2150
2151     return false;
2152 }
2153
2154 bool AccessibilityRenderObject::isTabItemSelected() const
2155 {
2156     if (!isTabItem() || !m_renderer)
2157         return false;
2158     
2159     Node* node = m_renderer->node();
2160     if (!node || !node->isElementNode())
2161         return false;
2162     
2163     // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
2164     // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
2165     // focus inside of it.
2166     AccessibilityObject* focusedElement = focusedUIElement();
2167     if (!focusedElement)
2168         return false;
2169     
2170     Vector<Element*> elements;
2171     elementsFromAttribute(elements, aria_controlsAttr);
2172     
2173     unsigned count = elements.size();
2174     for (unsigned k = 0; k < count; ++k) {
2175         Element* element = elements[k];
2176         AccessibilityObject* tabPanel = axObjectCache()->getOrCreate(element->renderer());
2177
2178         // A tab item should only control tab panels.
2179         if (!tabPanel || tabPanel->roleValue() != TabPanelRole)
2180             continue;
2181         
2182         AccessibilityObject* checkFocusElement = focusedElement;
2183         // Check if the focused element is a descendant of the element controlled by the tab item.
2184         while (checkFocusElement) {
2185             if (tabPanel == checkFocusElement)
2186                 return true;
2187             checkFocusElement = checkFocusElement->parentObject();
2188         }
2189     }
2190     
2191     return false;
2192 }
2193     
2194 bool AccessibilityRenderObject::isFocused() const
2195 {
2196     if (!m_renderer)
2197         return false;
2198     
2199     Document* document = m_renderer->document();
2200     if (!document)
2201         return false;
2202     
2203     Node* focusedNode = document->focusedNode();
2204     if (!focusedNode)
2205         return false;
2206     
2207     // A web area is represented by the Document node in the DOM tree, which isn't focusable.
2208     // Check instead if the frame's selection controller is focused
2209     if (focusedNode == m_renderer->node()
2210         || (roleValue() == WebAreaRole && document->frame()->selection()->isFocusedAndActive()))
2211         return true;
2212     
2213     return false;
2214 }
2215
2216 void AccessibilityRenderObject::setFocused(bool on)
2217 {
2218     if (!canSetFocusAttribute())
2219         return;
2220     
2221     if (!on)
2222         m_renderer->document()->setFocusedNode(0);
2223     else {
2224         if (m_renderer->node()->isElementNode())
2225             static_cast<Element*>(m_renderer->node())->focus();
2226         else
2227             m_renderer->document()->setFocusedNode(m_renderer->node());
2228     }
2229 }
2230
2231 void AccessibilityRenderObject::changeValueByStep(bool increase)
2232 {
2233     float step = stepValueForRange();
2234     float value = valueForRange();
2235     
2236     value += increase ? step : -step;
2237
2238     setValue(String::number(value));
2239     
2240     axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
2241 }
2242     
2243 void AccessibilityRenderObject::changeValueByPercent(float percentChange)
2244 {
2245     float range = maxValueForRange() - minValueForRange();
2246     float value = valueForRange();
2247     
2248     value += range * (percentChange / 100);
2249     setValue(String::number(value));
2250     
2251     axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
2252 }
2253
2254 void AccessibilityRenderObject::setSelectedRows(AccessibilityChildrenVector& selectedRows)
2255 {
2256     // Setting selected only makes sense in trees and tables (and tree-tables).
2257     AccessibilityRole role = roleValue();
2258     if (role != TreeRole && role != TreeGridRole && role != TableRole)
2259         return;
2260     
2261     bool isMulti = isMultiSelectable();
2262     unsigned count = selectedRows.size();
2263     if (count > 1 && !isMulti)
2264         count = 1;
2265     
2266     for (unsigned k = 0; k < count; ++k)
2267         selectedRows[k]->setSelected(true);
2268 }
2269     
2270 void AccessibilityRenderObject::setValue(const String& string)
2271 {
2272     if (!m_renderer || !m_renderer->node() || !m_renderer->node()->isElementNode())
2273         return;
2274     Element* element = static_cast<Element*>(m_renderer->node());
2275
2276     if (!m_renderer->isBoxModelObject())
2277         return;
2278     RenderBoxModelObject* renderer = toRenderBoxModelObject(m_renderer);
2279
2280     // FIXME: Do we want to do anything here for ARIA textboxes?
2281     if (renderer->isTextField()) {
2282         // FIXME: This is not safe!  Other elements could have a TextField renderer.
2283         static_cast<HTMLInputElement*>(element)->setValue(string);
2284     } else if (renderer->isTextArea()) {
2285         // FIXME: This is not safe!  Other elements could have a TextArea renderer.
2286         static_cast<HTMLTextAreaElement*>(element)->setValue(string);
2287     }
2288 }
2289
2290 void AccessibilityRenderObject::ariaOwnsElements(AccessibilityChildrenVector& axObjects) const
2291 {
2292     Vector<Element*> elements;
2293     elementsFromAttribute(elements, aria_ownsAttr);
2294     
2295     unsigned count = elements.size();
2296     for (unsigned k = 0; k < count; ++k) {
2297         RenderObject* render = elements[k]->renderer();
2298         AccessibilityObject* obj = axObjectCache()->getOrCreate(render);
2299         if (obj)
2300             axObjects.append(obj);
2301     }
2302 }
2303
2304 bool AccessibilityRenderObject::supportsARIAOwns() const
2305 {
2306     if (!m_renderer)
2307         return false;
2308     const AtomicString& ariaOwns = getAttribute(aria_ownsAttr);
2309
2310     return !ariaOwns.isEmpty();
2311 }
2312     
2313 bool AccessibilityRenderObject::isEnabled() const
2314 {
2315     ASSERT(m_renderer);
2316     
2317     if (equalIgnoringCase(getAttribute(aria_disabledAttr), "true"))
2318         return false;
2319     
2320     Node* node = m_renderer->node();
2321     if (!node || !node->isElementNode())
2322         return true;
2323
2324     return static_cast<Element*>(node)->isEnabledFormControl();
2325 }
2326
2327 RenderView* AccessibilityRenderObject::topRenderer() const
2328 {
2329     Document* topDoc = topDocument();
2330     if (!topDoc)
2331         return 0;
2332     
2333     return topDoc->renderView();
2334 }
2335
2336 Document* AccessibilityRenderObject::document() const
2337 {
2338     if (!m_renderer)
2339         return 0;
2340     return m_renderer->document();
2341 }
2342
2343 Document* AccessibilityRenderObject::topDocument() const
2344 {
2345     if (!document())
2346         return 0;
2347     return document()->topDocument();
2348 }
2349     
2350 FrameView* AccessibilityRenderObject::topDocumentFrameView() const
2351 {
2352     RenderView* renderView = topRenderer();
2353     if (!renderView || !renderView->view())
2354         return 0;
2355     return renderView->view()->frameView();
2356 }
2357
2358 Widget* AccessibilityRenderObject::widget() const
2359 {
2360     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isWidget())
2361         return 0;
2362     return toRenderWidget(m_renderer)->widget();
2363 }
2364
2365 AccessibilityObject* AccessibilityRenderObject::accessibilityParentForImageMap(HTMLMapElement* map) const
2366 {
2367     // find an image that is using this map
2368     if (!map)
2369         return 0;
2370
2371     HTMLImageElement* imageElement = map->imageElement();
2372     if (!imageElement)
2373         return 0;
2374     
2375     return axObjectCache()->getOrCreate(imageElement->renderer());
2376 }
2377     
2378 void AccessibilityRenderObject::getDocumentLinks(AccessibilityChildrenVector& result)
2379 {
2380     Document* document = m_renderer->document();
2381     RefPtr<HTMLCollection> coll = document->links();
2382     Node* curr = coll->firstItem();
2383     while (curr) {
2384         RenderObject* obj = curr->renderer();
2385         if (obj) {
2386             RefPtr<AccessibilityObject> axobj = document->axObjectCache()->getOrCreate(obj);
2387             ASSERT(axobj);
2388             if (!axobj->accessibilityIsIgnored() && axobj->isLink())
2389                 result.append(axobj);
2390         } else {
2391             Node* parent = curr->parentNode();
2392             if (parent && curr->hasTagName(areaTag) && parent->hasTagName(mapTag)) {
2393                 AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
2394                 areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(curr));
2395                 areaObject->setHTMLMapElement(static_cast<HTMLMapElement*>(parent));
2396                 areaObject->setParent(accessibilityParentForImageMap(static_cast<HTMLMapElement*>(parent)));
2397
2398                 result.append(areaObject);
2399             }
2400         }
2401         curr = coll->nextItem();
2402     }
2403 }
2404
2405 FrameView* AccessibilityRenderObject::documentFrameView() const 
2406
2407     if (!m_renderer || !m_renderer->document()) 
2408         return 0; 
2409
2410     // this is the RenderObject's Document's Frame's FrameView 
2411     return m_renderer->document()->view();
2412 }
2413
2414 Widget* AccessibilityRenderObject::widgetForAttachmentView() const
2415 {
2416     if (!isAttachment())
2417         return 0;
2418     return toRenderWidget(m_renderer)->widget();
2419 }
2420
2421 FrameView* AccessibilityRenderObject::frameViewIfRenderView() const
2422 {
2423     if (!m_renderer->isRenderView())
2424         return 0;
2425     // this is the RenderObject's Document's renderer's FrameView
2426     return m_renderer->view()->frameView();
2427 }
2428
2429 // This function is like a cross-platform version of - (WebCoreTextMarkerRange*)textMarkerRange. It returns
2430 // a Range that we can convert to a WebCoreTextMarkerRange in the Obj-C file
2431 VisiblePositionRange AccessibilityRenderObject::visiblePositionRange() const
2432 {
2433     if (!m_renderer)
2434         return VisiblePositionRange();
2435     
2436     // construct VisiblePositions for start and end
2437     Node* node = m_renderer->node();
2438     if (!node)
2439         return VisiblePositionRange();
2440
2441     VisiblePosition startPos = firstPositionInOrBeforeNode(node);
2442     VisiblePosition endPos = lastPositionInOrAfterNode(node);
2443
2444     // the VisiblePositions are equal for nodes like buttons, so adjust for that
2445     // FIXME: Really?  [button, 0] and [button, 1] are distinct (before and after the button)
2446     // I expect this code is only hit for things like empty divs?  In which case I don't think
2447     // the behavior is correct here -- eseidel
2448     if (startPos == endPos) {
2449         endPos = endPos.next();
2450         if (endPos.isNull())
2451             endPos = startPos;
2452     }
2453
2454     return VisiblePositionRange(startPos, endPos);
2455 }
2456
2457 VisiblePositionRange AccessibilityRenderObject::visiblePositionRangeForLine(unsigned lineCount) const
2458 {
2459     if (!lineCount || !m_renderer)
2460         return VisiblePositionRange();
2461     
2462     // iterate over the lines
2463     // FIXME: this is wrong when lineNumber is lineCount+1,  because nextLinePosition takes you to the
2464     // last offset of the last line
2465     VisiblePosition visiblePos = m_renderer->document()->renderer()->positionForPoint(IntPoint());
2466     VisiblePosition savedVisiblePos;
2467     while (--lineCount) {
2468         savedVisiblePos = visiblePos;
2469         visiblePos = nextLinePosition(visiblePos, 0);
2470         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
2471             return VisiblePositionRange();
2472     }
2473     
2474     // make a caret selection for the marker position, then extend it to the line
2475     // NOTE: ignores results of sel.modify because it returns false when
2476     // starting at an empty line.  The resulting selection in that case
2477     // will be a caret at visiblePos.
2478     FrameSelection selection;
2479     selection.setSelection(VisibleSelection(visiblePos));
2480     selection.modify(FrameSelection::AlterationExtend, DirectionRight, LineBoundary);
2481     
2482     return VisiblePositionRange(selection.selection().visibleStart(), selection.selection().visibleEnd());
2483 }
2484     
2485 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(int index) const
2486 {
2487     if (!m_renderer)
2488         return VisiblePosition();
2489     
2490     if (isNativeTextControl())
2491         return toRenderTextControl(m_renderer)->visiblePositionForIndex(index);
2492
2493     if (!allowsTextRanges() && !m_renderer->isText())
2494         return VisiblePosition();
2495     
2496     Node* node = m_renderer->node();
2497     if (!node)
2498         return VisiblePosition();
2499     
2500     if (index <= 0)
2501         return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
2502     
2503     ExceptionCode ec = 0;
2504     RefPtr<Range> range = Range::create(m_renderer->document());
2505     range->selectNodeContents(node, ec);
2506     CharacterIterator it(range.get());
2507     it.advance(index - 1);
2508     return VisiblePosition(Position(it.range()->endContainer(ec), it.range()->endOffset(ec), Position::PositionIsOffsetInAnchor), UPSTREAM);
2509 }
2510     
2511 int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& pos) const
2512 {
2513     if (isNativeTextControl()) {
2514         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2515         return textControl->indexForVisiblePosition(pos);
2516     }
2517
2518     if (!isTextControl())
2519         return 0;
2520     
2521     Node* node = m_renderer->node();
2522     if (!node)
2523         return 0;
2524     
2525     Position indexPosition = pos.deepEquivalent();
2526     if (indexPosition.isNull() || rootEditableElementForPosition(indexPosition) != node)
2527         return 0;
2528     
2529     ExceptionCode ec = 0;
2530     RefPtr<Range> range = Range::create(m_renderer->document());
2531     range->setStart(node, 0, ec);
2532     range->setEnd(indexPosition, ec);
2533
2534 #if PLATFORM(GTK)
2535     // We need to consider replaced elements for GTK, as they will be
2536     // presented with the 'object replacement character' (0xFFFC).
2537     return TextIterator::rangeLength(range.get(), true);
2538 #else
2539     return TextIterator::rangeLength(range.get());
2540 #endif
2541 }
2542
2543 Element* AccessibilityRenderObject::rootEditableElementForPosition(const Position& position) const
2544 {
2545     // Find the root editable or pseudo-editable (i.e. having an editable ARIA role) element.
2546     Element* result = 0;
2547     
2548     Element* rootEditableElement = position.rootEditableElement();
2549
2550     for (Element* e = position.element(); e && e != rootEditableElement; e = e->parentElement()) {
2551         if (nodeIsTextControl(e))
2552             result = e;
2553         if (e->hasTagName(bodyTag))
2554             break;
2555     }
2556
2557     if (result)
2558         return result;
2559
2560     return rootEditableElement;
2561 }
2562
2563 bool AccessibilityRenderObject::nodeIsTextControl(const Node* node) const
2564 {
2565     if (!node)
2566         return false;
2567
2568     const AccessibilityObject* axObjectForNode = axObjectCache()->getOrCreate(node->renderer());
2569     if (!axObjectForNode)
2570         return false;
2571
2572     return axObjectForNode->isTextControl();
2573 }
2574
2575 LayoutRect AccessibilityRenderObject::boundsForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) const
2576 {
2577     if (visiblePositionRange.isNull())
2578         return LayoutRect();
2579     
2580     // Create a mutable VisiblePositionRange.
2581     VisiblePositionRange range(visiblePositionRange);
2582     LayoutRect rect1 = range.start.absoluteCaretBounds();
2583     LayoutRect rect2 = range.end.absoluteCaretBounds();
2584     
2585     // readjust for position at the edge of a line.  This is to exclude line rect that doesn't need to be accounted in the range bounds
2586     if (rect2.y() != rect1.y()) {
2587         VisiblePosition endOfFirstLine = endOfLine(range.start);
2588         if (range.start == endOfFirstLine) {
2589             range.start.setAffinity(DOWNSTREAM);
2590             rect1 = range.start.absoluteCaretBounds();
2591         }
2592         if (range.end == endOfFirstLine) {
2593             range.end.setAffinity(UPSTREAM);
2594             rect2 = range.end.absoluteCaretBounds();
2595         }
2596     }
2597     
2598     LayoutRect ourrect = rect1;
2599     ourrect.unite(rect2);
2600     
2601     // if the rectangle spans lines and contains multiple text chars, use the range's bounding box intead
2602     if (rect1.maxY() != rect2.maxY()) {
2603         RefPtr<Range> dataRange = makeRange(range.start, range.end);
2604         LayoutRect boundingBox = dataRange->boundingBox();
2605         String rangeString = plainText(dataRange.get());
2606         if (rangeString.length() > 1 && !boundingBox.isEmpty())
2607             ourrect = boundingBox;
2608     }
2609     
2610 #if PLATFORM(MAC)
2611     return m_renderer->document()->view()->contentsToScreen(ourrect);
2612 #else
2613     return ourrect;
2614 #endif
2615 }
2616     
2617 void AccessibilityRenderObject::setSelectedVisiblePositionRange(const VisiblePositionRange& range) const
2618 {
2619     if (range.start.isNull() || range.end.isNull())
2620         return;
2621     
2622     // make selection and tell the document to use it. if it's zero length, then move to that position
2623     if (range.start == range.end)
2624         m_renderer->frame()->selection()->moveTo(range.start, UserTriggered);
2625     else {
2626         VisibleSelection newSelection = VisibleSelection(range.start, range.end);
2627         m_renderer->frame()->selection()->setSelection(newSelection);
2628     }    
2629 }
2630
2631 VisiblePosition AccessibilityRenderObject::visiblePositionForPoint(const LayoutPoint& point) const
2632 {
2633     if (!m_renderer)
2634         return VisiblePosition();
2635     
2636     // convert absolute point to view coordinates
2637     Document* topDoc = topDocument();
2638     if (!topDoc || !topDoc->renderer() || !topDoc->renderer()->view())
2639         return VisiblePosition();
2640     
2641     FrameView* frameView = topDoc->renderer()->view()->frameView();
2642     if (!frameView)
2643         return VisiblePosition();
2644     
2645     RenderView* renderView = topRenderer();
2646     if (!renderView)
2647         return VisiblePosition();
2648     
2649     Node* innerNode = 0;
2650     
2651     // locate the node containing the point
2652     LayoutPoint pointResult;
2653     while (1) {
2654         LayoutPoint ourpoint;
2655 #if PLATFORM(MAC)
2656         ourpoint = frameView->screenToContents(point);
2657 #else
2658         ourpoint = point;
2659 #endif
2660         HitTestRequest request(HitTestRequest::ReadOnly |
2661                                HitTestRequest::Active);
2662         HitTestResult result(ourpoint);
2663         renderView->layer()->hitTest(request, result);
2664         innerNode = result.innerNode();
2665         if (!innerNode)
2666             return VisiblePosition();
2667         
2668         RenderObject* renderer = innerNode->renderer();
2669         if (!renderer)
2670             return VisiblePosition();
2671         
2672         pointResult = result.localPoint();
2673
2674         // done if hit something other than a widget
2675         if (!renderer->isWidget())
2676             break;
2677
2678         // descend into widget (FRAME, IFRAME, OBJECT...)
2679         Widget* widget = toRenderWidget(renderer)->widget();
2680         if (!widget || !widget->isFrameView())
2681             break;
2682         Frame* frame = static_cast<FrameView*>(widget)->frame();
2683         if (!frame)
2684             break;
2685         renderView = frame->document()->renderView();
2686         frameView = static_cast<FrameView*>(widget);
2687     }
2688     
2689     return innerNode->renderer()->positionForPoint(pointResult);
2690 }
2691
2692 // NOTE: Consider providing this utility method as AX API
2693 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(unsigned indexValue, bool lastIndexOK) const
2694 {
2695     if (!isTextControl())
2696         return VisiblePosition();
2697     
2698     // lastIndexOK specifies whether the position after the last character is acceptable
2699     if (indexValue >= text().length()) {
2700         if (!lastIndexOK || indexValue > text().length())
2701             return VisiblePosition();
2702     }
2703     VisiblePosition position = visiblePositionForIndex(indexValue);
2704     position.setAffinity(DOWNSTREAM);
2705     return position;
2706 }
2707
2708 // NOTE: Consider providing this utility method as AX API
2709 int AccessibilityRenderObject::index(const VisiblePosition& position) const
2710 {
2711     if (!isTextControl())
2712         return -1;
2713
2714     if (renderObjectContainsPosition(m_renderer, position.deepEquivalent()))
2715         return indexForVisiblePosition(position);
2716     
2717     return -1;
2718 }
2719
2720 // Given a line number, the range of characters of the text associated with this accessibility
2721 // object that contains the line number.
2722 PlainTextRange AccessibilityRenderObject::doAXRangeForLine(unsigned lineNumber) const
2723 {
2724     if (!isTextControl())
2725         return PlainTextRange();
2726     
2727     // iterate to the specified line
2728     VisiblePosition visiblePos = visiblePositionForIndex(0);
2729     VisiblePosition savedVisiblePos;
2730     for (unsigned lineCount = lineNumber; lineCount; lineCount -= 1) {
2731         savedVisiblePos = visiblePos;
2732         visiblePos = nextLinePosition(visiblePos, 0);
2733         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
2734             return PlainTextRange();
2735     }
2736
2737     // Get the end of the line based on the starting position.
2738     VisiblePosition endPosition = endOfLine(visiblePos);
2739
2740     int index1 = indexForVisiblePosition(visiblePos);
2741     int index2 = indexForVisiblePosition(endPosition);
2742     
2743     // add one to the end index for a line break not caused by soft line wrap (to match AppKit)
2744     if (endPosition.affinity() == DOWNSTREAM && endPosition.next().isNotNull())
2745         index2 += 1;
2746     
2747     // return nil rather than an zero-length range (to match AppKit)
2748     if (index1 == index2)
2749         return PlainTextRange();
2750     
2751     return PlainTextRange(index1, index2 - index1);
2752 }
2753
2754 // The composed character range in the text associated with this accessibility object that
2755 // is specified by the given index value. This parameterized attribute returns the complete
2756 // range of characters (including surrogate pairs of multi-byte glyphs) at the given index.
2757 PlainTextRange AccessibilityRenderObject::doAXRangeForIndex(unsigned index) const
2758 {
2759     if (!isTextControl())
2760         return PlainTextRange();
2761     
2762     String elementText = text();
2763     if (!elementText.length() || index > elementText.length() - 1)
2764         return PlainTextRange();
2765     
2766     return PlainTextRange(index, 1);
2767 }
2768
2769 // A substring of the text associated with this accessibility object that is
2770 // specified by the given character range.
2771 String AccessibilityRenderObject::doAXStringForRange(const PlainTextRange& range) const
2772 {
2773     if (isPasswordField())
2774         return String();
2775     
2776     if (!range.length)
2777         return String();
2778     
2779     if (!isTextControl())
2780         return String();
2781     
2782     String elementText = text();
2783     if (range.start + range.length > elementText.length())
2784         return String();
2785     
2786     return elementText.substring(range.start, range.length);
2787 }
2788
2789 // The bounding rectangle of the text associated with this accessibility object that is
2790 // specified by the given range. This is the bounding rectangle a sighted user would see
2791 // on the display screen, in pixels.
2792 LayoutRect AccessibilityRenderObject::doAXBoundsForRange(const PlainTextRange& range) const
2793 {
2794     if (allowsTextRanges())
2795         return boundsForVisiblePositionRange(visiblePositionRangeForRange(range));
2796     return LayoutRect();
2797 }
2798
2799 AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
2800 {
2801     if (!area)
2802         return 0;
2803     
2804     HTMLMapElement* map = static_cast<HTMLMapElement*>(area->parentNode());
2805     AccessibilityObject* parent = accessibilityParentForImageMap(map);
2806     if (!parent)
2807         return 0;
2808     
2809     AccessibilityObject::AccessibilityChildrenVector children = parent->children();
2810     
2811     unsigned count = children.size();
2812     for (unsigned k = 0; k < count; ++k) {
2813         if (children[k]->elementRect().contains(point))
2814             return children[k].get();
2815     }
2816     
2817     return 0;
2818 }
2819     
2820 AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPoint& point) const
2821 {
2822     if (!m_renderer || !m_renderer->hasLayer())
2823         return 0;
2824     
2825     RenderLayer* layer = toRenderBox(m_renderer)->layer();
2826      
2827     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
2828     HitTestResult hitTestResult = HitTestResult(point);
2829     layer->hitTest(request, hitTestResult);
2830     if (!hitTestResult.innerNode())
2831         return 0;
2832     Node* node = hitTestResult.innerNode()->shadowAncestorNode();
2833
2834     if (node->hasTagName(areaTag)) 
2835         return accessibilityImageMapHitTest(static_cast<HTMLAreaElement*>(node), point);
2836     
2837     if (node->hasTagName(optionTag))
2838         node = static_cast<HTMLOptionElement*>(node)->ownerSelectElement();
2839     
2840     RenderObject* obj = node->renderer();
2841     if (!obj)
2842         return 0;
2843     
2844     AccessibilityObject* result = obj->document()->axObjectCache()->getOrCreate(obj);
2845     result->updateChildrenIfNecessary();
2846
2847     // Allow the element to perform any hit-testing it might need to do to reach non-render children.
2848     result = result->elementAccessibilityHitTest(point);
2849     
2850     if (result && result->accessibilityIsIgnored()) {
2851         // If this element is the label of a control, a hit test should return the control.
2852         AccessibilityObject* controlObject = result->correspondingControlForLabelElement();
2853         if (controlObject && !controlObject->exposesTitleUIElement())
2854             return controlObject;
2855
2856         result = result->parentObjectUnignored();
2857     }
2858
2859     return result;
2860 }
2861
2862 bool AccessibilityRenderObject::shouldFocusActiveDescendant() const
2863 {
2864     switch (ariaRoleAttribute()) {
2865     case GroupRole:
2866     case ComboBoxRole:
2867     case ListBoxRole:
2868     case MenuRole:
2869     case MenuBarRole:
2870     case RadioGroupRole:
2871     case RowRole:
2872     case PopUpButtonRole:
2873     case ProgressIndicatorRole:
2874     case ToolbarRole:
2875     case OutlineRole:
2876     case TreeRole:
2877     case GridRole:
2878     /* FIXME: replace these with actual roles when they are added to AccessibilityRole
2879     composite
2880     alert
2881     alertdialog
2882     status
2883     timer
2884     */
2885         return true;
2886     default:
2887         return false;
2888     }
2889 }
2890
2891 AccessibilityObject* AccessibilityRenderObject::activeDescendant() const
2892 {
2893     if (!m_renderer)
2894         return 0;
2895     
2896     if (m_renderer->node() && !m_renderer->node()->isElementNode())
2897         return 0;
2898     Element* element = static_cast<Element*>(m_renderer->node());
2899         
2900     const AtomicString& activeDescendantAttrStr = element->getAttribute(aria_activedescendantAttr);
2901     if (activeDescendantAttrStr.isNull() || activeDescendantAttrStr.isEmpty())
2902         return 0;
2903     
2904     Element* target = element->treeScope()->getElementById(activeDescendantAttrStr);
2905     if (!target)
2906         return 0;
2907     
2908     AccessibilityObject* obj = axObjectCache()->getOrCreate(target->renderer());
2909     if (obj && obj->isAccessibilityRenderObject())
2910     // an activedescendant is only useful if it has a renderer, because that's what's needed to post the notification
2911         return obj;
2912     return 0;
2913 }
2914
2915 void AccessibilityRenderObject::handleAriaExpandedChanged()
2916 {
2917     // Find if a parent of this object should handle aria-expanded changes.
2918     AccessibilityObject* containerParent = this->parentObject();
2919     while (containerParent) {
2920         bool foundParent = false;
2921         
2922         switch (containerParent->roleValue()) {
2923         case TreeRole:
2924         case TreeGridRole:
2925         case GridRole:
2926         case TableRole:
2927         case BrowserRole:
2928             foundParent = true;
2929             break;
2930         default:
2931             break;
2932         }
2933         
2934         if (foundParent)
2935             break;
2936         
2937         containerParent = containerParent->parentObject();
2938     }
2939     
2940     // Post that the row count changed.
2941     if (containerParent)
2942         axObjectCache()->postNotification(containerParent, document(), AXObjectCache::AXRowCountChanged, true);
2943
2944     // Post that the specific row either collapsed or expanded.
2945     if (roleValue() == RowRole || roleValue() == TreeItemRole)
2946         axObjectCache()->postNotification(this, document(), isExpanded() ? AXObjectCache::AXRowExpanded : AXObjectCache::AXRowCollapsed, true);
2947 }
2948
2949 void AccessibilityRenderObject::handleActiveDescendantChanged()
2950 {
2951     Element* element = static_cast<Element*>(renderer()->node());
2952     if (!element)
2953         return;
2954     Document* doc = renderer()->document();
2955     if (!doc->frame()->selection()->isFocusedAndActive() || doc->focusedNode() != element)
2956         return; 
2957     AccessibilityRenderObject* activedescendant = static_cast<AccessibilityRenderObject*>(activeDescendant());
2958     
2959     if (activedescendant && shouldFocusActiveDescendant())
2960         doc->axObjectCache()->postNotification(m_renderer, AXObjectCache::AXActiveDescendantChanged, true);
2961 }
2962
2963 AccessibilityObject* AccessibilityRenderObject::correspondingControlForLabelElement() const
2964 {
2965     HTMLLabelElement* labelElement = labelElementContainer();
2966     if (!labelElement)
2967         return 0;
2968     
2969     HTMLElement* correspondingControl = labelElement->control();
2970     if (!correspondingControl)
2971         return 0;
2972     
2973     return axObjectCache()->getOrCreate(correspondingControl->renderer());     
2974 }
2975
2976 AccessibilityObject* AccessibilityRenderObject::correspondingLabelForControlElement() const
2977 {
2978     if (!m_renderer)
2979         return 0;
2980
2981     Node* node = m_renderer->node();
2982     if (node && node->isHTMLElement()) {
2983         HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
2984         if (label)
2985             return axObjectCache()->getOrCreate(label->renderer());
2986     }
2987
2988     return 0;
2989 }
2990
2991 bool AccessibilityRenderObject::renderObjectIsObservable(RenderObject* renderer) const
2992 {
2993     // AX clients will listen for AXValueChange on a text control.
2994     if (renderer->isTextControl())
2995         return true;
2996     
2997     // AX clients will listen for AXSelectedChildrenChanged on listboxes.
2998     Node* node = renderer->node();
2999     if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListBox()))
3000         return true;
3001
3002     // Textboxes should send out notifications.
3003     if (nodeHasRole(node, "textbox"))
3004         return true;
3005     
3006     return false;
3007 }
3008     
3009 AccessibilityObject* AccessibilityRenderObject::observableObject() const
3010 {
3011     // Find the object going up the parent chain that is used in accessibility to monitor certain notifications.
3012     for (RenderObject* renderer = m_renderer; renderer && renderer->node(); renderer = renderer->parent()) {
3013         if (renderObjectIsObservable(renderer))
3014             return axObjectCache()->getOrCreate(renderer);
3015     }
3016     
3017     return 0;
3018 }
3019
3020 AccessibilityRole AccessibilityRenderObject::remapAriaRoleDueToParent(AccessibilityRole role) const
3021 {
3022     // Some objects change their role based on their parent.
3023     // However, asking for the unignoredParent calls accessibilityIsIgnored(), which can trigger a loop. 
3024     // While inside the call stack of creating an element, we need to avoid accessibilityIsIgnored().
3025     // https://bugs.webkit.org/show_bug.cgi?id=65174
3026
3027     if (role != ListBoxOptionRole && role != MenuItemRole)
3028         return role;
3029     
3030     for (AccessibilityObject* parent = parentObject(); parent && !parent->accessibilityIsIgnored(); parent = parent->parentObject()) {
3031         AccessibilityRole parentAriaRole = parent->ariaRoleAttribute();
3032
3033         // Selects and listboxes both have options as child roles, but they map to different roles within WebCore.
3034         if (role == ListBoxOptionRole && parentAriaRole == MenuRole)
3035             return MenuItemRole;
3036         // An aria "menuitem" may map to MenuButton or MenuItem depending on its parent.
3037         if (role == MenuItemRole && parentAriaRole == GroupRole)
3038             return MenuButtonRole;
3039         
3040         // If the parent had a different role, then we don't need to continue searching up the chain.
3041         if (parentAriaRole)
3042             break;
3043     }
3044     
3045     return role;
3046 }
3047     
3048 AccessibilityRole AccessibilityRenderObject::determineAriaRoleAttribute() const
3049 {
3050     const AtomicString& ariaRole = getAttribute(roleAttr);
3051     if (ariaRole.isNull() || ariaRole.isEmpty())
3052         return UnknownRole;
3053     
3054     AccessibilityRole role = ariaRoleToWebCoreRole(ariaRole);
3055
3056     if (role == ButtonRole && ariaHasPopup())
3057         role = PopUpButtonRole;
3058
3059     if (role == TextAreaRole && !ariaIsMultiline())
3060         role = TextFieldRole;
3061
3062     role = remapAriaRoleDueToParent(role);
3063     
3064     if (role)
3065         return role;
3066
3067     return UnknownRole;
3068 }
3069
3070 AccessibilityRole AccessibilityRenderObject::ariaRoleAttribute() const
3071 {
3072     return m_ariaRole;
3073 }
3074     
3075 void AccessibilityRenderObject::updateAccessibilityRole()
3076 {
3077     bool ignoredStatus = accessibilityIsIgnored();
3078     m_role = determineAccessibilityRole();
3079     
3080     // The AX hierarchy only needs to be updated if the ignored status of an element has changed.
3081     if (ignoredStatus != accessibilityIsIgnored())
3082         childrenChanged();
3083 }
3084     
3085 bool AccessibilityRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
3086 {
3087     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
3088         if (parent->node() && parent->node()->hasTagName(tagName))
3089             return true;
3090     }
3091     return false;
3092 }
3093     
3094 AccessibilityRole AccessibilityRenderObject::determineAccessibilityRole()
3095 {
3096     if (!m_renderer)
3097         return UnknownRole;
3098
3099     m_ariaRole = determineAriaRoleAttribute();
3100     
3101     Node* node = m_renderer->node();
3102     AccessibilityRole ariaRole = ariaRoleAttribute();
3103     if (ariaRole != UnknownRole)
3104         return ariaRole;
3105
3106     RenderBoxModelObject* cssBox = renderBoxModelObject();
3107
3108     if (node && node->isLink()) {
3109         if (cssBox && cssBox->isImage())
3110             return ImageMapRole;
3111         return WebCoreLinkRole;
3112     }
3113     if (cssBox && cssBox->isListItem())
3114         return ListItemRole;
3115     if (m_renderer->isListMarker())
3116         return ListMarkerRole;
3117     if (node && node->hasTagName(buttonTag))
3118         return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3119     if (m_renderer->isText())
3120         return StaticTextRole;
3121     if (cssBox && cssBox->isImage()) {
3122         if (node && node->hasTagName(inputTag))
3123             return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3124         return ImageRole;
3125     }
3126     if (node && node->hasTagName(canvasTag))
3127         return ImageRole;
3128
3129     if (cssBox && cssBox->isRenderView())
3130         return WebAreaRole;
3131     
3132     if (cssBox && cssBox->isTextField())
3133         return TextFieldRole;
3134     
3135     if (cssBox && cssBox->isTextArea())
3136         return TextAreaRole;
3137
3138     if (node && node->hasTagName(inputTag)) {
3139         HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
3140         if (input->isCheckbox())
3141             return CheckBoxRole;
3142         if (input->isRadioButton())
3143             return RadioButtonRole;
3144         if (input->isTextButton())
3145             return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3146     }
3147
3148     if (isFileUploadButton())
3149         return ButtonRole;
3150     
3151     if (cssBox && cssBox->isMenuList())
3152         return PopUpButtonRole;
3153     
3154     if (headingLevel())
3155         return HeadingRole;
3156     
3157 #if ENABLE(MATHML)
3158     if (node && node->hasTagName(MathMLNames::mathTag))
3159         return DocumentMathRole;
3160 #endif
3161     
3162     if (node && node->hasTagName(ddTag))
3163         return DefinitionListDefinitionRole;
3164     
3165     if (node && node->hasTagName(dtTag))
3166         return DefinitionListTermRole;
3167
3168     if (node && (node->hasTagName(rpTag) || node->hasTagName(rtTag)))
3169         return AnnotationRole;
3170
3171 #if PLATFORM(GTK)
3172     // Gtk ATs expect all tables, data and layout, to be exposed as tables.
3173     if (node && (node->hasTagName(tdTag) || node->hasTagName(thTag)))
3174         return CellRole;
3175
3176     if (node && node->hasTagName(trTag))
3177         return RowRole;
3178
3179     if (node && node->hasTagName(tableTag))
3180         return TableRole;
3181 #endif
3182
3183     // Table sections should be ignored.
3184     if (m_renderer->isTableSection())
3185         return IgnoredRole;
3186     
3187 #if PLATFORM(GTK)
3188     if (m_renderer->isHR())
3189         return SplitterRole;
3190
3191     if (node && node->hasTagName(pTag))
3192         return ParagraphRole;
3193
3194     if (node && node->hasTagName(labelTag))
3195         return LabelRole;
3196
3197     if (node && node->hasTagName(divTag))
3198         return DivRole;
3199
3200     if (node && node->hasTagName(formTag))
3201         return FormRole;
3202 #else
3203     if (node && node->hasTagName(labelTag))
3204         return GroupRole;
3205 #endif
3206
3207     if (node && node->hasTagName(articleTag))
3208         return DocumentArticleRole;
3209
3210     if (node && node->hasTagName(navTag))
3211         return LandmarkNavigationRole;
3212
3213     if (node && node->hasTagName(asideTag))
3214         return LandmarkComplementaryRole;
3215
3216     if (node && node->hasTagName(sectionTag))
3217         return DocumentRegionRole;
3218
3219     if (node && node->hasTagName(addressTag))
3220         return LandmarkContentInfoRole;
3221
3222     // There should only be one banner/contentInfo per page. If header/footer are being used within an article or section
3223     // then it should not be exposed as whole page's banner/contentInfo
3224     if (node && node->hasTagName(headerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
3225         return LandmarkBannerRole;
3226     if (node && node->hasTagName(footerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
3227         return LandmarkContentInfoRole;
3228
3229     if (m_renderer->isBlockFlow())
3230         return GroupRole;
3231     
3232     // If the element does not have role, but it has ARIA attributes, accessibility should fallback to exposing it as a group.
3233     if (supportsARIAAttributes())
3234         return GroupRole;
3235     
3236     return UnknownRole;
3237 }
3238
3239 AccessibilityOrientation AccessibilityRenderObject::orientation() const
3240 {
3241     const AtomicString& ariaOrientation = getAttribute(aria_orientationAttr);
3242     if (equalIgnoringCase(ariaOrientation, "horizontal"))
3243         return AccessibilityOrientationHorizontal;
3244     if (equalIgnoringCase(ariaOrientation, "vertical"))
3245         return AccessibilityOrientationVertical;
3246     
3247     return AccessibilityObject::orientation();
3248 }
3249     
3250 bool AccessibilityRenderObject::inheritsPresentationalRole() const
3251 {
3252     // ARIA spec says that when a parent object is presentational, and it has required child elements,
3253     // those child elements are also presentational. For example, <li> becomes presentational from <ul>.
3254     // http://www.w3.org/WAI/PF/aria/complete#presentation
3255     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, listItemParents, ());
3256
3257     HashSet<QualifiedName>* possibleParentTagNames = 0;
3258     switch (roleValue()) {
3259     case ListItemRole:
3260     case ListMarkerRole:
3261         if (listItemParents.isEmpty()) {
3262             listItemParents.add(ulTag);
3263             listItemParents.add(olTag);
3264             listItemParents.add(dlTag);
3265         }
3266         possibleParentTagNames = &listItemParents;
3267         break;
3268     default:
3269         break;
3270     }
3271     
3272     // Not all elements need to check for this, only ones that are required children.
3273     if (!possibleParentTagNames)
3274         return false;
3275     
3276     for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) { 
3277         if (!parent->isAccessibilityRenderObject())
3278             continue;
3279         
3280         Node* elementNode = static_cast<AccessibilityRenderObject*>(parent)->node();
3281         if (!elementNode || !elementNode->isElementNode())
3282             continue;
3283         
3284         // If native tag of the parent element matches an acceptable name, then return
3285         // based on its presentational status.
3286         if (possibleParentTagNames->contains(static_cast<Element*>(elementNode)->tagQName()))
3287             return parent->roleValue() == PresentationalRole;
3288     }
3289     
3290     return false;
3291 }
3292     
3293 bool AccessibilityRenderObject::isPresentationalChildOfAriaRole() const
3294 {
3295     // Walk the parent chain looking for a parent that has presentational children
3296     AccessibilityObject* parent;
3297     for (parent = parentObject(); parent && !parent->ariaRoleHasPresentationalChildren(); parent = parent->parentObject())
3298     { }
3299     
3300     return parent;
3301 }
3302     
3303 bool AccessibilityRenderObject::ariaRoleHasPresentationalChildren() const
3304 {
3305     switch (m_ariaRole) {
3306     case ButtonRole:
3307     case SliderRole:
3308     case ImageRole:
3309     case ProgressIndicatorRole:
3310     // case SeparatorRole:
3311         return true;
3312     default:
3313         return false;
3314     }
3315 }
3316
3317 bool AccessibilityRenderObject::canSetFocusAttribute() const
3318 {
3319     ASSERT(m_renderer);
3320     Node* node = m_renderer->node();
3321
3322     // NOTE: It would be more accurate to ask the document whether setFocusedNode() would
3323     // do anything.  For example, setFocusedNode() will do nothing if the current focused
3324     // node will not relinquish the focus.
3325     if (!node || !node->isElementNode())
3326         return false;
3327
3328     if (!static_cast<Element*>(node)->isEnabledFormControl())
3329         return false;
3330
3331     switch (roleValue()) {
3332     case WebCoreLinkRole:
3333     case ImageMapLinkRole:
3334     case TextFieldRole:
3335     case TextAreaRole:
3336     case ButtonRole:
3337     case PopUpButtonRole:
3338     case CheckBoxRole:
3339     case RadioButtonRole:
3340     case SliderRole:
3341         return true;
3342     default:
3343         return node->supportsFocus();
3344     }
3345 }
3346     
3347 bool AccessibilityRenderObject::canSetExpandedAttribute() const
3348 {
3349     // An object can be expanded if it aria-expanded is true or false.
3350     const AtomicString& ariaExpanded = getAttribute(aria_expandedAttr);
3351     return equalIgnoringCase(ariaExpanded, "true") || equalIgnoringCase(ariaExpanded, "false");
3352 }
3353
3354 bool AccessibilityRenderObject::canSetValueAttribute() const
3355 {
3356     if (equalIgnoringCase(getAttribute(aria_readonlyAttr), "true"))
3357         return false;
3358
3359     if (isProgressIndicator() || isSlider())
3360         return true;
3361
3362     if (isTextControl() && !isNativeTextControl())
3363         return true;
3364
3365     // Any node could be contenteditable, so isReadOnly should be relied upon
3366     // for this information for all elements.
3367     return !isReadOnly();
3368 }
3369
3370 bool AccessibilityRenderObject::canSetTextRangeAttributes() const
3371 {
3372     return isTextControl();
3373 }
3374
3375 void AccessibilityRenderObject::contentChanged()
3376 {
3377     // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
3378     // then notify the AT of changes.
3379     AXObjectCache* cache = axObjectCache();
3380     for (RenderObject* renderParent = m_renderer; renderParent; renderParent = renderParent->parent()) {
3381         AccessibilityObject* parent = cache->get(renderParent);
3382         if (!parent)
3383             continue;
3384         
3385         if (parent->supportsARIALiveRegion())
3386             cache->postNotification(renderParent, AXObjectCache::AXLiveRegionChanged, true);
3387
3388         if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->isContentEditable())
3389             cache->postNotification(renderParent, AXObjectCache::AXValueChanged, true);
3390     }
3391 }
3392     
3393 void AccessibilityRenderObject::childrenChanged()
3394 {
3395     // This method is meant as a quick way of marking a portion of the accessibility tree dirty.
3396     if (!m_renderer)
3397         return;
3398
3399     bool sentChildrenChanged = false;
3400     
3401     // Go up the accessibility parent chain, but only if the element already exists. This method is
3402     // called during render layouts, minimal work should be done. 
3403     // If AX elements are created now, they could interrogate the render tree while it's in a funky state.
3404     // At the same time, process ARIA live region changes.
3405     for (AccessibilityObject* parent = this; parent; parent = parent->parentObjectIfExists()) {
3406         if (!parent->isAccessibilityRenderObject())
3407             continue;
3408         
3409         AccessibilityRenderObject* axParent = toAccessibilityRenderObject(parent);
3410         
3411         // Send the children changed notification on the first accessibility render object ancestor.
3412         if (!sentChildrenChanged) {
3413             axObjectCache()->postNotification(axParent->renderer(), AXObjectCache::AXChildrenChanged, true);
3414             sentChildrenChanged = true;
3415         }
3416         
3417         axParent->setNeedsToUpdateChildren();
3418         
3419         // These notifications always need to be sent because screenreaders are reliant on them to perform. 
3420         // In other words, they need to be sent even when the screen reader has not accessed this live region since the last update.
3421
3422         // If this element supports ARIA live regions, then notify the AT of changes.
3423         if (axParent->supportsARIALiveRegion())
3424             axObjectCache()->postNotification(axParent->renderer(), AXObjectCache::AXLiveRegionChanged, true);
3425         
3426         // If this element is an ARIA text control, notify the AT of changes.
3427         if (axParent->isARIATextControl() && !axParent->isNativeTextControl() && !axParent->node()->isContentEditable())
3428             axObjectCache()->postNotification(axParent->renderer(), AXObjectCache::AXValueChanged, true);
3429     }
3430 }
3431     
3432 bool AccessibilityRenderObject::canHaveChildren() const
3433 {
3434     if (!m_renderer)
3435         return false;
3436     
3437     // Elements that should not have children
3438     switch (roleValue()) {
3439     case ImageRole:
3440     case ButtonRole:
3441     case PopUpButtonRole:
3442     case CheckBoxRole:
3443     case RadioButtonRole:
3444     case TabRole:
3445     case StaticTextRole:
3446     case ListBoxOptionRole:
3447     case ScrollBarRole:
3448         return false;
3449     default:
3450         return true;
3451     }
3452 }
3453
3454 void AccessibilityRenderObject::clearChildren()
3455 {
3456     AccessibilityObject::clearChildren();
3457     m_childrenDirty = false;
3458 }
3459
3460 void AccessibilityRenderObject::addImageMapChildren()
3461 {
3462     RenderBoxModelObject* cssBox = renderBoxModelObject();
3463     if (!cssBox || !cssBox->isRenderImage())
3464         return;
3465     
3466     HTMLMapElement* map = toRenderImage(cssBox)->imageMap();
3467     if (!map)
3468         return;
3469
3470     for (Node* current = map->firstChild(); current; current = current->traverseNextNode(map)) {
3471         
3472         // add an <area> element for this child if it has a link
3473         if (current->hasTagName(areaTag) && current->isLink()) {
3474             AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
3475             areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(current));
3476             areaObject->setHTMLMapElement(map);
3477             areaObject->setParent(this);
3478             
3479             m_children.append(areaObject);
3480         }
3481     }
3482 }
3483
3484 void AccessibilityRenderObject::updateChildrenIfNecessary()
3485 {
3486     if (needsToUpdateChildren())
3487         clearChildren();        
3488     
3489     AccessibilityObject::updateChildrenIfNecessary();
3490 }
3491     
3492 void AccessibilityRenderObject::addTextFieldChildren()
3493 {
3494     Node* node = this->node();
3495     if (!node || !node->hasTagName(inputTag))
3496         return;
3497     
3498     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
3499     HTMLElement* spinButtonElement = input->innerSpinButtonElement();
3500     if (!spinButtonElement || !spinButtonElement->isSpinButtonElement())
3501         return;
3502
3503     AccessibilitySpinButton* axSpinButton = static_cast<AccessibilitySpinButton*>(axObjectCache()->getOrCreate(SpinButtonRole));
3504     axSpinButton->setSpinButtonElement(static_cast<SpinButtonElement*>(spinButtonElement));
3505     axSpinButton->setParent(this);
3506     m_children.append(axSpinButton);
3507 }
3508
3509 void AccessibilityRenderObject::addChildren()
3510 {
3511     // If the need to add more children in addition to existing children arises, 
3512     // childrenChanged should have been called, leaving the object with no children.
3513     ASSERT(!m_haveChildren); 
3514     
3515     // nothing to add if there is no RenderObject
3516     if (!m_renderer)
3517         return;
3518     
3519     m_haveChildren = true;
3520     
3521     if (!canHaveChildren())
3522         return;
3523     
3524     // add all unignored acc children
3525     for (RefPtr<AccessibilityObject> obj = firstChild(); obj; obj = obj->nextSibling()) {
3526         if (obj->accessibilityIsIgnored()) {
3527
3528             // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op), 
3529             // or its visibility has changed. In the latter case, this child may have a stale child cached. 
3530             // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
3531             obj->clearChildren();
3532             
3533             AccessibilityChildrenVector children = obj->children();
3534             unsigned length = children.size();
3535             for (unsigned i = 0; i < length; ++i)
3536                 m_children.append(children[i]);
3537         } else {
3538             ASSERT(obj->parentObject() == this);
3539             m_children.append(obj);
3540         }
3541     }
3542     
3543     // FrameView's need to be inserted into the AX hierarchy when encountered.
3544     if (isAttachment()) {
3545         Widget* widget = widgetForAttachmentView();
3546         if (widget && widget->isFrameView())
3547             m_children.append(axObjectCache()->getOrCreate(widget));
3548     }
3549     
3550     addImageMapChildren();
3551     addTextFieldChildren();
3552 }
3553         
3554 const AtomicString& AccessibilityRenderObject::ariaLiveRegionStatus() const
3555 {
3556     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusAssertive, ("assertive"));
3557     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusPolite, ("polite"));
3558     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusOff, ("off"));
3559     
3560     const AtomicString& liveRegionStatus = getAttribute(aria_liveAttr);
3561     // These roles have implicit live region status.
3562     if (liveRegionStatus.isEmpty()) {
3563         switch (roleValue()) {
3564         case ApplicationAlertDialogRole:
3565         case ApplicationAlertRole:
3566             return liveRegionStatusAssertive;
3567         case ApplicationLogRole:
3568         case ApplicationStatusRole:
3569             return liveRegionStatusPolite;
3570         case ApplicationTimerRole:
3571         case ApplicationMarqueeRole:
3572             return liveRegionStatusOff;
3573         default:
3574             break;
3575         }
3576     }
3577
3578     return liveRegionStatus;
3579 }
3580
3581 const AtomicString& AccessibilityRenderObject::ariaLiveRegionRelevant() const
3582 {
3583     DEFINE_STATIC_LOCAL(const AtomicString, defaultLiveRegionRelevant, ("additions text"));
3584     const AtomicString& relevant = getAttribute(aria_relevantAttr);
3585
3586     // Default aria-relevant = "additions text".
3587     if (relevant.isEmpty())
3588         return defaultLiveRegionRelevant;
3589     
3590     return relevant;
3591 }
3592
3593 bool AccessibilityRenderObject::ariaLiveRegionAtomic() const
3594 {
3595     return elementAttributeValue(aria_atomicAttr);    
3596 }
3597
3598 bool AccessibilityRenderObject::ariaLiveRegionBusy() const
3599 {
3600     return elementAttributeValue(aria_busyAttr);    
3601 }
3602     
3603 void AccessibilityRenderObject::ariaSelectedRows(AccessibilityChildrenVector& result)
3604 {
3605     // Get all the rows. 
3606     AccessibilityChildrenVector allRows;
3607     ariaTreeRows(allRows);
3608
3609     // Determine which rows are selected.
3610     bool isMulti = isMultiSelectable();
3611
3612     // Prefer active descendant over aria-selected.
3613     AccessibilityObject* activeDesc = activeDescendant();
3614     if (activeDesc && (activeDesc->isTreeItem() || activeDesc->isTableRow())) {
3615         result.append(activeDesc);    
3616         if (!isMulti)
3617             return;
3618     }
3619
3620     unsigned count = allRows.size();
3621     for (unsigned k = 0; k < count; ++k) {
3622         if (allRows[k]->isSelected()) {
3623             result.append(allRows[k]);
3624             if (!isMulti)
3625                 break;
3626         }
3627     }
3628 }
3629     
3630 void AccessibilityRenderObject::ariaListboxSelectedChildren(AccessibilityChildrenVector& result)
3631 {
3632     bool isMulti = isMultiSelectable();
3633
3634     AccessibilityChildrenVector childObjects = children();
3635     unsigned childrenSize = childObjects.size();
3636     for (unsigned k = 0; k < childrenSize; ++k) {
3637         // Every child should have aria-role option, and if so, check for selected attribute/state.
3638         AccessibilityObject* child = childObjects[k].get();
3639         if (child->isSelected() && child->ariaRoleAttribute() == ListBoxOptionRole) {
3640             result.append(child);
3641             if (!isMulti)
3642                 return;
3643         }
3644     }
3645 }
3646
3647 void AccessibilityRenderObject::selectedChildren(AccessibilityChildrenVector& result)
3648 {
3649     ASSERT(result.isEmpty());
3650
3651     // only listboxes should be asked for their selected children. 
3652     AccessibilityRole role = roleValue();
3653     if (role == ListBoxRole) // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
3654         ariaListboxSelectedChildren(result);
3655     else if (role == TreeRole || role == TreeGridRole || role == TableRole)
3656         ariaSelectedRows(result);
3657 }
3658
3659 void AccessibilityRenderObject::ariaListboxVisibleChildren(AccessibilityChildrenVector& result)      
3660 {
3661     if (!hasChildren())
3662         addChildren();
3663     
3664     unsigned length = m_children.size();
3665     for (unsigned i = 0; i < length; i++) {
3666         if (!m_children[i]->isOffScreen())
3667             result.append(m_children[i]);
3668     }
3669 }
3670
3671 void AccessibilityRenderObject::visibleChildren(AccessibilityChildrenVector& result)
3672 {
3673     ASSERT(result.isEmpty());
3674         
3675     // only listboxes are asked for their visible children. 
3676     if (ariaRoleAttribute() != ListBoxRole) { // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
3677         ASSERT_NOT_REACHED();
3678         return;
3679     }
3680     return ariaListboxVisibleChildren(result);
3681 }
3682  
3683 void AccessibilityRenderObject::tabChildren(AccessibilityChildrenVector& result)
3684 {
3685     ASSERT(roleValue() == TabListRole);
3686     
3687     unsigned length = m_children.size();
3688     for (unsigned i = 0; i < length; ++i) {
3689         if (m_children[i]->isTabItem())
3690             result.append(m_children[i]);
3691     }
3692 }
3693     
3694 const String& AccessibilityRenderObject::actionVerb() const
3695 {
3696     // FIXME: Need to add verbs for select elements.
3697     DEFINE_STATIC_LOCAL(const String, buttonAction, (AXButtonActionVerb()));
3698     DEFINE_STATIC_LOCAL(const String, textFieldAction, (AXTextFieldActionVerb()));
3699     DEFINE_STATIC_LOCAL(const String, radioButtonAction, (AXRadioButtonActionVerb()));
3700     DEFINE_STATIC_LOCAL(const String, checkedCheckBoxAction, (AXCheckedCheckBoxActionVerb()));
3701     DEFINE_STATIC_LOCAL(const String, uncheckedCheckBoxAction, (AXUncheckedCheckBoxActionVerb()));
3702     DEFINE_STATIC_LOCAL(const String, linkAction, (AXLinkActionVerb()));
3703     DEFINE_STATIC_LOCAL(const String, noAction, ());
3704     
3705     switch (roleValue()) {
3706     case ButtonRole:
3707         return buttonAction;
3708     case TextFieldRole:
3709     case TextAreaRole:
3710         return textFieldAction;
3711     case RadioButtonRole:
3712         return radioButtonAction;
3713     case CheckBoxRole:
3714         return isChecked() ? checkedCheckBoxAction : uncheckedCheckBoxAction;
3715     case LinkRole:
3716     case WebCoreLinkRole:
3717         return linkAction;
3718     default:
3719         return noAction;
3720     }
3721 }
3722     
3723 void AccessibilityRenderObject::setAccessibleName(const AtomicString& name)
3724 {
3725     // Setting the accessible name can store the value in the DOM
3726     if (!m_renderer)
3727         return;
3728
3729     Node* domNode = 0;
3730     // For web areas, set the aria-label on the HTML element.
3731     if (isWebArea())
3732         domNode = m_renderer->document()->documentElement();
3733     else
3734         domNode = m_renderer->node();
3735
3736     if (domNode && domNode->isElementNode())
3737         static_cast<Element*>(domNode)->setAttribute(aria_labelAttr, name);
3738 }
3739     
3740 static bool isLinkable(const AccessibilityRenderObject& object)
3741 {
3742     if (!object.renderer())
3743         return false;
3744
3745     // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
3746     // Mozilla considers linkable.
3747     return object.isLink() || object.isImage() || object.renderer()->isText();
3748 }
3749
3750 String AccessibilityRenderObject::stringValueForMSAA() const
3751 {
3752     if (isLinkable(*this)) {
3753         Element* anchor = anchorElement();
3754         if (anchor && anchor->hasTagName(aTag))
3755             return static_cast<HTMLAnchorElement*>(anchor)->href();
3756     }
3757
3758     return stringValue();
3759 }
3760
3761 bool AccessibilityRenderObject::isLinked() const
3762 {
3763     if (!isLinkable(*this))
3764         return false;
3765
3766     Element* anchor = anchorElement();
3767     if (!anchor || !anchor->hasTagName(aTag))
3768         return false;
3769
3770     return !static_cast<HTMLAnchorElement*>(anchor)->href().isEmpty();
3771 }
3772
3773 bool AccessibilityRenderObject::hasBoldFont() const
3774 {
3775     if (!m_renderer)
3776         return false;
3777     
3778     return m_renderer->style()->fontDescription().weight() >= FontWeightBold;
3779 }
3780
3781 bool AccessibilityRenderObject::hasItalicFont() const
3782 {
3783     if (!m_renderer)
3784         return false;
3785     
3786     return m_renderer->style()->fontDescription().italic() == FontItalicOn;
3787 }
3788
3789 bool AccessibilityRenderObject::hasPlainText() const
3790 {
3791     if (!m_renderer)
3792         return false;
3793     
3794     RenderStyle* style = m_renderer->style();
3795     
3796     return style->fontDescription().weight() == FontWeightNormal
3797         && style->fontDescription().italic() == FontItalicOff
3798         && style->textDecorationsInEffect() == TDNONE;
3799 }
3800
3801 bool AccessibilityRenderObject::hasSameFont(RenderObject* renderer) const
3802 {
3803     if (!m_renderer || !renderer)
3804         return false;
3805     
3806     return m_renderer->style()->fontDescription().family() == renderer->style()->fontDescription().family();
3807 }
3808
3809 bool AccessibilityRenderObject::hasSameFontColor(RenderObject* renderer) const
3810 {
3811     if (!m_renderer || !renderer)
3812         return false;
3813     
3814     return m_renderer->style()->visitedDependentColor(CSSPropertyColor) == renderer->style()->visitedDependentColor(CSSPropertyColor);
3815 }
3816
3817 bool AccessibilityRenderObject::hasSameStyle(RenderObject* renderer) const
3818 {
3819     if (!m_renderer || !renderer)
3820         return false;
3821     
3822     return m_renderer->style() == renderer->style();
3823 }
3824
3825 bool AccessibilityRenderObject::hasUnderline() const
3826 {
3827     if (!m_renderer)
3828         return false;
3829     
3830     return m_renderer->style()->textDecorationsInEffect() & UNDERLINE;
3831 }
3832
3833 String AccessibilityRenderObject::nameForMSAA() const
3834 {
3835     if (m_renderer && m_renderer->isText())
3836         return textUnderElement();
3837
3838     return title();
3839 }
3840
3841 static bool shouldReturnTagNameAsRoleForMSAA(const Element& element)
3842 {
3843     // See "document structure",
3844     // https://wiki.mozilla.org/Accessibility/AT-Windows-API
3845     // FIXME: Add the other tag names that should be returned as the role.
3846     return element.hasTagName(h1Tag) || element.hasTagName(h2Tag) 
3847         || element.hasTagName(h3Tag) || element.hasTagName(h4Tag)
3848         || element.hasTagName(h5Tag) || element.hasTagName(h6Tag);
3849 }
3850
3851 String AccessibilityRenderObject::stringRoleForMSAA() const
3852 {
3853     if (!m_renderer)
3854         return String();
3855
3856     Node* node = m_renderer->node();
3857     if (!node || !node->isElementNode())
3858         return String();
3859
3860     Element* element = static_cast<Element*>(node);
3861     if (!shouldReturnTagNameAsRoleForMSAA(*element))
3862         return String();
3863
3864     return element->tagName();
3865 }