Rename positionNewFloats() to placeNewFloats().

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 2103 matching lines @@
   //
   // Note also that the previous flow may collapse its margin into the top of
   // our block. If this is the case, then we do not add the margin in to our
   // height when computing the position of the float. This condition can be
   // tested for by simply calling canCollapseWithMarginBefore. See
   // http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for
   // an example of this scenario.
   LayoutUnit logicalTop = logicalHeight();
   if (!marginInfo.canCollapseWithMarginBefore())
     logicalTop += marginInfo.margin();
-  positionNewFloats(logicalTop);
+  placeNewFloats(logicalTop);
 }
 
 void LayoutBlockFlow::handleAfterSideOfBlock(LayoutBox* lastChild,
                                              LayoutUnit beforeSide,
                                              LayoutUnit afterSide,
                                              MarginInfo& marginInfo) {
   marginInfo.setAtAfterSideOfBlock(true);
 
   // If our last child was a self-collapsing block with clearance then our
   // logical height is flush with the bottom edge of the float that the child
@@ skipping 1183 matching lines @@
 }
 
 void LayoutBlockFlow::childBecameNonInline(LayoutObject*) {
   makeChildrenNonInline();
   if (isAnonymousBlock() && parent() && parent()->isLayoutBlock())
     toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
   // |this| may be dead here
 }
 
 void LayoutBlockFlow::clearFloats(EClear clear) {
-  positionNewFloats(logicalHeight());
+  placeNewFloats(logicalHeight());
   // set y position
   LayoutUnit newY = lowestFloatLogicalBottom(clear);
   if (size().height() < newY)
     setLogicalHeight(newY);
 }
 
 bool LayoutBlockFlow::containsFloat(LayoutBox* layoutBox) const {
   return m_floatingObjects &&
          m_floatingObjects->set().contains<FloatingObjectHashTranslator>(
              layoutBox);
@@ skipping 219 matching lines @@
   FloatingObject* curr = floatingObjectSet.last().get();
   while (curr != lastFloat &&
          (!curr->isPlaced() || logicalTopForFloat(*curr) >= logicalOffset)) {
     m_floatingObjects->remove(curr);
     if (floatingObjectSet.isEmpty())
       break;
     curr = floatingObjectSet.last().get();
   }
 }
 
