add 'slow' prefix to RenderObject's firstChild() / lastChild() methods

Source/core/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 59 matching lines @@
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/text/PlatformLocale.h"
 #include "wtf/StdLibExtras.h"
 
 using blink::WebLocalizedString;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-static inline RenderObject* firstChildInContinuation(RenderObject* renderer)
+static inline RenderObject* firstChildInContinuation(const RenderInline& renderer)
 {
-    RenderObject* r = toRenderInline(renderer)->continuation();
+    RenderBoxModelObject* r = renderer.continuation();
 
     while (r) {
         if (r->isRenderBlock())
             return r;
-        if (RenderObject* child = r->firstChild())
+        if (RenderObject* child = r->slowFirstChild())
             return child;
         r = toRenderInline(r)->continuation();
     }
 
     return 0;
 }
 
 static inline bool isInlineWithContinuation(RenderObject* 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)
 {
-    RenderObject* firstChild = renderer->firstChild();
+    RenderObject* firstChild = renderer->slowFirstChild();
 
     if (!firstChild && isInlineWithContinuation(renderer))
-        firstChild = firstChildInContinuation(renderer);
+        firstChild = firstChildInContinuation(toRenderInline(*renderer));
 
     return firstChild;
 }
 
 static inline RenderInline* startOfContinuations(RenderObject* r)
 {
     if (r->isInlineElementContinuation()) {
         return toRenderInline(r->node()->renderer());
     }
 
@@ skipping 20 matching lines @@
         } else {
             cur = toRenderBlock(cur)->inlineElementContinuation();
         }
     }
 
     return prev;
 }
 
 static inline bool lastChildHasContinuation(RenderObject* renderer)
 {
-    return renderer->lastChild() && isInlineWithContinuation(renderer->lastChild());
+    RenderObject* lastChild = renderer->slowLastChild();
+    return lastChild && isInlineWithContinuation(lastChild);
 }
 
 static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
 {
     ASSERT(renderer);
     if (renderer->isRenderInline() && !renderer->isReplaced())
         return toRenderInline(renderer)->continuation();
     if (renderer->isRenderBlock())
         return toRenderBlock(renderer)->inlineElementContinuation();
     return 0;
@@ skipping 1210 matching lines @@
 
     RenderObject* nextSibling = 0;
 
     RenderInline* inlineContinuation;
     if (m_renderer->isRenderBlock() && (inlineContinuation = toRenderBlock(m_renderer)->inlineElementContinuation())) {
         // 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(m_renderer->lastChild())->parent();
+        RenderObject* lastParent = endOfContinuations(toRenderBlock(m_renderer)->lastChild())->parent();
         while (lastChildHasContinuation(lastParent))
-            lastParent = endOfContinuations(lastParent->lastChild())->parent();
+            lastParent = endOfContinuations(lastParent->slowLastChild())->parent();
         nextSibling = lastParent->nextSibling();
     } else if (RenderObject* 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.
@@ skipping 557 matching lines @@
     RenderObject* startOfConts = 0;
     RenderObject* firstChild = 0;
     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer))) {
         // Case 1: node is a block and is an inline's continuation. Parent
         // is the start of the continuation chain.
         parent = startOfConts;
     } else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent))) {
         // Case 2: node's parent is an inline which is some node's continuation; parent is
         // the earliest node in the continuation chain.
         parent = startOfConts;
-    } else if (parent && (firstChild = parent->firstChild()) && firstChild->node()) {
+    } else if (parent && (firstChild = parent->slowFirstChild()) && 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.
         RenderObject* nodeRenderFirstChild = firstChild->node()->renderer();
         while (nodeRenderFirstChild != firstChild) {
             for (RenderObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
                 if (contsTest == firstChild) {
                     parent = nodeRenderFirstChild->parent();
                     break;
                 }
             }
-            if (firstChild == parent->firstChild())
+            RenderObject* newFirstChild = parent->slowFirstChild();
+            if (firstChild == newFirstChild)
                 break;
-            firstChild = parent->firstChild();
+            firstChild = newFirstChild;
             if (!firstChild->node())
                 break;
             nodeRenderFirstChild = firstChild->node()->renderer();
         }
     }
 
     return parent;
 }
 
 bool AXRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
@@ skipping 319 matching lines @@
         if (label && label->renderer()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace WebCore