Let lowestFloatLogicalBottom() take EClear instead of FloatingObject::Type

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 2631 matching lines @@
 }
 
 LayoutUnit LayoutBlockFlow::getClearDelta(LayoutBox* child,
                                           LayoutUnit logicalTop) {
   // There is no need to compute clearance if we have no floats.
   if (!containsFloats())
     return LayoutUnit();
 
   // At least one float is present. We need to perform the clearance
   // computation.
-  bool clearSet = child->style()->clear() != ClearNone;
-  LayoutUnit logicalBottom;
-  switch (child->style()->clear()) {
-    case ClearNone:
-      break;
-    case ClearLeft:
-      logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
-      break;
-    case ClearRight:
-      logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatRight);
-      break;
-    case ClearBoth:
-      logicalBottom = lowestFloatLogicalBottom();
-      break;
-  }
+  EClear clear = child->style()->clear();
+  LayoutUnit logicalBottom = lowestFloatLogicalBottom(clear);
 
   // We also clear floats if we are too big to sit on the same line as a float
   // (and wish to avoid floats by default).
-  LayoutUnit result = clearSet
+  LayoutUnit result = clear != ClearNone
                           ? (logicalBottom - logicalTop).clampNegativeToZero()
                           : LayoutUnit();
   if (!result && child->avoidsFloats()) {
     LayoutUnit newLogicalTop = logicalTop;
     LayoutRect borderBox = child->borderBoxRect();
     LayoutUnit childLogicalWidthAtOldLogicalTopOffset =
         isHorizontalWritingMode() ? borderBox.width() : borderBox.height();
     while (true) {
       LayoutUnit availableLogicalWidthAtNewLogicalTopOffset =
           availableLogicalWidthForLine(newLogicalTop, DoNotIndentText,
@@ skipping 652 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());
   // set y position
-  LayoutUnit newY;
-  switch (clear) {
-    case ClearLeft:
-      newY = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
-      break;
-    case ClearRight:
-      newY = lowestFloatLogicalBottom(FloatingObject::FloatRight);
-      break;
-    case ClearBoth:
-      newY = lowestFloatLogicalBottom();
-    default:
-      break;
-  }
+  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 280 matching lines @@
     FloatingObject& floatingObject,
     LayoutUnit logicalTop) {
   LayoutBox& childBox = *floatingObject.layoutObject();
 
   // FIXME Investigate if this can be removed. crbug.com/370006
   childBox.setMayNeedPaintInvalidation();
 
   LayoutUnit childLogicalLeftMargin = style()->isLeftToRightDirection()
                                           ? marginStartForChild(childBox)
                                           : marginEndForChild(childBox);
-  if (childBox.style()->clear() & ClearLeft) {
-    logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatLeft),
-                          logicalTop);
-  }
-  if (childBox.style()->clear() & ClearRight) {
-    logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatRight),
-                          logicalTop);
-  }
+  logicalTop =
+      std::max(logicalTop, 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());
     }
   }
@@ skipping 215 matching lines @@
       // need to go ahead and add its overflow in to the child now.
       if (floatingObject.isDescendant())
         child->addOverflowFromChild(
             floatingObject.layoutObject(),
             LayoutSize(xPositionForFloatIncludingMargin(floatingObject),
                        yPositionForFloatIncludingMargin(floatingObject)));
     }
   }
 }
 
-LayoutUnit LayoutBlockFlow::lowestFloatLogicalBottom(
-    FloatingObject::Type floatType) const {
-  if (!m_floatingObjects)
+LayoutUnit LayoutBlockFlow::lowestFloatLogicalBottom(EClear clear) const {
+  if (clear == ClearNone || !m_floatingObjects)
     return LayoutUnit();
 
+  FloatingObject::Type floatType =
+      clear == ClearLeft ? FloatingObject::FloatLeft
+                         : clear == ClearRight ? FloatingObject::FloatRight
+                                               : FloatingObject::FloatLeftRight;
   return m_floatingObjects->lowestFloatLogicalBottom(floatType);
 }
 
 LayoutUnit LayoutBlockFlow::nextFloatLogicalBottomBelow(
     LayoutUnit logicalHeight) const {
   if (!m_floatingObjects)
     return logicalHeight;
   return m_floatingObjects->findNextFloatLogicalBottomBelow(logicalHeight);
 }
 
@@ skipping 656 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink