CSS: Use count unitless 0 supplied as <angle>

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 629 matching lines @@
     if (args.AtEnd()) {
       context->Count(UseCounter::kCSSFilterFunctionNoArguments);
       return filter_value;
     }
     if (filter_type == CSSValueBrightness) {
       // FIXME (crbug.com/397061): Support calc expressions like calc(10% + 0.5)
       parsed_value = ConsumePercent(args, kValueRangeAll);
       if (!parsed_value)
         parsed_value = ConsumeNumber(args, kValueRangeAll);
     } else if (filter_type == CSSValueHueRotate) {
-      parsed_value = ConsumeAngle(args);
+      parsed_value =
+          ConsumeAngle(args, *context, UseCounter::kUnitlessZeroAngleFilter);
     } else if (filter_type == CSSValueBlur) {
       parsed_value =
           ConsumeLength(args, kHTMLStandardMode, kValueRangeNonNegative);
     } else {
       // FIXME (crbug.com/397061): Support calc expressions like calc(10% + 0.5)
       parsed_value = ConsumePercent(args, kValueRangeNonNegative);
       if (!parsed_value)
         parsed_value = ConsumeNumber(args, kValueRangeNonNegative);
       if (parsed_value && filter_type != CSSValueSaturate &&
           filter_type != CSSValueContrast) {
@@ skipping 47 matching lines @@
     if (list->HasValue(*ident))
       return nullptr;
     list->Append(*ident);
   }
 
   if (!list->length())
     return nullptr;
   return list;
 }
 
-static CSSValue* ConsumeOffsetRotate(CSSParserTokenRange& range) {
-  CSSValue* angle = ConsumeAngle(range);
+static CSSValue* ConsumeOffsetRotate(CSSParserTokenRange& range,
+                                     const CSSParserContext& context) {
+  CSSValue* angle =
+      ConsumeAngle(range, context, UseCounter::kUnitlessZeroAngleOffsetRotate);
   CSSValue* keyword = ConsumeIdent<CSSValueAuto, CSSValueReverse>(range);
   if (!angle && !keyword)
     return nullptr;
 
-  if (!angle)
-    angle = ConsumeAngle(range);
+  if (!angle) {
+    angle = ConsumeAngle(range, context,
+                         UseCounter::kUnitlessZeroAngleOffsetRotate);
+  }
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   if (keyword)
     list->Append(*keyword);
   if (angle)
     list->Append(*angle);
   return list;
 }
 
 // offset: <offset-path> <offset-distance> <offset-rotate>
 bool CSSPropertyParser::ConsumeOffsetShorthand(bool important) {
   const CSSValue* offset_path =
       CSSPropertyOffsetPathUtils::ConsumeOffsetPath(range_, context_);
   const CSSValue* offset_distance =
       ConsumeLengthOrPercent(range_, context_->Mode(), kValueRangeAll);
-  const CSSValue* offset_rotate = ConsumeOffsetRotate(range_);
+  const CSSValue* offset_rotate = ConsumeOffsetRotate(range_, *context_);
   if (!offset_path || !offset_distance || !offset_rotate || !range_.AtEnd())
     return false;
 
   AddProperty(CSSPropertyOffsetPath, CSSPropertyOffset, *offset_path,
               important);
   AddProperty(CSSPropertyOffsetDistance, CSSPropertyOffset, *offset_distance,
               important);
   AddProperty(CSSPropertyOffsetRotate, CSSPropertyOffset, *offset_rotate,
               important);
 
@@ skipping 984 matching lines @@
       return ConsumeFilter(range_, context_);
     case CSSPropertyTextDecoration:
       DCHECK(!RuntimeEnabledFeatures::css3TextDecorationsEnabled());
     // fallthrough
     case CSSPropertyWebkitTextDecorationsInEffect:
     case CSSPropertyTextDecorationLine:
       return ConsumeTextDecorationLine(range_);
     case CSSPropertyOffsetDistance:
       return ConsumeLengthOrPercent(range_, context_->Mode(), kValueRangeAll);
     case CSSPropertyOffsetRotate:
-      return ConsumeOffsetRotate(range_);
+      return ConsumeOffsetRotate(range_, *context_);
     case CSSPropertyWebkitTransformOriginX:
     case CSSPropertyWebkitPerspectiveOriginX:
       return CSSPropertyPositionUtils::ConsumePositionLonghand<CSSValueLeft,
                                                                CSSValueRight>(
           range_, context_->Mode());
     case CSSPropertyWebkitTransformOriginY:
     case CSSPropertyWebkitPerspectiveOriginY:
       return CSSPropertyPositionUtils::ConsumePositionLonghand<CSSValueTop,
                                                                CSSValueBottom>(
           range_, context_->Mode());
@@ skipping 1667 matching lines @@
     case CSSPropertyPlaceItems:
       return ConsumePlaceItemsShorthand(important);
     case CSSPropertyPlaceSelf:
       return ConsumePlaceSelfShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink