Move inlineElementContinuation() to LayoutBlockFlow.

third_party/WebKit/Source/modules/accessibility/AXLayoutObject.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 117 matching lines @@
     return firstChild;
 }
 
 static inline LayoutInline* startOfContinuations(LayoutObject* r)
 {
     if (r->isInlineElementContinuation()) {
         return toLayoutInline(r->node()->layoutObject());
     }
 
     // Blocks with a previous continuation always have a next continuation
-    if (r->isLayoutBlock() && toLayoutBlock(r)->inlineElementContinuation())
-        return toLayoutInline(toLayoutBlock(r)->inlineElementContinuation()->node()->layoutObject());
+    if (r->isLayoutBlockFlow() && toLayoutBlockFlow(r)->inlineElementContinuation())
+        return toLayoutInline(toLayoutBlockFlow(r)->inlineElementContinuation()->node()->layoutObject());
 
     return 0;
 }
 
 static inline LayoutObject* endOfContinuations(LayoutObject* layoutObject)
 {
     LayoutObject* prev = layoutObject;
     LayoutObject* cur = layoutObject;
 
-    if (!cur->isLayoutInline() && !cur->isLayoutBlock())
+    if (!cur->isLayoutInline() && !cur->isLayoutBlockFlow())
         return layoutObject;
 
     while (cur) {
         prev = cur;
         if (cur->isLayoutInline()) {
             cur = toLayoutInline(cur)->inlineElementContinuation();
             ASSERT(cur || !toLayoutInline(prev)->continuation());
         } else {
-            cur = toLayoutBlock(cur)->inlineElementContinuation();
+            cur = toLayoutBlockFlow(cur)->inlineElementContinuation();
         }
     }
 
     return prev;
 }
 
 static inline bool lastChildHasContinuation(LayoutObject* layoutObject)
 {
     LayoutObject* lastChild = layoutObject->slowLastChild();
     return lastChild && isInlineWithContinuation(lastChild);
 }
 
 static LayoutBoxModelObject* nextContinuation(LayoutObject* layoutObject)
 {
     ASSERT(layoutObject);
     if (layoutObject->isLayoutInline() && !layoutObject->isAtomicInlineLevel())
         return toLayoutInline(layoutObject)->continuation();
-    if (layoutObject->isLayoutBlock())
-        return toLayoutBlock(layoutObject)->inlineElementContinuation();
+    if (layoutObject->isLayoutBlockFlow())
+        return toLayoutBlockFlow(layoutObject)->inlineElementContinuation();
     return 0;
 }
 
 AXLayoutObject::AXLayoutObject(LayoutObject* layoutObject, AXObjectCacheImpl& axObjectCache)
     : AXNodeObject(layoutObject->node(), axObjectCache)
     , m_layoutObject(layoutObject)
     , m_cachedElementRectDirty(true)
 {
 #if ENABLE(ASSERT)
     m_layoutObject->setHasAXObject(true);
@@ skipping 1350 matching lines @@
     return axObjectCache().getOrCreate(firstChild);
 }
 
 AXObject* AXLayoutObject::rawNextSibling() const
 {
     if (!m_layoutObject)
         return 0;
 
     LayoutObject* nextSibling = 0;
 
-    LayoutInline* inlineContinuation = m_layoutObject->isLayoutBlock() ? toLayoutBlock(m_layoutObject)->inlineElementContinuation() : 0;
+    LayoutInline* inlineContinuation = m_layoutObject->isLayoutBlockFlow() ? toLayoutBlockFlow(m_layoutObject)->inlineElementContinuation() : nullptr;
     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_layoutObject->isAnonymousBlock() && lastChildHasContinuation(m_layoutObject)) {
         // 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.
         LayoutObject* lastParent = endOfContinuations(toLayoutBlock(m_layoutObject)->lastChild())->parent();
         while (lastChildHasContinuation(lastParent))
             lastParent = endOfContinuations(lastParent->slowLastChild())->parent();
         nextSibling = lastParent->nextSibling();
@@ skipping 647 matching lines @@
     }
 
     return 0;
 }
 
 LayoutObject* AXLayoutObject::layoutParentObject() const
 {
     if (!m_layoutObject)
         return 0;
 
-    LayoutObject* startOfConts = m_layoutObject->isLayoutBlock() ? startOfContinuations(m_layoutObject) : 0;
+    LayoutObject* startOfConts = m_layoutObject->isLayoutBlockFlow() ? startOfContinuations(m_layoutObject) : nullptr;
     if (startOfConts) {
         // Case 1: node is a block and is an inline's continuation. Parent
         // is the start of the continuation chain.
         return startOfConts;
     }
 
     LayoutObject* parent = m_layoutObject->parent();
     startOfConts = parent && parent->isLayoutInline() ? startOfContinuations(parent) : 0;
     if (startOfConts) {
         // Case 2: node's parent is an inline which is some node's continuation; parent is
@@ skipping 244 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache().getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink