Implement computedRole and computedName (behind a flag)

Source/modules/accessibility/AXObjectCacheImpl.cpp

 /*
  * Copyright (C) 2014, Google 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
@@ skipping 159 matching lines @@
 
     // the HTML element, for example, is focusable but has an AX object that is ignored
     if (obj->accessibilityIsIgnored())
         obj = obj->parentObjectUnignored();
 
     return obj;
 }
 
 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;
 
     AXID axID = m_inlineTextBoxObjectMapping.get(inlineTextBox);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
         return 0;
 
     return m_objects.get(axID);
 }
 
 // FIXME: This probably belongs on Node.
 // FIXME: This should take a const char*, but one caller passes nullAtom.
 bool nodeHasRole(Node* node, const String& role)
 {
     if (!node || !node->isElementNode())
         return false;
 
     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();
 
     // If the node is aria role="list" or the aria role is empty and its a
     // 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)
 {
     if (!widget)
         return 0;
 
     if (AXObject* obj = get(widget))
         return obj;
 
     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));
 
     // Catch the case if an (unsupported) widget type is used. Only FrameView and ScrollBar are supported now.
     ASSERT(newObj);
     if (!newObj)
         return 0;
 
     getAXID(newObj.get());
 
     m_widgetObjectMapping.set(widget, newObj->axObjectID());
     m_objects.set(newObj->axObjectID(), newObj);
     newObj->init();
     return newObj.get();
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(Node* node)
 {
     if (!node)
         return 0;
 
     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;
 
     // It's only allowed to create an AXObject from a Node if it's in a canvas subtree.
     // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
     bool inCanvasSubtree = node->parentElement()->isInCanvasSubtree();
     bool isHidden = !node->renderer() && isNodeAriaVisible(node);
     if (!inCanvasSubtree && !isHidden)
         return 0;
@@ skipping 67 matching lines @@
     return getOrCreate(m_document.view());
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(AccessibilityRole role)
 {
     RefPtr<AXObject> obj = nullptr;
 
     // 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;
     }
 
     if (obj)
         getAXID(obj.get());
     else
         return 0;
 
@@ skipping 566 matching lines @@
     if (targetAXObject && !targetAXObject->children().isEmpty())
         targetAXObject = targetAXObject->children()[0].get();
     postPlatformNotification(targetAXObject, AXScrollPositionChanged);
 }
 
 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);
     if (!obj)
         return;
 
     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