remove childrenInline & setChildrenInline

sky/engine/core/rendering/RenderBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 268 matching lines @@
     if (beforeChild && beforeChild->parent() != this) {
         RenderObject* beforeChildContainer = beforeChild->parent();
         ASSERT(beforeChildContainer->parent() == this);
         ASSERT(beforeChildContainer->isAnonymousBlock());
         addChild(newChild, beforeChildContainer);
         return;
     }
 
     // TODO(ojan): What should we do in this case? For now we insert an anonymous paragraph.
     // This only happens if we have a text node directly inside a non-paragraph.
-    if (!childrenInline() && newChild->isInline()) {
+    if (!isRenderParagraph() && newChild->isInline()) {
         RenderBlock* newBox = createAnonymousBlock();
-        ASSERT(newBox->childrenInline());
+        ASSERT(newBox->isRenderParagraph());
         RenderBox::addChild(newBox, beforeChild);
         newBox->addChild(newChild);
         return;
     }
 
     RenderBox::addChild(newChild, beforeChild);
 }
 
 void RenderBlock::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     addChildIgnoringAnonymousColumnBlocks(newChild, beforeChild);
 }
 
 void RenderBlock::deleteLineBoxTree()
 {
     ASSERT(!m_lineBoxes.firstLineBox());
 }
 
 void RenderBlock::removeChild(RenderObject* oldChild)
 {
     RenderBox::removeChild(oldChild);
 
     // No need to waste time deleting the line box tree if we're getting destroyed.
     if (documentBeingDestroyed())
         return;
 
     // If this was our last child be sure to clear out our line boxes.
-    if (!firstChild() && childrenInline())
+    if (!firstChild() && isRenderParagraph())
         deleteLineBoxTree();
 }
 
 void RenderBlock::startDelayUpdateScrollInfo()
 {
     if (gDelayUpdateScrollInfo == 0) {
         ASSERT(!gDelayedUpdateScrollInfoSet);
         gDelayedUpdateScrollInfoSet = new DelayedUpdateScrollInfoSet;
     }
     ASSERT(gDelayedUpdateScrollInfoSet);
@@ skipping 63 matching lines @@
 }
 
 void RenderBlock::layoutBlock(bool)
 {
     ASSERT_NOT_REACHED();
     clearNeedsLayout();
 }
 
 void RenderBlock::addOverflowFromChildren()
 {
-    if (childrenInline())
+    if (isRenderParagraph())
         toRenderBlockFlow(this)->addOverflowFromInlineChildren();
     else
         addOverflowFromBlockChildren();
 }
 
 void RenderBlock::computeOverflow(LayoutUnit oldClientAfterEdge, bool)
 {
     m_overflow.clear();
 
     // Add overflow from children.
@@ skipping 51 matching lines @@
     if (relayoutChildren || (child->hasRelativeLogicalHeight() && !isRenderView()))
         child->setChildNeedsLayout(MarkOnlyThis);
 
     // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
     if (relayoutChildren && child->needsPreferredWidthsRecalculation())
         child->setPreferredLogicalWidthsDirty(MarkOnlyThis);
 }
 
 void RenderBlock::simplifiedNormalFlowLayout()
 {
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             RenderObject* o = walker.current();
             if (!o->isOutOfFlowPositioned() && o->isReplaced()) {
                 o->layoutIfNeeded();
                 if (toRenderBox(o)->inlineBoxWrapper()) {
                     RootInlineBox& box = toRenderBox(o)->inlineBoxWrapper()->root();
                     lineBoxes.add(&box);
                 }
             } else if (o->isText() || (o->isRenderInline() && !walker.atEndOfInline())) {
@@ skipping 164 matching lines @@
 }
 
 void RenderBlock::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     // Avoid painting descendants of the root element when stylesheets haven't loaded.  This eliminates FOUC.
     // It's ok not to draw, because later on, when all the stylesheets do load, styleResolverChanged() on the Document
     // will do a full paint invalidation.
     if (document().didLayoutWithPendingStylesheets() && !isRenderView())
         return;
 
-    if (childrenInline())
+    if (isRenderParagraph())
         m_lineBoxes.paint(this, paintInfo, paintOffset);
     else {
         PaintPhase newPhase = (paintInfo.phase == PaintPhaseChildOutlines) ? PaintPhaseOutline : paintInfo.phase;
         newPhase = (newPhase == PaintPhaseChildBlockBackgrounds) ? PaintPhaseChildBlockBackground : newPhase;
 
         // We don't paint our own background, but we do let the kids paint their backgrounds.
         PaintInfo paintInfoForChild(paintInfo);
         paintInfoForChild.phase = newPhase;
         paintInfoForChild.updatePaintingRootForChildren(this);
         paintChildren(paintInfoForChild, paintOffset);
@@ skipping 242 matching lines @@
         return result;
 
     if (hasTransform()) {
         // FIXME: We should learn how to gap fill multiple columns and transforms eventually.
         lastLogicalTop = rootBlock->blockDirectionOffset(offsetFromRootBlock) + logicalHeight();
         lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, logicalHeight());
         lastLogicalRight = logicalRightSelectionOffset(rootBlock, logicalHeight());
         return result;
     }
 
-    if (childrenInline())
+    if (isRenderParagraph())
         result = toRenderBlockFlow(this)->inlineSelectionGaps(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight, paintInfo);
     else
         result = blockSelectionGaps(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight, paintInfo);
 
     // Go ahead and fill the vertical gap all the way to the bottom of our block if the selection extends past our block.
     if (rootBlock == this && (selectionState() != SelectionBoth && selectionState() != SelectionEnd))
         result.uniteCenter(blockSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight,
                                              logicalHeight(), paintInfo));
     return result;
 }
