Implement computedRole and computedName (behind a flag)

Source/modules/accessibility/AXObjectCacheImpl.cpp

Index: Source/modules/accessibility/AXObjectCacheImpl.cpp
diff --git a/Source/modules/accessibility/AXObjectCacheImpl.cpp b/Source/modules/accessibility/AXObjectCacheImpl.cpp
index a17b75167db5f827637e0a16f3a91891736c9e7d..720c601a95ddca028e25398e2a325e31d7bb5835 100644
--- a/Source/modules/accessibility/AXObjectCacheImpl.cpp
+++ b/Source/modules/accessibility/AXObjectCacheImpl.cpp
@@ -177,60 +177,83 @@ AXObject* AXObjectCacheImpl::focusedUIElementForPage(const Page* page)
 
 AXObject* AXObjectCacheImpl::get(Widget* widget)
 {
+    fprintf(stderr, "AXObjectCacheImpl.get(widget)\n");
     if (!widget)
         return 0;
 
+    fprintf(stderr, "about to call m_widgetObjectMapping(%p)\n", widget);
     AXID axID = m_widgetObjectMapping.get(widget);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
         return 0;
 
+    fprintf(stderr, "about to call m_objects.get(%d)\n", axID);
     return m_objects.get(axID);
 }
 
 AXObject* AXObjectCacheImpl::get(RenderObject* renderer)
 {
+    fprintf(stderr, "AXObjectCacheImpl::get(renderer)\n");
     if (!renderer)
         return 0;
 
+    fprintf(stderr, "about to call m_renderObjectMapping.get(%p)\n", renderer);
     AXID axID = m_renderObjectMapping.get(renderer);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
         return 0;
 
+    fprintf(stderr, "about to call m_objects.get(%d)\n", axID);
     return m_objects.get(axID);
 }
 
 AXObject* AXObjectCacheImpl::get(Node* node)
 {
+    fprintf(stderr, "AXObjectCacheImpl.get(node)\n");
     if (!node)
         return 0;
 
+    fprintf(stderr, "about to call m_renderObjectMapping(%p)\n", node->renderer());
     AXID renderID = node->renderer() ? m_renderObjectMapping.get(node->renderer()) : 0;
+    fprintf(stderr, "got renderID: %d\n", renderID);
     ASSERT(!HashTraits<AXID>::isDeletedValue(renderID));
 
+    fprintf(stderr, "about to call m_nodeObjectMapping(%p)\n", node);
     AXID nodeID = m_nodeObjectMapping.get(node);
+    fprintf(stderr, "got nodeID %d\n", nodeID);
     ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
+    fprintf(stderr, "Assert passed\n");
 
     if (node->renderer() && nodeID && !renderID) {
+        fprintf(stderr, "about to call remove(%d)\n", nodeID);
         // This can happen if an AXNodeObject is created for a node that's not
         // rendered, but later something changes and it gets a renderer (like if it's
         // reparented).
         remove(nodeID);
         return 0;
+    } else {
+        fprintf(stderr, "not removing nodeID\n");
     }
 
-    if (renderID)
+    if (renderID) {
+        fprintf(stderr, "about to call m_objects.get(%d)\n", renderID);
         return m_objects.get(renderID);
+    }
+    fprintf(stderr, "%d was false\n", renderID);
 
-    if (!nodeID)
+    if (!nodeID) {
+        fprintf(stderr, "returning 0\n");
         return 0;
+    }
+    fprintf(stderr, "!%d was false\n", nodeID);
 
+    fprintf(stderr, "about to call m_objects.get(%d)\n", nodeID);
     return m_objects.get(nodeID);
 }
 
 AXObject* AXObjectCacheImpl::get(AbstractInlineTextBox* inlineTextBox)
 {
+    fprintf(stderr, "get(AbstractInlineTextBox)\n");
     if (!inlineTextBox)
         return 0;
 
@@ -252,7 +275,7 @@ bool nodeHasRole(Node* node, const String& role)
     return equalIgnoringCase(toElement(node)->getAttribute(roleAttr), role);
 }
 
-static PassRefPtr<AXObject> createFromRenderer(RenderObject* renderer)
+PassRefPtr<AXObject> AXObjectCacheImpl::createFromRenderer(RenderObject* renderer)
 {
     // FIXME: How could renderer->node() ever not be an Element?
     Node* node = renderer->node();
@@ -261,61 +284,61 @@ static PassRefPtr<AXObject> createFromRenderer(RenderObject* renderer)
     // ul/ol/dl type (it shouldn't be a list if aria says otherwise).
     if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
         || (nodeHasRole(node, nullAtom) && (isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node)))))
-        return AXList::create(renderer);
+        return AXList::create(renderer, this);
 
     // aria tables
     if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
-        return AXARIAGrid::create(renderer);
+        return AXARIAGrid::create(renderer, this);
     if (nodeHasRole(node, "row"))
-        return AXARIAGridRow::create(renderer);
+        return AXARIAGridRow::create(renderer, this);
     if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
-        return AXARIAGridCell::create(renderer);
+        return AXARIAGridCell::create(renderer, this);
 
     // media controls
     if (node && node->isMediaControlElement())
-        return AccessibilityMediaControl::create(renderer);
+        return AccessibilityMediaControl::create(renderer, this);
 
     if (isHTMLOptionElement(node))
-        return AXListBoxOption::create(renderer);
+        return AXListBoxOption::create(renderer, this);
 
     if (renderer->isSVGRoot())
-        return AXSVGRoot::create(renderer);
+        return AXSVGRoot::create(renderer, this);
 
     if (renderer->isBoxModelObject()) {
         RenderBoxModelObject* cssBox = toRenderBoxModelObject(renderer);
         if (cssBox->isListBox())
-            return AXListBox::create(toRenderListBox(cssBox));
+            return AXListBox::create(toRenderListBox(cssBox), this);
         if (cssBox->isMenuList())
-            return AXMenuList::create(toRenderMenuList(cssBox));
+            return AXMenuList::create(toRenderMenuList(cssBox), this);
 
         // standard tables
         if (cssBox->isTable())
-            return AXTable::create(toRenderTable(cssBox));
+            return AXTable::create(toRenderTable(cssBox), this);
         if (cssBox->isTableRow())
-            return AXTableRow::create(toRenderTableRow(cssBox));
+            return AXTableRow::create(toRenderTableRow(cssBox), this);
         if (cssBox->isTableCell())
-            return AXTableCell::create(toRenderTableCell(cssBox));
+            return AXTableCell::create(toRenderTableCell(cssBox), this);
 
         // progress bar
         if (cssBox->isProgress())
-            return AXProgressIndicator::create(toRenderProgress(cssBox));
+            return AXProgressIndicator::create(toRenderProgress(cssBox), this);
 
         // input type=range
         if (cssBox->isSlider())
-            return AXSlider::create(toRenderSlider(cssBox));
+            return AXSlider::create(toRenderSlider(cssBox), this);
     }
 
-    return AXRenderObject::create(renderer);
+    return AXRenderObject::create(renderer, this);
 }
 
-static PassRefPtr<AXObject> createFromNode(Node* node)
+PassRefPtr<AXObject> AXObjectCacheImpl::createFromNode(Node* node)
 {
-    return AXNodeObject::create(node);
+    return AXNodeObject::create(node, this);
 }
 
