Move rendering/RenderObject to layout/LayoutObject.

Source/modules/accessibility/AXRenderObject.cpp

 /*
 * Copyright (C) 2008 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
@@ skipping 62 matching lines @@
 #include "modules/accessibility/AXTable.h"
 #include "platform/text/PlatformLocale.h"
 #include "wtf/StdLibExtras.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static inline RenderObject* firstChildInContinuation(const RenderInline& renderer)
+static inline LayoutObject* firstChildInContinuation(const RenderInline& renderer)
 {
     RenderBoxModelObject* r = renderer.continuation();
 
     while (r) {
         if (r->isRenderBlock())
             return r;
-        if (RenderObject* child = r->slowFirstChild())
+        if (LayoutObject* child = r->slowFirstChild())
             return child;
         r = toRenderInline(r)->continuation();
     }
 
     return 0;
 }
 
-static inline bool isInlineWithContinuation(RenderObject* object)
+static inline bool isInlineWithContinuation(LayoutObject* object)
 {
     if (!object->isBoxModelObject())
         return false;
 
     RenderBoxModelObject* renderer = toRenderBoxModelObject(object);
     if (!renderer->isRenderInline())
         return false;
 
     return toRenderInline(renderer)->continuation();
 }
 
-static inline RenderObject* firstChildConsideringContinuation(RenderObject* renderer)
+static inline LayoutObject* firstChildConsideringContinuation(LayoutObject* renderer)
 {
-    RenderObject* firstChild = renderer->slowFirstChild();
+    LayoutObject* firstChild = renderer->slowFirstChild();
 
     if (!firstChild && isInlineWithContinuation(renderer))
         firstChild = firstChildInContinuation(toRenderInline(*renderer));
 
     return firstChild;
 }
 
-static inline RenderInline* startOfContinuations(RenderObject* r)
+static inline RenderInline* startOfContinuations(LayoutObject* r)
 {
     if (r->isInlineElementContinuation()) {
         return toRenderInline(r->node()->renderer());
     }
 
     // Blocks with a previous continuation always have a next continuation
     if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())
         return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->node()->renderer());
 
     return 0;
 }
 
-static inline RenderObject* endOfContinuations(RenderObject* renderer)
+static inline LayoutObject* endOfContinuations(LayoutObject* renderer)
 {
-    RenderObject* prev = renderer;
-    RenderObject* cur = renderer;
+    LayoutObject* prev = renderer;
+    LayoutObject* cur = renderer;
 
     if (!cur->isRenderInline() && !cur->isRenderBlock())
         return renderer;
 
     while (cur) {
         prev = cur;
         if (cur->isRenderInline()) {
             cur = toRenderInline(cur)->inlineElementContinuation();
             ASSERT(cur || !toRenderInline(prev)->continuation());
         } else {
             cur = toRenderBlock(cur)->inlineElementContinuation();
         }
     }
 
     return prev;
 }
 
-static inline bool lastChildHasContinuation(RenderObject* renderer)
+static inline bool lastChildHasContinuation(LayoutObject* renderer)
 {
-    RenderObject* lastChild = renderer->slowLastChild();
+    LayoutObject* lastChild = renderer->slowLastChild();
     return lastChild && isInlineWithContinuation(lastChild);
 }
 
-static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
+static RenderBoxModelObject* nextContinuation(LayoutObject* renderer)
 {
     ASSERT(renderer);
     if (renderer->isRenderInline() && !renderer->isReplaced())
         return toRenderInline(renderer)->continuation();
     if (renderer->isRenderBlock())
         return toRenderBlock(renderer)->inlineElementContinuation();
     return 0;
 }
 
-AXRenderObject::AXRenderObject(RenderObject* renderer, AXObjectCacheImpl* axObjectCache)
+AXRenderObject::AXRenderObject(LayoutObject* renderer, AXObjectCacheImpl* axObjectCache)
     : AXNodeObject(renderer->node(), axObjectCache)
     , m_renderer(renderer)
     , m_cachedElementRectDirty(true)
 {
 #if ENABLE(ASSERT)
     m_renderer->setHasAXObject(true);
 #endif
 }
 
-PassRefPtr<AXRenderObject> AXRenderObject::create(RenderObject* renderer, AXObjectCacheImpl* axObjectCache)
+PassRefPtr<AXRenderObject> AXRenderObject::create(LayoutObject* renderer, AXObjectCacheImpl* axObjectCache)
 {
     return adoptRef(new AXRenderObject(renderer, axObjectCache));
 }
 
 AXRenderObject::~AXRenderObject()
 {
     ASSERT(isDetached());
 }
 
 LayoutRect AXRenderObject::elementRect() const
@@ skipping 10 matching lines @@
             toAXRenderObject(obj)->checkCachedElementRect();
     }
     for (const AXObject* obj = this; obj; obj = obj->parentObject()) {
         if (obj->isAXRenderObject())
             toAXRenderObject(obj)->updateCachedElementRect();
     }
 
     return m_cachedElementRect;
 }
 
-void AXRenderObject::setRenderer(RenderObject* renderer)
+void AXRenderObject::setRenderer(LayoutObject* renderer)
 {
     m_renderer = renderer;
     setNode(renderer->node());
 }
 
 RenderBoxModelObject* AXRenderObject::renderBoxModelObject() const
 {
     if (!m_renderer || !m_renderer->isBoxModelObject())
         return 0;
     return toRenderBoxModelObject(m_renderer);
@@ skipping 347 matching lines @@
     // An ARIA tree can only have tree items and static text as children.
     if (!isAllowedChildOfTree())
         return true;
 
     // TODO: we should refactor this - but right now this is necessary to make
     // sure scroll areas stay in the tree.
     if (isAttachment())
         return false;
 
     // ignore popup menu items because AppKit does
-    for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
+    for (LayoutObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
         if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
             return true;
     }
 
     // find out if this element is inside of a label element.
     // if so, it may be ignored because it's the label for a checkbox or radio button
     AXObject* controlObject = correspondingControlForLabelElement();
     if (controlObject && !controlObject->exposesTitleUIElement() && controlObject->isCheckboxOrRadio())
         return true;
 
@@ skipping 629 matching lines @@
 
     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
     if (!ariaHelp.isEmpty())
         return ariaHelp;
 
     String describedBy = ariaDescribedByAttribute();
     if (!describedBy.isEmpty())
         return describedBy;
 
     String description = accessibilityDescription();
-    for (RenderObject* curr = m_renderer; curr; curr = curr->parent()) {
+    for (LayoutObject* curr = m_renderer; curr; curr = curr->parent()) {
         if (curr->node() && curr->node()->isHTMLElement()) {
             const AtomicString& summary = toElement(curr->node())->getAttribute(summaryAttr);
             if (!summary.isEmpty())
                 return summary;
 
             // The title attribute should be used as help text unless it is already being used as descriptive text.
             const AtomicString& title = toElement(curr->node())->getAttribute(titleAttr);
             if (!title.isEmpty() && description != title)
                 return title;
         }
@@ skipping 112 matching lines @@
     // Allow the hit test to return media control buttons.
     if (node->isInShadowTree() && (!isHTMLInputElement(*node) || !node->isMediaControlElement()))
         node = node->shadowHost();
 
     if (isHTMLAreaElement(node))
         return accessibilityImageMapHitTest(toHTMLAreaElement(node), point);
 
     if (isHTMLOptionElement(node))
         node = toHTMLOptionElement(*node).ownerSelectElement();
 
-    RenderObject* obj = node->renderer();
+    LayoutObject* obj = node->renderer();
     if (!obj)
         return 0;
 
     AXObject* result = axObjectCache()->getOrCreate(obj);
     result->updateChildrenIfNecessary();
 
     // Allow the element to perform any hit-testing it might need to do to reach non-render children.
     result = result->elementAccessibilityHitTest(point);
 
     if (result && result->accessibilityIsIgnored()) {
@@ skipping 30 matching lines @@
     if (ariaRoleAttribute() == MenuBarRole)
         return axObjectCache()->getOrCreate(m_renderer->parent());
 
     // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
     if (ariaRoleAttribute() == MenuRole) {
         AXObject* parent = menuButtonForMenu();
         if (parent)
             return parent;
     }
 
-    RenderObject* parentObj = renderParentObject();
+    LayoutObject* parentObj = renderParentObject();
     if (parentObj)
         return axObjectCache()->getOrCreate(parentObj);
 
     // WebArea's parent should be the scroll view containing it.
     if (isWebArea())
         return axObjectCache()->getOrCreate(m_renderer->frame()->view());
 
     return 0;
 }
 
 AXObject* AXRenderObject::computeParentIfExists() const
 {
     if (!m_renderer)
         return 0;
 
     if (ariaRoleAttribute() == MenuBarRole)
         return axObjectCache()->get(m_renderer->parent());
 
     // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
     if (ariaRoleAttribute() == MenuRole) {
         AXObject* parent = menuButtonForMenu();
         if (parent)
             return parent;
     }
 
-    RenderObject* parentObj = renderParentObject();
+    LayoutObject* parentObj = renderParentObject();
     if (parentObj)
         return axObjectCache()->get(parentObj);
 
     // WebArea's parent should be the scroll view containing it.
     if (isWebArea())
         return axObjectCache()->get(m_renderer->frame()->view());
 
     return 0;
 }
 
 //
 // Low-level accessibility tree exploration, only for use within the accessibility module.
 //
 
 AXObject* AXRenderObject::firstChild() const
 {
     if (!m_renderer)
         return 0;
 
-    RenderObject* firstChild = firstChildConsideringContinuation(m_renderer);
+    LayoutObject* firstChild = firstChildConsideringContinuation(m_renderer);
 
     if (!firstChild)
         return 0;
 
     return axObjectCache()->getOrCreate(firstChild);
 }
 
 AXObject* AXRenderObject::nextSibling() const
 {
     if (!m_renderer)
         return 0;
 
-    RenderObject* nextSibling = 0;
+    LayoutObject* nextSibling = 0;
 
     RenderInline* inlineContinuation = m_renderer->isRenderBlock() ? toRenderBlock(m_renderer)->inlineElementContinuation() : 0;
     if (inlineContinuation) {
         // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's first child.
         nextSibling = firstChildConsideringContinuation(inlineContinuation);
     } else if (m_renderer->isAnonymousBlock() && lastChildHasContinuation(m_renderer)) {
         // Case 2: Anonymous block parent of the start of a continuation - skip all the way to
         // after the parent of the end, since everything in between will be linked up via the continuation.
-        RenderObject* lastParent = endOfContinuations(toRenderBlock(m_renderer)->lastChild())->parent();
+        LayoutObject* lastParent = endOfContinuations(toRenderBlock(m_renderer)->lastChild())->parent();
         while (lastChildHasContinuation(lastParent))
             lastParent = endOfContinuations(lastParent->slowLastChild())->parent();
         nextSibling = lastParent->nextSibling();
-    } else if (RenderObject* ns = m_renderer->nextSibling()) {
+    } else if (LayoutObject* ns = m_renderer->nextSibling()) {
         // Case 3: node has an actual next sibling
         nextSibling = ns;
     } else if (isInlineWithContinuation(m_renderer)) {
         // Case 4: node is an inline with a continuation. Next sibling is the next sibling of the end
         // of the continuation chain.
         nextSibling = endOfContinuations(m_renderer)->nextSibling();
     } else if (isInlineWithContinuation(m_renderer->parent())) {
         // Case 5: node has no next sibling, and its parent is an inline with a continuation.
-        RenderObject* continuation = toRenderInline(m_renderer->parent())->continuation();
+        LayoutObject* continuation = toRenderInline(m_renderer->parent())->continuation();
 
         if (continuation->isRenderBlock()) {
             // Case 5a: continuation is a block - in this case the block itself is the next sibling.
             nextSibling = continuation;
         } else {
             // Case 5b: continuation is an inline - in this case the inline's first child is the next sibling.
             nextSibling = firstChildConsideringContinuation(continuation);
         }
     }
 
@@ skipping 50 matching lines @@
 
 void AXRenderObject::clearChildren()
 {
     AXObject::clearChildren();
     m_childrenDirty = false;
 }
 
 AXObject* AXRenderObject::observableObject() const
 {
     // Find the object going up the parent chain that is used in accessibility to monitor certain notifications.
-    for (RenderObject* renderer = m_renderer; renderer && renderer->node(); renderer = renderer->parent()) {
-        if (renderObjectIsObservable(renderer))
+    for (LayoutObject* renderer = m_renderer; renderer && renderer->node(); renderer = renderer->parent()) {
+        if (layoutObjectIsObservable(renderer))
             return axObjectCache()->getOrCreate(renderer);
     }
 
     return 0;
 }
 
 //
 // Properties of the object's owning document or page.
 //
 
@@ skipping 24 matching lines @@
     if (!m_renderer)
         return 0;
     return &m_renderer->document();
 }
 
 FrameView* AXRenderObject::documentFrameView() const
 {
     if (!m_renderer)
         return 0;
 
-    // this is the RenderObject's Document's LocalFrame's FrameView
+    // this is the LayoutObject's Document's LocalFrame's FrameView
     return m_renderer->document().view();
 }
 
 Element* AXRenderObject::anchorElement() const
 {
     if (!m_renderer)
         return 0;
 
     AXObjectCacheImpl* cache = axObjectCache();
-    RenderObject* currRenderer;
+    LayoutObject* currRenderer;
 
-    // Search up the render tree for a RenderObject with a DOM node. Defer to an earlier continuation, though.
+    // Search up the render tree for a LayoutObject with a DOM node. Defer to an earlier continuation, though.
     for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent()) {
         if (currRenderer->isAnonymousBlock()) {
-            RenderObject* continuation = toRenderBlock(currRenderer)->continuation();
+            LayoutObject* continuation = toRenderBlock(currRenderer)->continuation();
             if (continuation)
                 return cache->getOrCreate(continuation)->anchorElement();
         }
     }
 
     // bail if none found
     if (!currRenderer)
         return 0;
 
     // search up the DOM tree for an anchor element
@@ skipping 168 matching lines @@
 //
 // Text metrics. Most of these should be deprecated, needs major cleanup.
 //
 
 // NOTE: Consider providing this utility method as AX API
 int AXRenderObject::index(const VisiblePosition& position) const
 {
     if (position.isNull() || !isTextControl())
         return -1;
 
-    if (renderObjectContainsPosition(m_renderer, position.deepEquivalent()))
+    if (layoutObjectContainsPosition(m_renderer, position.deepEquivalent()))
         return indexForVisiblePosition(position);
 
     return -1;
 }
 
 VisiblePosition AXRenderObject::visiblePositionForIndex(int index) const
 {
     if (!m_renderer)
         return VisiblePosition();
 
@@ skipping 208 matching lines @@
     AXObject::AccessibilityChildrenVector children = parent->children();
     unsigned count = children.size();
     for (unsigned k = 0; k < count; ++k) {
         if (children[k]->elementRect().contains(point))
             return children[k].get();
     }
 
     return 0;
 }
 
-bool AXRenderObject::renderObjectIsObservable(RenderObject* renderer) const
+bool AXRenderObject::layoutObjectIsObservable(LayoutObject* renderer) const
 {
     // AX clients will listen for AXValueChange on a text control.
     if (renderer->isTextControl())
         return true;
 
     // AX clients will listen for AXSelectedChildrenChanged on listboxes.
     Node* node = renderer->node();
     if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListBox()))
         return true;
 
     // Textboxes should send out notifications.
     if (nodeHasRole(node, "textbox"))
         return true;
 
     return false;
 }
 
-RenderObject* AXRenderObject::renderParentObject() const
+LayoutObject* AXRenderObject::renderParentObject() const
 {
     if (!m_renderer)
         return 0;
 
-    RenderObject* startOfConts = m_renderer->isRenderBlock() ? startOfContinuations(m_renderer) : 0;
+    LayoutObject* startOfConts = m_renderer->isRenderBlock() ? startOfContinuations(m_renderer) : 0;
     if (startOfConts) {
         // Case 1: node is a block and is an inline's continuation. Parent
         // is the start of the continuation chain.
         return startOfConts;
     }
 
-    RenderObject* parent = m_renderer->parent();
+    LayoutObject* parent = m_renderer->parent();
     startOfConts = parent && parent->isRenderInline() ? startOfContinuations(parent) : 0;
     if (startOfConts) {
         // Case 2: node's parent is an inline which is some node's continuation; parent is
         // the earliest node in the continuation chain.
         return startOfConts;
     }
 
-    RenderObject* firstChild = parent ? parent->slowFirstChild() : 0;
+    LayoutObject* firstChild = parent ? parent->slowFirstChild() : 0;
     if (firstChild && firstChild->node()) {
         // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
         // Get the node's renderer and follow that continuation chain until the first child is found.
-        for (RenderObject* nodeRenderFirstChild = firstChild->node()->renderer(); nodeRenderFirstChild != firstChild; nodeRenderFirstChild = firstChild->node()->renderer()) {
-            for (RenderObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
+        for (LayoutObject* nodeRenderFirstChild = firstChild->node()->renderer(); nodeRenderFirstChild != firstChild; nodeRenderFirstChild = firstChild->node()->renderer()) {
+            for (LayoutObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
                 if (contsTest == firstChild) {
                     parent = nodeRenderFirstChild->parent();
                     break;
                 }
             }
-            RenderObject* newFirstChild = parent->slowFirstChild();
+            LayoutObject* newFirstChild = parent->slowFirstChild();
             if (firstChild == newFirstChild)
                 break;
             firstChild = newFirstChild;
             if (!firstChild->node())
                 break;
         }
     }
 
     return parent;
 }
 
 bool AXRenderObject::isDescendantOfElementType(const HTMLQualifiedName& tagName) const
 {
-    for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
+    for (LayoutObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
         if (parent->node() && parent->node()->hasTagName(tagName))
             return true;
     }
     return false;
 }
 
 bool AXRenderObject::isSVGImage() const
 {
     return remoteSVGRootElement();
 }
@@ skipping 244 matching lines @@
         return false;
 
     if (parent->roleValue() == NoneRole || parent->roleValue() == PresentationalRole)
         return ariaRoleAttribute() == UnknownRole;
 
     return false;
 }
 
 LayoutRect AXRenderObject::computeElementRect() const
 {
-    RenderObject* obj = m_renderer;
+    LayoutObject* obj = m_renderer;
 
     if (!obj)
         return LayoutRect();
 
     if (obj->node()) // If we are a continuation, we want to make sure to use the primary renderer.
         obj = obj->node()->renderer();
 
     // absoluteFocusRingBoundingBox will query the hierarchy below this element, which for large webpages can be very slow.
     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
     // We should also use absoluteQuads for SVG elements, otherwise transforms won't be applied.
@@ skipping 28 matching lines @@
         if (label && label->renderer()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink