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

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 879 matching lines @@
     LayoutBox& child,
     LayoutUnit mainAxisBorderAndPadding,
     ChildLayoutType childLayoutType) {
   child.clearOverrideSize();
 
   if (child.isImage() || child.isVideo() || child.isCanvas())
     UseCounter::count(document(), UseCounter::AspectRatioFlexItem);
 
   Length flexBasis = flexBasisForChild(child);
   if (mainAxisLengthIsDefinite(child, flexBasis))
-    return std::max(LayoutUnit(), computeMainAxisExtentForChild(
-                                      child, MainOrPreferredSize, flexBasis));
+    return std::max(
+        LayoutUnit(),
+        computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis));
 
   if (child.styleRef().containsSize())
     return LayoutUnit();
 
   // The flex basis is indefinite (=auto), so we need to compute the actual
   // width of the child. For the logical width axis we just use the preferred
   // width; for the height we need to lay out the child.
   LayoutUnit mainAxisExtent;
   if (hasOrthogonalFlow(child)) {
     if (childLayoutType == NeverLayout)
@@ skipping 944 matching lines @@
       // The last item does not get extra space added.
       mainAxisOffset += justifyContentSpaceBetweenChildren(
           availableFreeSpace, distribution, children.size());
     }
 
     if (isPaginated)
       updateFragmentationInfoForChild(*child);
   }
 
   if (isColumnFlow())
-    setLogicalHeight(std::max(
-        logicalHeight(), mainAxisOffset + flowAwareBorderEnd() +
-                             flowAwarePaddingEnd() + scrollbarLogicalHeight()));
+    setLogicalHeight(std::max(logicalHeight(),
+                              mainAxisOffset + flowAwareBorderEnd() +
+                                  flowAwarePaddingEnd() +
+                                  scrollbarLogicalHeight()));
 
   if (style()->flexDirection() == FlowColumnReverse) {
     // We have to do an extra pass for column-reverse to reposition the flex
     // items since the start depends on the height of the flexbox, which we
     // only know after we've positioned all the flex items.
     updateLogicalHeight();
     layoutColumnReverse(children, crossAxisOffset, availableFreeSpace);
   }
 
   if (m_numberOfInFlowChildrenOnFirstLine == -1)
@@ skipping 118 matching lines @@
 
     lineOffset += alignContentSpaceBetweenChildren(
         availableCrossAxisSpace, distribution, lineContexts.size());
   }
 }
 
 void LayoutFlexibleBox::adjustAlignmentForChild(LayoutBox& child,
                                                 LayoutUnit delta) {
   DCHECK(!child.isOutOfFlowPositioned());
 
-  setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) +
-                                          LayoutSize(LayoutUnit(), delta));
+  setFlowAwareLocationForChild(
+      child,
+      flowAwareLocationForChild(child) + LayoutSize(LayoutUnit(), delta));
 }
 
 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;
 
   for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
     const LineContext& lineContext = lineContexts[lineNumber];
 
     LayoutUnit minMarginAfterBaseline = LayoutUnit::max();
     LayoutUnit lineCrossAxisExtent = lineContext.crossAxisExtent;
     LayoutUnit maxAscent = lineContext.maxAscent;
 
     for (size_t childNumber = 0; childNumber < lineContext.flexItems.size();
          ++childNumber) {
       const FlexItem& flexItem = lineContext.flexItems[childNumber];
       DCHECK(!flexItem.box->isOutOfFlowPositioned());
 
       if (updateAutoMarginsInCrossAxis(
               *flexItem.box,
-              std::max(LayoutUnit(), availableAlignmentSpaceForChild(
-                                         lineCrossAxisExtent, *flexItem.box))))
+              std::max(LayoutUnit(),
+                       availableAlignmentSpaceForChild(lineCrossAxisExtent,
+                                                       *flexItem.box))))
         continue;
 
       ItemPosition position = alignmentForChild(*flexItem.box);
       if (position == ItemPositionStretch)
         applyStretchAlignmentToChild(*flexItem.box, lineCrossAxisExtent);
       LayoutUnit availableSpace =
           availableAlignmentSpaceForChild(lineCrossAxisExtent, *flexItem.box);
       LayoutUnit offset = alignmentOffset(
           availableSpace, position, marginBoxAscentForChild(*flexItem.box),
           maxAscent, styleRef().flexWrap() == FlexWrapReverse);
       adjustAlignmentForChild(*flexItem.box, offset);
       if (position == ItemPositionBaseline &&
           styleRef().flexWrap() == FlexWrapReverse) {
-        minMarginAfterBaseline = std::min(
-            minMarginAfterBaseline, availableAlignmentSpaceForChild(
-                                        lineCrossAxisExtent, *flexItem.box) -
-                                        offset);
+        minMarginAfterBaseline =
+            std::min(minMarginAfterBaseline,
+                     availableAlignmentSpaceForChild(lineCrossAxisExtent,
+                                                     *flexItem.box) -
+                         offset);
       }
     }
     minMarginAfterBaselines.push_back(minMarginAfterBaseline);
   }
 
   if (style()->flexWrap() != FlexWrapReverse)
     return;
 
   // wrap-reverse flips the cross axis start and end. For baseline alignment,
   // this means we need to align the after edge of baseline elements with the
@@ skipping 105 matching lines @@
       LayoutUnit originalOffset =
           lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
       LayoutUnit newOffset =
           contentExtent - originalOffset - lineCrossAxisExtent;
       adjustAlignmentForChild(*flexItem.box, newOffset - originalOffset);
     }
   }
 }
 
 }  // namespace blink