CSS: Use count unitless 0 supplied as <angle>

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

 // Copyright 2016 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/CSSPropertyParserHelpers.h"
 
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSGradientValue.h"
@@ skipping 305 matching lines @@
   if (token.GetType() == kPercentageToken)
     return ConsumePercent(range, value_range);
   CalcParser calc_parser(range, value_range);
   if (const CSSCalcValue* calculation = calc_parser.Value()) {
     if (CanConsumeCalcValue(calculation->Category(), css_parser_mode))
       return calc_parser.ConsumeValue();
   }
   return nullptr;
 }
 
-CSSPrimitiveValue* ConsumeAngle(CSSParserTokenRange& range) {
+CSSPrimitiveValue* ConsumeGradientLengthOrPercent(

[alancutter (OOO until 2018), 2017/05/25 01:53:16]

I don't understand the purpose of this function, can we avoid adding it?

[Eric Willigers, 2017/05/25 02:56:41]

ConsumeLengthOrPercent accepts a CSSParserMode.
For example, in CSSSyntaxDescriptor.cpp we explicitly pass kHTMLStandardMode
regardless of the context mode.

However, ConsumeGradientLengthOrPercent is called by function pointer and now
needs to accept a CSSParserContext const ref, as ConsumeGradientColorStops can
be called instead, and the arguments need to be consistent.

[alancutter (OOO until 2018), 2017/05/25 03:11:52]

Ack. You should make this reason clear in the description.

[Eric Willigers, 2017/05/25 03:58:14]

Done.

+    CSSParserTokenRange& range,
+    const CSSParserContext& context,
+    ValueRange value_range,
+    UnitlessQuirk unitless) {
+  return ConsumeLengthOrPercent(range, context.Mode(), value_range, unitless);
+}
+
+CSSPrimitiveValue* ConsumeAngle(
+    CSSParserTokenRange& range,
+    const CSSParserContext& context,
+    UnitlessQuirk angleQuirk,
+    WTF::Optional<UseCounter::Feature> literalZeroFeature) {

[alancutter (OOO until 2018), 2017/05/25 01:53:16]

DCHECK that the quirk is disallowed iff the feature is null.

[Eric Willigers, 2017/05/25 02:56:41]

Retiring the quirk argument, it was added in an earlier version of this CL
before we used Optional.

   const CSSParserToken& token = range.Peek();
   if (token.GetType() == kDimensionToken) {
     switch (token.GetUnitType()) {
       case CSSPrimitiveValue::UnitType::kDegrees:
       case CSSPrimitiveValue::UnitType::kRadians:
       case CSSPrimitiveValue::UnitType::kGradians:
       case CSSPrimitiveValue::UnitType::kTurns:
         return CSSPrimitiveValue::Create(
             range.ConsumeIncludingWhitespace().NumericValue(),
             token.GetUnitType());
       default:
         return nullptr;
     }
   }
-  if (token.GetType() == kNumberToken && token.NumericValue() == 0) {
+  if (token.GetType() == kNumberToken && token.NumericValue() == 0 &&
+      literalZeroFeature) {

[alancutter (OOO until 2018), 2017/05/25 01:53:16]

Use the quirk parameter instead. It's completely unused otherwise.

     range.ConsumeIncludingWhitespace();
+    context.Count(*literalZeroFeature);
     return CSSPrimitiveValue::Create(0, CSSPrimitiveValue::UnitType::kDegrees);
   }
   CalcParser calc_parser(range, kValueRangeAll);
   if (const CSSCalcValue* calculation = calc_parser.Value()) {
     if (calculation->Category() == kCalcAngle)
       return calc_parser.ConsumeValue();
   }
   return nullptr;
 }
 
@@ skipping 598 matching lines @@
   CSSGradientColorStop stop;
   while (ConsumeCommaIncludingWhitespace(args)) {
     if (!ConsumeDeprecatedGradientColorStop(args, stop, css_parser_mode))
       return nullptr;
     result->AddStop(stop);
   }
 
   return result;
 }
 
-static CSSPrimitiveValue* ConsumeAngleOrPercent(CSSParserTokenRange& range,
-                                                CSSParserMode,
-                                                ValueRange value_range,
-                                                UnitlessQuirk) {
+static CSSPrimitiveValue* ConsumeGradientAngleOrPercent(
+    CSSParserTokenRange& range,
+    const CSSParserContext& context,
+    ValueRange value_range,
+    UnitlessQuirk) {
   const CSSParserToken& token = range.Peek();
-  if (token.GetType() == kDimensionToken || token.GetType() == kNumberToken)
-    return ConsumeAngle(range);
+  if (token.GetType() == kDimensionToken || token.GetType() == kNumberToken) {
+    return ConsumeAngle(range, context, UnitlessQuirk::kAllow,
+                        UseCounter::kZeroAngleGradient);
+  }
   if (token.GetType() == kPercentageToken)
     return ConsumePercent(range, value_range);
   CalcParser calc_parser(range, value_range);
   if (const CSSCalcValue* calculation = calc_parser.Value()) {
     CalculationCategory category = calculation->Category();
     // TODO(fs): Add and support kCalcPercentAngle?
     if (category == kCalcAngle || category == kCalcPercent)
       return calc_parser.ConsumeValue();
   }
   return nullptr;
 }
 
 using PositionFunctor = CSSPrimitiveValue* (*)(CSSParserTokenRange&,
-                                               CSSParserMode,
+                                               const CSSParserContext&,
                                                ValueRange,
                                                UnitlessQuirk);
 
 static bool ConsumeGradientColorStops(CSSParserTokenRange& range,
-                                      CSSParserMode css_parser_mode,
+                                      const CSSParserContext& context,
                                       CSSGradientValue* gradient,
                                       PositionFunctor consume_position_func) {
   bool supports_color_hints = gradient->GradientType() == kCSSLinearGradient ||
                               gradient->GradientType() == kCSSRadialGradient ||
                               gradient->GradientType() == kCSSConicGradient;
 
   // The first color stop cannot be a color hint.
   bool previous_stop_was_color_hint = true;
   do {
     CSSGradientColorStop stop;
-    stop.color_ = ConsumeColor(range, css_parser_mode);
+    stop.color_ = ConsumeColor(range, context.Mode());
     // Two hints in a row are not allowed.
     if (!stop.color_ && (!supports_color_hints || previous_stop_was_color_hint))
       return false;
     previous_stop_was_color_hint = !stop.color_;
-    stop.offset_ = consume_position_func(range, css_parser_mode, kValueRangeAll,
+    stop.offset_ = consume_position_func(range, context, kValueRangeAll,
                                          UnitlessQuirk::kForbid);
     if (!stop.color_ && !stop.offset_)
       return false;
     gradient->AddStop(stop);
 
     if (RuntimeEnabledFeatures::multipleColorStopPositionsEnabled()) {
       if (!stop.color_ || !stop.offset_)
         continue;
 
       // Optional second position.
-      stop.offset_ = consume_position_func(
-          range, css_parser_mode, kValueRangeAll, UnitlessQuirk::kForbid);
+      stop.offset_ = consume_position_func(range, context, kValueRangeAll,
+                                           UnitlessQuirk::kForbid);
       if (stop.offset_)
         gradient->AddStop(stop);
     }
   } while (ConsumeCommaIncludingWhitespace(range));
 
   // The last color stop cannot be a color hint.
   if (previous_stop_was_color_hint)
     return false;
 
   // Must have 2 or more stops to be valid.
   return gradient->StopCount() >= 2;
 }
 
-static CSSValue* ConsumeDeprecatedRadialGradient(CSSParserTokenRange& args,
-                                                 CSSParserMode css_parser_mode,
-                                                 CSSGradientRepeat repeating) {
+static CSSValue* ConsumeDeprecatedRadialGradient(
+    CSSParserTokenRange& args,
+    const CSSParserContext& context,
+    CSSGradientRepeat repeating) {
   CSSValue* center_x = nullptr;
   CSSValue* center_y = nullptr;
-  ConsumeOneOrTwoValuedPosition(args, css_parser_mode, UnitlessQuirk::kForbid,
+  ConsumeOneOrTwoValuedPosition(args, context.Mode(), UnitlessQuirk::kForbid,
                                 center_x, center_y);
   if ((center_x || center_y) && !ConsumeCommaIncludingWhitespace(args))
     return nullptr;
 
   const CSSIdentifierValue* shape =
       ConsumeIdent<CSSValueCircle, CSSValueEllipse>(args);
   const CSSIdentifierValue* size_keyword =
       ConsumeIdent<CSSValueClosestSide, CSSValueClosestCorner,
                    CSSValueFarthestSide, CSSValueFarthestCorner,
                    CSSValueContain, CSSValueCover>(args);
   if (!shape)
     shape = ConsumeIdent<CSSValueCircle, CSSValueEllipse>(args);
 
   // Or, two lengths or percentages
   const CSSPrimitiveValue* horizontal_size = nullptr;
   const CSSPrimitiveValue* vertical_size = nullptr;
   if (!shape && !size_keyword) {
     horizontal_size =
-        ConsumeLengthOrPercent(args, css_parser_mode, kValueRangeAll);
+        ConsumeLengthOrPercent(args, context.Mode(), kValueRangeAll);
     if (horizontal_size) {
       vertical_size =
-          ConsumeLengthOrPercent(args, css_parser_mode, kValueRangeAll);
+          ConsumeLengthOrPercent(args, context.Mode(), kValueRangeAll);
       if (!vertical_size)
         return nullptr;
       ConsumeCommaIncludingWhitespace(args);
     }
   } else {
     ConsumeCommaIncludingWhitespace(args);
   }
 
   CSSGradientValue* result = CSSRadialGradientValue::Create(
       center_x, center_y, shape, size_keyword, horizontal_size, vertical_size,
       repeating, kCSSPrefixedRadialGradient);
-  return ConsumeGradientColorStops(args, css_parser_mode, result,
-                                   ConsumeLengthOrPercent)
+  return ConsumeGradientColorStops(args, context, result,
+                                   ConsumeGradientLengthOrPercent)
              ? result
              : nullptr;
 }
 
 static CSSValue* ConsumeRadialGradient(CSSParserTokenRange& args,
                                        const CSSParserContext& context,
                                        CSSGradientRepeat repeating) {
   const CSSIdentifierValue* shape = nullptr;
   const CSSIdentifierValue* size_keyword = nullptr;
   const CSSPrimitiveValue* horizontal_size = nullptr;
@@ skipping 67 matching lines @@
   }
 
   if ((shape || size_keyword || horizontal_size || center_x || center_y) &&
       !ConsumeCommaIncludingWhitespace(args)) {
     return nullptr;
   }
 
   CSSGradientValue* result = CSSRadialGradientValue::Create(
       center_x, center_y, shape, size_keyword, horizontal_size, vertical_size,
       repeating, kCSSRadialGradient);
-  return ConsumeGradientColorStops(args, context.Mode(), result,
-                                   ConsumeLengthOrPercent)
+  return ConsumeGradientColorStops(args, context, result,
+                                   ConsumeGradientLengthOrPercent)
              ? result
              : nullptr;
 }
 
 static CSSValue* ConsumeLinearGradient(CSSParserTokenRange& args,
-                                       CSSParserMode css_parser_mode,
+                                       const CSSParserContext& context,
                                        CSSGradientRepeat repeating,
                                        CSSGradientType gradient_type) {
   bool expect_comma = true;
-  const CSSPrimitiveValue* angle = ConsumeAngle(args);
+  const CSSPrimitiveValue* angle = ConsumeAngle(
+      args, context, UnitlessQuirk::kAllow, UseCounter::kZeroAngleGradient);
   const CSSIdentifierValue* end_x = nullptr;
   const CSSIdentifierValue* end_y = nullptr;
   if (!angle) {
     if (gradient_type == kCSSPrefixedLinearGradient ||
         ConsumeIdent<CSSValueTo>(args)) {
       end_x = ConsumeIdent<CSSValueLeft, CSSValueRight>(args);
       end_y = ConsumeIdent<CSSValueBottom, CSSValueTop>(args);
       if (!end_x && !end_y) {
         if (gradient_type == kCSSLinearGradient)
           return nullptr;
         end_y = CSSIdentifierValue::Create(CSSValueTop);
         expect_comma = false;
       } else if (!end_x) {
         end_x = ConsumeIdent<CSSValueLeft, CSSValueRight>(args);
       }
     } else {
       expect_comma = false;
     }
   }
 
   if (expect_comma && !ConsumeCommaIncludingWhitespace(args))
     return nullptr;
 
   CSSGradientValue* result = CSSLinearGradientValue::Create(
       end_x, end_y, nullptr, nullptr, angle, repeating, gradient_type);
-  return ConsumeGradientColorStops(args, css_parser_mode, result,
-                                   ConsumeLengthOrPercent)
+  return ConsumeGradientColorStops(args, context, result,
+                                   ConsumeGradientLengthOrPercent)
              ? result
              : nullptr;
 }
 
 static CSSValue* ConsumeConicGradient(CSSParserTokenRange& args,
                                       const CSSParserContext& context,
                                       CSSGradientRepeat repeating) {
   if (!RuntimeEnabledFeatures::conicGradientEnabled())
     return nullptr;
 
   const CSSPrimitiveValue* from_angle = nullptr;
   if (ConsumeIdent<CSSValueFrom>(args)) {
-    if (!(from_angle = ConsumeAngle(args)))
+    if (!(from_angle = ConsumeAngle(args, context, UnitlessQuirk::kAllow,
+                                    UseCounter::kZeroAngleGradient)))
       return nullptr;
   }
 
   CSSValue* center_x = nullptr;
   CSSValue* center_y = nullptr;
   if (ConsumeIdent<CSSValueAt>(args)) {
     if (!ConsumePosition(args, context, UnitlessQuirk::kForbid,
                          UseCounter::kThreeValuedPositionGradient, center_x,
                          center_y))
       return nullptr;
   }
 
   // Comma separator required when fromAngle or position is present.
   if ((from_angle || center_x || center_y) &&
       !ConsumeCommaIncludingWhitespace(args)) {
     return nullptr;
   }
 
   CSSGradientValue* result =
       CSSConicGradientValue::Create(center_x, center_y, from_angle, repeating);
-  return ConsumeGradientColorStops(args, context.Mode(), result,
-                                   ConsumeAngleOrPercent)
+  return ConsumeGradientColorStops(args, context, result,
+                                   ConsumeGradientAngleOrPercent)
              ? result
              : nullptr;
 }
 
 CSSValue* ConsumeImageOrNone(CSSParserTokenRange& range,
                              const CSSParserContext* context) {
   if (range.Peek().Id() == CSSValueNone)
     return ConsumeIdent(range);
   return ConsumeImage(range, context);
 }
@@ skipping 72 matching lines @@
   CSSValueID id = range.Peek().FunctionId();
   CSSParserTokenRange range_copy = range;
   CSSParserTokenRange args = ConsumeFunction(range_copy);
   CSSValue* result = nullptr;
   if (id == CSSValueRadialGradient) {
     result = ConsumeRadialGradient(args, *context, kNonRepeating);
   } else if (id == CSSValueRepeatingRadialGradient) {
     result = ConsumeRadialGradient(args, *context, kRepeating);
   } else if (id == CSSValueWebkitLinearGradient) {
     context->Count(UseCounter::kDeprecatedWebKitLinearGradient);
-    result = ConsumeLinearGradient(args, context->Mode(), kNonRepeating,
+    result = ConsumeLinearGradient(args, *context, kNonRepeating,
                                    kCSSPrefixedLinearGradient);
   } else if (id == CSSValueWebkitRepeatingLinearGradient) {
     context->Count(UseCounter::kDeprecatedWebKitRepeatingLinearGradient);
-    result = ConsumeLinearGradient(args, context->Mode(), kRepeating,
+    result = ConsumeLinearGradient(args, *context, kRepeating,
                                    kCSSPrefixedLinearGradient);
   } else if (id == CSSValueRepeatingLinearGradient) {
-    result = ConsumeLinearGradient(args, context->Mode(), kRepeating,
-                                   kCSSLinearGradient);
+    result =
+        ConsumeLinearGradient(args, *context, kRepeating, kCSSLinearGradient);
   } else if (id == CSSValueLinearGradient) {
-    result = ConsumeLinearGradient(args, context->Mode(), kNonRepeating,
+    result = ConsumeLinearGradient(args, *context, kNonRepeating,
                                    kCSSLinearGradient);
   } else if (id == CSSValueWebkitGradient) {
     context->Count(UseCounter::kDeprecatedWebKitGradient);
     result = ConsumeDeprecatedGradient(args, context->Mode());
   } else if (id == CSSValueWebkitRadialGradient) {
     context->Count(UseCounter::kDeprecatedWebKitRadialGradient);
-    result =
-        ConsumeDeprecatedRadialGradient(args, context->Mode(), kNonRepeating);
+    result = ConsumeDeprecatedRadialGradient(args, *context, kNonRepeating);
   } else if (id == CSSValueWebkitRepeatingRadialGradient) {
     context->Count(UseCounter::kDeprecatedWebKitRepeatingRadialGradient);
-    result = ConsumeDeprecatedRadialGradient(args, context->Mode(), kRepeating);
+    result = ConsumeDeprecatedRadialGradient(args, *context, kRepeating);
   } else if (id == CSSValueConicGradient) {
     result = ConsumeConicGradient(args, *context, kNonRepeating);
   } else if (id == CSSValueRepeatingConicGradient) {
     result = ConsumeConicGradient(args, *context, kRepeating);
   } else if (id == CSSValueWebkitCrossFade) {
     result = ConsumeCrossFade(args, context);
   } else if (id == CSSValuePaint) {
     result = RuntimeEnabledFeatures::cssPaintAPIEnabled()
                  ? ConsumePaint(args, context)
                  : nullptr;
@@ skipping 83 matching lines @@
 
 // https://drafts.csswg.org/css-shapes-1/#typedef-shape-box
 CSSIdentifierValue* ConsumeShapeBox(CSSParserTokenRange& range) {
   return ConsumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox,
                       CSSValueMarginBox>(range);
 }
 
 }  // namespace CSSPropertyParserHelpers
 
 }  // namespace blink