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

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 741 matching lines @@
 
 LayoutUnit LayoutBox::constrainLogicalWidthByMinMax(LayoutUnit logicalWidth,
                                                     LayoutUnit availableWidth,
                                                     LayoutBlock* cb) const {
   const ComputedStyle& styleToUse = styleRef();
   if (!styleToUse.logicalMaxWidth().isMaxSizeNone())
     logicalWidth =
         std::min(logicalWidth,
                  computeLogicalWidthUsing(MaxSize, styleToUse.logicalMaxWidth(),
                                           availableWidth, cb));
-  return std::max(logicalWidth, computeLogicalWidthUsing(
-                                    MinSize, styleToUse.logicalMinWidth(),
-                                    availableWidth, cb));
+  return std::max(
+      logicalWidth,
+      computeLogicalWidthUsing(MinSize, styleToUse.logicalMinWidth(),
+                               availableWidth, cb));
 }
 
 LayoutUnit LayoutBox::constrainLogicalHeightByMinMax(
     LayoutUnit logicalHeight,
     LayoutUnit intrinsicContentHeight) const {
   const ComputedStyle& styleToUse = styleRef();
   if (!styleToUse.logicalMaxHeight().isMaxSizeNone()) {
     LayoutUnit maxH = computeLogicalHeightUsing(
         MaxSize, styleToUse.logicalMaxHeight(), intrinsicContentHeight);
     if (maxH != -1)
       logicalHeight = std::min(logicalHeight, maxH);
   }
-  return std::max(logicalHeight, computeLogicalHeightUsing(
-                                     MinSize, styleToUse.logicalMinHeight(),
-                                     intrinsicContentHeight));
+  return std::max(
+      logicalHeight,
+      computeLogicalHeightUsing(MinSize, styleToUse.logicalMinHeight(),
+                                intrinsicContentHeight));
 }
 
 LayoutUnit LayoutBox::constrainContentBoxLogicalHeightByMinMax(
     LayoutUnit logicalHeight,
     LayoutUnit intrinsicContentHeight) const {
   // If the min/max height and logical height are both percentages we take
   // advantage of already knowing the current resolved percentage height
   // to avoid recursing up through our containing blocks again to determine it.
   const ComputedStyle& styleToUse = styleRef();
   if (!styleToUse.logicalMaxHeight().isMaxSizeNone()) {
     if (styleToUse.logicalMaxHeight().type() == Percent &&
         styleToUse.logicalHeight().type() == Percent) {
       LayoutUnit availableLogicalHeight(
           logicalHeight / styleToUse.logicalHeight().value() * 100);
-      logicalHeight =
-          std::min(logicalHeight, valueForLength(styleToUse.logicalMaxHeight(),
-                                                 availableLogicalHeight));
+      logicalHeight = std::min(logicalHeight,
+                               valueForLength(styleToUse.logicalMaxHeight(),
+                                              availableLogicalHeight));
     } else {
       LayoutUnit maxHeight(computeContentLogicalHeight(
           MaxSize, styleToUse.logicalMaxHeight(), intrinsicContentHeight));
       if (maxHeight != -1)
         logicalHeight = std::min(logicalHeight, maxHeight);
     }
   }
 
   if (styleToUse.logicalMinHeight().type() == Percent &&
       styleToUse.logicalHeight().type() == Percent) {
@@ skipping 983 matching lines @@
 }
 
 LayoutRect LayoutBox::overflowClipRect(
     const LayoutPoint& location,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior) const {
   // FIXME: When overflow-clip (CSS3) is implemented, we'll obtain the property
   // here.
   LayoutRect clipRect = borderBoxRect();
   clipRect.setLocation(location + clipRect.location() +
                        LayoutSize(borderLeft(), borderTop()));
-  clipRect.setSize(clipRect.size() - LayoutSize(borderLeft() + borderRight(),
-                                                borderTop() + borderBottom()));
+  clipRect.setSize(
+      clipRect.size() -
+      LayoutSize(borderLeft() + borderRight(), borderTop() + borderBottom()));
 
   if (hasOverflowClip())
     excludeScrollbars(clipRect, overlayScrollbarClipBehavior);
 
   if (hasControlClip())
     clipRect.intersect(controlClipRect(location));
 
   return clipRect;
 }
 
@@ skipping 29 matching lines @@
         size().width() - valueForLength(style()->clipRight(), size().width()),
         LayoutUnit());
 
   if (!style()->clipTop().isAuto()) {
     LayoutUnit c = valueForLength(style()->clipTop(), borderBoxRect.height());
     clipRect.move(LayoutUnit(), c);
     clipRect.contract(LayoutUnit(), c);
   }
 
   if (!style()->clipBottom().isAuto())
-    clipRect.contract(LayoutUnit(),
-                      size().height() - valueForLength(style()->clipBottom(),
-                                                       size().height()));
+    clipRect.contract(
+        LayoutUnit(),
+        size().height() -
+            valueForLength(style()->clipBottom(), size().height()));
 
   return clipRect;
 }
 
 static LayoutUnit portionOfMarginNotConsumedByFloat(LayoutUnit childMargin,
                                                     LayoutUnit contentSide,
                                                     LayoutUnit offset) {
   if (childMargin <= 0)
     return LayoutUnit();
   LayoutUnit contentSideWithMargin = contentSide + childMargin;
@@ skipping 815 matching lines @@
     return computeIntrinsicLogicalWidthUsing(
         logicalWidth, availableLogicalWidth, borderAndPaddingLogicalWidth());
 
   LayoutUnit marginStart;
   LayoutUnit marginEnd;
   LayoutUnit logicalWidthResult =
       fillAvailableMeasure(availableLogicalWidth, marginStart, marginEnd);
 
   if (shrinkToAvoidFloats() && cb->isLayoutBlockFlow() &&
       toLayoutBlockFlow(cb)->containsFloats())
-    logicalWidthResult = std::min(
-        logicalWidthResult, shrinkLogicalWidthToAvoidFloats(
-                                marginStart, marginEnd, toLayoutBlockFlow(cb)));
+    logicalWidthResult =
+        std::min(logicalWidthResult,
+                 shrinkLogicalWidthToAvoidFloats(marginStart, marginEnd,
+                                                 toLayoutBlockFlow(cb)));
 
   if (widthType == MainOrPreferredSize &&
       sizesLogicalWidthToFitContent(logicalWidth))
     return std::max(minPreferredLogicalWidth(),
                     std::min(maxPreferredLogicalWidth(), logicalWidthResult));
   return logicalWidthResult;
 }
 
 bool LayoutBox::columnFlexItemHasStretchAlignment() const {
   // auto margins mean we don't stretch. Note that this function will only be
@@ skipping 152 matching lines @@
       marginEnd = std::max(LayoutUnit(), marginEndWidth);
     }
   }
 
   // CSS 2.1 (10.3.3): "If 'width' is not 'auto' and 'border-left-width' +
   // 'padding-left' + 'width' + 'padding-right' + 'border-right-width' (plus any
   // of 'margin-left' or 'margin-right' that are not 'auto') is larger than the
   // width of the containing block, then any 'auto' values for 'margin-left' or
   // 'margin-right' are, for the following rules, treated as zero.
   LayoutUnit marginBoxWidth =
-      childWidth + (!style()->width().isAuto()
-                        ? marginStartWidth + marginEndWidth
-                        : LayoutUnit());
+      childWidth +
+      (!style()->width().isAuto() ? marginStartWidth + marginEndWidth
+                                  : LayoutUnit());
 
   if (marginBoxWidth < availableWidth) {
     // CSS 2.1: "If both 'margin-left' and 'margin-right' are 'auto', their used
     // values are equal. This horizontally centers the element with respect to
     // the edges of the containing block."
     const ComputedStyle& containingBlockStyle = containingBlock->styleRef();
     if ((marginStartLength.isAuto() && marginEndLength.isAuto()) ||
         (!marginStartLength.isAuto() && !marginEndLength.isAuto() &&
          containingBlockStyle.textAlign() == ETextAlign::kWebkitCenter)) {
       // Other browsers center the margin box for align=center elements so we
@@ skipping 378 matching lines @@
     availableHeight += cb->paddingLogicalHeight();
 
   LayoutUnit result = valueForLength(height, availableHeight);
   // |overrideLogicalContentHeight| is the maximum height made available by the
   // cell to its percent height children when we decide they can determine the
   // height of the cell. If the percent height child is box-sizing:content-box
   // then we must subtract the border and padding from the cell's
   // |availableHeight| (given by |overrideLogicalContentHeight|) to arrive
   // at the child's computed height.
   bool subtractBorderAndPadding =
-      isTable() || (cb->isTableCell() && !skippedAutoHeightContainingBlock &&
-                    cb->hasOverrideLogicalContentHeight() &&
-                    style()->boxSizing() == EBoxSizing::kContentBox);
+      isTable() ||
+      (cb->isTableCell() && !skippedAutoHeightContainingBlock &&
+       cb->hasOverrideLogicalContentHeight() &&
+       style()->boxSizing() == EBoxSizing::kContentBox);
   if (subtractBorderAndPadding) {
     result -= borderAndPaddingLogicalHeight();
     return std::max(LayoutUnit(), result);
   }
   return result;
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalWidth(
     ShouldComputePreferred shouldComputePreferred) const {
   return computeReplacedLogicalWidthRespectingMinMaxWidth(
@@ skipping 51 matching lines @@
                                 ? containingBlockLogicalWidthForPositioned(
                                       toLayoutBoxModelObject(container()))
                                 : containingBlockLogicalWidthForContent();
       Length containerLogicalWidth = containingBlock()->style()->logicalWidth();
       // FIXME: Handle cases when containing block width is calculated or
       // viewport percent. https://bugs.webkit.org/show_bug.cgi?id=91071
       if (logicalWidth.isIntrinsic())
         return computeIntrinsicLogicalWidthUsing(
                    logicalWidth, cw, borderAndPaddingLogicalWidth()) -
                borderAndPaddingLogicalWidth();
-      if (cw > 0 || (!cw && (containerLogicalWidth.isFixed() ||
-                             containerLogicalWidth.isPercentOrCalc())))
+      if (cw > 0 ||
+          (!cw &&
+           (containerLogicalWidth.isFixed() ||
+            containerLogicalWidth.isPercentOrCalc())))
         return adjustContentBoxLogicalWidthForBoxSizing(
             minimumValueForLength(logicalWidth, cw));
       return LayoutUnit();
     }
     case Auto:
     case MaxSizeNone:
       return intrinsicLogicalWidth();
     case ExtendToZoom:
     case DeviceWidth:
     case DeviceHeight:
@@ skipping 191 matching lines @@
         containingBlockLogicalHeightForPositioned(containingBlock());
     return adjustContentBoxLogicalHeightForBoxSizing(
         valueForLength(h, availableHeight));
   }
 
   // FIXME: Should we pass intrinsicContentLogicalHeight() instead of -1 here?
   LayoutUnit heightIncludingScrollbar =
       computeContentAndScrollbarLogicalHeightUsing(MainOrPreferredSize, h,
                                                    LayoutUnit(-1));
   if (heightIncludingScrollbar != -1)
-    return std::max(LayoutUnit(), adjustContentBoxLogicalHeightForBoxSizing(
-                                      heightIncludingScrollbar) -
-                                      scrollbarLogicalHeight());
+    return std::max(
+        LayoutUnit(),
+        adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar) -
+            scrollbarLogicalHeight());
 
   // FIXME: Check logicalTop/logicalBottom here to correctly handle vertical
   // writing-mode.
   // https://bugs.webkit.org/show_bug.cgi?id=46500
   if (isLayoutBlock() && isOutOfFlowPositioned() &&
       style()->height().isAuto() &&
       !(style()->top().isAuto() || style()->bottom().isAuto())) {
     LayoutBlock* block = const_cast<LayoutBlock*>(toLayoutBlock(this));
     LogicalExtentComputedValues computedValues;
     block->computeLogicalHeight(block->logicalHeight(), LayoutUnit(),
@@ skipping 459 matching lines @@
     // ignore the value for 'left' (in case the 'direction' property of the
     // containing block is 'rtl') or 'right' (in case 'direction' is 'ltr')
     // and solve for that value.
     // -------------------------------------------------------------------------
     // NOTE:  It is not necessary to solve for 'right' in the over constrained
     // case because the value is not used for any further calculations.
 
     computedValues.m_extent = logicalWidthValue;
 
     const LayoutUnit availableSpace =
-        containerLogicalWidth - (logicalLeftValue + computedValues.m_extent +
-                                 logicalRightValue + bordersPlusPadding);
+        containerLogicalWidth -
+        (logicalLeftValue + computedValues.m_extent + logicalRightValue +
+         bordersPlusPadding);
 
     // Margins are now the only unknown
     if (marginLogicalLeft.isAuto() && marginLogicalRight.isAuto()) {
       // Both margins auto, solve for equality
       if (availableSpace >= 0) {
         marginLogicalLeftValue = availableSpace / 2;  // split the difference
         marginLogicalRightValue =
             availableSpace -
             marginLogicalLeftValue;  // account for odd valued differences
       } else {
@@ skipping 1668 matching lines @@
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 bool LayoutBox::shouldClipOverflow() const {
   return hasOverflowClip() || styleRef().containsPaint() || hasControlClip();
 }
 
 }  // namespace blink