-bool LayoutBlockFlow::positionNewFloats(LayoutUnit logicalTop,
-                                        LineWidth* width) {
+bool LayoutBlockFlow::placeNewFloats(LayoutUnit logicalTopMarginEdge,
+                                     LineWidth* width) {
   if (!m_floatingObjects)
     return false;
 
   const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
   if (floatingObjectSet.isEmpty())
     return false;
 
   // If all floats have already been positioned, then we have no work to do.
   if (floatingObjectSet.last()->isPlaced())
     return false;
 
   // Move backwards through our floating object list until we find a float that
   // has already been positioned. Then we'll be able to move forward,
   // positioning all of the new floats that need it.
   FloatingObjectSetIterator it = floatingObjectSet.end();
   --it;  // Go to last item.
   FloatingObjectSetIterator begin = floatingObjectSet.begin();
   FloatingObject* lastPlacedFloatingObject = nullptr;
   while (it != begin) {
     --it;
     if ((*it)->isPlaced()) {
       lastPlacedFloatingObject = it->get();
       ++it;
       break;
     }
   }
 
   // The float cannot start above the top position of the last positioned float.
-  if (lastPlacedFloatingObject)
-    logicalTop =
-        std::max(logicalTopForFloat(*lastPlacedFloatingObject), logicalTop);
+  if (lastPlacedFloatingObject) {
+    logicalTopMarginEdge = std::max(
+        logicalTopMarginEdge, logicalTopForFloat(*lastPlacedFloatingObject));
+  }
 
   FloatingObjectSetIterator end = floatingObjectSet.end();
   // Now walk through the set of unpositioned floats and place them.
   for (; it != end; ++it) {
     FloatingObject& floatingObject = *it->get();
     // The containing block is responsible for positioning floats, so if we have
     // unplaced floats in our list that come from somewhere else, we have a bug.
     DCHECK_EQ(floatingObject.layoutObject()->containingBlock(), this);
 
-    logicalTop = positionAndLayoutFloat(floatingObject, logicalTop);
+    logicalTopMarginEdge =
+        positionAndLayoutFloat(floatingObject, logicalTopMarginEdge);
 
     m_floatingObjects->addPlacedObject(floatingObject);
 
     if (width)
       width->shrinkAvailableWidthForNewFloatIfNeeded(floatingObject);
   }
   return true;
 }
 
 LayoutUnit LayoutBlockFlow::positionAndLayoutFloat(
     FloatingObject& floatingObject,
-    LayoutUnit logicalTop) {
+    LayoutUnit logicalTopMarginEdge) {
   LayoutBox& childBox = *floatingObject.layoutObject();
 
   // FIXME Investigate if this can be removed. crbug.com/370006
   childBox.setMayNeedPaintInvalidation();
 
   LayoutUnit childLogicalLeftMargin = style()->isLeftToRightDirection()
                                           ? marginStartForChild(childBox)
                                           : marginEndForChild(childBox);
-  logicalTop =
-      std::max(logicalTop, lowestFloatLogicalBottom(childBox.style()->clear()));
+  logicalTopMarginEdge =
+      std::max(logicalTopMarginEdge,
+               lowestFloatLogicalBottom(childBox.style()->clear()));
 
   bool isPaginated = view()->layoutState()->isPaginated();
   if (isPaginated && !childrenInline()) {
     // Forced breaks are inserted at class A break points. Floats may be
     // affected by a break-after value on the previous in-flow sibling.
     if (LayoutBox* previousInFlowBox = childBox.previousInFlowSiblingBox()) {
-      logicalTop =
-          applyForcedBreak(logicalTop, previousInFlowBox->breakAfter());
+      logicalTopMarginEdge = applyForcedBreak(logicalTopMarginEdge,
+                                              previousInFlowBox->breakAfter());
     }
   }
 
   LayoutPoint floatLogicalLocation =
-      computeLogicalLocationForFloat(floatingObject, logicalTop);
+      computeLogicalLocationForFloat(floatingObject, logicalTopMarginEdge);
+  logicalTopMarginEdge = floatLogicalLocation.y();
 
   setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
 
   setLogicalLeftForChild(childBox,
                          floatLogicalLocation.x() + childLogicalLeftMargin);
-  setLogicalTopForChild(
-      childBox, floatLogicalLocation.y() + marginBeforeForChild(childBox));
+  setLogicalTopForChild(childBox,
+                        logicalTopMarginEdge + marginBeforeForChild(childBox));
 
   SubtreeLayoutScope layoutScope(childBox);
   if (isPaginated && !childBox.needsLayout())
     markChildForPaginationRelayoutIfNeeded(childBox, layoutScope);
 
   childBox.layoutIfNeeded();
 
   if (isPaginated) {
     LayoutBlockFlow* childBlockFlow =
         childBox.isLayoutBlockFlow() ? toLayoutBlockFlow(&childBox) : nullptr;
@@ skipping 21 matching lines @@
           LayoutUnit remainingSpace = pageRemainingLogicalHeightForOffset(
               marginEdge, AssociateWithLatterPage);
           if (remainingSpace <= marginBefore)
             strut += remainingSpace;
         }
       }
     }
     if (!strut) {
       // If we are unsplittable and don't fit, move to the next page or column
       // if that helps the situation.
-      strut = adjustForUnsplittableChild(childBox, floatLogicalLocation.y()) -
-              floatLogicalLocation.y();
+      strut = adjustForUnsplittableChild(childBox, logicalTopMarginEdge) -
+              logicalTopMarginEdge;
     }
 
     childBox.setPaginationStrut(strut);
     if (strut) {
       floatLogicalLocation = computeLogicalLocationForFloat(
-          floatingObject, floatLogicalLocation.y() + strut);
+          floatingObject, logicalTopMarginEdge + strut);
+      logicalTopMarginEdge = floatLogicalLocation.y();
       setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
 
       setLogicalLeftForChild(childBox,
                              floatLogicalLocation.x() + childLogicalLeftMargin);
       setLogicalTopForChild(
-          childBox, floatLogicalLocation.y() + marginBeforeForChild(childBox));
+          childBox, logicalTopMarginEdge + marginBeforeForChild(childBox));
 
       if (childBox.isLayoutBlock())
         childBox.setChildNeedsLayout(MarkOnlyThis);
       childBox.layoutIfNeeded();
     }
   }
 
-  setLogicalTopForFloat(floatingObject, floatLogicalLocation.y());
+  setLogicalTopForFloat(floatingObject, logicalTopMarginEdge);
 
   setLogicalHeightForFloat(floatingObject, logicalHeightForChild(childBox) +
                                                marginBeforeForChild(childBox) +
                                                marginAfterForChild(childBox));
 
   if (ShapeOutsideInfo* shapeOutside = childBox.shapeOutsideInfo())
     shapeOutside->setReferenceBoxLogicalSize(logicalSizeForChild(childBox));
 
-  return floatLogicalLocation.y();
+  return logicalTopMarginEdge;
 }
 
 bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* layoutBox) {
   if (!m_floatingObjects || !parent())
     return false;
 
   const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
   FloatingObjectSetIterator it =
       floatingObjectSet.find<FloatingObjectHashTranslator>(layoutBox);
   if (it == floatingObjectSet.end())
@@ skipping 807 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink