Split more Paragraph-specific code from RenderBlock into RenderParagraph

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 65 matching lines @@
 
 typedef WTF::HashSet<RenderBlock*> DelayedUpdateScrollInfoSet;
 static int gDelayUpdateScrollInfo = 0;
 static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = 0;
 
 RenderBlock::RenderBlock(ContainerNode* node)
     : RenderBox(node)
     , m_hasMarginBeforeQuirk(false)
     , m_hasMarginAfterQuirk(false)
     , m_beingDestroyed(false)
-    , m_hasMarkupTruncation(false)
     , m_hasBorderOrPaddingLogicalWidthChanged(false)
 {
 }
 
 static void removeBlockFromDescendantAndContainerMaps(RenderBlock* block, TrackedDescendantsMap*& descendantMap, TrackedContainerMap*& containerMap)
 {
     if (OwnPtr<TrackedRendererListHashSet> descendantSet = descendantMap->take(block)) {
         TrackedRendererListHashSet::iterator end = descendantSet->end();
         for (TrackedRendererListHashSet::iterator descendant = descendantSet->begin(); descendant != end; ++descendant) {
             TrackedContainerMap::iterator it = containerMap->find(*descendant);
@@ skipping 781 matching lines @@
 
     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 (isRenderParagraph())
-        result = toRenderBlockFlow(this)->inlineSelectionGaps(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight, paintInfo);
+        result = toRenderParagraph(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 811 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 (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)
-                    return curr->logicalTop() + result; // Translate to our coordinate space.
-            }
+    for (RenderBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
+        if (!curr->isFloatingOrOutOfFlowPositioned()) {
+            int result = curr->firstLineBoxBaseline();
+            if (result != -1)
+                return curr->logicalTop() + result; // Translate to our coordinate space.
         }
     }
 
     return -1;
 }
 
 int RenderBlock::inlineBlockBaseline(LineDirectionMode direction) const
 {
     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 (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());
+    bool haveNormalFlowChild = false;
+    for (RenderBox* curr = lastChildBox(); curr; curr = curr->previousSiblingBox()) {
+        if (!curr->isFloatingOrOutOfFlowPositioned()) {
+            haveNormalFlowChild = true;
+            int result = curr->inlineBlockBaseline(lineDirection);
+            if (result != -1)
+                return curr->logicalTop() + result; // Translate to our coordinate space.
         }
-        if (lastLineBox())
-            return lastLineBox()->logicalTop() + style(lastLineBox() == firstLineBox())->fontMetrics().ascent(lastRootBox()->baselineType());
-        return -1;
-    } else {
-        bool haveNormalFlowChild = false;
-        for (RenderBox* curr = lastChildBox(); curr; curr = curr->previousSiblingBox()) {
-            if (!curr->isFloatingOrOutOfFlowPositioned()) {
-                haveNormalFlowChild = true;
-                int result = curr->inlineBlockBaseline(lineDirection);
-                if (result != -1)
-                    return curr->logicalTop() + result; // Translate to our coordinate space.
-            }
-        }
-        if (!haveNormalFlowChild && hasLineIfEmpty()) {
-            const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
-            return fontMetrics.ascent()
-                 + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
-                 + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
-        }
+    }
+    if (!haveNormalFlowChild && hasLineIfEmpty()) {
+        const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
+        return fontMetrics.ascent()
+             + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
+             + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
     }
 
     return -1;
 }
 
 RenderBlock* RenderBlock::firstLineBlock() const
 {
     RenderBlock* firstLineBlock = const_cast<RenderBlock*>(this);
     bool hasPseudo = false;
     while (true) {
@@ skipping 21 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->isRenderParagraph()) {
-        for (RootInlineBox* box = toRenderBlockFlow(block)->firstRootBox(); box; box = box->nextRootBox()) {
-            if (++count == l)
-                return box->lineBottom() + (includeBottom ? (block->borderBottom() + block->paddingBottom()) : LayoutUnit());
+    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;
         }
-    } 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();
     }
+    if (normalFlowChildWithoutLines && l == 0)
+        return normalFlowChildWithoutLines->y() + normalFlowChildWithoutLines->height();
 
     return -1;
 }
 
 RootInlineBox* RenderBlock::lineAtIndex(int i) const
 {
     ASSERT(i >= 0);
 
-    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;
-        }
+    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 (isRenderParagraph()) {
-        for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
-            count++;
-            if (box == stopRootInlineBox) {
+    for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling()) {
+        if (shouldCheckLines(obj)) {
+            bool recursiveFound = false;
+            count += toRenderBlock(obj)->lineCount(stopRootInlineBox, &recursiveFound);
+            if (recursiveFound) {
                 if (found)
                     *found = true;
                 break;
             }
         }
-    } else {
-        for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling())
-            if (shouldCheckLines(obj)) {
-                bool recursiveFound = false;
-                count += toRenderBlock(obj)->lineCount(stopRootInlineBox, &recursiveFound);
-                if (recursiveFound) {
-                    if (found)
-                        *found = true;
-                    break;
-                }
-            }
     }
+
     return count;
 }
 
-int RenderBlock::heightForLineCount(int l)
-{
-    int count = 0;
-    return getHeightForLineCount(this, l, true, count);
-}
-
 void RenderBlock::clearTruncation()
 {
-    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();
-        }
+    for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling()) {
+        if (shouldCheckLines(obj))
+            toRenderBlock(obj)->clearTruncation();
     }
 }
 
 void RenderBlock::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     rects.append(pixelSnappedIntRect(accumulatedOffset, size()));
 }
 
 void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads) const
 {
@@ skipping 197 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