Separate method for calculating logical height based on CSS properties.

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

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 343 matching lines @@
   // nor what authors expect.
   // FIXME: When we convert to sub-pixel layout for tables we can remove the int
   // conversion. http://crbug.com/241198
   ASSERT(logicalWidth().floor() >= minPreferredLogicalWidth().floor());
 }
 
 // This method takes a ComputedStyle's logical width, min-width, or max-width
 // length and computes its actual value.
 LayoutUnit LayoutTable::convertStyleLogicalWidthToComputedWidth(
     const Length& styleLogicalWidth,
-    LayoutUnit availableWidth) {
+    LayoutUnit availableWidth) const {
   if (styleLogicalWidth.isIntrinsic())
     return computeIntrinsicLogicalWidthUsing(
         styleLogicalWidth, availableWidth,
         bordersPaddingAndSpacingInRowDirection());
 
   // HTML tables' width styles already include borders and paddings, but CSS
   // tables' width styles do not.
   LayoutUnit borders;
   bool isCSSTable = !isHTMLTableElement(node());
   if (isCSSTable && styleLogicalWidth.isSpecified() &&
       styleLogicalWidth.isPositive() &&
       style()->boxSizing() == BoxSizingContentBox)
     borders =
         borderStart() + borderEnd() +
         (collapseBorders() ? LayoutUnit() : paddingStart() + paddingEnd());
 
   return minimumValueForLength(styleLogicalWidth, availableWidth) + borders;
 }
 
 LayoutUnit LayoutTable::convertStyleLogicalHeightToComputedHeight(
-    const Length& styleLogicalHeight) {
+    const Length& styleLogicalHeight) const {
   LayoutUnit borderAndPaddingBefore =
       borderBefore() + (collapseBorders() ? LayoutUnit() : paddingBefore());
   LayoutUnit borderAndPaddingAfter =
       borderAfter() + (collapseBorders() ? LayoutUnit() : paddingAfter());
   LayoutUnit borderAndPadding = borderAndPaddingBefore + borderAndPaddingAfter;
   LayoutUnit computedLogicalHeight;
   if (styleLogicalHeight.isFixed()) {
     // HTML tables size as though CSS height includes border/padding, CSS tables
     // do not.
     LayoutUnit borders = LayoutUnit();
@@ skipping 52 matching lines @@
   if (m_columnLogicalWidthChanged)
     layouter.setChildNeedsLayout(&section);
   if (!section.needsLayout())
     markChildForPaginationRelayoutIfNeeded(section, layouter);
   section.layoutIfNeeded();
   int sectionLogicalHeight = section.calcRowLogicalHeight();
   section.setLogicalHeight(LayoutUnit(sectionLogicalHeight));
   setLogicalHeight(logicalHeight() + sectionLogicalHeight);
 }
 
+LayoutUnit LayoutTable::logicalHeightFromStyle() const {
+  LayoutUnit computedLogicalHeight;
+  Length logicalHeightLength = style()->logicalHeight();
+  if (logicalHeightLength.isIntrinsic() ||
+      (logicalHeightLength.isSpecified() && logicalHeightLength.isPositive())) {
+    computedLogicalHeight =
+        convertStyleLogicalHeightToComputedHeight(logicalHeightLength);
+  }
+
+  Length logicalMaxHeightLength = style()->logicalMaxHeight();
+  if (logicalMaxHeightLength.isIntrinsic() ||
+      (logicalMaxHeightLength.isSpecified() &&
+       !logicalMaxHeightLength.isNegative())) {
+    LayoutUnit computedMaxLogicalHeight =
+        convertStyleLogicalHeightToComputedHeight(logicalMaxHeightLength);
+    computedLogicalHeight =
+        std::min(computedLogicalHeight, computedMaxLogicalHeight);
+  }
+
+  Length logicalMinHeightLength = style()->logicalMinHeight();
+  if (logicalMinHeightLength.isIntrinsic() ||
+      (logicalMinHeightLength.isSpecified() &&
+       !logicalMinHeightLength.isNegative())) {
+    LayoutUnit computedMinLogicalHeight =
+        convertStyleLogicalHeightToComputedHeight(logicalMinHeightLength);
+    computedLogicalHeight =
+        std::max(computedLogicalHeight, computedMinLogicalHeight);
+  }
+
+  return computedLogicalHeight;
+}
+
 void LayoutTable::distributeExtraLogicalHeight(int extraLogicalHeight) {
   if (extraLogicalHeight <= 0)
     return;
 
   // FIXME: Distribute the extra logical height between all table sections
   // instead of giving it all to the first one.
   if (LayoutTableSection* section = firstBody())
     extraLogicalHeight -=
         section->distributeExtraLogicalHeightToRows(extraLogicalHeight);
 
@@ skipping 138 matching lines @@
         DCHECK(child->isTableCaption());
       }
     }
 
     // Lay out table footer.
     if (LayoutTableSection* section = footer())
       layoutSection(*section, layouter, sectionLogicalLeft);
 
     setLogicalHeight(tableBoxLogicalTop + borderAndPaddingBefore);
 
-    LayoutUnit computedLogicalHeight;
-
-    Length logicalHeightLength = style()->logicalHeight();
-    if (logicalHeightLength.isIntrinsic() ||
-        (logicalHeightLength.isSpecified() && logicalHeightLength.isPositive()))
-      computedLogicalHeight =
-          convertStyleLogicalHeightToComputedHeight(logicalHeightLength);
-
-    Length logicalMaxHeightLength = style()->logicalMaxHeight();
-    if (logicalMaxHeightLength.isIntrinsic() ||
-        (logicalMaxHeightLength.isSpecified() &&
-         !logicalMaxHeightLength.isNegative())) {
-      LayoutUnit computedMaxLogicalHeight =
-          convertStyleLogicalHeightToComputedHeight(logicalMaxHeightLength);
-      computedLogicalHeight =
-          std::min(computedLogicalHeight, computedMaxLogicalHeight);
-    }
-
-    Length logicalMinHeightLength = style()->logicalMinHeight();
-    if (logicalMinHeightLength.isIntrinsic() ||
-        (logicalMinHeightLength.isSpecified() &&
-         !logicalMinHeightLength.isNegative())) {
-      LayoutUnit computedMinLogicalHeight =
-          convertStyleLogicalHeightToComputedHeight(logicalMinHeightLength);
-      computedLogicalHeight =
-          std::max(computedLogicalHeight, computedMinLogicalHeight);
-    }
-
+    LayoutUnit computedLogicalHeight = logicalHeightFromStyle();
     LayoutUnit totalSectionLogicalHeight;
     if (topSection) {
       totalSectionLogicalHeight =
           bottomSection->logicalBottom() - topSection->logicalTop();
     }
 
     distributeExtraLogicalHeight(
         floorToInt(computedLogicalHeight - totalSectionLogicalHeight));
 
     bool isPaginated = view()->layoutState()->isPaginated();
@@ skipping 1024 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink