rendering/RenderBoxModelObject -> layout/LayoutBoxModelObject

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 64 matching lines @@
 #include "wtf/StdLibExtras.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static inline LayoutObject* firstChildInContinuation(const RenderInline& renderer)
 {
-    RenderBoxModelObject* r = renderer.continuation();
+    LayoutBoxModelObject* r = renderer.continuation();
 
     while (r) {
         if (r->isRenderBlock())
             return r;
         if (LayoutObject* child = r->slowFirstChild())
             return child;
         r = toRenderInline(r)->continuation();
     }
 
     return 0;
 }
 
 static inline bool isInlineWithContinuation(LayoutObject* object)
 {
     if (!object->isBoxModelObject())
         return false;
 
-    RenderBoxModelObject* renderer = toRenderBoxModelObject(object);
+    LayoutBoxModelObject* renderer = toLayoutBoxModelObject(object);
     if (!renderer->isRenderInline())
         return false;
 
     return toRenderInline(renderer)->continuation();
 }
 
 static inline LayoutObject* firstChildConsideringContinuation(LayoutObject* renderer)
 {
     LayoutObject* firstChild = renderer->slowFirstChild();
 
@@ skipping 36 matching lines @@
 
     return prev;
 }
 
 static inline bool lastChildHasContinuation(LayoutObject* renderer)
 {
     LayoutObject* lastChild = renderer->slowLastChild();
     return lastChild && isInlineWithContinuation(lastChild);
 }
 
-static RenderBoxModelObject* nextContinuation(LayoutObject* renderer)
+static LayoutBoxModelObject* 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(LayoutObject* renderer, AXObjectCacheImpl* axObjectCache)
@@ skipping 36 matching lines @@
 
     return m_cachedElementRect;
 }
 
 void AXRenderObject::setRenderer(LayoutObject* renderer)
 {
     m_renderer = renderer;
     setNode(renderer->node());
 }
 
-RenderBoxModelObject* AXRenderObject::renderBoxModelObject() const
+LayoutBoxModelObject* AXRenderObject::layoutBoxModelObject() const
 {
     if (!m_renderer || !m_renderer->isBoxModelObject())
         return 0;
-    return toRenderBoxModelObject(m_renderer);
+    return toLayoutBoxModelObject(m_renderer);
 }
 
 Document* AXRenderObject::topDocument() const
 {
     if (!document())
         return 0;
     return &document()->topDocument();
 }
 
 bool AXRenderObject::shouldNotifyActiveDescendant() const
@@ skipping 15 matching lines @@
     if (!m_renderer || !m_renderer->isBox())
         return 0;
 
     RenderBox* box = toRenderBox(m_renderer);
     if (!box->canBeScrolledAndHasScrollableArea())
         return 0;
 
     return box->scrollableArea();
 }
 
-static bool isImageOrAltText(RenderBoxModelObject* box, Node* node)
+static bool isImageOrAltText(LayoutBoxModelObject* box, Node* node)
 {
     if (box && box->isImage())
         return true;
     if (isHTMLImageElement(node))
         return true;
     if (isHTMLInputElement(node) && toHTMLInputElement(node)->hasFallbackContent())
         return true;
     return false;
 }
 
 AccessibilityRole AXRenderObject::determineAccessibilityRole()
 {
     if (!m_renderer)
         return UnknownRole;
 
     if ((m_ariaRole = determineAriaRoleAttribute()) != UnknownRole)
         return m_ariaRole;
 
     Node* node = m_renderer->node();
-    RenderBoxModelObject* cssBox = renderBoxModelObject();
+    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
 
     if ((cssBox && cssBox->isListItem()) || isHTMLLIElement(node))
         return ListItemRole;
     if (m_renderer->isListMarker())
         return ListMarkerRole;
     if (m_renderer->isBR())
         return LineBreakRole;
     if (isHTMLLegendElement(node))
         return LegendRole;
     if (m_renderer->isText())
@@ skipping 114 matching lines @@
 #endif
     m_renderer = 0;
 }
 
 //
 // Check object role or purpose.
 //
 
 bool AXRenderObject::isAttachment() const
 {
-    RenderBoxModelObject* renderer = renderBoxModelObject();
+    LayoutBoxModelObject* renderer = layoutBoxModelObject();
     if (!renderer)
         return false;
     // Widgets are the replaced elements that we represent to AX as attachments
     bool isLayoutPart = renderer->isLayoutPart();
     ASSERT(!isLayoutPart || (renderer->isReplaced() && !isImage()));
     return isLayoutPart;
 }
 
 static bool isLinkable(const AXObject& object)
 {
@@ skipping 147 matching lines @@
     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 (LayoutObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
-        if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
+        if (parent->isBoxModelObject() && toLayoutBoxModelObject(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;
 
     if (m_renderer->isBR())
@@ skipping 324 matching lines @@
     default:
         return emptyString();
     }
 }
 
 String AXRenderObject::stringValue() const
 {
     if (!m_renderer)
         return String();
 
-    RenderBoxModelObject* cssBox = renderBoxModelObject();
+    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
 
     if (ariaRoleAttribute() == StaticTextRole) {
         String staticText = text();
         if (!staticText.length())
             staticText = textUnderElement(TextUnderElementAll);
         return staticText;
     }
 
     if (m_renderer->isText())
         return textUnderElement(TextUnderElementAll);
@@ skipping 765 matching lines @@
         Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
 }
 
 void AXRenderObject::setValue(const String& string)
 {
     if (!node() || !node()->isElementNode())
         return;
     if (!m_renderer || !m_renderer->isBoxModelObject())
         return;
 
-    RenderBoxModelObject* renderer = toRenderBoxModelObject(m_renderer);
+    LayoutBoxModelObject* renderer = toLayoutBoxModelObject(m_renderer);
     if (renderer->isTextField() && isHTMLInputElement(*node()))
         toHTMLInputElement(*node()).setValue(string);
     else if (renderer->isTextArea() && isHTMLTextAreaElement(*node()))
         toHTMLTextAreaElement(*node()).setValue(string);
 }
 
 // FIXME: This function should use an IntSize to avoid the conversion below.
 void AXRenderObject::scrollTo(const IntPoint& point) const
 {
     if (!m_renderer || !m_renderer->isBox())
@@ skipping 320 matching lines @@
 }
 
 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()))
+    if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toLayoutBoxModelObject(renderer)->isListBox()))
         return true;
 
     // Textboxes should send out notifications.
     if (nodeHasRole(node, "textbox"))
         return true;
 
     return false;
 }
 
 LayoutObject* AXRenderObject::renderParentObject() const
@@ skipping 153 matching lines @@
         return;
 
     AXSpinButton* axSpinButton = toAXSpinButton(axObjectCache()->getOrCreate(SpinButtonRole));
     axSpinButton->setSpinButtonElement(toSpinButtonElement(spinButtonElement));
     axSpinButton->setParent(this);
     m_children.append(axSpinButton);
 }
 
 void AXRenderObject::addImageMapChildren()
 {
-    RenderBoxModelObject* cssBox = renderBoxModelObject();
+    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
     if (!cssBox || !cssBox->isLayoutImage())
         return;
 
     HTMLMapElement* map = toLayoutImage(cssBox)->imageMap();
     if (!map)
         return;
 
     for (HTMLAreaElement& area : Traversal<HTMLAreaElement>::descendantsOf(*map)) {
         // add an <area> element for this child if it has a link
         if (area.isLink()) {
@@ skipping 174 matching lines @@
         if (label && label->renderer()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink