Add a sketch of CSS @counter-style descriptor parsing

This patch adds the descriptors of @counter-style and a sketch of their
parsing code. Follow up patches will actually implement the parsing.

Bug: 687225
Change-Id: I7a2c6b5d94538a541ac3d68f3655f28b5511c57d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2519889
Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
Reviewed-by: Rune Lillesveen <futhark@chromium.org>
Cr-Commit-Position: refs/heads/master@{#825177}

third_party/blink/public/mojom/use_counter/css_property_id.mojom

@@ -725,6 +725,17 @@ enum CSSSampleId {
     kAdvanceProportionalOverride = 678,
     kOverflowClipMargin = 679,
     kScrollbarWidth = 680,
+    // @counter-style descriptors
+    kSystem = 681,
+    kNegative = 682,
+    kPrefix = 683,
+    kSuffix = 684,
+    kRange = 685,
+    kPad = 686,
+    kFallback = 687,
+    kSymbols = 688,
+    kAdditiveSymbols = 689,
+    kSpeakAs = 690,
     // 1. Add new features above this line (don't change the assigned numbers of
     //    the existing items).
     // 2. Run the src/tools/metrics/histograms/update_use_counter_css.py script

third_party/blink/renderer/core/css/build.gni

@@ -387,6 +387,7 @@ blink_core_sources_css = [
   "offscreen_font_selector.h",
   "page_rule_collector.cc",
   "page_rule_collector.h",
+  "parser/at_rule_counter_style_descriptor_parser.cc",
   "parser/at_rule_descriptor_parser.cc",
   "parser/at_rule_descriptor_parser.h",
   "parser/css_at_rule_id.cc",

third_party/blink/renderer/core/css/css_properties.json5

@@ -5193,6 +5193,66 @@
       is_property: false,
       runtime_flag: "CSSFontMetricsOverride",
     },
+    {
+      name: "system",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "negative",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "prefix",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "suffix",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "range",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "pad",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "fallback",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "symbols",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "additive-symbols",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
+    {
+      name: "speak-as",
+      is_descriptor: true,
+      is_property: false,
+      runtime_flag: "CSSAtRuleCounterStyle",
+    },
 
     // Shorthands
     {

third_party/blink/renderer/core/css/parser/at_rule_counter_style_descriptor_parser.cc

+// Copyright 2020 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 "third_party/blink/renderer/core/css/parser/at_rule_descriptor_parser.h"
+
+#include "third_party/blink/renderer/core/css/css_string_value.h"
+#include "third_party/blink/renderer/core/css/css_value.h"
+#include "third_party/blink/renderer/core/css/parser/css_parser_token_range.h"
+#include "third_party/blink/renderer/core/css/properties/css_parsing_utils.h"
+
+namespace blink {
+
+namespace {
+
+CSSValue* ConsumeCounterStyleName(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleSymbol(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleSystem(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleNegative(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleRange(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStylePad(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleSymbols(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleAdditiveSymbols(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+CSSValue* ConsumeCounterStyleSpeakAs(CSSParserTokenRange& range) {
+  // TODO(crbug.com/687225): Implement.
+  return nullptr;
+}
+
+}  // namespace
+
+CSSValue* AtRuleDescriptorParser::ParseAtCounterStyleDescriptor(
+    AtRuleDescriptorID id,
+    CSSParserTokenRange& range,
+    const CSSParserContext& context) {
+  DCHECK(RuntimeEnabledFeatures::CSSAtRuleCounterStyleEnabled());
+
+  CSSValue* parsed_value = nullptr;
+  switch (id) {
+    case AtRuleDescriptorID::System:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleSystem(range);
+      break;
+    case AtRuleDescriptorID::Negative:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleNegative(range);
+      break;
+    case AtRuleDescriptorID::Prefix:
+    case AtRuleDescriptorID::Suffix:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleSymbol(range);
+      break;
+    case AtRuleDescriptorID::Range:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleRange(range);
+      break;
+    case AtRuleDescriptorID::Pad:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStylePad(range);
+      break;
+    case AtRuleDescriptorID::Fallback:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleName(range);
+      break;
+    case AtRuleDescriptorID::Symbols:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleSymbols(range);
+      break;
+    case AtRuleDescriptorID::AdditiveSymbols:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleAdditiveSymbols(range);
+      break;
+    case AtRuleDescriptorID::SpeakAs:
+      range.ConsumeWhitespace();
+      parsed_value = ConsumeCounterStyleSpeakAs(range);
+      break;
+    default:
+      break;
+  }
+
+  if (!parsed_value || !range.AtEnd())
+    return nullptr;
+
+  return parsed_value;
+}
+
+}  // namespace blink

third_party/blink/renderer/core/css/parser/at_rule_descriptor_parser.cc

@@ -345,23 +345,6 @@ CSSValue* AtRuleDescriptorParser::ParseAtPropertyDescriptor(
   return parsed_value;
 }
 
-CSSValue* AtRuleDescriptorParser::ParseAtCounterStyleDescriptor(
-    AtRuleDescriptorID id,
-    CSSParserTokenRange& range,
-    const CSSParserContext& context) {
-  CSSValue* parsed_value = nullptr;
-  switch (id) {
-    // TODO(crbug.com/687225): Parse the descriptors
-    default:
-      break;
-  }
-
-  if (!parsed_value || !range.AtEnd())
-    return nullptr;
-
-  return parsed_value;
-}
-
 CSSValue* AtRuleDescriptorParser::ParseAtScrollTimelineDescriptor(
     AtRuleDescriptorID id,
     CSSParserTokenRange& range,

third_party/blink/renderer/core/css/parser/at_rule_names.json5

@@ -14,6 +14,9 @@
   },
 
   data: [
+    {
+      name: "additive-symbols",
+    },
     {
       name: "ascent-override",
     },
@@ -60,6 +63,9 @@
     {
       name: "advance-proportional-override"
     },
+    {
+      name: "fallback",
+    },
     {
       name: "line-gap-override",
     },
@@ -81,21 +87,45 @@
     {
       name: "min-zoom",
     },
+    {
+      name: "negative",
+    },
     {
       name: "orientation",
     },
+    {
+      name: "pad",
+    },
+    {
+      name: "prefix",
+    },
+    {
+      name: "range",
+    },
     {
       name: "source",
     },
+    {
+      name: "speak-as",
+    },
     {
       name: "src",
     },
     {
       name: "start",
     },
+    {
+      name: "suffix",
+    },
+    {
+      name: "symbols",
+    },
     {
       name: "syntax"
     },
+    {
+      name: "system",
+    },
     {
       name: "time-range",
     },

third_party/blink/renderer/core/css/style_rule.cc

@@ -498,7 +498,19 @@ void StyleRuleViewport::TraceAfterDispatch(blink::Visitor* visitor) const {
 
 StyleRuleCounterStyle::StyleRuleCounterStyle(const AtomicString& name,
                                              CSSPropertyValueSet* properties)
-    : StyleRuleBase(kCounterStyle), name_(name) {
+    : StyleRuleBase(kCounterStyle),
+      name_(name),
+      system_(properties->GetPropertyCSSValue(CSSPropertyID::kSystem)),
+      negative_(properties->GetPropertyCSSValue(CSSPropertyID::kNegative)),
+      prefix_(properties->GetPropertyCSSValue(CSSPropertyID::kPrefix)),
+      suffix_(properties->GetPropertyCSSValue(CSSPropertyID::kSuffix)),
+      range_(properties->GetPropertyCSSValue(CSSPropertyID::kRange)),
+      pad_(properties->GetPropertyCSSValue(CSSPropertyID::kPad)),
+      fallback_(properties->GetPropertyCSSValue(CSSPropertyID::kFallback)),
+      symbols_(properties->GetPropertyCSSValue(CSSPropertyID::kSymbols)),
+      additive_symbols_(
+          properties->GetPropertyCSSValue(CSSPropertyID::kAdditiveSymbols)),
+      speak_as_(properties->GetPropertyCSSValue(CSSPropertyID::kSpeakAs)) {
   DCHECK(properties);
 }
 
@@ -508,6 +520,16 @@ StyleRuleCounterStyle::StyleRuleCounterStyle(const StyleRuleCounterStyle&) =
 StyleRuleCounterStyle::~StyleRuleCounterStyle() = default;
 
 void StyleRuleCounterStyle::TraceAfterDispatch(blink::Visitor* visitor) const {
+  visitor->Trace(system_);
+  visitor->Trace(negative_);
+  visitor->Trace(prefix_);
+  visitor->Trace(suffix_);
+  visitor->Trace(range_);
+  visitor->Trace(pad_);
+  visitor->Trace(fallback_);
+  visitor->Trace(symbols_);
+  visitor->Trace(additive_symbols_);
+  visitor->Trace(speak_as_);
   StyleRuleBase::TraceAfterDispatch(visitor);
 }
 

third_party/blink/renderer/core/css/style_rule.h

@@ -352,9 +352,31 @@ class CORE_EXPORT StyleRuleCounterStyle : public StyleRuleBase {
   StyleRuleCounterStyle(const StyleRuleCounterStyle&);
   ~StyleRuleCounterStyle();
 
-  AtomicString GetName() { return name_; }
-
-  // TODO(crbug.com/687225): Add descriptor getters and setters.
+  AtomicString GetName() const { return name_; }
+  const CSSValue* GetSystem() const { return system_; }
+  const CSSValue* GetNegative() const { return negative_; }
+  const CSSValue* GetPrefix() const { return prefix_; }
+  const CSSValue* GetSuffix() const { return suffix_; }
+  const CSSValue* GetRange() const { return range_; }
+  const CSSValue* GetPad() const { return pad_; }
+  const CSSValue* GetFallback() const { return fallback_; }
+  const CSSValue* GetSymbols() const { return symbols_; }
+  const CSSValue* GetAdditiveSymbols() const { return additive_symbols_; }
+  const CSSValue* GetSpeakAs() const { return speak_as_; }
+
+  void SetName(const AtomicString& name) { name_ = name; }
+  void SetSystem(const CSSValue* system) { system_ = system; }
+  void SetNegative(const CSSValue* negative) { negative_ = negative; }
+  void SetPrefix(const CSSValue* prefix) { prefix_ = prefix; }
+  void SetSuffix(const CSSValue* suffix) { suffix_ = suffix; }
+  void SetRange(const CSSValue* range) { range_ = range; }
+  void SetPad(const CSSValue* pad) { pad_ = pad; }
+  void SetFallback(const CSSValue* fallback) { fallback_ = fallback; }
+  void SetSymbols(const CSSValue* symbols) { symbols_ = symbols; }
+  void SetAdditiveSymbols(const CSSValue* additive_symbols) {
+    additive_symbols_ = additive_symbols;
+  }
+  void SetSpeakAs(const CSSValue* speak_as) { speak_as_ = speak_as; }
 
   bool HasFailedOrCanceledSubresources() const {
     // TODO(crbug.com/687225): Implement.
@@ -369,6 +391,16 @@ class CORE_EXPORT StyleRuleCounterStyle : public StyleRuleBase {
 
  private:
   AtomicString name_;
+  Member<const CSSValue> system_;
+  Member<const CSSValue> negative_;
+  Member<const CSSValue> prefix_;
+  Member<const CSSValue> suffix_;
+  Member<const CSSValue> range_;
+  Member<const CSSValue> pad_;
+  Member<const CSSValue> fallback_;
+  Member<const CSSValue> symbols_;
+  Member<const CSSValue> additive_symbols_;
+  Member<const CSSValue> speak_as_;
 };
 
 template <>

tools/metrics/histograms/enums.xml

@@ -47499,6 +47499,16 @@ Called by update_use_counter_css.py.-->
   <int value="678" label="advance-proportional-override"/>
   <int value="679" label="overflow-clip-margin"/>
   <int value="680" label="scrollbar-width"/>
+  <int value="681" label="system"/>
+  <int value="682" label="negative"/>
+  <int value="683" label="prefix"/>
+  <int value="684" label="suffix"/>
+  <int value="685" label="range"/>
+  <int value="686" label="pad"/>
+  <int value="687" label="fallback"/>
+  <int value="688" label="symbols"/>
+  <int value="689" label="additive-symbols"/>
+  <int value="690" label="speak-as"/>
 </enum>
 
 <enum name="MappedEditingCommands">