Expose InlineTextBoxes in the accessibility tree.

Source/core/accessibility/AXObjectCache.h

 /*
  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef AXObjectCache_h
 #define AXObjectCache_h
 
 #include "core/accessibility/AXObject.h"
+#include "core/rendering/RenderText.h"
 #include "platform/Timer.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/RefPtr.h"
 
 namespace WebCore {
 
+class AbstractInlineTextBox;
 class Document;
 class HTMLAreaElement;
 class Node;
 class Page;
 class RenderObject;
 class ScrollView;
 class VisiblePosition;
 class Widget;
 
 struct TextMarkerData {
@@ skipping 34 matching lines @@
 
     static AXObject* focusedUIElementForPage(const Page*);
 
     // Returns the root object for the entire document.
     AXObject* rootObject();
 
     // For AX objects with elements that back them.
     AXObject* getOrCreate(RenderObject*);
     AXObject* getOrCreate(Widget*);
     AXObject* getOrCreate(Node*);
+    AXObject* getOrCreate(AbstractInlineTextBox*);
 
     // used for objects without backing elements
     AXObject* getOrCreate(AccessibilityRole);
 
     // will only return the AXObject if it already exists
     AXObject* get(RenderObject*);
     AXObject* get(Widget*);
     AXObject* get(Node*);
+    AXObject* get(AbstractInlineTextBox*);
 
     void remove(RenderObject*);
     void remove(Node*);
     void remove(Widget*);
+    void remove(AbstractInlineTextBox*);
     void remove(AXID);
 
     void detachWrapper(AXObject*);
     void attachWrapper(AXObject*);
     void childrenChanged(Node*);
     void childrenChanged(RenderObject*);
     void childrenChanged(AXObject*);
     void checkedStateChanged(Node*);
     void selectedChildrenChanged(Node*);
     void selectedChildrenChanged(RenderObject*);
@@ skipping 10 matching lines @@
     void handleScrolledToAnchor(const Node* anchorNode);
     void handleAriaExpandedChange(Node*);
     void handleScrollbarUpdate(ScrollView*);
 
     void handleAttributeChanged(const QualifiedName& attrName, Element*);
     void recomputeIsIgnored(RenderObject* renderer);
 
 #if HAVE(ACCESSIBILITY)
     static void enableAccessibility() { gAccessibilityEnabled = true; }
     static bool accessibilityEnabled() { return gAccessibilityEnabled; }
+    static void setInlineTextBoxAccessibility(bool flag) { gInlineTextBoxAccessibility = flag; }
+    static bool inlineTextBoxAccessibility() { return gInlineTextBoxAccessibility; }
 #else
     static void enableAccessibility() { }
+    static void setInlineTextBoxAccessibility(bool) { }
     static bool accessibilityEnabled() { return false; }
+    static bool inlineTextBoxAccessibility() { return false; }
 #endif
 
     void removeAXID(AXObject*);
     bool isIDinUse(AXID id) const { return m_idsInUse.contains(id); }
 
     Element* rootAXEditableElement(Node*);
     const Element* rootAXEditableElement(const Node*);
     bool nodeIsTextControl(const Node*);
 
     AXID platformGenerateAXID() const;
@@ skipping 53 matching lines @@
     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
     void removeNodeForUse(Node* n) { m_textMarkerNodes.remove(n); }
     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
 
 private:
     Document* m_document;
     HashMap<AXID, RefPtr<AXObject> > m_objects;
     HashMap<RenderObject*, AXID> m_renderObjectMapping;
     HashMap<Widget*, AXID> m_widgetObjectMapping;
     HashMap<Node*, AXID> m_nodeObjectMapping;
+    HashMap<AbstractInlineTextBox*, AXID> m_inlineTextBoxObjectMapping;
     HashSet<Node*> m_textMarkerNodes;
     OwnPtr<AXComputedObjectAttributeCache> m_computedObjectAttributeCache;
     static bool gAccessibilityEnabled;
+    static bool gInlineTextBoxAccessibility;
 
     HashSet<AXID> m_idsInUse;
 
     Timer<AXObjectCache> m_notificationPostTimer;
     Vector<pair<RefPtr<AXObject>, AXNotification> > m_notificationsToPost;
     void notificationPostTimerFired(Timer<AXObjectCache>*);
 
     static AXObject* focusedImageMapUIElement(HTMLAreaElement*);
 
     AXID getAXID(AXObject*);
 };
 
 bool nodeHasRole(Node*, const String& role);
 // This will let you know if aria-hidden was explicitly set to false.
 bool isNodeAriaVisible(Node*);
 
 #if !HAVE(ACCESSIBILITY)
 inline AXObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return DefaultBehavior; }
 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AXObjectInclusion) { }
 inline AXObjectCache::AXObjectCache(const Document* doc) : m_document(const_cast<Document*>(doc)), m_notificationPostTimer(this, 0) { }
 inline AXObjectCache::~AXObjectCache() { }
 inline AXObject* AXObjectCache::focusedUIElementForPage(const Page*) { return 0; }
 inline AXObject* AXObjectCache::get(RenderObject*) { return 0; }
 inline AXObject* AXObjectCache::get(Node*) { return 0; }
 inline AXObject* AXObjectCache::get(Widget*) { return 0; }
+inline AXObject* AXObjectCache::get(AbstractInlineTextBox*) { return 0; }
 inline AXObject* AXObjectCache::getOrCreate(AccessibilityRole) { return 0; }
 inline AXObject* AXObjectCache::getOrCreate(RenderObject*) { return 0; }
 inline AXObject* AXObjectCache::getOrCreate(Node*) { return 0; }
 inline AXObject* AXObjectCache::getOrCreate(Widget*) { return 0; }
+inline AXObject* AXObjectCache::getOrCreate(AbstractInlineTextBox*) { return 0; }
 inline AXObject* AXObjectCache::rootObject() { return 0; }
 inline Element* AXObjectCache::rootAXEditableElement(Node*) { return 0; }
 inline bool nodeHasRole(Node*, const String&) { return false; }
 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
 inline bool isNodeAriaVisible(Node*) { return true; }
 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return 0; }
 inline void AXObjectCache::attachWrapper(AXObject*) { }
 inline void AXObjectCache::checkedStateChanged(Node*) { }
 inline void AXObjectCache::childrenChanged(RenderObject*) { }
@@ skipping 15 matching lines @@
 inline void AXObjectCache::nodeTextChangeNotification(Node*, AXTextChange, unsigned, const String&) { }
 inline void AXObjectCache::nodeTextChangePlatformNotification(AXObject*, AXTextChange, unsigned, const String&) { }
 inline void AXObjectCache::postNotification(AXObject*, Document*, AXNotification, bool, PostType) { }
 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, bool, PostType) { }
 inline void AXObjectCache::postNotification(Node*, AXNotification, bool, PostType) { }
 inline void AXObjectCache::postPlatformNotification(AXObject*, AXNotification) { }
 inline void AXObjectCache::remove(AXID) { }
 inline void AXObjectCache::remove(RenderObject*) { }
 inline void AXObjectCache::remove(Node*) { }
 inline void AXObjectCache::remove(Widget*) { }
+inline void AXObjectCache::remove(AbstractInlineTextBox*) { }
 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
 #endif
 
 }
 
 #endif