-static PassRefPtr<AXObject> createFromInlineTextBox(AbstractInlineTextBox* inlineTextBox)
+PassRefPtr<AXObject> AXObjectCacheImpl::createFromInlineTextBox(AbstractInlineTextBox* inlineTextBox)
 {
-    return AXInlineTextBox::create(inlineTextBox);
+    return AXInlineTextBox::create(inlineTextBox, this);
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(Widget* widget)
@@ -328,9 +351,9 @@ AXObject* AXObjectCacheImpl::getOrCreate(Widget* widget)
 
     RefPtr<AXObject> newObj = nullptr;
     if (widget->isFrameView())
-        newObj = AXScrollView::create(toFrameView(widget));
+        newObj = AXScrollView::create(toFrameView(widget), this);
     else if (widget->isScrollbar())
-        newObj = AXScrollbar::create(toScrollbar(widget));
+        newObj = AXScrollbar::create(toScrollbar(widget), this);
 
     // Will crash later if we have two objects for the same widget.
     ASSERT(!get(widget));
@@ -356,8 +379,13 @@ AXObject* AXObjectCacheImpl::getOrCreate(Node* node)
     if (AXObject* obj = get(node))
         return obj;
 
-    if (node->renderer())
+    fprintf(stderr, "get(node) returned nil\n");
+
+    if (node->renderer()) {
+        fprintf(stderr, "calling getOrCreate(Renderer)\n");
         return getOrCreate(node->renderer());
+    }
+    fprintf(stderr, "renderer was null\n");
 
     if (!node->parentElement())
         return 0;
@@ -445,28 +473,28 @@ AXObject* AXObjectCacheImpl::getOrCreate(AccessibilityRole role)
     // will be filled in...
     switch (role) {
     case ImageMapLinkRole:
-        obj = AXImageMapLink::create();
+        obj = AXImageMapLink::create(this);
         break;
     case ColumnRole:
-        obj = AXTableColumn::create();
+        obj = AXTableColumn::create(this);
         break;
     case TableHeaderContainerRole:
-        obj = AXTableHeaderContainer::create();
+        obj = AXTableHeaderContainer::create(this);
         break;
     case SliderThumbRole:
-        obj = AXSliderThumb::create();
+        obj = AXSliderThumb::create(this);
         break;
     case MenuListPopupRole:
-        obj = AXMenuListPopup::create();
+        obj = AXMenuListPopup::create(this);
         break;
     case MenuListOptionRole:
-        obj = AXMenuListOption::create();
+        obj = AXMenuListOption::create(this);
         break;
     case SpinButtonRole:
-        obj = AXSpinButton::create();
+        obj = AXSpinButton::create(this);
         break;
     case SpinButtonPartRole:
-        obj = AXSpinButtonPart::create();
+        obj = AXSpinButtonPart::create(this);
         break;
     default:
         obj = nullptr;
@@ -1053,6 +1081,14 @@ void AXObjectCacheImpl::handleScrollPositionChanged(RenderObject* renderObject)
     postPlatformNotification(getOrCreate(renderObject), AXScrollPositionChanged);
 }
 
+PublicAXObject* AXObjectCacheImpl::publicAXObjectForNode(Node* node)
+{
+    fprintf(stderr, "publicAXObjectForNode(%p)\n", node);
+    AXObject* obj = getOrCreate(node);
+    fprintf(stderr, "Got AXObject %p\n", obj);
+    return new PublicAXObjectImpl(obj);
+}
+
 void AXObjectCacheImpl::setCanvasObjectBounds(Element* element, const LayoutRect& rect)
 {
     AXObject* obj = getOrCreate(element);
@@ -1062,4 +1098,32 @@ void AXObjectCacheImpl::setCanvasObjectBounds(Element* element, const LayoutRect
     obj->setElementRect(rect);
 }
 
+PublicAXObjectImpl::PublicAXObjectImpl(AXObject* axObject)
+    : m_object(axObject)
+{
+    fprintf(stderr, "PublicAXObjectImpl constructor\n");
+}
+
+PublicAXObjectImpl::~PublicAXObjectImpl() { }
+
+const AtomicString& PublicAXObjectImpl::computedRole()
+{
+    fprintf(stderr, "computedRole()\n");
+    if (!m_object)
+        return AXObject::roleName(NoRole);
+
+    AccessibilityRole role = m_object->roleValue();
+    return AXObject::roleName(role);
+}
+
+const String PublicAXObjectImpl::computedText()
+{
+    fprintf(stderr, "publicaxobjectimpl::computedText()\n");
+    if (!m_object) {
+        fprintf(stderr, "!m_object\n");
+        return "";
+    }
+    return m_object->title();
+}
+
 } // namespace blink