Lay out table children in visual order, and set position and size.

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 394 matching lines @@
   } else if (styleLogicalHeight.isIntrinsic()) {
     computedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(
         styleLogicalHeight, logicalHeight() - borderAndPadding,
         borderAndPadding);
   } else {
     ASSERT_NOT_REACHED();
   }
   return computedLogicalHeight.clampNegativeToZero();
 }
 
-void LayoutTable::layoutCaption(LayoutTableCaption& caption) {
+void LayoutTable::layoutCaption(LayoutTableCaption& caption,
+                                SubtreeLayoutScope& layouter) {
+  if (!caption.needsLayout())
+    markChildForPaginationRelayoutIfNeeded(caption, layouter);
   if (caption.needsLayout()) {
     // The margins may not be available but ensure the caption is at least
     // located beneath any previous sibling caption so that it does not
     // mistakenly think any floats in the previous caption intrude into it.
     caption.setLogicalLocation(
         LayoutPoint(caption.marginStart(),
                     collapsedMarginBeforeForChild(caption) + logicalHeight()));
     // If LayoutTableCaption ever gets a layout() function, use it here.
     caption.layoutIfNeeded();
   }
   // Apply the margins to the location now that they are definitely available
   // from layout
   LayoutUnit captionLogicalTop =
       collapsedMarginBeforeForChild(caption) + logicalHeight();
   caption.setLogicalLocation(
       LayoutPoint(caption.marginStart(), captionLogicalTop));
 
   if (!selfNeedsLayout())
     caption.setMayNeedPaintInvalidation();
 
   setLogicalHeight(logicalHeight() + caption.logicalHeight() +
                    collapsedMarginBeforeForChild(caption) +
                    collapsedMarginAfterForChild(caption));
 }
 
+void LayoutTable::layoutSection(LayoutTableSection& section,
+                                SubtreeLayoutScope& layouter,
+                                LayoutUnit logicalLeft) {
+  section.setLogicalLocation(LayoutPoint(logicalLeft, logicalHeight()));
+  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);
+}
+
 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 55 matching lines @@
   TextAutosizer::LayoutScope textAutosizerLayoutScope(this);
 
   recalcSectionsIfNeeded();
   // FIXME: We should do this recalc lazily in borderStart/borderEnd so that we
   // don't have to make sure to call this before we call borderStart/borderEnd
   // to avoid getting a stale value.
   recalcBordersInRowDirection();
 
   SubtreeLayoutScope layouter(*this);
 
-  // If any table section moved vertically, we will just issue paint
-  // invalidations for everything from that section down (it is quite unlikely
-  // that any of the following sections did not shift).
-  bool sectionMoved = false;
   {
     LayoutState state(*this, locationOffset());
     LayoutUnit oldLogicalWidth = logicalWidth();
     LayoutUnit oldLogicalHeight = logicalHeight();
 
     setLogicalHeight(LayoutUnit());
     updateLogicalWidth();
 
     if (logicalWidth() != oldLogicalWidth) {
       for (unsigned i = 0; i < m_captions.size(); i++)
         layouter.setNeedsLayout(m_captions[i],
                                 LayoutInvalidationReason::TableChanged);
     }
     // FIXME: The optimisation below doesn't work since the internal table
     // layout could have changed. We need to add a flag to the table
     // layout that tells us if something has changed in the min max
     // calculations to do it correctly.
     // if ( oldWidth != width() || columns.size() + 1 != columnPos.size() )
     m_tableLayout->layout();
 
-    LayoutUnit totalSectionLogicalHeight;
-    LayoutUnit oldTableLogicalTop;
-    for (unsigned i = 0; i < m_captions.size(); i++)
-      oldTableLogicalTop += m_captions[i]->logicalHeight() +
-                            m_captions[i]->marginBefore() +
-                            m_captions[i]->marginAfter();
+    // Lay out top captions.
+    // FIXME: Collapse caption margin.
+    for (unsigned i = 0; i < m_captions.size(); i++) {
+      if (m_captions[i]->style()->captionSide() == ECaptionSide::Bottom)
+        continue;
+      layoutCaption(*m_captions[i], layouter);
+    }
+
+    LayoutTableSection* topSection = this->topSection();
+    LayoutTableSection* bottomSection = this->bottomSection();
+
+    // This is the border-before edge of the "table box", relative to the "table
+    // wrapper box", i.e. right after all top captions.
+    // https://www.w3.org/TR/2011/REC-CSS2-20110607/tables.html#model
+    LayoutUnit tableBoxLogicalTop = logicalHeight();
 
     bool collapsing = collapseBorders();
-
-    for (LayoutObject* child = firstChild(); child;
-         child = child->nextSibling()) {
-      if (!child->needsLayout() && child->isBox())
-        markChildForPaginationRelayoutIfNeeded(*toLayoutBox(child), layouter);
-      if (child->isTableSection()) {
-        LayoutTableSection* section = toLayoutTableSection(child);
-        if (m_columnLogicalWidthChanged)
-          layouter.setChildNeedsLayout(section);
-        section->layoutIfNeeded();
-        totalSectionLogicalHeight += section->calcRowLogicalHeight();
-        if (collapsing)
-          section->recalcOuterBorder();
-        ASSERT(!section->needsLayout());
-      } else if (child->isLayoutTableCol()) {
-        child->layoutIfNeeded();
-        ASSERT(!child->needsLayout());
-      } else {
-        // FIXME: We should never have other type of children (they should be
-        // wrapped in an anonymous table section) but our code is too crazy and
-        // this can happen in practice. Until this is fixed, let's make sure we
-        // don't leave non laid out children in the tree.
-        child->layoutIfNeeded();
-      }
-    }
-
-    // FIXME: Collapse caption margin.
-    if (!m_captions.isEmpty()) {
-      for (unsigned i = 0; i < m_captions.size(); i++) {
-        if (m_captions[i]->style()->captionSide() == ECaptionSide::Bottom)
-          continue;
-        layoutCaption(*m_captions[i]);
-      }
-      sectionMoved = logicalHeight() != oldTableLogicalTop;
+    if (collapsing) {
+      // Need to set up the table borders before we can position the sections.
+      for (LayoutTableSection* section = topSection; section;
+           section = sectionBelow(section))
+        section->recalcOuterBorder();
     }
 
     LayoutUnit borderAndPaddingBefore =
         borderBefore() + (collapsing ? LayoutUnit() : paddingBefore());
     LayoutUnit borderAndPaddingAfter =
         borderAfter() + (collapsing ? LayoutUnit() : paddingAfter());
 
-    setLogicalHeight(logicalHeight() + borderAndPaddingBefore);
+    setLogicalHeight(tableBoxLogicalTop + borderAndPaddingBefore);
+
+    LayoutUnit sectionLogicalLeft = LayoutUnit(
+        style()->isLeftToRightDirection() ? borderStart() : borderEnd());
+    if (!collapsing) {
+      sectionLogicalLeft +=
+          style()->isLeftToRightDirection() ? paddingStart() : paddingEnd();
+    }
+
+    // Lay out table header group.
+    if (LayoutTableSection* section = header())
+      layoutSection(*section, layouter, sectionLogicalLeft);
+
+    // Lay out table body groups, and column groups.
+    for (LayoutObject* child = firstChild(); child;
+         child = child->nextSibling()) {
+      if (child->isTableSection()) {
+        if (child != header() && child != footer()) {
+          LayoutTableSection& section = *toLayoutTableSection(child);
+          layoutSection(section, layouter, sectionLogicalLeft);
+        }
+      } else if (child->isLayoutTableCol()) {
+        child->layoutIfNeeded();
+      } else {
+        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 totalSectionLogicalHeight;
+    if (topSection) {
+      totalSectionLogicalHeight =
+          bottomSection->logicalBottom() - topSection->logicalTop();
+    }
+
     distributeExtraLogicalHeight(
         floorToInt(computedLogicalHeight - totalSectionLogicalHeight));
 
     bool isPaginated = view()->layoutState()->isPaginated();
-    LayoutTableSection* topSection = this->topSection();
     LayoutUnit logicalOffset =
         topSection ? topSection->logicalTop() : LayoutUnit();
     for (LayoutTableSection* section = topSection; section;
          section = sectionBelow(section)) {
       section->setLogicalTop(logicalOffset);
       section->layoutRows();
       logicalOffset += section->logicalHeight();
       // If the section is a repeating header group that allows at least one row
       // of content then store the offset for other sections to offset their
       // rows against.
@@ skipping 11 matching lines @@
       }
     }
 
     if (!topSection && computedLogicalHeight > totalSectionLogicalHeight &&
         !document().inQuirksMode()) {
       // Completely empty tables (with no sections or anything) should at least
       // honor specified height in strict mode.
       setLogicalHeight(logicalHeight() + computedLogicalHeight);
     }
 
-    LayoutUnit sectionLogicalLeft = LayoutUnit(
-        style()->isLeftToRightDirection() ? borderStart() : borderEnd());
-    if (!collapsing)
-      sectionLogicalLeft +=
-          style()->isLeftToRightDirection() ? paddingStart() : paddingEnd();
-
     // position the table sections
     LayoutTableSection* section = topSection;
     while (section) {
-      if (!sectionMoved && section->logicalTop() != logicalHeight())
-        sectionMoved = true;
       section->setLogicalLocation(
           LayoutPoint(sectionLogicalLeft, logicalHeight()));
 
-      // As we may skip invalidation on the table, we need to ensure that
-      // sections are invalidated when they moved.
-      if (sectionMoved && !section->selfNeedsLayout())
-        section->setMayNeedPaintInvalidation();
-
       setLogicalHeight(logicalHeight() + section->logicalHeight());
 
       section->updateLayerTransformAfterLayout();
       section->addVisualEffectOverflow();
 
       section = sectionBelow(section);
     }
 
     setLogicalHeight(logicalHeight() + borderAndPaddingAfter);
 
+    // Lay out bottom captions.
     for (unsigned i = 0; i < m_captions.size(); i++) {
       if (m_captions[i]->style()->captionSide() != ECaptionSide::Bottom)
         continue;
-      layoutCaption(*m_captions[i]);
+      layoutCaption(*m_captions[i], layouter);
     }
 
     updateLogicalHeight();
 
     // table can be containing block of positioned elements.
     bool dimensionChanged = oldLogicalWidth != logicalWidth() ||
                             oldLogicalHeight != logicalHeight();
     layoutPositionedObjects(dimensionChanged);
 
     updateLayerTransformAfterLayout();
@@ skipping 962 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink