Move rendering/RenderObject to layout/LayoutObject.

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 170 matching lines @@
         return 0;
 
     AXID axID = m_widgetObjectMapping.get(widget);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
         return 0;
 
     return m_objects.get(axID);
 }
 
-AXObject* AXObjectCacheImpl::get(RenderObject* renderer)
+AXObject* AXObjectCacheImpl::get(LayoutObject* renderer)
 {
     if (!renderer)
         return 0;
 
-    AXID axID = m_renderObjectMapping.get(renderer);
+    AXID axID = m_layoutObjectMapping.get(renderer);
     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
     if (!axID)
         return 0;
 
     return m_objects.get(axID);
 }
 
 AXObject* AXObjectCacheImpl::get(Node* node)
 {
     if (!node)
         return 0;
 
-    AXID renderID = node->renderer() ? m_renderObjectMapping.get(node->renderer()) : 0;
+    AXID renderID = node->renderer() ? m_layoutObjectMapping.get(node->renderer()) : 0;
     ASSERT(!HashTraits<AXID>::isDeletedValue(renderID));
 
     AXID nodeID = m_nodeObjectMapping.get(node);
     ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
 
     if (node->renderer() && nodeID && !renderID) {
         // 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);
@@ skipping 25 matching lines @@
 // 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);
 }
 
-PassRefPtr<AXObject> AXObjectCacheImpl::createFromRenderer(RenderObject* renderer)
+PassRefPtr<AXObject> AXObjectCacheImpl::createFromRenderer(LayoutObject* 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, this);
 
@@ skipping 111 matching lines @@
     getAXID(newObj.get());
 
     m_nodeObjectMapping.set(node, newObj->axObjectID());
     m_objects.set(newObj->axObjectID(), newObj);
     newObj->init();
     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
 
     return newObj.get();
 }
 
-AXObject* AXObjectCacheImpl::getOrCreate(RenderObject* renderer)
+AXObject* AXObjectCacheImpl::getOrCreate(LayoutObject* renderer)
 {
     if (!renderer)
         return 0;
 
     if (AXObject* obj = get(renderer))
         return obj;
 
     RefPtr<AXObject> newObj = createFromRenderer(renderer);
 
     // Will crash later if we have two objects for the same renderer.
     ASSERT(!get(renderer));
 
     getAXID(newObj.get());
 
-    m_renderObjectMapping.set(renderer, newObj->axObjectID());
+    m_layoutObjectMapping.set(renderer, newObj->axObjectID());
     m_objects.set(newObj->axObjectID(), newObj);
     newObj->init();
     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
 
     return newObj.get();
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(AbstractInlineTextBox* inlineTextBox)
 {
     if (!inlineTextBox)
@@ skipping 82 matching lines @@
     obj->detach();
     removeAXID(obj);
 
     // finally remove the object
     if (!m_objects.take(axID))
         return;
 
     ASSERT(m_objects.size() >= m_idsInUse.size());
 }
 
-void AXObjectCacheImpl::remove(RenderObject* renderer)
+void AXObjectCacheImpl::remove(LayoutObject* renderer)
 {
     if (!renderer)
         return;
 
-    AXID axID = m_renderObjectMapping.get(renderer);
+    AXID axID = m_layoutObjectMapping.get(renderer);
     remove(axID);
-    m_renderObjectMapping.remove(renderer);
+    m_layoutObjectMapping.remove(renderer);
 }
 
 void AXObjectCacheImpl::remove(Node* node)
 {
     if (!node)
         return;
 
     removeNodeForUse(node);
 
     // This is all safe even if we didn't have a mapping.
@@ skipping 105 matching lines @@
         }
         node = node->parentNode();
     }
 }
 
 void AXObjectCacheImpl::textChanged(Node* node)
 {
     textChanged(getOrCreate(node));
 }
 
-void AXObjectCacheImpl::textChanged(RenderObject* renderer)
+void AXObjectCacheImpl::textChanged(LayoutObject* renderer)
 {
     textChanged(getOrCreate(renderer));
 }
 
 void AXObjectCacheImpl::textChanged(AXObject* obj)
 {
     if (!obj)
         return;
 
     bool parentAlreadyExists = obj->parentObjectIfExists();
     obj->textChanged();
     postNotification(obj, obj->document(), AXObjectCacheImpl::AXTextChanged, true);
     if (parentAlreadyExists)
         obj->notifyIfIgnoredValueChanged();
 }
 
 void AXObjectCacheImpl::updateCacheAfterNodeIsAttached(Node* node)
 {
     // Calling get() will update the AX object if we had an AXNodeObject but now we need
     // an AXRenderObject, because it was reparented to a location outside of a canvas.
     get(node);
 }
 
 void AXObjectCacheImpl::childrenChanged(Node* node)
 {
     childrenChanged(get(node));
 }
 
-void AXObjectCacheImpl::childrenChanged(RenderObject* renderer)
+void AXObjectCacheImpl::childrenChanged(LayoutObject* renderer)
 {
     childrenChanged(get(renderer));
 }
 
 void AXObjectCacheImpl::childrenChanged(AXObject* obj)
 {
     if (!obj)
         return;
 
     obj->childrenChanged();
@@ skipping 12 matching lines @@
             continue;
 
         if (!obj->axObjectCache())
             continue;
 
 #if ENABLE(ASSERT)
         // Make sure none of the render views are in the process of being layed out.
         // Notifications should only be sent after the renderer has finished
         if (obj->isAXRenderObject()) {
             AXRenderObject* renderObj = toAXRenderObject(obj);
-            RenderObject* renderer = renderObj->renderer();
+            LayoutObject* renderer = renderObj->renderer();
             if (renderer && renderer->view())
                 ASSERT(!renderer->view()->layoutState());
         }
 #endif
 
         AXNotification notification = m_notificationsToPost[i].second;
         postPlatformNotification(obj, notification);
 
         if (notification == AXChildrenChanged && obj->parentObjectIfExists() && obj->lastKnownIsIgnoredValue() != obj->accessibilityIsIgnored())
             childrenChanged(obj->parentObject());
     }
 
     m_notificationsToPost.clear();
 }
 
-void AXObjectCacheImpl::postNotification(RenderObject* renderer, AXNotification notification, bool postToElement)
+void AXObjectCacheImpl::postNotification(LayoutObject* renderer, AXNotification notification, bool postToElement)
 {
     if (!renderer)
         return;
 
     m_modificationCount++;
 
     // Get an accessibility object that already exists. One should not be created here
     // because a render update may be in progress and creating an AX object can re-trigger a layout
     RefPtr<AXObject> object = get(renderer);
     while (!object && renderer) {
@@ skipping 51 matching lines @@
     postNotification(node, AXObjectCacheImpl::AXCheckedStateChanged, true);
 }
 
 void AXObjectCacheImpl::selectedChildrenChanged(Node* node)
 {
     // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
     // to find the container which should send out the notification.
     postNotification(node, AXSelectedChildrenChanged, false);
 }
 
-void AXObjectCacheImpl::selectedChildrenChanged(RenderObject* renderer)
+void AXObjectCacheImpl::selectedChildrenChanged(LayoutObject* renderer)
 {
     // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
     // to find the container which should send out the notification.
     postNotification(renderer, AXSelectedChildrenChanged, false);
 }
 
 void AXObjectCacheImpl::handleScrollbarUpdate(FrameView* view)
 {
     if (!view)
         return;
 
     // We don't want to create a scroll view from this method, only update an existing one.
     if (AXObject* scrollViewObject = get(view)) {
         m_modificationCount++;
         scrollViewObject->updateChildrenIfNecessary();
     }
 }
 
-void AXObjectCacheImpl::handleLayoutComplete(RenderObject* renderer)
+void AXObjectCacheImpl::handleLayoutComplete(LayoutObject* renderer)
 {
     if (!renderer)
         return;
 
     m_modificationCount++;
 
     // Create the AXObject if it didn't yet exist - that's always safe at the end of a layout, and it
     // allows an AX notification to be sent when a page has its first layout, rather than when the
     // document first loads.
     if (AXObject* obj = getOrCreate(renderer))
@@ skipping 51 matching lines @@
         postNotification(element, AXObjectCacheImpl::AXInvalidStatusChanged, true);
     else
         postNotification(element, AXObjectCacheImpl::AXAriaAttributeChanged, true);
 }
 
 void AXObjectCacheImpl::labelChanged(Element* element)
 {
     textChanged(toHTMLLabelElement(element)->control());
 }
 
-void AXObjectCacheImpl::recomputeIsIgnored(RenderObject* renderer)
+void AXObjectCacheImpl::recomputeIsIgnored(LayoutObject* renderer)
 {
     if (AXObject* obj = get(renderer))
         obj->notifyIfIgnoredValueChanged();
 }
 
-void AXObjectCacheImpl::inlineTextBoxesUpdated(RenderObject* renderer)
+void AXObjectCacheImpl::inlineTextBoxesUpdated(LayoutObject* renderer)
 {
     if (!inlineTextBoxAccessibilityEnabled())
         return;
 
     // Only update if the accessibility object already exists and it's
     // not already marked as dirty.
     if (AXObject* obj = get(renderer)) {
         if (!obj->needsToUpdateChildren()) {
             obj->setNeedsToUpdateChildren();
             postNotification(renderer, AXChildrenChanged, true);
@@ skipping 166 matching lines @@
 
 void AXObjectCacheImpl::handleScrollPositionChanged(FrameView* frameView)
 {
     // Prefer to fire the scroll position changed event on the frame view's child web area, if possible.
     AXObject* targetAXObject = getOrCreate(frameView);
     if (targetAXObject && !targetAXObject->children().isEmpty())
         targetAXObject = targetAXObject->children()[0].get();
     postPlatformNotification(targetAXObject, AXScrollPositionChanged);
 }
 
-void AXObjectCacheImpl::handleScrollPositionChanged(RenderObject* renderObject)
+void AXObjectCacheImpl::handleScrollPositionChanged(LayoutObject* layoutObject)
 {
-    postPlatformNotification(getOrCreate(renderObject), AXScrollPositionChanged);
+    postPlatformNotification(getOrCreate(layoutObject), AXScrollPositionChanged);
 }
 
 const AtomicString& AXObjectCacheImpl::computedRoleForNode(Node* node)
 {
     AXObject* obj = getOrCreate(node);
     if (!obj)
         return AXObject::roleName(UnknownRole);
     return AXObject::roleName(obj->roleValue());
 }
 
@@ skipping 36 matching lines @@
 void AXObjectCacheImpl::setCanvasObjectBounds(Element* element, const LayoutRect& rect)
 {
     AXObject* obj = getOrCreate(element);
     if (!obj)
         return;
 
     obj->setElementRect(rect);
 }
 
 } // namespace blink