Revert commit# 415577 "Add grid/flex layout support for <fieldset>"

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 425 matching lines @@
   // this value.
   m_hasDefiniteHeight = SizeDefiniteness::Unknown;
 }
 
 void LayoutFlexibleBox::paintChildren(const PaintInfo& paintInfo,
                                       const LayoutPoint& paintOffset) const {
   BlockPainter::paintChildrenOfFlexibleBox(*this, paintInfo, paintOffset);
 }
 
 void LayoutFlexibleBox::repositionLogicalHeightDependentFlexItems(
-    Vector<LineContext>& lineContexts,
-    LayoutObject* childToExclude) {
+    Vector<LineContext>& lineContexts) {
   LayoutUnit crossAxisStartEdge =
       lineContexts.isEmpty() ? LayoutUnit() : lineContexts[0].crossAxisOffset;
   alignFlexLines(lineContexts);
 
-  alignChildren(lineContexts, childToExclude);
+  alignChildren(lineContexts);
 
   if (style()->flexWrap() == FlexWrapReverse)
     flipForWrapReverse(lineContexts, crossAxisStartEdge);
 
   // direction:rtl + flex-direction:column means the cross-axis direction is
   // flipped.
   flipForRightToLeftColumn();
 }
 
 DISABLE_CFI_PERF
@@ skipping 513 matching lines @@
   OrderedFlexItemList orderedChildren;
   LayoutUnit sumFlexBaseSize;
   double totalFlexGrow;
   double totalFlexShrink;
   double totalWeightedFlexShrink;
   LayoutUnit sumHypotheticalMainSize;
 
   PaintLayerScrollableArea::PreventRelayoutScope preventRelayoutScope(
       layoutScope);
 
-  // Fieldsets need to find their legend and position it inside the border of
-  // the object. The legend then gets skipped during normal layout. It
-  // doesn't get included in the normal layout process but is instead skipped.
-  LayoutObject* childToExclude =
-      layoutSpecialExcludedChild(relayoutChildren, layoutScope);
 
   m_orderIterator.first();
   LayoutUnit crossAxisOffset =
       flowAwareBorderBefore() + flowAwarePaddingBefore();
   while (computeNextFlexLine(orderedChildren, sumFlexBaseSize, totalFlexGrow,
                              totalFlexShrink, totalWeightedFlexShrink,
-                             sumHypotheticalMainSize, relayoutChildren,
-                             childToExclude)) {
+                             sumHypotheticalMainSize, relayoutChildren)) {
     LayoutUnit containerMainInnerSize =
         mainAxisContentExtent(sumHypotheticalMainSize);
     // availableFreeSpace is the initial amount of free space in this flexbox.
     // remainingFreeSpace starts out at the same value but as we place and lay
     // out flex items we subtract from it. Note that both values can be
     // negative.
     LayoutUnit remainingFreeSpace = containerMainInnerSize - sumFlexBaseSize;
     FlexSign flexSign = (sumHypotheticalMainSize < containerMainInnerSize)
                             ? PositiveFlexibility
                             : NegativeFlexibility;
@@ skipping 29 matching lines @@
     // Even if computeNextFlexLine returns true, the flexbox might not have
     // a line because all our children might be out of flow positioned.
     // Instead of just checking if we have a line, make sure the flexbox
     // has at least a line's worth of height to cover this case.
     LayoutUnit minHeight = minimumLogicalHeightForEmptyLine();
     if (size().height() < minHeight)
       setLogicalHeight(minHeight);
   }
 
   updateLogicalHeight();
-  repositionLogicalHeightDependentFlexItems(lineContexts, childToExclude);
+  repositionLogicalHeightDependentFlexItems(lineContexts);
 }
 
 LayoutUnit LayoutFlexibleBox::autoMarginOffsetInMainAxis(
     const OrderedFlexItemList& children,
     LayoutUnit& availableFreeSpace) {
   if (availableFreeSpace <= LayoutUnit())
     return LayoutUnit();
 
   int numberOfAutoMargins = 0;
   bool isHorizontal = isHorizontalFlow();
@@ skipping 325 matching lines @@
                   childMinMaxAppliedMainAxisExtent, borderAndPadding, margin);
 }
 
 bool LayoutFlexibleBox::computeNextFlexLine(
     OrderedFlexItemList& orderedChildren,
     LayoutUnit& sumFlexBaseSize,
     double& totalFlexGrow,
     double& totalFlexShrink,
     double& totalWeightedFlexShrink,
     LayoutUnit& sumHypotheticalMainSize,
-    bool relayoutChildren,
-    LayoutObject* childToExclude) {
+    bool relayoutChildren) {
   orderedChildren.clear();
   sumFlexBaseSize = LayoutUnit();
   totalFlexGrow = totalFlexShrink = totalWeightedFlexShrink = 0;
   sumHypotheticalMainSize = LayoutUnit();
 
   if (!m_orderIterator.currentChild())
     return false;
 
   LayoutUnit lineBreakLength = mainAxisContentExtent(LayoutUnit::max());
 
   bool lineHasInFlowItem = false;
 
   for (LayoutBox* child = m_orderIterator.currentChild(); child;
        child = m_orderIterator.next()) {
-    if (childToExclude == child)
-      continue;  // Skip this child, since it will be positioned by the
-                 // specialized subclass (fieldsets runs).
 
     if (child->isOutOfFlowPositioned()) {
       orderedChildren.append(FlexItem(child));
       continue;
     }
 
     ChildLayoutType layoutType =
         relayoutChildren ? ForceLayout : LayoutIfNeeded;
 
     // If this condition is true, then computeMainAxisExtentForChild will call
@@ skipping 695 matching lines @@
 
 void LayoutFlexibleBox::adjustAlignmentForChild(LayoutBox& child,
                                                 LayoutUnit delta) {
   if (child.isOutOfFlowPositioned())
     return;
 
   setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) +
                                           LayoutSize(LayoutUnit(), delta));
 }
 
-void LayoutFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts,
-                                      LayoutObject* childToExclude) {
+void LayoutFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts) {
   // Keep track of the space between the baseline edge and the after edge of
   // the box for each line.
   Vector<LayoutUnit> minMarginAfterBaselines;
 
   LayoutBox* child = m_orderIterator.first();
   for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
     LayoutUnit minMarginAfterBaseline = LayoutUnit::max();
     LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
     LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
 
     for (size_t childNumber = 0;
          childNumber < lineContexts[lineNumber].numberOfChildren;
          ++childNumber, child = m_orderIterator.next()) {
       DCHECK(child);
-      if (child == childToExclude)
-        continue;
       if (child->isOutOfFlowPositioned()) {
         if (style()->flexWrap() == FlexWrapReverse)
           adjustAlignmentForChild(*child, lineCrossAxisExtent);
         continue;
       }
 
       if (updateAutoMarginsInCrossAxis(
               *child, std::max(LayoutUnit(), availableAlignmentSpaceForChild(
                                                  lineCrossAxisExtent, *child))))
         continue;
@@ skipping 129 matching lines @@
       LayoutUnit originalOffset =
           lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
       LayoutUnit newOffset =
           contentExtent - originalOffset - lineCrossAxisExtent;
       adjustAlignmentForChild(*child, newOffset - originalOffset);
     }
   }
 }
 
 }  // namespace blink