Revert: Detect floats to avoid or clear due to negative margin top (and followup)

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

 /*
  * Copyright (C) 2013 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 1691 matching lines @@
 
   if (marginInfo.quirkContainer() && marginInfo.atBeforeSideOfBlock() &&
       (posTop - negTop))
     marginInfo.setHasMarginBeforeQuirk(topQuirk);
 
   LayoutUnit beforeCollapseLogicalTop = logicalHeight();
   LayoutUnit logicalTop = beforeCollapseLogicalTop;
 
   LayoutObject* prev = child.previousSibling();
   LayoutBlockFlow* previousBlockFlow =
-      prev && prev->isLayoutBlockFlow() ? toLayoutBlockFlow(prev) : nullptr;
-  bool previousBlockFlowCanSelfCollapse =
-      previousBlockFlow &&
-      !previousBlockFlow->isFloatingOrOutOfFlowPositioned();
+      prev && prev->isLayoutBlockFlow() &&
+              !prev->isFloatingOrOutOfFlowPositioned()
+          ? toLayoutBlockFlow(prev)
+          : 0;
   // If the child's previous sibling is a self-collapsing block that cleared a
   // float then its top border edge has been set at the bottom border edge of
   // the float. Since we want to collapse the child's top margin with the self-
   // collapsing block's top and bottom margins we need to adjust our parent's
   // height to match the margin top of the self-collapsing block. If the
   // resulting collapsed margin leaves the child still intruding into the float
   // then we will want to clear it.
-  if (!marginInfo.canCollapseWithMarginBefore() &&
-      previousBlockFlowCanSelfCollapse &&
+  if (!marginInfo.canCollapseWithMarginBefore() && previousBlockFlow &&
       marginInfo.lastChildIsSelfCollapsingBlockWithClearance())
     setLogicalHeight(
         logicalHeight() -
         marginValuesForChild(*previousBlockFlow).positiveMarginBefore());
 
   if (childIsSelfCollapsing) {
     // For a self collapsing block both the before and after margins get
     // discarded. The block doesn't contribute anything to the height of the
     // block. Also, the child's top position equals the logical height of the
     // container.
@@ skipping 60 matching lines @@
   }
 
   if (view()->layoutState()->isPaginated() && isPageLogicalHeightKnown()) {
     LayoutUnit oldLogicalTop = logicalTop;
     LayoutUnit margin = adjustedMarginBeforeForPagination(
         child, beforeCollapseLogicalTop, logicalTop, layoutInfo);
     logicalTop = beforeCollapseLogicalTop + margin;
     setLogicalHeight(logicalHeight() + (logicalTop - oldLogicalTop));
   }
 
-  // If |child| has moved up into previous siblings it needs to avoid or clear
-  // any floats they contain.
-  LayoutUnit oldLogicalHeight = logicalHeight();
-  setLogicalHeight(logicalTop);
-  while (previousBlockFlow) {
-    auto lowestFloat = previousBlockFlow->logicalTop() +
-                       previousBlockFlow->lowestFloatLogicalBottom();
-    if (lowestFloat > logicalTop)
+  if (previousBlockFlow) {
+    // If |child| is a self-collapsing block it may have collapsed into a
+    // previous sibling and although it hasn't reduced the height of the parent
+    // yet any floats from the parent will now overhang.
+    LayoutUnit oldLogicalHeight = logicalHeight();
+    setLogicalHeight(logicalTop);
+    if (!previousBlockFlow->avoidsFloats() &&
+        (previousBlockFlow->logicalTop() +
+         previousBlockFlow->lowestFloatLogicalBottom()) > logicalTop)
       addOverhangingFloats(previousBlockFlow, false);
-    else
-      break;
-    LayoutObject* prev = previousBlockFlow->previousSibling();
-    if (prev && prev->isLayoutBlockFlow())
-      previousBlockFlow = toLayoutBlockFlow(prev);
-    else
-      previousBlockFlow = nullptr;
-  }
-  setLogicalHeight(oldLogicalHeight);
+    setLogicalHeight(oldLogicalHeight);
 
-  if (previousBlockFlowCanSelfCollapse) {
     // If |child|'s previous sibling is or contains a self-collapsing block that
     // cleared a float and margin collapsing resulted in |child| moving up
     // into the margin area of the self-collapsing block then the float it
     // clears is now intruding into |child|. Layout again so that we can look
     // for floats in the parent that overhang |child|'s new logical top.
     bool logicalTopIntrudesIntoFloat = logicalTop < beforeCollapseLogicalTop;
     if (logicalTopIntrudesIntoFloat && containsFloats() &&
         !child.avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
       child.setNeedsLayoutAndFullPaintInvalidation(
           LayoutInvalidationReason::AncestorMarginCollapsing);
@@ skipping 2744 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink