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

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include <memory>
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
@@ skipping 798 matching lines @@
       // FIXME (crbug.com/397061): Support calc expressions like calc(10% + 0.5)
       parsedValue = consumePercent(args, ValueRangeNonNegative);
       if (!parsedValue)
         parsedValue = consumeNumber(args, ValueRangeNonNegative);
       if (parsedValue && filterType != CSSValueSaturate &&
           filterType != CSSValueContrast) {
         bool isPercentage = toCSSPrimitiveValue(parsedValue)->isPercentage();
         double maxAllowed = isPercentage ? 100.0 : 1.0;
         if (toCSSPrimitiveValue(parsedValue)->getDoubleValue() > maxAllowed) {
           parsedValue = CSSPrimitiveValue::create(
-              maxAllowed, isPercentage ? CSSPrimitiveValue::UnitType::Percentage
-                                       : CSSPrimitiveValue::UnitType::Number);
+              maxAllowed,
+              isPercentage ? CSSPrimitiveValue::UnitType::Percentage
+                           : CSSPrimitiveValue::UnitType::Number);
         }
       }
     }
   }
   if (!parsedValue || !args.atEnd())
     return nullptr;
   filterValue->append(*parsedValue);
   return filterValue;
 }
 
@@ skipping 958 matching lines @@
 static CSSValue* consumeGridTrackSize(CSSParserTokenRange& range,
                                       CSSParserMode cssParserMode) {
   const CSSParserToken& token = range.peek();
   if (identMatches<CSSValueAuto>(token.id()))
     return consumeIdent(range);
 
   if (token.functionId() == CSSValueMinmax) {
     CSSParserTokenRange rangeCopy = range;
     CSSParserTokenRange args = consumeFunction(rangeCopy);
     CSSValue* minTrackBreadth = consumeGridBreadth(args, cssParserMode);
-    if (!minTrackBreadth || (minTrackBreadth->isPrimitiveValue() &&
-                             toCSSPrimitiveValue(minTrackBreadth)->isFlex()) ||
+    if (!minTrackBreadth ||
+        (minTrackBreadth->isPrimitiveValue() &&
+         toCSSPrimitiveValue(minTrackBreadth)->isFlex()) ||
         !consumeCommaIncludingWhitespace(args))
       return nullptr;
     CSSValue* maxTrackBreadth = consumeGridBreadth(args, cssParserMode);
     if (!maxTrackBreadth || !args.atEnd())
       return nullptr;
     range = rangeCopy;
     CSSFunctionValue* result = CSSFunctionValue::create(CSSValueMinmax);
     result->append(*minTrackBreadth);
     result->append(*maxTrackBreadth);
     return result;
@@ skipping 319 matching lines @@
     case CSSPropertyWebkitBorderStartWidth:
     case CSSPropertyWebkitBorderEndWidth:
     case CSSPropertyWebkitBorderBeforeWidth:
     case CSSPropertyWebkitBorderAfterWidth:
       return consumeBorderWidth(m_range, m_context->mode(),
                                 UnitlessQuirk::Forbid);
     case CSSPropertyBorderBottomColor:
     case CSSPropertyBorderLeftColor:
     case CSSPropertyBorderRightColor:
     case CSSPropertyBorderTopColor: {
-      bool allowQuirkyColors =
-          inQuirksMode() && (currentShorthand == CSSPropertyInvalid ||
-                             currentShorthand == CSSPropertyBorderColor);
+      bool allowQuirkyColors = inQuirksMode() &&
+                               (currentShorthand == CSSPropertyInvalid ||
+                                currentShorthand == CSSPropertyBorderColor);
       return consumeColor(m_range, m_context->mode(), allowQuirkyColors);
     }
     case CSSPropertyBorderBottomWidth:
     case CSSPropertyBorderLeftWidth:
     case CSSPropertyBorderRightWidth:
     case CSSPropertyBorderTopWidth: {
-      bool allowQuirkyLengths =
-          inQuirksMode() && (currentShorthand == CSSPropertyInvalid ||
-                             currentShorthand == CSSPropertyBorderWidth);
+      bool allowQuirkyLengths = inQuirksMode() &&
+                                (currentShorthand == CSSPropertyInvalid ||
+                                 currentShorthand == CSSPropertyBorderWidth);
       UnitlessQuirk unitless =
           allowQuirkyLengths ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
       return consumeBorderWidth(m_range, m_context->mode(), unitless);
     }
     case CSSPropertyTextShadow:
     case CSSPropertyBoxShadow:
       return consumeShadow(m_range, m_context->mode(),
                            property == CSSPropertyBoxShadow);
     case CSSPropertyFilter:
     case CSSPropertyBackdropFilter:
@@ skipping 304 matching lines @@
     if (id == CSSValueInherit || id == CSSValueInitial)
       return false;
   }
   // Optional font-style, font-variant, font-stretch and font-weight.
   CSSIdentifierValue* fontStyle = nullptr;
   CSSIdentifierValue* fontVariantCaps = nullptr;
   CSSIdentifierValue* fontWeight = nullptr;
   CSSIdentifierValue* fontStretch = nullptr;
   while (!m_range.atEnd()) {
     CSSValueID id = m_range.peek().id();
-    if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue(
-                          CSSPropertyFontStyle, id, m_context->mode())) {
+    if (!fontStyle &&
+        CSSParserFastPaths::isValidKeywordPropertyAndValue(
+            CSSPropertyFontStyle, id, m_context->mode())) {
       fontStyle = consumeIdent(m_range);
       continue;
     }
     if (!fontVariantCaps && (id == CSSValueNormal || id == CSSValueSmallCaps)) {
       // Font variant in the shorthand is particular, it only accepts normal or
       // small-caps.
       // See https://drafts.csswg.org/css-fonts/#propdef-font
       fontVariantCaps = consumeFontVariantCSS21(m_range);
       if (fontVariantCaps)
         continue;
     }
     if (!fontWeight) {
       fontWeight = consumeFontWeight(m_range);
       if (fontWeight)
         continue;
     }
-    if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue(
-                            CSSPropertyFontStretch, id, m_context->mode()))
+    if (!fontStretch &&
+        CSSParserFastPaths::isValidKeywordPropertyAndValue(
+            CSSPropertyFontStretch, id, m_context->mode()))
       fontStretch = consumeIdent(m_range);
     else
       break;
   }
 
   if (m_range.atEnd())
     return false;
 
   addProperty(
       CSSPropertyFontStyle, CSSPropertyFont,
@@ skipping 1263 matching lines @@
     case CSSPropertyGridTemplate:
       return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
       return consumeGridShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink