DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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 352 matching lines @@
     for (LayoutBlock* cb = containingBlock(); !cb->isLayoutView();
          cb = cb->containingBlock()) {
       if (cb->style()->logicalHeight().isFixed() || cb->isTableCell())
         hasAutoHeight = false;
     }
   }
 
   // If the height is 0 or auto, then whether or not we are a self-collapsing
   // block depends on whether we have content that is all self-collapsing.
   // TODO(alancutter): Make this work correctly for calc lengths.
-  if (hasAutoHeight || ((logicalHeightLength.isFixed() ||
-                         logicalHeightLength.isPercentOrCalc()) &&
-                        logicalHeightLength.isZero())) {
+  if (hasAutoHeight ||
+      ((logicalHeightLength.isFixed() ||
+        logicalHeightLength.isPercentOrCalc()) &&
+       logicalHeightLength.isZero())) {
     // If the block has inline children, see if we generated any line boxes.
     // If we have any line boxes, then we can't be self-collapsing, since we
     // have content.
     if (childrenInline())
       return !firstLineBox();
 
     // Whether or not we collapse is dependent on whether all our normal flow
     // children are also self-collapsing.
     for (LayoutBox* child = firstChildBox(); child;
          child = child->nextSiblingBox()) {
@@ skipping 248 matching lines @@
     // If the child is being centred then the margin calculated to do that has
     // factored in any offset required to avoid floats, so use it if necessary.
     if (style()->textAlign() == ETextAlign::kWebkitCenter ||
         child.style()->marginStartUsing(style()).isAuto())
       newPosition =
           std::max(newPosition, positionToAvoidFloats + childMarginStart);
     else if (positionToAvoidFloats > initialStartPosition)
       newPosition = std::max(newPosition, positionToAvoidFloats);
   }
 
-  setLogicalLeftForChild(child, style()->isLeftToRightDirection()
-                                    ? newPosition
-                                    : totalAvailableLogicalWidth - newPosition -
-                                          logicalWidthForChild(child));
+  setLogicalLeftForChild(child,
+                         style()->isLeftToRightDirection()
+                             ? newPosition
+                             : totalAvailableLogicalWidth - newPosition -
+                                   logicalWidthForChild(child));
 }
 
 void LayoutBlockFlow::setLogicalLeftForChild(LayoutBox& child,
                                              LayoutUnit logicalLeft) {
   if (isHorizontalWritingMode()) {
     child.setX(logicalLeft);
   } else {
     child.setY(logicalLeft);
   }
 }
@@ skipping 638 matching lines @@
   if (!parent() || !parent()->isLayoutBlockFlow())
     return;
 
   // Attempt to locate a previous sibling with overhanging floats. We skip any
   // elements that may have shifted to avoid floats, and any objects whose
   // floats cannot interact with objects outside it (i.e. objects that create a
   // new block formatting context).
   LayoutBlockFlow* parentBlockFlow = toLayoutBlockFlow(parent());
   bool siblingFloatMayIntrude = false;
   LayoutObject* prev = previousSibling();
-  while (prev && (!prev->isBox() || !prev->isLayoutBlock() ||
-                  toLayoutBlock(prev)->avoidsFloats() ||
-                  toLayoutBlock(prev)->createsNewFormattingContext())) {
+  while (prev &&
+         (!prev->isBox() || !prev->isLayoutBlock() ||
+          toLayoutBlock(prev)->avoidsFloats() ||
+          toLayoutBlock(prev)->createsNewFormattingContext())) {
     if (prev->isFloating())
       siblingFloatMayIntrude = true;
     prev = prev->previousSibling();
   }
 
   // First add in floats from the parent. Self-collapsing blocks let their
   // parent track any floats that intrude into them (as opposed to floats they
   // contain themselves) so check for those here too. If margin collapsing has
   // moved us up past the top a previous sibling then we need to check for
   // floats from the parent too.
@@ skipping 1350 matching lines @@
 void LayoutBlockFlow::markSiblingsWithFloatsForLayout(
     LayoutBox* floatToRemove) {
   if (!m_floatingObjects)
     return;
 
   const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
   FloatingObjectSetIterator end = floatingObjectSet.end();
 
   for (LayoutObject* next = nextSibling(); next; next = next->nextSibling()) {
     if (!next->isLayoutBlockFlow() ||
-        (!floatToRemove && (next->isFloatingOrOutOfFlowPositioned() ||
-                            toLayoutBlockFlow(next)->avoidsFloats())))
+        (!floatToRemove &&
+         (next->isFloatingOrOutOfFlowPositioned() ||
+          toLayoutBlockFlow(next)->avoidsFloats())))
       continue;
 
     LayoutBlockFlow* nextBlock = toLayoutBlockFlow(next);
     for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end;
          ++it) {
       LayoutBox* floatingBox = (*it)->layoutObject();
       if (floatToRemove && floatingBox != floatToRemove)
         continue;
       if (nextBlock->containsFloat(floatingBox))
         nextBlock->markAllDescendantsWithFloatsForLayout(floatingBox);
@@ skipping 1068 matching lines @@
       child.layoutIfNeeded();
     }
   }
 
   LayoutUnit childLogicalLeftMargin =
       style()->isLeftToRightDirection() ? marginStart : marginEnd;
   setLogicalLeftForChild(child,
                          floatLogicalLocation.x() + childLogicalLeftMargin);
   setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
   setLogicalTopForFloat(floatingObject, logicalTopMarginEdge);
-  setLogicalHeightForFloat(floatingObject, logicalHeightForChild(child) +
-                                               marginBefore + marginAfter);
+  setLogicalHeightForFloat(
+      floatingObject,
+      logicalHeightForChild(child) + marginBefore + marginAfter);
 
   if (ShapeOutsideInfo* shapeOutside = child.shapeOutsideInfo())
     shapeOutside->setReferenceBoxLogicalSize(logicalSizeForChild(child));
 
   return logicalTopMarginEdge;
 }
 
 bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* layoutBox) {
   if (!m_floatingObjects || !parent())
     return false;
@@ skipping 37 matching lines @@
           createFloatingObjects();
 
         // Applying the child's margin makes no sense in the case where the
         // child was passed in since this margin was added already through the
         // modification of the |logicalLeftOffset| variable above.
         // |logicalLeftOffset| will equal the margin in this case, so it's
         // already been taken into account. Only apply this code if prev is the
         // parent, since otherwise the left margin will get applied twice.
         LayoutSize offset =
             isHorizontalWritingMode()
-                ? LayoutSize(
-                      logicalLeftOffset - (prev != parent() ? prev->marginLeft()
-                                                            : LayoutUnit()),
-                      logicalTopOffset)
-                : LayoutSize(
-                      logicalTopOffset,
-                      logicalLeftOffset - (prev != parent() ? prev->marginTop()
-                                                            : LayoutUnit()));
+                ? LayoutSize(logicalLeftOffset -
+                                 (prev != parent() ? prev->marginLeft()
+                                                   : LayoutUnit()),
+                             logicalTopOffset)
+                : LayoutSize(logicalTopOffset,
+                             logicalLeftOffset -
+                                 (prev != parent() ? prev->marginTop()
+                                                   : LayoutUnit()));
 
         m_floatingObjects->add(floatingObject.copyToNewContainer(offset));
       }
     }
   }
 }
 
 void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child,
                                            bool makeChildPaintOtherFloats) {
   // Prevent floats from being added to the canvas by the root element, e.g.,
@@ skipping 121 matching lines @@
 
   if (hitTestAction == HitTestFloat &&
       hitTestFloats(result, locationInContainer, scrolledOffset))
     return true;
 
   if (childrenInline()) {
     if (m_lineBoxes.hitTest(LineLayoutBoxModel(this), result,
                             locationInContainer, scrolledOffset,
                             hitTestAction)) {
       updateHitTestResult(
-          result, flipForWritingMode(toLayoutPoint(locationInContainer.point() -
-                                                   accumulatedOffset)));
+          result,
+          flipForWritingMode(
+              toLayoutPoint(locationInContainer.point() - accumulatedOffset)));
       return true;
     }
   } else if (LayoutBlock::hitTestChildren(result, locationInContainer,
                                           accumulatedOffset, hitTestAction)) {
     return true;
   }
 
   return false;
 }
 
@@ skipping 595 matching lines @@
           std::min<LayoutUnit>(curr->lineBottom(), curr->y() + curr->height());
       LayoutRect rect(additionalOffset.x() + curr->x(),
                       additionalOffset.y() + top, curr->width(), bottom - top);
       if (!rect.isEmpty())
         rects.push_back(rect);
     }
   }
 
   if (inlineElementContinuation)
     inlineElementContinuation->addOutlineRects(
-        rects, additionalOffset +
-                   (inlineElementContinuation->containingBlock()->location() -
-                    location()),
+        rects,
+        additionalOffset +
+            (inlineElementContinuation->containingBlock()->location() -
+             location()),
         includeBlockOverflows);
 }
 
 PaintInvalidationReason LayoutBlockFlow::invalidatePaintIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   if (containsFloats())
     paintInvalidationState.paintingLayer().setNeedsPaintPhaseFloat();
 
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink