Move LayoutDeprecatedFlexibleBox-specific line handling.

third_party/WebKit/Source/core/layout/LayoutDeprecatedFlexibleBox.cpp

 /*
  * This file is part of the layout object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * 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 103 matching lines @@
     LayoutDeprecatedFlexibleBox* m_box;
     LayoutBox* m_currentChild;
     bool m_forward;
     unsigned m_currentOrdinal;
     unsigned m_largestOrdinal;
     HashSet<unsigned> m_ordinalValues;
     Vector<unsigned> m_sortedOrdinalValues;
     int m_ordinalIteration;
 };
 
+// Helper methods for obtaining the last line, computing line counts and heights for line counts
+// (crawling into blocks).
+static bool shouldCheckLines(LayoutBlockFlow* blockFlow)
+{
+    return !blockFlow->isFloatingOrOutOfFlowPositioned() && blockFlow->style()->height().isAuto();
+}
+
+static int getHeightForLineCount(const LayoutBlockFlow* blockFlow, int lineCount, bool includeBottom, int& count)
+{
+    if (blockFlow->style()->visibility() != VISIBLE)
+        return -1;
+    if (blockFlow->childrenInline()) {
+        for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
+            if (++count == lineCount)
+                return box->lineBottom() + (includeBottom ? (blockFlow->borderBottom() + blockFlow->paddingBottom()) : LayoutUnit());
+        }
+        return -1;
+    }
+
+    LayoutBox* normalFlowChildWithoutLines = nullptr;
+    for (LayoutBox* obj = blockFlow->firstChildBox(); obj; obj = obj->nextSiblingBox()) {
+        if (obj->isLayoutBlockFlow() && shouldCheckLines(toLayoutBlockFlow(obj))) {
+            int result = getHeightForLineCount(toLayoutBlockFlow(obj), lineCount, false, count);
+            if (result != -1)
+                return result + obj->location().y() + (includeBottom ? (blockFlow->borderBottom() + blockFlow->paddingBottom()) : LayoutUnit());
+        } else if (!obj->isFloatingOrOutOfFlowPositioned()) {
+            normalFlowChildWithoutLines = obj;
+        }
+    }
+    if (normalFlowChildWithoutLines && lineCount == 0)
+        return normalFlowChildWithoutLines->location().y() + normalFlowChildWithoutLines->size().height();
+
+    return -1;
+}
+
+static RootInlineBox* lineAtIndex(const LayoutBlockFlow* blockFlow, int i)
+{
+    ASSERT(i >= 0);
+
+    if (blockFlow->style()->visibility() != VISIBLE)
+        return nullptr;
+
+    if (blockFlow->childrenInline()) {
+        for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
+            if (!i--)
+                return box;
+        }
+        return nullptr;
+    }
+    for (LayoutObject* child = blockFlow->firstChild(); child; child = child->nextSibling()) {
+        if (!child->isLayoutBlockFlow())
+            continue;
+        LayoutBlockFlow* childBlockFlow = toLayoutBlockFlow(child);
+        if (!shouldCheckLines(childBlockFlow))
+            continue;
+        if (RootInlineBox* box = lineAtIndex(childBlockFlow, i))
+            return box;
+    }
+
+    return nullptr;
+}
+
+static int lineCount(const LayoutBlockFlow* blockFlow, const RootInlineBox* stopRootInlineBox = nullptr, bool* found = nullptr)
+{
+    if (blockFlow->style()->visibility() != VISIBLE)
+        return 0;
+    int count = 0;
+    if (blockFlow->childrenInline()) {
+        for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
+            count++;
+            if (box == stopRootInlineBox) {
+                if (found)
+                    *found = true;
+                break;
+            }
+        }
+        return count;
+    }
+    for (LayoutObject* obj = blockFlow->firstChild(); obj; obj = obj->nextSibling()) {
+        if (!obj->isLayoutBlockFlow())
+            continue;
+        LayoutBlockFlow* childBlockFlow = toLayoutBlockFlow(obj);
+        if (!shouldCheckLines(childBlockFlow))
+            continue;
+        bool recursiveFound = false;
+        count += lineCount(childBlockFlow, stopRootInlineBox, &recursiveFound);
+        if (recursiveFound) {
+            if (found)
+                *found = true;
+            break;
+        }
+    }
+    return count;
+}
+
+static void clearTruncation(LayoutBlockFlow* blockFlow)
+{
+    if (blockFlow->style()->visibility() != VISIBLE)
+        return;
+    if (blockFlow->childrenInline() && blockFlow->hasMarkupTruncation()) {
+        blockFlow->setHasMarkupTruncation(false);
+        for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox())
+            box->clearTruncation();
+        return;
+    }
+    for (LayoutObject* obj = blockFlow->firstChild(); obj; obj = obj->nextSibling()) {
+        if (!obj->isLayoutBlockFlow())
+            continue;
+        LayoutBlockFlow* childBlockFlow = toLayoutBlockFlow(obj);
+        if (shouldCheckLines(childBlockFlow))
+            clearTruncation(childBlockFlow);
+    }
+}
+
 LayoutDeprecatedFlexibleBox::LayoutDeprecatedFlexibleBox(Element& element)
     : LayoutBlock(&element)
 {
     ASSERT(!childrenInline());
     m_stretchingChildren = false;
     if (!isAnonymous()) {
         const KURL& url = document().url();
         if (url.protocolIs("chrome"))
             UseCounter::count(document(), UseCounter::DeprecatedFlexboxChrome);
         else if (url.protocolIs("chrome-extension"))
@@ skipping 711 matching lines @@
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
             continue;
 
         child->clearOverrideSize();
         if (relayoutChildren || (child->isAtomicInlineLevel() && (child->style()->width().hasPercent() || child->style()->height().hasPercent()))
             || (child->style()->height().isAuto() && child->isLayoutBlock())) {
             child->setChildNeedsLayout(MarkOnlyThis);
 
             // Dirty all the positioned objects.
-            if (child->isLayoutBlock()) {
-                toLayoutBlock(child)->markPositionedObjectsForLayout();
-                toLayoutBlock(child)->clearTruncation();
+            if (child->isLayoutBlockFlow()) {
+                toLayoutBlockFlow(child)->markPositionedObjectsForLayout();
+                clearTruncation(toLayoutBlockFlow(child));
             }
         }
         child->layoutIfNeeded();
-        if (child->style()->height().isAuto() && child->isLayoutBlock())
-            maxLineCount = std::max(maxLineCount, toLayoutBlock(child)->lineCount());
+        if (child->style()->height().isAuto() && child->isLayoutBlockFlow())
+            maxLineCount = std::max(maxLineCount, lineCount(toLayoutBlockFlow(child)));
     }
 
     // Get the number of lines and then alter all block flow children with auto height to use the
     // specified height. We always try to leave room for at least one line.
     LineClampValue lineClamp = style()->lineClamp();
     int numVisibleLines = lineClamp.isPercentage() ? std::max(1, (maxLineCount + 1) * lineClamp.value() / 100) : lineClamp.value();
     if (numVisibleLines >= maxLineCount)
         return;
 
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
-        if (childDoesNotAffectWidthOrFlexing(child) || !child->style()->height().isAuto() || !child->isLayoutBlock())
+        if (childDoesNotAffectWidthOrFlexing(child) || !child->style()->height().isAuto() || !child->isLayoutBlockFlow())
             continue;
 
-        LayoutBlock* blockChild = toLayoutBlock(child);
-        int lineCount = blockChild->lineCount();
+        LayoutBlockFlow* blockChild = toLayoutBlockFlow(child);
+        int lineCount = blink::lineCount(blockChild);
         if (lineCount <= numVisibleLines)
             continue;
 
-        LayoutUnit newHeight(blockChild->heightForLineCount(numVisibleLines));
+        int dummyCount = 0;
+        LayoutUnit newHeight(getHeightForLineCount(blockChild, numVisibleLines, true, dummyCount));
         if (newHeight == child->size().height())
             continue;
 
         child->setOverrideLogicalContentHeight(newHeight - child->borderAndPaddingHeight());
         child->forceChildLayout();
 
         // FIXME: For now don't support RTL.
         if (style()->direction() != LTR)
             continue;
 
         // Get the last line
-        RootInlineBox* lastLine = blockChild->lineAtIndex(lineCount - 1);
+        RootInlineBox* lastLine = lineAtIndex(blockChild, lineCount - 1);
         if (!lastLine)
             continue;
 
-        RootInlineBox* lastVisibleLine = blockChild->lineAtIndex(numVisibleLines - 1);
+        RootInlineBox* lastVisibleLine = lineAtIndex(blockChild, numVisibleLines - 1);
         if (!lastVisibleLine)
             continue;
 
         DEFINE_STATIC_LOCAL(AtomicString, ellipsisStr, (&horizontalEllipsisCharacter, 1));
         const Font& font = style(numVisibleLines == 1)->font();
         float totalWidth = font.width(constructTextRun(font, &horizontalEllipsisCharacter, 1, styleRef(), style()->direction()));
 
         // See if this width can be accommodated on the last visible line
         LineLayoutBlockFlow destBlock = lastVisibleLine->block();
         LineLayoutBlockFlow srcBlock = lastLine->block();
@@ skipping 23 matching lines @@
     FlexBoxIterator iterator(this);
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
             continue;
 
         child->clearOverrideSize();
         if ((child->isAtomicInlineLevel() && (child->style()->width().hasPercent() || child->style()->height().hasPercent()))
             || (child->style()->height().isAuto() && child->isLayoutBlock())) {
             child->setChildNeedsLayout();
 
-            if (child->isLayoutBlock()) {
-                toLayoutBlock(child)->markPositionedObjectsForLayout();
-                toLayoutBlock(child)->clearTruncation();
+            if (child->isLayoutBlockFlow()) {
+                toLayoutBlockFlow(child)->markPositionedObjectsForLayout();
+                clearTruncation(toLayoutBlockFlow(child));
             }
         }
     }
 }
 
 void LayoutDeprecatedFlexibleBox::placeChild(LayoutBox* child, const LayoutPoint& location)
 {
     // FIXME Investigate if this can be removed based on other flags. crbug.com/370010
     child->setMayNeedPaintInvalidation();
 
@@ skipping 43 matching lines @@
     if (minHeight.isFixed() || minHeight.isAuto()) {
         LayoutUnit minHeight(child->style()->minHeight().value());
         LayoutUnit height = contentHeightForChild(child);
         LayoutUnit allowedShrinkage = (minHeight - height).clampPositiveToZero();
         return allowedShrinkage;
     }
     return LayoutUnit();
 }
 
 } // namespace blink