@@ skipping 478 matching lines @@
             if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
                 return true;
         }
     }
 
     return false;
 }
 
 bool RenderBlock::hitTestContents(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         // We have to hit-test our line boxes.
         if (m_lineBoxes.hitTest(this, request, result, locationInContainer, accumulatedOffset, hitTestAction))
             return true;
     } else {
         // Hit test our children.
         HitTestAction childHitTest = hitTestAction;
         if (hitTestAction == HitTestChildBlockBackgrounds)
             childHitTest = HitTestChildBlockBackground;
         for (RenderBox* child = lastChildBox(); child; child = child->previousSiblingBox()) {
             if (!child->hasSelfPaintingLayer() && child->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, childHitTest))
@@ skipping 57 matching lines @@
     // Otherwise return before or after the child, depending on if the click was to the logical left or logical right of the child
     LayoutUnit childMiddle = parent->logicalWidthForChild(child) / 2;
     LayoutUnit logicalLeft = pointInChildCoordinates.x();
     if (logicalLeft < childMiddle)
         return ancestor->createPositionWithAffinity(childNode->nodeIndex(), DOWNSTREAM);
     return ancestor->createPositionWithAffinity(childNode->nodeIndex() + 1, UPSTREAM);
 }
 
 PositionWithAffinity RenderBlock::positionForPointWithInlineChildren(const LayoutPoint& pointInLogicalContents)
 {
-    ASSERT(childrenInline());
+    ASSERT(isRenderParagraph());
 
     if (!firstRootBox())
         return createPositionWithAffinity(0, DOWNSTREAM);
 
     // look for the closest line box in the root box which is at the passed-in y coordinate
     InlineBox* closestBox = 0;
     RootInlineBox* firstRootBoxWithChildren = 0;
     RootInlineBox* lastRootBoxWithChildren = 0;
     for (RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox()) {
         if (!root->firstLeafChild())
@@ skipping 75 matching lines @@
         if (pointLogicalTop < 0)
             return createPositionWithAffinity(caretMinOffset(), DOWNSTREAM);
         if (pointLogicalTop >= logicalHeight())
             return createPositionWithAffinity(caretMaxOffset(), DOWNSTREAM);
     }
 
     LayoutPoint pointInContents = point;
     offsetForContents(pointInContents);
     LayoutPoint pointInLogicalContents(pointInContents);
 
-    if (childrenInline())
+    if (isRenderParagraph())
         return positionForPointWithInlineChildren(pointInLogicalContents);
 
     RenderBox* lastCandidateBox = lastChildBox();
     while (lastCandidateBox && !isChildHitTestCandidate(lastCandidateBox))
         lastCandidateBox = lastCandidateBox->previousSiblingBox();
 
     if (lastCandidateBox) {
         if (pointInLogicalContents.y() > logicalTopForChild(lastCandidateBox)
             || (pointInLogicalContents.y() == logicalTopForChild(lastCandidateBox)))
             return positionForPointRespectingEditingBoundaries(this, lastCandidateBox, pointInContents);
@@ skipping 18 matching lines @@
         offset += scrolledContentOffset();
 }
 
 LayoutUnit RenderBlock::availableLogicalWidth() const
 {
     return RenderBox::availableLogicalWidth();
 }
 
 void RenderBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         // FIXME: Remove this const_cast.
         toRenderBlockFlow(const_cast<RenderBlock*>(this))->computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
     } else {
         computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
     }
 
     maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
 }
 
 void RenderBlock::computePreferredLogicalWidths()
@@ skipping 136 matching lines @@
 LayoutUnit RenderBlock::minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const
 {
     if (!(style(isFirstLine)->lineBoxContain() & LineBoxContainBlock))
         return 0;
 
     return std::max<LayoutUnit>(replacedHeight, lineHeight(isFirstLine, HorizontalLine, PositionOfInteriorLineBoxes));
 }
 
 int RenderBlock::firstLineBoxBaseline() const
 {
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         if (firstLineBox())
             return firstLineBox()->logicalTop() + style(true)->fontMetrics().ascent(firstRootBox()->baselineType());
         else
             return -1;
     }
     else {
         for (RenderBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
             if (!curr->isFloatingOrOutOfFlowPositioned()) {
                 int result = curr->firstLineBoxBaseline();
                 if (result != -1)
@@ skipping 10 matching lines @@
     if (!style()->isOverflowVisible()) {
         // We are not calling RenderBox::baselinePosition here because the caller should add the margin-top/margin-right, not us.
         return direction == HorizontalLine ? height() + m_marginBox.bottom() : width() + m_marginBox.left();
     }
 
     return lastLineBoxBaseline(direction);
 }
 
 int RenderBlock::lastLineBoxBaseline(LineDirectionMode lineDirection) const
 {
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         if (!firstLineBox() && hasLineIfEmpty()) {
             const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
             return fontMetrics.ascent()
                  + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
                  + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
         }
         if (lastLineBox())
             return lastLineBox()->logicalTop() + style(lastLineBox() == firstLineBox())->fontMetrics().ascent(lastRootBox()->baselineType());
         return -1;
     } else {
@@ skipping 46 matching lines @@
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(RenderObject* obj)
 {
     return !obj->isFloatingOrOutOfFlowPositioned()
         && obj->isRenderBlock() && obj->style()->height().isAuto();
 }
 
 static int getHeightForLineCount(RenderBlock* block, int l, bool includeBottom, int& count)
 {
-    if (block->isRenderBlockFlow() && block->childrenInline()) {
+    if (block->isRenderBlockFlow() && block->isRenderParagraph()) {

[ojan, 2014/11/21 22:55:10]

Nit: this is redundant. RenderParagraphs are always RenderBlockFlows.

[rafaelw, 2014/11/21 23:13:54]

Done.

         for (RootInlineBox* box = toRenderBlockFlow(block)->firstRootBox(); box; box = box->nextRootBox()) {
             if (++count == l)
                 return box->lineBottom() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
         }
     } else {
         RenderBox* normalFlowChildWithoutLines = 0;
         for (RenderBox* obj = block->firstChildBox(); obj; obj = obj->nextSiblingBox()) {
             if (shouldCheckLines(obj)) {
                 int result = getHeightForLineCount(toRenderBlock(obj), l, false, count);
                 if (result != -1)
                     return result + obj->y() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
             } else if (!obj->isFloatingOrOutOfFlowPositioned()) {
                 normalFlowChildWithoutLines = obj;
             }
         }
         if (normalFlowChildWithoutLines && l == 0)
             return normalFlowChildWithoutLines->y() + normalFlowChildWithoutLines->height();
     }
 
     return -1;
 }
 
 RootInlineBox* RenderBlock::lineAtIndex(int i) const
 {
     ASSERT(i >= 0);
 
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox())
             if (!i--)
                 return box;
     } else {
         for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
             if (!shouldCheckLines(child))
                 continue;
             if (RootInlineBox* box = toRenderBlock(child)->lineAtIndex(i))
                 return box;
         }
     }
 
     return 0;
 }
 
 int RenderBlock::lineCount(const RootInlineBox* stopRootInlineBox, bool* found) const
 {
     int count = 0;
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
             count++;
             if (box == stopRootInlineBox) {
                 if (found)
                     *found = true;
                 break;
             }
         }
     } else {
         for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling())
@@ skipping 11 matching lines @@
 }
 
 int RenderBlock::heightForLineCount(int l)
 {
     int count = 0;
     return getHeightForLineCount(this, l, true, count);
 }
 
 void RenderBlock::clearTruncation()
 {
-    if (childrenInline() && hasMarkupTruncation()) {
+    if (isRenderParagraph() && hasMarkupTruncation()) {
         setHasMarkupTruncation(false);
         for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox())
             box->clearTruncation();
     } else {
         for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling()) {
             if (shouldCheckLines(obj))
                 toRenderBlock(obj)->clearTruncation();
         }
     }
 }
@@ skipping 107 matching lines @@
     return toRenderBlock(renderer)->recalcOverflowAfterStyleChange();
 }
 
 bool RenderBlock::recalcChildOverflowAfterStyleChange()
 {
     ASSERT(childNeedsOverflowRecalcAfterStyleChange());
     setChildNeedsOverflowRecalcAfterStyleChange(false);
 
     bool childrenOverflowChanged = false;
 
-    if (childrenInline()) {
+    if (isRenderParagraph()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             RenderObject* renderer = walker.current();
             if (recalcNormalFlowChildOverflowIfNeeded(renderer)) {
                 childrenOverflowChanged = true;
                 if (InlineBox* inlineBoxWrapper = toRenderBlock(renderer)->inlineBoxWrapper())
                     lineBoxes.add(&inlineBoxWrapper->root());
             }
         }
 
@@ skipping 77 matching lines @@
 void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
 {
     showRenderObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink