Port CSS keywords in longhands CSS properties to CSSValueID

CSSValueID was changed to an scoped enum in https://crrev.com/c/1530916,
and equivalent int variables were introduced while the remaining uses
were ported. This CL ports the keyword values in
third_party/blink/renderer/core/css/properties/longhands.

Bug: 936371
Change-Id: I3bd83971f8cd5345b93f00a59ffaed6b6c5806f2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1532014
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Kent Tamura <tkent@chromium.org>
Cr-Commit-Position: refs/heads/master@{#643730}
diff --git a/third_party/blink/renderer/core/css/properties/longhands/align_items_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/align_items_custom.cc
index e77d25d8..3f4cdff 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/align_items_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/align_items_custom.cc
@@ -17,7 +17,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   // align-items property does not allow the 'auto' value.
-  if (css_property_parser_helpers::IdentMatches<CSSValueAuto>(
+  if (css_property_parser_helpers::IdentMatches<CSSValueID::kAuto>(
           range.Peek().Id()))
     return nullptr;
   return css_parsing_utils::ConsumeSelfPositionOverflowPosition(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/animation_direction_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/animation_direction_custom.cc
index 4deae2d..afece0d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/animation_direction_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/animation_direction_custom.cc
@@ -18,8 +18,8 @@
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
       css_property_parser_helpers::ConsumeIdent<
-          CSSValueNormal, CSSValueAlternate, CSSValueReverse,
-          CSSValueAlternateReverse>,
+          CSSValueID::kNormal, CSSValueID::kAlternate, CSSValueID::kReverse,
+          CSSValueID::kAlternateReverse>,
       range);
 }
 
@@ -44,7 +44,7 @@
 
 const CSSValue* AnimationDirection::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueNormal)));
+                      (CSSIdentifierValue::Create(CSSValueID::kNormal)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/animation_fill_mode_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/animation_fill_mode_custom.cc
index e1fb860..b60de34 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/animation_fill_mode_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/animation_fill_mode_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
       css_property_parser_helpers::ConsumeIdent<
-          CSSValueNone, CSSValueForwards, CSSValueBackwards, CSSValueBoth>,
+          CSSValueID::kNone, CSSValueID::kForwards, CSSValueID::kBackwards,
+          CSSValueID::kBoth>,
       range);
 }
 
@@ -43,7 +44,7 @@
 
 const CSSValue* AnimationFillMode::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueNone)));
+                      (CSSIdentifierValue::Create(CSSValueID::kNone)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/animation_name_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/animation_name_custom.cc
index 8603f6ab..6a71b6d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/animation_name_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/animation_name_custom.cc
@@ -41,7 +41,7 @@
 
 const CSSValue* AnimationName::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueNone)));
+                      (CSSIdentifierValue::Create(CSSValueID::kNone)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/animation_play_state_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/animation_play_state_custom.cc
index 16e02578..b2a238a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/animation_play_state_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/animation_play_state_custom.cc
@@ -17,8 +17,8 @@
     const CSSParserContext&,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
-      css_property_parser_helpers::ConsumeIdent<CSSValueRunning,
-                                                CSSValuePaused>,
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kRunning,
+                                                CSSValueID::kPaused>,
       range);
 }
 
@@ -43,7 +43,7 @@
 
 const CSSValue* AnimationPlayState::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueRunning)));
+                      (CSSIdentifierValue::Create(CSSValueID::kRunning)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/animation_timing_function_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/animation_timing_function_custom.cc
index 205f333..ed89c48 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/animation_timing_function_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/animation_timing_function_custom.cc
@@ -32,7 +32,7 @@
 
 const CSSValue* AnimationTimingFunction::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueEase)));
+                      (CSSIdentifierValue::Create(CSSValueID::kEase)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/backface_visibility_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/backface_visibility_custom.cc
index 7ef04f62..79dc4c9c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/backface_visibility_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/backface_visibility_custom.cc
@@ -15,8 +15,8 @@
     bool allow_visited_style) const {
   return CSSIdentifierValue::Create(
       (style.BackfaceVisibility() == EBackfaceVisibility::kHidden)
-          ? CSSValueHidden
-          : CSSValueVisible);
+          ? CSSValueID::kHidden
+          : CSSValueID::kVisible);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/background_position_x_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/background_position_x_custom.cc
index de6066d..54930de 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/background_position_x_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/background_position_x_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
-      css_parsing_utils::ConsumePositionLonghand<CSSValueLeft, CSSValueRight>,
+      css_parsing_utils::ConsumePositionLonghand<CSSValueID::kLeft,
+                                                 CSSValueID::kRight>,
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/background_position_y_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/background_position_y_custom.cc
index f5a453c..31ab5d44 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/background_position_y_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/background_position_y_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
-      css_parsing_utils::ConsumePositionLonghand<CSSValueTop, CSSValueBottom>,
+      css_parsing_utils::ConsumePositionLonghand<CSSValueID::kTop,
+                                                 CSSValueID::kBottom>,
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/baseline_shift_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/baseline_shift_custom.cc
index caaf83b..75ac944 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/baseline_shift_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/baseline_shift_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
+  if (id == CSSValueID::kBaseline || id == CSSValueID::kSub ||
+      id == CSSValueID::kSuper)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeLengthOrPercent(
       range, kSVGAttributeMode, kValueRangeAll);
@@ -32,9 +33,9 @@
     bool allow_visited_style) const {
   switch (svg_style.BaselineShift()) {
     case BS_SUPER:
-      return CSSIdentifierValue::Create(CSSValueSuper);
+      return CSSIdentifierValue::Create(CSSValueID::kSuper);
     case BS_SUB:
-      return CSSIdentifierValue::Create(CSSValueSub);
+      return CSSIdentifierValue::Create(CSSValueID::kSub);
     case BS_LENGTH:
       return ComputedStyleUtils::ZoomAdjustedPixelValueForLength(
           svg_style.BaselineShiftValue(), style);
@@ -63,14 +64,14 @@
     return;
   }
   switch (identifier_value->GetValueID()) {
-    case CSSValueBaseline:
+    case CSSValueID::kBaseline:
       svg_style.SetBaselineShift(BS_LENGTH);
       svg_style.SetBaselineShiftValue(Length::Fixed());
       return;
-    case CSSValueSub:
+    case CSSValueID::kSub:
       svg_style.SetBaselineShift(BS_SUB);
       return;
-    case CSSValueSuper:
+    case CSSValueID::kSuper:
       svg_style.SetBaselineShift(BS_SUPER);
       return;
     default:
diff --git a/third_party/blink/renderer/core/css/properties/longhands/border_collapse_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/border_collapse_custom.cc
index d6a4bfdf..dbccd58 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/border_collapse_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/border_collapse_custom.cc
@@ -16,8 +16,8 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.BorderCollapse() == EBorderCollapse::kCollapse)
-    return CSSIdentifierValue::Create(CSSValueCollapse);
-  return CSSIdentifierValue::Create(CSSValueSeparate);
+    return CSSIdentifierValue::Create(CSSValueID::kCollapse);
+  return CSSIdentifierValue::Create(CSSValueID::kSeparate);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/border_image_repeat_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/border_image_repeat_custom.cc
index 96d7358..9a704b85 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/border_image_repeat_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/border_image_repeat_custom.cc
@@ -29,7 +29,7 @@
 
 const CSSValue* BorderImageRepeat::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueStretch)));
+                      (CSSIdentifierValue::Create(CSSValueID::kStretch)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/border_image_source_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/border_image_source_custom.cc
index ac5c4f5..f3a684f 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/border_image_source_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/border_image_source_custom.cc
@@ -29,12 +29,12 @@
     bool allow_visited_style) const {
   if (style.BorderImageSource())
     return style.BorderImageSource()->ComputedCSSValue();
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 const CSSValue* BorderImageSource::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueNone)));
+                      (CSSIdentifierValue::Create(CSSValueID::kNone)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/box_sizing_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/box_sizing_custom.cc
index 560b580..b7dfdda 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/box_sizing_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/box_sizing_custom.cc
@@ -16,8 +16,8 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.BoxSizing() == EBoxSizing::kContentBox)
-    return CSSIdentifierValue::Create(CSSValueContentBox);
-  return CSSIdentifierValue::Create(CSSValueBorderBox);
+    return CSSIdentifierValue::Create(CSSValueID::kContentBox);
+  return CSSIdentifierValue::Create(CSSValueID::kBorderBox);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/caret_color_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/caret_color_custom.cc
index 48d4150..1cd66f6 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/caret_color_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/caret_color_custom.cc
@@ -17,7 +17,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeColor(range, context.Mode());
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/clip_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/clip_custom.cc
index 968d00a..badb1a1 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/clip_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/clip_custom.cc
@@ -15,7 +15,7 @@
 
 CSSValue* ConsumeClipComponent(CSSParserTokenRange& range,
                                CSSParserMode css_parser_mode) {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeLength(
       range, css_parser_mode, kValueRangeAll,
@@ -28,10 +28,10 @@
 const CSSValue* Clip::ParseSingleValue(CSSParserTokenRange& range,
                                        const CSSParserContext& context,
                                        const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
 
-  if (range.Peek().FunctionId() != CSSValueRect)
+  if (range.Peek().FunctionId() != CSSValueID::kRect)
     return nullptr;
 
   CSSParserTokenRange args =
@@ -66,7 +66,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.HasAutoClip())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   CSSValue* top = ComputedStyleUtils::ZoomAdjustedPixelValueOrAuto(
       style.Clip().Top(), style);
   CSSValue* right = ComputedStyleUtils::ZoomAdjustedPixelValueOrAuto(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/clip_path_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/clip_path_custom.cc
index 6fcb5f9..57b048d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/clip_path_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/clip_path_custom.cc
@@ -18,7 +18,7 @@
 const CSSValue* ClipPath::ParseSingleValue(CSSParserTokenRange& range,
                                            const CSSParserContext& context,
                                            const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   if (cssvalue::CSSURIValue* url =
           css_property_parser_helpers::ConsumeUrl(range, &context))
@@ -42,7 +42,7 @@
           To<ReferenceClipPathOperation>(operation)->Url());
     }
   }
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/color_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/color_custom.cc
index 790c983..14a0b2dd 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/color_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/color_custom.cc
@@ -61,7 +61,7 @@
   // As per the spec, 'color: currentColor' is treated as 'color: inherit'
   auto* identifier_value = DynamicTo<CSSIdentifierValue>(value);
   if (identifier_value &&
-      identifier_value->GetValueID() == CSSValueCurrentcolor) {
+      identifier_value->GetValueID() == CSSValueID::kCurrentcolor) {
     ApplyInherit(state);
     return;
   }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/column_count_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/column_count_custom.cc
index 629c19f..ae3332d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/column_count_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/column_count_custom.cc
@@ -24,7 +24,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.HasAutoColumnCount())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSPrimitiveValue::Create(style.ColumnCount(),
                                    CSSPrimitiveValue::UnitType::kNumber);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/column_span_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/column_span_custom.cc
index 030e7a8..a7370f09d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/column_span_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/column_span_custom.cc
@@ -13,8 +13,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  return css_property_parser_helpers::ConsumeIdent<CSSValueAll, CSSValueNone>(
-      range);
+  return css_property_parser_helpers::ConsumeIdent<CSSValueID::kAll,
+                                                   CSSValueID::kNone>(range);
 }
 
 const CSSValue* ColumnSpan::CSSValueFromComputedStyleInternal(
@@ -24,8 +24,8 @@
     Node*,
     bool allow_visited_style) const {
   return CSSIdentifierValue::Create(static_cast<unsigned>(style.GetColumnSpan())
-                                        ? CSSValueAll
-                                        : CSSValueNone);
+                                        ? CSSValueID::kAll
+                                        : CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/column_width_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/column_width_custom.cc
index d8f23451..26a3b23 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/column_width_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/column_width_custom.cc
@@ -25,7 +25,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.HasAutoColumnWidth())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return ZoomAdjustedPixelValue(style.ColumnWidth(), style);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/contain_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/contain_custom.cc
index cfcbfe0..bb0c7a7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/contain_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/contain_custom.cc
@@ -17,11 +17,11 @@
                                           const CSSParserContext& context,
                                           const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
-  if (id == CSSValueStrict || id == CSSValueContent) {
+  if (id == CSSValueID::kStrict || id == CSSValueID::kContent) {
     list->Append(*css_property_parser_helpers::ConsumeIdent(range));
     return list;
   }
@@ -32,13 +32,13 @@
   CSSIdentifierValue* paint = nullptr;
   while (true) {
     id = range.Peek().Id();
-    if (id == CSSValueSize && !size)
+    if (id == CSSValueID::kSize && !size)
       size = css_property_parser_helpers::ConsumeIdent(range);
-    else if (id == CSSValueLayout && !layout)
+    else if (id == CSSValueID::kLayout && !layout)
       layout = css_property_parser_helpers::ConsumeIdent(range);
-    else if (id == CSSValueStyle && !style)
+    else if (id == CSSValueID::kStyle && !style)
       style = css_property_parser_helpers::ConsumeIdent(range);
-    else if (id == CSSValuePaint && !paint)
+    else if (id == CSSValueID::kPaint && !paint)
       paint = css_property_parser_helpers::ConsumeIdent(range);
     else
       break;
@@ -63,21 +63,21 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.Contain())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   if (style.Contain() == kContainsStrict)
-    return CSSIdentifierValue::Create(CSSValueStrict);
+    return CSSIdentifierValue::Create(CSSValueID::kStrict);
   if (style.Contain() == kContainsContent)
-    return CSSIdentifierValue::Create(CSSValueContent);
+    return CSSIdentifierValue::Create(CSSValueID::kContent);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   if (style.ContainsSize())
-    list->Append(*CSSIdentifierValue::Create(CSSValueSize));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kSize));
   if (style.Contain() & kContainsLayout)
-    list->Append(*CSSIdentifierValue::Create(CSSValueLayout));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kLayout));
   if (style.ContainsStyle())
-    list->Append(*CSSIdentifierValue::Create(CSSValueStyle));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kStyle));
   if (style.ContainsPaint())
-    list->Append(*CSSIdentifierValue::Create(CSSValuePaint));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kPaint));
   DCHECK(list->length());
   return list;
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/content_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/content_custom.cc
index 4188af07..a9ec2b1 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/content_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/content_custom.cc
@@ -30,7 +30,7 @@
   if (context.IsHTMLDocument())
     attr_name = attr_name.LowerASCII();
 
-  CSSFunctionValue* attr_value = CSSFunctionValue::Create(CSSValueAttr);
+  CSSFunctionValue* attr_value = CSSFunctionValue::Create(CSSValueID::kAttr);
   attr_value->Append(*CSSCustomIdentValue::Create(attr_name));
   return attr_value;
 }
@@ -57,12 +57,12 @@
   CSSIdentifierValue* list_style = nullptr;
   if (css_property_parser_helpers::ConsumeCommaIncludingWhitespace(args)) {
     CSSValueID id = args.Peek().Id();
-    if ((id != CSSValueNone &&
-         (id < CSSValueDisc || id > CSSValueKatakanaIroha)))
+    if ((id != CSSValueID::kNone &&
+         (id < CSSValueID::kDisc || id > CSSValueID::kKatakanaIroha)))
       return nullptr;
     list_style = css_property_parser_helpers::ConsumeIdent(args);
   } else {
-    list_style = CSSIdentifierValue::Create(CSSValueDecimal);
+    list_style = CSSIdentifierValue::Create(CSSValueID::kDecimal);
   }
 
   if (!args.AtEnd())
@@ -76,7 +76,8 @@
 const CSSValue* Content::ParseSingleValue(CSSParserTokenRange& range,
                                           const CSSParserContext& context,
                                           const CSSParserLocalContext&) const {
-  if (css_property_parser_helpers::IdentMatches<CSSValueNone, CSSValueNormal>(
+  if (css_property_parser_helpers::IdentMatches<CSSValueID::kNone,
+                                                CSSValueID::kNormal>(
           range.Peek().Id()))
     return css_property_parser_helpers::ConsumeIdent(range);
 
@@ -87,20 +88,20 @@
         css_property_parser_helpers::ConsumeImage(range, &context);
     if (!parsed_value) {
       parsed_value = css_property_parser_helpers::ConsumeIdent<
-          CSSValueOpenQuote, CSSValueCloseQuote, CSSValueNoOpenQuote,
-          CSSValueNoCloseQuote>(range);
+          CSSValueID::kOpenQuote, CSSValueID::kCloseQuote,
+          CSSValueID::kNoOpenQuote, CSSValueID::kNoCloseQuote>(range);
     }
     if (!parsed_value)
       parsed_value = css_property_parser_helpers::ConsumeString(range);
     if (!parsed_value) {
-      if (range.Peek().FunctionId() == CSSValueAttr) {
+      if (range.Peek().FunctionId() == CSSValueID::kAttr) {
         parsed_value = ConsumeAttr(
             css_property_parser_helpers::ConsumeFunction(range), context);
-      } else if (range.Peek().FunctionId() == CSSValueCounter) {
+      } else if (range.Peek().FunctionId() == CSSValueID::kCounter) {
         parsed_value = ConsumeCounterContent(
             css_property_parser_helpers::ConsumeFunction(range), context,
             false);
-      } else if (range.Peek().FunctionId() == CSSValueCounters) {
+      } else if (range.Peek().FunctionId() == CSSValueID::kCounters) {
         parsed_value = ConsumeCounterContent(
             css_property_parser_helpers::ConsumeFunction(range), context, true);
       }
@@ -134,8 +135,8 @@
 void Content::ApplyValue(StyleResolverState& state,
                          const CSSValue& value) const {
   if (auto* identifier_value = DynamicTo<CSSIdentifierValue>(value)) {
-    DCHECK(identifier_value->GetValueID() == CSSValueNormal ||
-           identifier_value->GetValueID() == CSSValueNone);
+    DCHECK(identifier_value->GetValueID() == CSSValueID::kNormal ||
+           identifier_value->GetValueID() == CSSValueID::kNone);
     state.Style()->SetContent(nullptr);
     return;
   }
@@ -164,16 +165,16 @@
         default:
           NOTREACHED();
           FALLTHROUGH;
-        case CSSValueOpenQuote:
+        case CSSValueID::kOpenQuote:
           quote_type = QuoteType::kOpen;
           break;
-        case CSSValueCloseQuote:
+        case CSSValueID::kCloseQuote:
           quote_type = QuoteType::kClose;
           break;
-        case CSSValueNoOpenQuote:
+        case CSSValueID::kNoOpenQuote:
           quote_type = QuoteType::kNoOpen;
           break;
-        case CSSValueNoCloseQuote:
+        case CSSValueID::kNoCloseQuote:
           quote_type = QuoteType::kNoClose;
           break;
       }
@@ -182,7 +183,7 @@
       String string;
       if (const auto* function_value =
               DynamicTo<CSSFunctionValue>(item.Get())) {
-        DCHECK_EQ(function_value->FunctionType(), CSSValueAttr);
+        DCHECK_EQ(function_value->FunctionType(), CSSValueID::kAttr);
         state.Style()->SetHasAttrContent();
         // TODO: Can a namespace be specified for an attr(foo)?
         QualifiedName attr(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/cursor_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/cursor_custom.cc
index e70a686..81bb82e 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/cursor_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/cursor_custom.cc
@@ -46,23 +46,23 @@
 
   CSSValueID id = range.Peek().Id();
   if (!range.AtEnd()) {
-    if (id == CSSValueWebkitZoomIn)
+    if (id == CSSValueID::kWebkitZoomIn)
       context.Count(WebFeature::kPrefixedCursorZoomIn);
-    else if (id == CSSValueWebkitZoomOut)
+    else if (id == CSSValueID::kWebkitZoomOut)
       context.Count(WebFeature::kPrefixedCursorZoomOut);
-    else if (id == CSSValueWebkitGrab)
+    else if (id == CSSValueID::kWebkitGrab)
       context.Count(WebFeature::kPrefixedCursorGrab);
-    else if (id == CSSValueWebkitGrabbing)
+    else if (id == CSSValueID::kWebkitGrabbing)
       context.Count(WebFeature::kPrefixedCursorGrabbing);
   }
   CSSValue* cursor_type = nullptr;
-  if (id == CSSValueHand) {
+  if (id == CSSValueID::kHand) {
     if (!in_quirks_mode)  // Non-standard behavior
       return nullptr;
-    cursor_type = CSSIdentifierValue::Create(CSSValuePointer);
+    cursor_type = CSSIdentifierValue::Create(CSSValueID::kPointer);
     range.ConsumeIncludingWhitespace();
-  } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) ||
-             id == CSSValueCopy || id == CSSValueNone) {
+  } else if ((id >= CSSValueID::kAuto && id <= CSSValueID::kWebkitZoomOut) ||
+             id == CSSValueID::kCopy || id == CSSValueID::kNone) {
     cursor_type = css_property_parser_helpers::ConsumeIdent(range);
   } else {
     return nullptr;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/d_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/d_custom.cc
index c24d8c194..aaade2d2 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/d_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/d_custom.cc
@@ -24,7 +24,7 @@
     bool allow_visited_style) const {
   if (const StylePath* style_path = svg_style.D())
     return style_path->ComputedCSSValue();
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/display_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/display_custom.cc
index 6bdde0c..1a909143 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/display_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/display_custom.cc
@@ -25,7 +25,7 @@
     return nullptr;
 
   CSSValueID function = range.Peek().FunctionId();
-  if (function != CSSValueLayout && function != CSSValueInlineLayout)
+  if (function != CSSValueID::kLayout && function != CSSValueID::kInlineLayout)
     return nullptr;
 
   CSSParserTokenRange range_copy = range;
@@ -41,7 +41,7 @@
 
   range = range_copy;
   return cssvalue::CSSLayoutFunctionValue::Create(
-      name, /* is_inline */ function == CSSValueInlineLayout);
+      name, /* is_inline */ function == CSSValueID::kInlineLayout);
 }
 
 const CSSValue* Display::CSSValueFromComputedStyleInternal(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/flex_basis_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/flex_basis_custom.cc
index f186c40..4b6f569 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/flex_basis_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/flex_basis_custom.cc
@@ -16,7 +16,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   // FIXME: Support intrinsic dimensions too.
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeLengthOrPercent(
       range, context.Mode(), kValueRangeNonNegative);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/float_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/float_custom.cc
index 3eacdda..86658d8 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/float_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/float_custom.cc
@@ -16,7 +16,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.Display() != EDisplay::kNone && style.HasOutOfFlowPosition())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return CSSIdentifierValue::Create(style.Floating());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_feature_settings_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_feature_settings_custom.cc
index 68ddb3d..8a6de17 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_feature_settings_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_feature_settings_custom.cc
@@ -27,7 +27,7 @@
   const blink::FontFeatureSettings* feature_settings =
       style.GetFontDescription().FeatureSettings();
   if (!feature_settings || !feature_settings->size())
-    return CSSIdentifierValue::Create(CSSValueNormal);
+    return CSSIdentifierValue::Create(CSSValueID::kNormal);
   CSSValueList* list = CSSValueList::CreateCommaSeparated();
   for (wtf_size_t i = 0; i < feature_settings->size(); ++i) {
     const FontFeature& feature = feature_settings->at(i);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_size_adjust_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_size_adjust_custom.cc
index 182ee12..0c0750c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_size_adjust_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_size_adjust_custom.cc
@@ -17,7 +17,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   DCHECK(RuntimeEnabledFeatures::CSSFontSizeAdjustEnabled());
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeNumber(range,
                                                     kValueRangeNonNegative);
@@ -33,7 +33,7 @@
     return CSSPrimitiveValue::Create(style.FontSizeAdjust(),
                                      CSSPrimitiveValue::UnitType::kNumber);
   }
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_variant_caps_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_variant_caps_custom.cc
index d129401..8e2468d0 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_variant_caps_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_variant_caps_custom.cc
@@ -17,9 +17,9 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeIdent<
-      CSSValueNormal, CSSValueSmallCaps, CSSValueAllSmallCaps,
-      CSSValuePetiteCaps, CSSValueAllPetiteCaps, CSSValueUnicase,
-      CSSValueTitlingCaps>(range);
+      CSSValueID::kNormal, CSSValueID::kSmallCaps, CSSValueID::kAllSmallCaps,
+      CSSValueID::kPetiteCaps, CSSValueID::kAllPetiteCaps, CSSValueID::kUnicase,
+      CSSValueID::kTitlingCaps>(range);
 }
 
 const CSSValue* FontVariantCaps::CSSValueFromComputedStyleInternal(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_variant_east_asian_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_variant_east_asian_custom.cc
index 4fad3ff..ebabe47a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_variant_east_asian_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_variant_east_asian_custom.cc
@@ -16,7 +16,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNormal)
+  if (range.Peek().Id() == CSSValueID::kNormal)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   FontVariantEastAsianParser east_asian_parser;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_variant_ligatures_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_variant_ligatures_custom.cc
index 3d0f7921..a8fea93a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_variant_ligatures_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_variant_ligatures_custom.cc
@@ -16,7 +16,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNormal || range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNormal ||
+      range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   FontVariantLigaturesParser ligatures_parser;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_variant_numeric_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_variant_numeric_custom.cc
index 999082a7..c76a1d3b 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_variant_numeric_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_variant_numeric_custom.cc
@@ -16,7 +16,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNormal)
+  if (range.Peek().Id() == CSSValueID::kNormal)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   FontVariantNumericParser numeric_parser;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/font_variation_settings_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/font_variation_settings_custom.cc
index 96c5224f..f135f1b 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/font_variation_settings_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/font_variation_settings_custom.cc
@@ -48,7 +48,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNormal)
+  if (range.Peek().Id() == CSSValueID::kNormal)
     return css_property_parser_helpers::ConsumeIdent(range);
   CSSValueList* variation_settings = CSSValueList::CreateCommaSeparated();
   do {
@@ -70,7 +70,7 @@
   const blink::FontVariationSettings* variation_settings =
       style.GetFontDescription().VariationSettings();
   if (!variation_settings || !variation_settings->size())
-    return CSSIdentifierValue::Create(CSSValueNormal);
+    return CSSIdentifierValue::Create(CSSValueID::kNormal);
   CSSValueList* list = CSSValueList::CreateCommaSeparated();
   for (wtf_size_t i = 0; i < variation_settings->size(); ++i) {
     const FontVariationAxis& variation_axis = variation_settings->at(i);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/grid_auto_flow_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/grid_auto_flow_custom.cc
index 5120a20..11a12e97 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/grid_auto_flow_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/grid_auto_flow_custom.cc
@@ -17,14 +17,14 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSIdentifierValue* row_or_column_value =
-      css_property_parser_helpers::ConsumeIdent<CSSValueRow, CSSValueColumn>(
-          range);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kRow,
+                                                CSSValueID::kColumn>(range);
   CSSIdentifierValue* dense_algorithm =
-      css_property_parser_helpers::ConsumeIdent<CSSValueDense>(range);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kDense>(range);
   if (!row_or_column_value) {
     row_or_column_value =
-        css_property_parser_helpers::ConsumeIdent<CSSValueRow, CSSValueColumn>(
-            range);
+        css_property_parser_helpers::ConsumeIdent<CSSValueID::kRow,
+                                                  CSSValueID::kColumn>(range);
     if (!row_or_column_value && !dense_algorithm)
       return nullptr;
   }
@@ -46,11 +46,11 @@
   switch (style.GetGridAutoFlow()) {
     case kAutoFlowRow:
     case kAutoFlowRowDense:
-      list->Append(*CSSIdentifierValue::Create(CSSValueRow));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kRow));
       break;
     case kAutoFlowColumn:
     case kAutoFlowColumnDense:
-      list->Append(*CSSIdentifierValue::Create(CSSValueColumn));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kColumn));
       break;
     default:
       NOTREACHED();
@@ -59,7 +59,7 @@
   switch (style.GetGridAutoFlow()) {
     case kAutoFlowRowDense:
     case kAutoFlowColumnDense:
-      list->Append(*CSSIdentifierValue::Create(CSSValueDense));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kDense));
       break;
     default:
       // Do nothing.
diff --git a/third_party/blink/renderer/core/css/properties/longhands/grid_template_areas_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/grid_template_areas_custom.cc
index a634d96..88ae6f1 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/grid_template_areas_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/grid_template_areas_custom.cc
@@ -22,7 +22,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext&,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   NamedGridAreaMap grid_area_map;
@@ -52,7 +52,7 @@
     bool allow_visited_style) const {
   if (!style.NamedGridAreaRowCount()) {
     DCHECK(!style.NamedGridAreaColumnCount());
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   }
 
   return cssvalue::CSSGridTemplateAreasValue::Create(
@@ -81,7 +81,7 @@
                                    const CSSValue& value) const {
   if (auto* identifier_value = DynamicTo<CSSIdentifierValue>(value)) {
     // FIXME: Shouldn't we clear the grid-area values
-    DCHECK_EQ(identifier_value->GetValueID(), CSSValueNone);
+    DCHECK_EQ(identifier_value->GetValueID(), CSSValueID::kNone);
     return;
   }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/image_orientation_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/image_orientation_custom.cc
index 83946507..41f52e0 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/image_orientation_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/image_orientation_custom.cc
@@ -18,7 +18,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   DCHECK(RuntimeEnabledFeatures::ImageOrientationEnabled());
-  if (range.Peek().Id() == CSSValueFromImage)
+  if (range.Peek().Id() == CSSValueID::kFromImage)
     return css_property_parser_helpers::ConsumeIdent(range);
   if (range.Peek().GetType() != kNumberToken) {
     CSSPrimitiveValue* angle = css_property_parser_helpers::ConsumeAngle(
@@ -36,7 +36,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.RespectImageOrientation() == kRespectImageOrientation)
-    return CSSIdentifierValue::Create(CSSValueFromImage);
+    return CSSIdentifierValue::Create(CSSValueID::kFromImage);
   return CSSPrimitiveValue::Create(0, CSSPrimitiveValue::UnitType::kDegrees);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/justify_content_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/justify_content_custom.cc
index 0bada6e..ab88b66 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/justify_content_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/justify_content_custom.cc
@@ -16,8 +16,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   // justify-content property does not allow the <baseline-position> values.
-  if (css_property_parser_helpers::IdentMatches<CSSValueFirst, CSSValueLast,
-                                                CSSValueBaseline>(
+  if (css_property_parser_helpers::IdentMatches<
+          CSSValueID::kFirst, CSSValueID::kLast, CSSValueID::kBaseline>(
           range.Peek().Id()))
     return nullptr;
   return css_parsing_utils::ConsumeContentDistributionOverflowPosition(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/justify_items_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/justify_items_custom.cc
index 327401e..fa73607 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/justify_items_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/justify_items_custom.cc
@@ -20,17 +20,19 @@
     const CSSParserLocalContext&) const {
   CSSParserTokenRange range_copy = range;
   // justify-items property does not allow the 'auto' value.
-  if (css_property_parser_helpers::IdentMatches<CSSValueAuto>(
+  if (css_property_parser_helpers::IdentMatches<CSSValueID::kAuto>(
           range.Peek().Id()))
     return nullptr;
   CSSIdentifierValue* legacy =
-      css_property_parser_helpers::ConsumeIdent<CSSValueLegacy>(range_copy);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kLegacy>(
+          range_copy);
   CSSIdentifierValue* position_keyword =
-      css_property_parser_helpers::ConsumeIdent<CSSValueCenter, CSSValueLeft,
-                                                CSSValueRight>(range_copy);
+      css_property_parser_helpers::ConsumeIdent<
+          CSSValueID::kCenter, CSSValueID::kLeft, CSSValueID::kRight>(
+          range_copy);
   if (!legacy) {
-    legacy =
-        css_property_parser_helpers::ConsumeIdent<CSSValueLegacy>(range_copy);
+    legacy = css_property_parser_helpers::ConsumeIdent<CSSValueID::kLegacy>(
+        range_copy);
   }
   if (legacy) {
     range = range_copy;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/letter_spacing_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/letter_spacing_custom.cc
index 612ec5b..674547a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/letter_spacing_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/letter_spacing_custom.cc
@@ -25,7 +25,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.LetterSpacing())
-    return CSSIdentifierValue::Create(CSSValueNormal);
+    return CSSIdentifierValue::Create(CSSValueID::kNormal);
   return ZoomAdjustedPixelValue(style.LetterSpacing(), style);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/list_style_image_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/list_style_image_custom.cc
index d904c6d..43902d0 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/list_style_image_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/list_style_image_custom.cc
@@ -28,7 +28,7 @@
     bool allow_visited_style) const {
   if (style.ListStyleImage())
     return style.ListStyleImage()->ComputedCSSValue();
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 void ListStyleImage::ApplyValue(StyleResolverState& state,
diff --git a/third_party/blink/renderer/core/css/properties/longhands/marker_end_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/marker_end_custom.cc
index 092e27b..1f76a606 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/marker_end_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/marker_end_custom.cc
@@ -17,7 +17,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeUrl(range, &context);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/marker_mid_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/marker_mid_custom.cc
index e6f75ae..8fb3ae9 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/marker_mid_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/marker_mid_custom.cc
@@ -17,7 +17,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeUrl(range, &context);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/marker_start_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/marker_start_custom.cc
index 8fcf23a..b24d294 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/marker_start_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/marker_start_custom.cc
@@ -17,7 +17,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeUrl(range, &context);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/mask_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/mask_custom.cc
index c891a09..9fc71bd 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/mask_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/mask_custom.cc
@@ -16,7 +16,7 @@
 const CSSValue* Mask::ParseSingleValue(CSSParserTokenRange& range,
                                        const CSSParserContext& context,
                                        const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeUrl(range, &context);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/mask_source_type_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/mask_source_type_custom.cc
index 70c72ab0..042b1f9 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/mask_source_type_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/mask_source_type_custom.cc
@@ -21,9 +21,9 @@
 static CSSValue* ValueForFillSourceType(EMaskSourceType type) {
   switch (type) {
     case EMaskSourceType::kAlpha:
-      return CSSIdentifierValue::Create(CSSValueAlpha);
+      return CSSIdentifierValue::Create(CSSValueID::kAlpha);
     case EMaskSourceType::kLuminance:
-      return CSSIdentifierValue::Create(CSSValueLuminance);
+      return CSSIdentifierValue::Create(CSSValueID::kLuminance);
   }
   NOTREACHED();
   return nullptr;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/max_height_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/max_height_custom.cc
index 76456f5d..72c0f39 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/max_height_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/max_height_custom.cc
@@ -27,7 +27,7 @@
     bool allow_visited_style) const {
   const Length& max_height = style.MaxHeight();
   if (max_height.IsMaxSizeNone())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return ComputedStyleUtils::ZoomAdjustedPixelValueForLength(max_height, style);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/max_width_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/max_width_custom.cc
index 5dd083db..87ee6d0 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/max_width_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/max_width_custom.cc
@@ -26,7 +26,7 @@
     bool allow_visited_style) const {
   const Length& max_width = style.MaxWidth();
   if (max_width.IsMaxSizeNone())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return ComputedStyleUtils::ZoomAdjustedPixelValueForLength(max_width, style);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/offset_anchor_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/offset_anchor_custom.cc
index f1d20ee3..61913de 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/offset_anchor_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/offset_anchor_custom.cc
@@ -21,7 +21,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueAuto)
+  if (id == CSSValueID::kAuto)
     return ConsumeIdent(range);
   return ConsumePosition(range, context, UnitlessQuirk::kForbid,
                          base::Optional<WebFeature>());
diff --git a/third_party/blink/renderer/core/css/properties/longhands/offset_path_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/offset_path_custom.cc
index 3146325..e39339d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/offset_path_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/offset_path_custom.cc
@@ -25,7 +25,7 @@
     bool allow_visited_style) const {
   if (const BasicShape* style_motion_path = style.OffsetPath())
     return ValueForBasicShape(style, style_motion_path);
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/offset_position_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/offset_position_custom.cc
index f7fa82f..5f9dcf7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/offset_position_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/offset_position_custom.cc
@@ -21,7 +21,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueAuto)
+  if (id == CSSValueID::kAuto)
     return ConsumeIdent(range);
   CSSValue* value = ConsumePosition(range, context, UnitlessQuirk::kForbid,
                                     base::Optional<WebFeature>());
diff --git a/third_party/blink/renderer/core/css/properties/longhands/offset_rotate_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/offset_rotate_custom.cc
index de1a31d..066f4dd 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/offset_rotate_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/offset_rotate_custom.cc
@@ -23,7 +23,7 @@
     bool allow_visited_style) const {
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   if (style.OffsetRotate().type == OffsetRotationType::kAuto)
-    list->Append(*CSSIdentifierValue::Create(CSSValueAuto));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kAuto));
   list->Append(*CSSPrimitiveValue::Create(
       style.OffsetRotate().angle, CSSPrimitiveValue::UnitType::kDegrees));
   return list;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/outline_color_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/outline_color_custom.cc
index aebb8f0..09e55f8 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/outline_color_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/outline_color_custom.cc
@@ -18,7 +18,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   // Allow the special focus color even in HTML Standard parsing mode.
-  if (range.Peek().Id() == CSSValueWebkitFocusRingColor)
+  if (range.Peek().Id() == CSSValueID::kWebkitFocusRingColor)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeColor(range, context.Mode());
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/outline_style_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/outline_style_custom.cc
index 9966473..c04527c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/outline_style_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/outline_style_custom.cc
@@ -17,7 +17,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.OutlineStyleIsAuto())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSIdentifierValue::Create(style.OutlineStyle());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/page_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/page_custom.cc
index 68be30e..873d8d18 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/page_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/page_custom.cc
@@ -12,7 +12,7 @@
 const CSSValue* Page::ParseSingleValue(CSSParserTokenRange& range,
                                        const CSSParserContext& context,
                                        const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeCustomIdent(range, context);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/paint_order_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/paint_order_custom.cc
index 6a0e2fd..3ac43b7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/paint_order_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/paint_order_custom.cc
@@ -15,7 +15,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNormal)
+  if (range.Peek().Id() == CSSValueID::kNormal)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   Vector<CSSValueID, 3> paint_type_list;
@@ -24,11 +24,11 @@
   CSSIdentifierValue* markers = nullptr;
   do {
     CSSValueID id = range.Peek().Id();
-    if (id == CSSValueFill && !fill)
+    if (id == CSSValueID::kFill && !fill)
       fill = css_property_parser_helpers::ConsumeIdent(range);
-    else if (id == CSSValueStroke && !stroke)
+    else if (id == CSSValueID::kStroke && !stroke)
       stroke = css_property_parser_helpers::ConsumeIdent(range);
-    else if (id == CSSValueMarkers && !markers)
+    else if (id == CSSValueID::kMarkers && !markers)
       markers = css_property_parser_helpers::ConsumeIdent(range);
     else
       return nullptr;
@@ -41,19 +41,19 @@
   CSSValueID first_paint_order_type = paint_type_list.at(0);
   CSSValueList* paint_order_list = CSSValueList::CreateSpaceSeparated();
   switch (first_paint_order_type) {
-    case CSSValueFill:
-    case CSSValueStroke:
+    case CSSValueID::kFill:
+    case CSSValueID::kStroke:
       paint_order_list->Append(
-          first_paint_order_type == CSSValueFill ? *fill : *stroke);
+          first_paint_order_type == CSSValueID::kFill ? *fill : *stroke);
       if (paint_type_list.size() > 1) {
-        if (paint_type_list.at(1) == CSSValueMarkers)
+        if (paint_type_list.at(1) == CSSValueID::kMarkers)
           paint_order_list->Append(*markers);
       }
       break;
-    case CSSValueMarkers:
+    case CSSValueID::kMarkers:
       paint_order_list->Append(*markers);
       if (paint_type_list.size() > 1) {
-        if (paint_type_list.at(1) == CSSValueStroke)
+        if (paint_type_list.at(1) == CSSValueID::kStroke)
           paint_order_list->Append(*stroke);
       }
       break;
@@ -72,7 +72,7 @@
     bool allow_visited_style) const {
   const EPaintOrder paint_order = svg_style.PaintOrder();
   if (paint_order == kPaintOrderNormal)
-    return CSSIdentifierValue::Create(CSSValueNormal);
+    return CSSIdentifierValue::Create(CSSValueID::kNormal);
 
   // Table mapping to the shortest (canonical) form of the property.
   //
diff --git a/third_party/blink/renderer/core/css/properties/longhands/perspective_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/perspective_custom.cc
index 19f423c3..4772fb61 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/perspective_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/perspective_custom.cc
@@ -18,7 +18,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext& localContext) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   CSSPrimitiveValue* parsed_value = css_property_parser_helpers::ConsumeLength(
       range, context.Mode(), kValueRangeAll);
@@ -44,7 +44,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.HasPerspective())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return ZoomAdjustedPixelValue(style.Perspective(), style);
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/quotes_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/quotes_custom.cc
index 9524d5e..1bde966 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/quotes_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/quotes_custom.cc
@@ -16,7 +16,7 @@
 const CSSValue* Quotes::ParseSingleValue(CSSParserTokenRange& range,
                                          const CSSParserContext& context,
                                          const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   CSSValueList* values = CSSValueList::CreateSpaceSeparated();
   while (!range.AtEnd()) {
@@ -50,7 +50,7 @@
     }
     return list;
   }
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/resize_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/resize_custom.cc
index 1fe82500..72362e30 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/resize_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/resize_custom.cc
@@ -25,7 +25,7 @@
   const CSSIdentifierValue& identifier_value = To<CSSIdentifierValue>(value);
 
   EResize r = EResize::kNone;
-  if (identifier_value.GetValueID() == CSSValueAuto) {
+  if (identifier_value.GetValueID() == CSSValueID::kAuto) {
     if (Settings* settings = state.GetDocument().GetSettings()) {
       r = settings->GetTextAreasAreResizable() ? EResize::kBoth
                                                : EResize::kNone;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/rotate_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/rotate_custom.cc
index 9e46283b..96facc06 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/rotate_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/rotate_custom.cc
@@ -20,7 +20,7 @@
   DCHECK(RuntimeEnabledFeatures::CSSIndependentTransformPropertiesEnabled());
 
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
@@ -52,7 +52,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.Rotate())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   if (style.Rotate()->X() != 0 || style.Rotate()->Y() != 0 ||
diff --git a/third_party/blink/renderer/core/css/properties/longhands/rx_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/rx_custom.cc
index 231414c..ef60309 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/rx_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/rx_custom.cc
@@ -13,7 +13,7 @@
 const CSSValue* Rx::ParseSingleValue(CSSParserTokenRange& range,
                                      const CSSParserContext& context,
                                      const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeSVGGeometryPropertyLength(
       range, context, kValueRangeNonNegative);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/ry_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/ry_custom.cc
index d8f95008..deeb9f5 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/ry_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/ry_custom.cc
@@ -13,7 +13,7 @@
 const CSSValue* Ry::ParseSingleValue(CSSParserTokenRange& range,
                                      const CSSParserContext& context,
                                      const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeSVGGeometryPropertyLength(
       range, context, kValueRangeNonNegative);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/scale_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/scale_custom.cc
index 461a180..e99ad9d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/scale_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/scale_custom.cc
@@ -18,7 +18,7 @@
   DCHECK(RuntimeEnabledFeatures::CSSIndependentTransformPropertiesEnabled());
 
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValue* scale =
@@ -45,7 +45,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.Scale())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   list->Append(*CSSPrimitiveValue::Create(
       style.Scale()->X(), CSSPrimitiveValue::UnitType::kNumber));
diff --git a/third_party/blink/renderer/core/css/properties/longhands/scroll_customization_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/scroll_customization_custom.cc
index 8f1e4e4..a9b303f 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/scroll_customization_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/scroll_customization_custom.cc
@@ -18,11 +18,12 @@
                        CSSValue** pan_x,
                        CSSValue** pan_y) {
   CSSValueID id = range.Peek().Id();
-  if ((id == CSSValuePanX || id == CSSValuePanRight || id == CSSValuePanLeft) &&
+  if ((id == CSSValueID::kPanX || id == CSSValueID::kPanRight ||
+       id == CSSValueID::kPanLeft) &&
       !*pan_x) {
     *pan_x = css_property_parser_helpers::ConsumeIdent(range);
-  } else if ((id == CSSValuePanY || id == CSSValuePanDown ||
-              id == CSSValuePanUp) &&
+  } else if ((id == CSSValueID::kPanY || id == CSSValueID::kPanDown ||
+              id == CSSValueID::kPanUp) &&
              !*pan_y) {
     *pan_y = css_property_parser_helpers::ConsumeIdent(range);
   } else {
@@ -40,7 +41,7 @@
     const CSSParserLocalContext&) const {
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueAuto || id == CSSValueNone) {
+  if (id == CSSValueID::kAuto || id == CSSValueID::kNone) {
     list->Append(*css_property_parser_helpers::ConsumeIdent(range));
     return list;
   }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_align_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_align_custom.cc
index 3fc3e66..1fb15a52 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_align_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_align_custom.cc
@@ -17,14 +17,16 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValue* block_value = css_property_parser_helpers::ConsumeIdent<
-      CSSValueNone, CSSValueStart, CSSValueEnd, CSSValueCenter>(range);
+      CSSValueID::kNone, CSSValueID::kStart, CSSValueID::kEnd,
+      CSSValueID::kCenter>(range);
   if (!block_value)
     return nullptr;
   if (range.AtEnd())
     return block_value;
 
   CSSValue* inline_value = css_property_parser_helpers::ConsumeIdent<
-      CSSValueNone, CSSValueStart, CSSValueEnd, CSSValueCenter>(range);
+      CSSValueID::kNone, CSSValueID::kStart, CSSValueID::kEnd,
+      CSSValueID::kCenter>(range);
   if (!inline_value)
     return block_value;
   CSSValuePair* pair = CSSValuePair::Create(block_value, inline_value,
diff --git a/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_type_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_type_custom.cc
index edc61c33..00310c4 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_type_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/scroll_snap_type_custom.cc
@@ -17,16 +17,17 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID axis_id = range.Peek().Id();
-  if (axis_id != CSSValueNone && axis_id != CSSValueX && axis_id != CSSValueY &&
-      axis_id != CSSValueBlock && axis_id != CSSValueInline &&
-      axis_id != CSSValueBoth)
+  if (axis_id != CSSValueID::kNone && axis_id != CSSValueID::kX &&
+      axis_id != CSSValueID::kY && axis_id != CSSValueID::kBlock &&
+      axis_id != CSSValueID::kInline && axis_id != CSSValueID::kBoth)
     return nullptr;
   CSSValue* axis_value = css_property_parser_helpers::ConsumeIdent(range);
-  if (range.AtEnd() || axis_id == CSSValueNone)
+  if (range.AtEnd() || axis_id == CSSValueID::kNone)
     return axis_value;
 
   CSSValueID strictness_id = range.Peek().Id();
-  if (strictness_id != CSSValueProximity && strictness_id != CSSValueMandatory)
+  if (strictness_id != CSSValueID::kProximity &&
+      strictness_id != CSSValueID::kMandatory)
     return axis_value;
   CSSValue* strictness_value = css_property_parser_helpers::ConsumeIdent(range);
   CSSValuePair* pair = CSSValuePair::Create(axis_value, strictness_value,
diff --git a/third_party/blink/renderer/core/css/properties/longhands/size_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/size_custom.cc
index be6e4e2..0443ed5 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/size_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/size_custom.cc
@@ -14,8 +14,9 @@
 
 static CSSValue* ConsumePageSize(CSSParserTokenRange& range) {
   return css_property_parser_helpers::ConsumeIdent<
-      CSSValueA3, CSSValueA4, CSSValueA5, CSSValueB4, CSSValueB5,
-      CSSValueLedger, CSSValueLegal, CSSValueLetter>(range);
+      CSSValueID::kA3, CSSValueID::kA4, CSSValueID::kA5, CSSValueID::kB4,
+      CSSValueID::kB5, CSSValueID::kLedger, CSSValueID::kLegal,
+      CSSValueID::kLetter>(range);
 }
 
 static float MmToPx(float mm) {
@@ -26,21 +27,21 @@
 }
 static FloatSize GetPageSizeFromName(const CSSIdentifierValue& page_size_name) {
   switch (page_size_name.GetValueID()) {
-    case CSSValueA5:
+    case CSSValueID::kA5:
       return FloatSize(MmToPx(148), MmToPx(210));
-    case CSSValueA4:
+    case CSSValueID::kA4:
       return FloatSize(MmToPx(210), MmToPx(297));
-    case CSSValueA3:
+    case CSSValueID::kA3:
       return FloatSize(MmToPx(297), MmToPx(420));
-    case CSSValueB5:
+    case CSSValueID::kB5:
       return FloatSize(MmToPx(176), MmToPx(250));
-    case CSSValueB4:
+    case CSSValueID::kB4:
       return FloatSize(MmToPx(250), MmToPx(353));
-    case CSSValueLetter:
+    case CSSValueID::kLetter:
       return FloatSize(InchToPx(8.5), InchToPx(11));
-    case CSSValueLegal:
+    case CSSValueID::kLegal:
       return FloatSize(InchToPx(8.5), InchToPx(14));
-    case CSSValueLedger:
+    case CSSValueID::kLedger:
       return FloatSize(InchToPx(11), InchToPx(17));
     default:
       NOTREACHED();
@@ -53,7 +54,7 @@
                                        const CSSParserLocalContext&) const {
   CSSValueList* result = CSSValueList::CreateSpaceSeparated();
 
-  if (range.Peek().Id() == CSSValueAuto) {
+  if (range.Peek().Id() == CSSValueID::kAuto) {
     result->Append(*css_property_parser_helpers::ConsumeIdent(range));
     return result;
   }
@@ -70,8 +71,8 @@
 
   CSSValue* page_size = ConsumePageSize(range);
   CSSValue* orientation =
-      css_property_parser_helpers::ConsumeIdent<CSSValuePortrait,
-                                                CSSValueLandscape>(range);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kPortrait,
+                                                CSSValueID::kLandscape>(range);
   if (!page_size)
     page_size = ConsumePageSize(range);
 
@@ -109,9 +110,11 @@
       // <page-size> <orientation>
       size = GetPageSizeFromName(To<CSSIdentifierValue>(first));
 
-      DCHECK(To<CSSIdentifierValue>(second).GetValueID() == CSSValueLandscape ||
-             To<CSSIdentifierValue>(second).GetValueID() == CSSValuePortrait);
-      if (To<CSSIdentifierValue>(second).GetValueID() == CSSValueLandscape)
+      DCHECK(To<CSSIdentifierValue>(second).GetValueID() ==
+                 CSSValueID::kLandscape ||
+             To<CSSIdentifierValue>(second).GetValueID() ==
+                 CSSValueID::kPortrait);
+      if (To<CSSIdentifierValue>(second).GetValueID() == CSSValueID::kLandscape)
         size = size.TransposedSize();
     }
     page_size_type = EPageSizeType::kResolved;
@@ -129,13 +132,13 @@
     } else {
       const auto& ident = To<CSSIdentifierValue>(first);
       switch (ident.GetValueID()) {
-        case CSSValueAuto:
+        case CSSValueID::kAuto:
           page_size_type = EPageSizeType::kAuto;
           break;
-        case CSSValuePortrait:
+        case CSSValueID::kPortrait:
           page_size_type = EPageSizeType::kPortrait;
           break;
-        case CSSValueLandscape:
+        case CSSValueID::kLandscape:
           page_size_type = EPageSizeType::kLandscape;
           break;
         default:
diff --git a/third_party/blink/renderer/core/css/properties/longhands/stroke_dasharray_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/stroke_dasharray_custom.cc
index 214fb673..f55494a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/stroke_dasharray_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/stroke_dasharray_custom.cc
@@ -17,7 +17,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValueList* dashes = CSSValueList::CreateCommaSeparated();
diff --git a/third_party/blink/renderer/core/css/properties/longhands/text_align_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/text_align_custom.cc
index e4f241ba..78168264 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/text_align_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/text_align_custom.cc
@@ -19,11 +19,12 @@
 void TextAlign::ApplyValue(StyleResolverState& state,
                            const CSSValue& value) const {
   const auto* ident_value = DynamicTo<CSSIdentifierValue>(value);
-  if (ident_value && ident_value->GetValueID() != CSSValueWebkitMatchParent) {
+  if (ident_value &&
+      ident_value->GetValueID() != CSSValueID::kWebkitMatchParent) {
     // Special case for th elements - UA stylesheet text-align does not apply if
     // parent's computed value for text-align is not its initial value
     // https://html.spec.whatwg.org/C/#tables-2
-    if (ident_value->GetValueID() == CSSValueInternalCenter &&
+    if (ident_value->GetValueID() == CSSValueID::kInternalCenter &&
         state.ParentStyle()->GetTextAlign() !=
             ComputedStyleInitialValues::InitialTextAlign())
       state.Style()->SetTextAlign(state.ParentStyle()->GetTextAlign());
diff --git a/third_party/blink/renderer/core/css/properties/longhands/text_indent_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/text_indent_custom.cc
index c5b62b0..f16041a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/text_indent_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/text_indent_custom.cc
@@ -35,11 +35,11 @@
 
     if (RuntimeEnabledFeatures::CSS3TextEnabled()) {
       CSSValueID id = range.Peek().Id();
-      if (!hanging && id == CSSValueHanging) {
+      if (!hanging && id == CSSValueID::kHanging) {
         hanging = css_property_parser_helpers::ConsumeIdent(range);
         continue;
       }
-      if (!each_line && id == CSSValueEachLine) {
+      if (!each_line && id == CSSValueID::kEachLine) {
         each_line = css_property_parser_helpers::ConsumeIdent(range);
         continue;
       }
@@ -72,9 +72,9 @@
       style.TextIndent(), style));
   if (RuntimeEnabledFeatures::CSS3TextEnabled()) {
     if (style.GetTextIndentType() == TextIndentType::kHanging)
-      list->Append(*CSSIdentifierValue::Create(CSSValueHanging));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kHanging));
     if (style.GetTextIndentLine() == TextIndentLine::kEachLine)
-      list->Append(*CSSIdentifierValue::Create(CSSValueEachLine));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kEachLine));
   }
   return list;
 }
@@ -107,10 +107,10 @@
       length_or_percentage_value = list_primitive_value->ConvertToLength(
           state.CssToLengthConversionData());
     } else if (To<CSSIdentifierValue>(*list_value).GetValueID() ==
-               CSSValueEachLine) {
+               CSSValueID::kEachLine) {
       text_indent_line_value = TextIndentLine::kEachLine;
     } else if (To<CSSIdentifierValue>(*list_value).GetValueID() ==
-               CSSValueHanging) {
+               CSSValueID::kHanging) {
       text_indent_type_value = TextIndentType::kHanging;
     } else {
       NOTREACHED();
diff --git a/third_party/blink/renderer/core/css/properties/longhands/text_overflow_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/text_overflow_custom.cc
index 7d8863c..18b2fcb 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/text_overflow_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/text_overflow_custom.cc
@@ -16,8 +16,8 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.TextOverflow() != ETextOverflow::kClip)
-    return CSSIdentifierValue::Create(CSSValueEllipsis);
-  return CSSIdentifierValue::Create(CSSValueClip);
+    return CSSIdentifierValue::Create(CSSValueID::kEllipsis);
+  return CSSIdentifierValue::Create(CSSValueID::kClip);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/text_size_adjust_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/text_size_adjust_custom.cc
index 865b9276..97b0dc9e 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/text_size_adjust_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/text_size_adjust_custom.cc
@@ -15,9 +15,9 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumePercent(range,
                                                      kValueRangeNonNegative);
@@ -30,7 +30,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.GetTextSizeAdjust().IsAuto())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSPrimitiveValue::Create(style.GetTextSizeAdjust().Multiplier() * 100,
                                    CSSPrimitiveValue::UnitType::kPercentage);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/text_underline_position_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/text_underline_position_custom.cc
index 912e260..5bc6173 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/text_underline_position_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/text_underline_position_custom.cc
@@ -17,19 +17,19 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSIdentifierValue* under_value =
-      css_property_parser_helpers::ConsumeIdent<CSSValueUnder>(range);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kUnder>(range);
   CSSIdentifierValue* left_or_right_value = nullptr;
   if (RuntimeEnabledFeatures::TextUnderlinePositionLeftRightEnabled()) {
     left_or_right_value =
-        css_property_parser_helpers::ConsumeIdent<CSSValueLeft, CSSValueRight>(
-            range);
+        css_property_parser_helpers::ConsumeIdent<CSSValueID::kLeft,
+                                                  CSSValueID::kRight>(range);
     if (left_or_right_value && !under_value) {
       under_value =
-          css_property_parser_helpers::ConsumeIdent<CSSValueUnder>(range);
+          css_property_parser_helpers::ConsumeIdent<CSSValueID::kUnder>(range);
     }
   }
   if (!under_value && !left_or_right_value) {
@@ -51,21 +51,21 @@
     bool allow_visited_style) const {
   auto text_underline_position = style.TextUnderlinePosition();
   if (text_underline_position == kTextUnderlinePositionAuto)
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   if (text_underline_position == kTextUnderlinePositionUnder)
-    return CSSIdentifierValue::Create(CSSValueUnder);
+    return CSSIdentifierValue::Create(CSSValueID::kUnder);
   if (text_underline_position == kTextUnderlinePositionLeft)
-    return CSSIdentifierValue::Create(CSSValueLeft);
+    return CSSIdentifierValue::Create(CSSValueID::kLeft);
   if (text_underline_position == kTextUnderlinePositionRight)
-    return CSSIdentifierValue::Create(CSSValueRight);
+    return CSSIdentifierValue::Create(CSSValueID::kRight);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   DCHECK(text_underline_position & kTextUnderlinePositionUnder);
-  list->Append(*CSSIdentifierValue::Create(CSSValueUnder));
+  list->Append(*CSSIdentifierValue::Create(CSSValueID::kUnder));
   if (text_underline_position & kTextUnderlinePositionLeft)
-    list->Append(*CSSIdentifierValue::Create(CSSValueLeft));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kLeft));
   if (text_underline_position & kTextUnderlinePositionRight)
-    list->Append(*CSSIdentifierValue::Create(CSSValueRight));
+    list->Append(*CSSIdentifierValue::Create(CSSValueID::kRight));
   DCHECK_EQ(list->length(), 2U);
   return list;
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/touch_action_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/touch_action_custom.cc
index 57897d6..d3b38c2 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/touch_action_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/touch_action_custom.cc
@@ -17,14 +17,15 @@
                        CSSValue*& pan_y,
                        CSSValue*& pinch_zoom) {
   CSSValueID id = range.Peek().Id();
-  if ((id == CSSValuePanX || id == CSSValuePanRight || id == CSSValuePanLeft) &&
+  if ((id == CSSValueID::kPanX || id == CSSValueID::kPanRight ||
+       id == CSSValueID::kPanLeft) &&
       !pan_x) {
     pan_x = css_property_parser_helpers::ConsumeIdent(range);
-  } else if ((id == CSSValuePanY || id == CSSValuePanDown ||
-              id == CSSValuePanUp) &&
+  } else if ((id == CSSValueID::kPanY || id == CSSValueID::kPanDown ||
+              id == CSSValueID::kPanUp) &&
              !pan_y) {
     pan_y = css_property_parser_helpers::ConsumeIdent(range);
-  } else if (id == CSSValuePinchZoom && !pinch_zoom) {
+  } else if (id == CSSValueID::kPinchZoom && !pinch_zoom) {
     pinch_zoom = css_property_parser_helpers::ConsumeIdent(range);
   } else {
     return false;
@@ -41,7 +42,8 @@
     const CSSParserLocalContext&) const {
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueManipulation) {
+  if (id == CSSValueID::kAuto || id == CSSValueID::kNone ||
+      id == CSSValueID::kManipulation) {
     list->Append(*css_property_parser_helpers::ConsumeIdent(range));
     return list;
   }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/transform_style_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/transform_style_custom.cc
index 60712b2..6d7ab1b 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/transform_style_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/transform_style_custom.cc
@@ -15,8 +15,8 @@
     bool allow_visited_style) const {
   return CSSIdentifierValue::Create(
       (style.TransformStyle3D() == ETransformStyle3D::kPreserve3d)
-          ? CSSValuePreserve3d
-          : CSSValueFlat);
+          ? CSSValueID::kPreserve3d
+          : CSSValueID::kFlat);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/transition_property_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/transition_property_custom.cc
index 407674c7..ac8c834 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/transition_property_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/transition_property_custom.cc
@@ -35,7 +35,7 @@
 
 const CSSValue* TransitionProperty::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueAll)));
+                      (CSSIdentifierValue::Create(CSSValueID::kAll)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/transition_timing_function_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/transition_timing_function_custom.cc
index 50b2a1d..51a1e6d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/transition_timing_function_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/transition_timing_function_custom.cc
@@ -32,7 +32,7 @@
 
 const CSSValue* TransitionTimingFunction::InitialValue() const {
   DEFINE_STATIC_LOCAL(Persistent<CSSValue>, value,
-                      (CSSIdentifierValue::Create(CSSValueEase)));
+                      (CSSIdentifierValue::Create(CSSValueID::kEase)));
   return value;
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/translate_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/translate_custom.cc
index e513d0e..41e66f7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/translate_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/translate_custom.cc
@@ -22,7 +22,7 @@
     const CSSParserLocalContext&) const {
   DCHECK(RuntimeEnabledFeatures::CSSIndependentTransformPropertiesEnabled());
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValue* translate_x = css_property_parser_helpers::ConsumeLengthOrPercent(
@@ -61,7 +61,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.Translate())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
 
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   list->Append(*ComputedStyleUtils::ZoomAdjustedPixelValueForLength(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/vertical_align_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/vertical_align_custom.cc
index b587f8c..3d1671c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/vertical_align_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/vertical_align_custom.cc
@@ -17,7 +17,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValue* parsed_value = css_property_parser_helpers::ConsumeIdentRange(
-      range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
+      range, CSSValueID::kBaseline, CSSValueID::kWebkitBaselineMiddle);
   if (!parsed_value) {
     parsed_value = css_property_parser_helpers::ConsumeLengthOrPercent(
         range, context.Mode(), kValueRangeAll,
@@ -34,23 +34,23 @@
     bool allow_visited_style) const {
   switch (style.VerticalAlign()) {
     case EVerticalAlign::kBaseline:
-      return CSSIdentifierValue::Create(CSSValueBaseline);
+      return CSSIdentifierValue::Create(CSSValueID::kBaseline);
     case EVerticalAlign::kMiddle:
-      return CSSIdentifierValue::Create(CSSValueMiddle);
+      return CSSIdentifierValue::Create(CSSValueID::kMiddle);
     case EVerticalAlign::kSub:
-      return CSSIdentifierValue::Create(CSSValueSub);
+      return CSSIdentifierValue::Create(CSSValueID::kSub);
     case EVerticalAlign::kSuper:
-      return CSSIdentifierValue::Create(CSSValueSuper);
+      return CSSIdentifierValue::Create(CSSValueID::kSuper);
     case EVerticalAlign::kTextTop:
-      return CSSIdentifierValue::Create(CSSValueTextTop);
+      return CSSIdentifierValue::Create(CSSValueID::kTextTop);
     case EVerticalAlign::kTextBottom:
-      return CSSIdentifierValue::Create(CSSValueTextBottom);
+      return CSSIdentifierValue::Create(CSSValueID::kTextBottom);
     case EVerticalAlign::kTop:
-      return CSSIdentifierValue::Create(CSSValueTop);
+      return CSSIdentifierValue::Create(CSSValueID::kTop);
     case EVerticalAlign::kBottom:
-      return CSSIdentifierValue::Create(CSSValueBottom);
+      return CSSIdentifierValue::Create(CSSValueID::kBottom);
     case EVerticalAlign::kBaselineMiddle:
-      return CSSIdentifierValue::Create(CSSValueWebkitBaselineMiddle);
+      return CSSIdentifierValue::Create(CSSValueID::kWebkitBaselineMiddle);
     case EVerticalAlign::kLength:
       return ComputedStyleUtils::ZoomAdjustedPixelValueForLength(
           style.GetVerticalAlignLength(), style);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_app_region_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_app_region_custom.cc
index 0cbbdd3..bbcd222 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_app_region_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_app_region_custom.cc
@@ -17,11 +17,11 @@
     Node*,
     bool allow_visited_style) const {
   if (style.DraggableRegionMode() == EDraggableRegionMode::kNone)
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return CSSIdentifierValue::Create(style.DraggableRegionMode() ==
                                             EDraggableRegionMode::kDrag
-                                        ? CSSValueDrag
-                                        : CSSValueNoDrag);
+                                        ? CSSValueID::kDrag
+                                        : CSSValueID::kNoDrag);
 }
 
 void WebkitAppRegion::ApplyInitial(StyleResolverState& state) const {}
@@ -32,7 +32,7 @@
                                  const CSSValue& value) const {
   const auto& identifier_value = To<CSSIdentifierValue>(value);
   state.Style()->SetDraggableRegionMode(identifier_value.GetValueID() ==
-                                                CSSValueDrag
+                                                CSSValueID::kDrag
                                             ? EDraggableRegionMode::kDrag
                                             : EDraggableRegionMode::kNoDrag);
   state.GetDocument().SetHasAnnotatedRegions(true);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_box_decoration_break_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_box_decoration_break_custom.cc
index 25bc591..3644c3e 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_box_decoration_break_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_box_decoration_break_custom.cc
@@ -16,8 +16,8 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.BoxDecorationBreak() == EBoxDecorationBreak::kSlice)
-    return CSSIdentifierValue::Create(CSSValueSlice);
-  return CSSIdentifierValue::Create(CSSValueClone);
+    return CSSIdentifierValue::Create(CSSValueID::kSlice);
+  return CSSIdentifierValue::Create(CSSValueID::kClone);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_box_reflect_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_box_reflect_custom.cc
index 187e7478..554e0a7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_box_reflect_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_box_reflect_custom.cc
@@ -18,7 +18,8 @@
 CSSValue* ConsumeReflect(CSSParserTokenRange& range,
                          const CSSParserContext& context) {
   CSSIdentifierValue* direction = css_property_parser_helpers::ConsumeIdent<
-      CSSValueAbove, CSSValueBelow, CSSValueLeft, CSSValueRight>(range);
+      CSSValueID::kAbove, CSSValueID::kBelow, CSSValueID::kLeft,
+      CSSValueID::kRight>(range);
   if (!direction)
     return nullptr;
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_highlight_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_highlight_custom.cc
index 04f5bc2..8f22d06 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_highlight_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_highlight_custom.cc
@@ -15,7 +15,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueNone)
+  if (range.Peek().Id() == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeString(range);
 }
@@ -27,7 +27,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.Highlight() == g_null_atom)
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return CSSStringValue::Create(style.Highlight());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_hyphenate_character_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_hyphenate_character_custom.cc
index 8009063..2150a16 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_hyphenate_character_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_hyphenate_character_custom.cc
@@ -15,7 +15,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext&,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeString(range);
 }
@@ -27,7 +27,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.HyphenationString().IsNull())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSStringValue::Create(style.HyphenationString());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_line_clamp_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_line_clamp_custom.cc
index 6bb0bb1b..d01769a 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_line_clamp_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_line_clamp_custom.cc
@@ -25,7 +25,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (!style.HasLineClamp())
-    return CSSIdentifierValue::Create(CSSValueNone);
+    return CSSIdentifierValue::Create(CSSValueID::kNone);
   return CSSPrimitiveValue::Create(style.LineClamp(),
                                    CSSPrimitiveValue::UnitType::kNumber);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_locale_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_locale_custom.cc
index 09dbde4..7b99a28 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_locale_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_locale_custom.cc
@@ -15,7 +15,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext&,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeString(range);
 }
@@ -27,14 +27,14 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.Locale().IsNull())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSStringValue::Create(style.Locale());
 }
 
 void WebkitLocale::ApplyValue(StyleResolverState& state,
                               const CSSValue& value) const {
   if (auto* identifier_value = DynamicTo<CSSIdentifierValue>(value)) {
-    DCHECK_EQ(identifier_value->GetValueID(), CSSValueAuto);
+    DCHECK_EQ(identifier_value->GetValueID(), CSSValueID::kAuto);
     state.GetFontBuilder().SetLocale(nullptr);
   } else {
     state.GetFontBuilder().SetLocale(
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_box_image_source_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_box_image_source_custom.cc
index b817f652..25a8d40e 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_box_image_source_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_box_image_source_custom.cc
@@ -28,7 +28,7 @@
     bool allow_visited_style) const {
   if (style.MaskBoxImageSource())
     return style.MaskBoxImageSource()->ComputedCSSValue();
-  return CSSIdentifierValue::Create(CSSValueNone);
+  return CSSIdentifierValue::Create(CSSValueID::kNone);
 }
 
 void WebkitMaskBoxImageSource::ApplyValue(StyleResolverState& state,
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_x_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_x_custom.cc
index 5de6d2e0..29ae3a8 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_x_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_x_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
-      css_parsing_utils::ConsumePositionLonghand<CSSValueLeft, CSSValueRight>,
+      css_parsing_utils::ConsumePositionLonghand<CSSValueID::kLeft,
+                                                 CSSValueID::kRight>,
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_y_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_y_custom.cc
index 1327489a9..163b673 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_y_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_mask_position_y_custom.cc
@@ -18,7 +18,8 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   return css_property_parser_helpers::ConsumeCommaSeparatedList(
-      css_parsing_utils::ConsumePositionLonghand<CSSValueTop, CSSValueBottom>,
+      css_parsing_utils::ConsumePositionLonghand<CSSValueID::kTop,
+                                                 CSSValueID::kBottom>,
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_x_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_x_custom.cc
index 8b2599d0..6cf7cd71 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_x_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_x_custom.cc
@@ -15,8 +15,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  return css_parsing_utils::ConsumePositionLonghand<CSSValueLeft,
-                                                    CSSValueRight>(
+  return css_parsing_utils::ConsumePositionLonghand<CSSValueID::kLeft,
+                                                    CSSValueID::kRight>(
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_y_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_y_custom.cc
index 3b4020f..14bd3d7 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_y_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_perspective_origin_y_custom.cc
@@ -15,8 +15,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  return css_parsing_utils::ConsumePositionLonghand<CSSValueTop,
-                                                    CSSValueBottom>(
+  return css_parsing_utils::ConsumePositionLonghand<CSSValueID::kTop,
+                                                    CSSValueID::kBottom>(
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_rtl_ordering_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_rtl_ordering_custom.cc
index 7419992..80bf611 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_rtl_ordering_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_rtl_ordering_custom.cc
@@ -14,8 +14,8 @@
     Node*,
     bool allow_visited_style) const {
   return CSSIdentifierValue::Create(style.RtlOrdering() == EOrder::kVisual
-                                        ? CSSValueVisual
-                                        : CSSValueLogical);
+                                        ? CSSValueID::kVisual
+                                        : CSSValueID::kLogical);
 }
 
 }  // namespace css_longhand
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_combine_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_combine_custom.cc
index ba24bd2..f4d31df 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_combine_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_combine_custom.cc
@@ -16,7 +16,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.TextCombine() == ETextCombine::kAll)
-    return CSSIdentifierValue::Create(CSSValueHorizontal);
+    return CSSIdentifierValue::Create(CSSValueID::kHorizontal);
   return CSSIdentifierValue::Create(style.TextCombine());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_position_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_position_custom.cc
index 68079e5a9..be00b7d 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_position_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_position_custom.cc
@@ -22,14 +22,15 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSIdentifierValue* values[2] = {
-      css_property_parser_helpers::ConsumeIdent<CSSValueOver, CSSValueUnder,
-                                                CSSValueRight, CSSValueLeft>(
-          range),
+      css_property_parser_helpers::ConsumeIdent<
+          CSSValueID::kOver, CSSValueID::kUnder, CSSValueID::kRight,
+          CSSValueID::kLeft>(range),
       nullptr};
   if (!values[0])
     return nullptr;
   values[1] = css_property_parser_helpers::ConsumeIdent<
-      CSSValueOver, CSSValueUnder, CSSValueRight, CSSValueLeft>(range);
+      CSSValueID::kOver, CSSValueID::kUnder, CSSValueID::kRight,
+      CSSValueID::kLeft>(range);
   CSSIdentifierValue* over_under = nullptr;
   CSSIdentifierValue* left_right = nullptr;
 
@@ -37,14 +38,14 @@
     if (!value)
       break;
     switch (value->GetValueID()) {
-      case CSSValueOver:
-      case CSSValueUnder:
+      case CSSValueID::kOver:
+      case CSSValueID::kUnder:
         if (over_under)
           return nullptr;
         over_under = value;
         break;
-      case CSSValueLeft:
-      case CSSValueRight:
+      case CSSValueID::kLeft:
+      case CSSValueID::kRight:
         if (left_right)
           return nullptr;
         left_right = value;
@@ -57,7 +58,7 @@
   if (!over_under)
     return nullptr;
   if (!left_right)
-    left_right = CSSIdentifierValue::Create(CSSValueRight);
+    left_right = CSSIdentifierValue::Create(CSSValueID::kRight);
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   list->Append(*over_under);
   list->Append(*left_right);
@@ -73,20 +74,20 @@
   CSSValueList* list = CSSValueList::CreateSpaceSeparated();
   switch (style.GetTextEmphasisPosition()) {
     case TextEmphasisPosition::kOverRight:
-      list->Append(*CSSIdentifierValue::Create(CSSValueOver));
-      list->Append(*CSSIdentifierValue::Create(CSSValueRight));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kOver));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kRight));
       break;
     case TextEmphasisPosition::kOverLeft:
-      list->Append(*CSSIdentifierValue::Create(CSSValueOver));
-      list->Append(*CSSIdentifierValue::Create(CSSValueLeft));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kOver));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kLeft));
       break;
     case TextEmphasisPosition::kUnderRight:
-      list->Append(*CSSIdentifierValue::Create(CSSValueUnder));
-      list->Append(*CSSIdentifierValue::Create(CSSValueRight));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kUnder));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kRight));
       break;
     case TextEmphasisPosition::kUnderLeft:
-      list->Append(*CSSIdentifierValue::Create(CSSValueUnder));
-      list->Append(*CSSIdentifierValue::Create(CSSValueLeft));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kUnder));
+      list->Append(*CSSIdentifierValue::Create(CSSValueID::kLeft));
       break;
   }
   return list;
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_style_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_style_custom.cc
index 0a50412..0922a4f 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_style_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_emphasis_style_custom.cc
@@ -18,7 +18,7 @@
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
   CSSValueID id = range.Peek().Id();
-  if (id == CSSValueNone)
+  if (id == CSSValueID::kNone)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   if (CSSValue* text_emphasis_style =
@@ -26,15 +26,14 @@
     return text_emphasis_style;
 
   CSSIdentifierValue* fill =
-      css_property_parser_helpers::ConsumeIdent<CSSValueFilled, CSSValueOpen>(
-          range);
+      css_property_parser_helpers::ConsumeIdent<CSSValueID::kFilled,
+                                                CSSValueID::kOpen>(range);
   CSSIdentifierValue* shape = css_property_parser_helpers::ConsumeIdent<
-      CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle,
-      CSSValueSesame>(range);
+      CSSValueID::kDot, CSSValueID::kCircle, CSSValueID::kDoubleCircle,
+      CSSValueID::kTriangle, CSSValueID::kSesame>(range);
   if (!fill) {
-    fill =
-        css_property_parser_helpers::ConsumeIdent<CSSValueFilled, CSSValueOpen>(
-            range);
+    fill = css_property_parser_helpers::ConsumeIdent<CSSValueID::kFilled,
+                                                     CSSValueID::kOpen>(range);
   }
   if (fill && shape) {
     CSSValueList* parsed_values = CSSValueList::CreateSpaceSeparated();
@@ -57,7 +56,7 @@
     bool allow_visited_style) const {
   switch (style.GetTextEmphasisMark()) {
     case TextEmphasisMark::kNone:
-      return CSSIdentifierValue::Create(CSSValueNone);
+      return CSSIdentifierValue::Create(CSSValueID::kNone);
     case TextEmphasisMark::kCustom:
       return CSSStringValue::Create(style.TextEmphasisCustomMark());
     case TextEmphasisMark::kAuto:
@@ -102,8 +101,8 @@
     DCHECK_EQ(list->length(), 2U);
     for (unsigned i = 0; i < 2; ++i) {
       const auto& ident_value = To<CSSIdentifierValue>(list->Item(i));
-      if (ident_value.GetValueID() == CSSValueFilled ||
-          ident_value.GetValueID() == CSSValueOpen) {
+      if (ident_value.GetValueID() == CSSValueID::kFilled ||
+          ident_value.GetValueID() == CSSValueID::kOpen) {
         state.Style()->SetTextEmphasisFill(
             ident_value.ConvertTo<TextEmphasisFill>());
       } else {
@@ -127,8 +126,8 @@
 
   state.Style()->SetTextEmphasisCustomMark(g_null_atom);
 
-  if (identifier_value.GetValueID() == CSSValueFilled ||
-      identifier_value.GetValueID() == CSSValueOpen) {
+  if (identifier_value.GetValueID() == CSSValueID::kFilled ||
+      identifier_value.GetValueID() == CSSValueID::kOpen) {
     state.Style()->SetTextEmphasisFill(
         identifier_value.ConvertTo<TextEmphasisFill>());
     state.Style()->SetTextEmphasisMark(TextEmphasisMark::kAuto);
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_orientation_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_orientation_custom.cc
index ea81cb6..29b4c26 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_text_orientation_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_text_orientation_custom.cc
@@ -16,7 +16,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.GetTextOrientation() == ETextOrientation::kMixed)
-    return CSSIdentifierValue::Create(CSSValueVerticalRight);
+    return CSSIdentifierValue::Create(CSSValueID::kVerticalRight);
   return CSSIdentifierValue::Create(style.GetTextOrientation());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_x_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_x_custom.cc
index 5b3f969..7e5ccd2 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_x_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_x_custom.cc
@@ -15,8 +15,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  return css_parsing_utils::ConsumePositionLonghand<CSSValueLeft,
-                                                    CSSValueRight>(
+  return css_parsing_utils::ConsumePositionLonghand<CSSValueID::kLeft,
+                                                    CSSValueID::kRight>(
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_y_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_y_custom.cc
index 0d0d1f3f..e0101ef 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_y_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/webkit_transform_origin_y_custom.cc
@@ -15,8 +15,8 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  return css_parsing_utils::ConsumePositionLonghand<CSSValueTop,
-                                                    CSSValueBottom>(
+  return css_parsing_utils::ConsumePositionLonghand<CSSValueID::kTop,
+                                                    CSSValueID::kBottom>(
       range, context.Mode());
 }
 
diff --git a/third_party/blink/renderer/core/css/properties/longhands/will_change_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/will_change_custom.cc
index 3022efe..e3aa80c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/will_change_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/will_change_custom.cc
@@ -18,7 +18,7 @@
     CSSParserTokenRange& range,
     const CSSParserContext& context,
     const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
 
   CSSValueList* values = CSSValueList::CreateCommaSeparated();
@@ -44,15 +44,15 @@
       range.ConsumeIncludingWhitespace();
     } else {
       switch (range.Peek().Id()) {
-        case CSSValueNone:
-        case CSSValueAll:
-        case CSSValueAuto:
-        case CSSValueDefault:
-        case CSSValueInitial:
-        case CSSValueInherit:
+        case CSSValueID::kNone:
+        case CSSValueID::kAll:
+        case CSSValueID::kAuto:
+        case CSSValueID::kDefault:
+        case CSSValueID::kInitial:
+        case CSSValueID::kInherit:
           return nullptr;
-        case CSSValueContents:
-        case CSSValueScrollPosition:
+        case CSSValueID::kContents:
+        case CSSValueID::kScrollPosition:
           values->Append(*css_property_parser_helpers::ConsumeIdent(range));
           break;
         default:
@@ -107,17 +107,17 @@
   Vector<CSSPropertyID> will_change_properties;
 
   if (auto* identifier_value = DynamicTo<CSSIdentifierValue>(value)) {
-    DCHECK_EQ(identifier_value->GetValueID(), CSSValueAuto);
+    DCHECK_EQ(identifier_value->GetValueID(), CSSValueID::kAuto);
   } else {
     for (auto& will_change_value : To<CSSValueList>(value)) {
       if (auto* ident_value =
               DynamicTo<CSSCustomIdentValue>(will_change_value.Get())) {
         will_change_properties.push_back(ident_value->ValueAsPropertyID());
       } else if (To<CSSIdentifierValue>(*will_change_value).GetValueID() ==
-                 CSSValueContents) {
+                 CSSValueID::kContents) {
         will_change_contents = true;
       } else if (To<CSSIdentifierValue>(*will_change_value).GetValueID() ==
-                 CSSValueScrollPosition) {
+                 CSSValueID::kScrollPosition) {
         will_change_scroll_position = true;
       } else {
         NOTREACHED();
diff --git a/third_party/blink/renderer/core/css/properties/longhands/z_index_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/z_index_custom.cc
index 966179c..486675c 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/z_index_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/z_index_custom.cc
@@ -14,7 +14,7 @@
 const CSSValue* ZIndex::ParseSingleValue(CSSParserTokenRange& range,
                                          const CSSParserContext& context,
                                          const CSSParserLocalContext&) const {
-  if (range.Peek().Id() == CSSValueAuto)
+  if (range.Peek().Id() == CSSValueID::kAuto)
     return css_property_parser_helpers::ConsumeIdent(range);
   return css_property_parser_helpers::ConsumeInteger(range);
 }
@@ -26,7 +26,7 @@
     Node* styled_node,
     bool allow_visited_style) const {
   if (style.HasAutoZIndex() || !style.IsStackingContext())
-    return CSSIdentifierValue::Create(CSSValueAuto);
+    return CSSIdentifierValue::Create(CSSValueID::kAuto);
   return CSSPrimitiveValue::Create(style.ZIndex(),
                                    CSSPrimitiveValue::UnitType::kInteger);
 }
diff --git a/third_party/blink/renderer/core/css/properties/longhands/zoom_custom.cc b/third_party/blink/renderer/core/css/properties/longhands/zoom_custom.cc
index 48ebcc9..1a8f7ee 100644
--- a/third_party/blink/renderer/core/css/properties/longhands/zoom_custom.cc
+++ b/third_party/blink/renderer/core/css/properties/longhands/zoom_custom.cc
@@ -18,7 +18,8 @@
   const CSSParserToken& token = range.Peek();
   CSSValue* zoom = nullptr;
   if (token.GetType() == kIdentToken) {
-    zoom = css_property_parser_helpers::ConsumeIdent<CSSValueNormal>(range);
+    zoom =
+        css_property_parser_helpers::ConsumeIdent<CSSValueID::kNormal>(range);
   } else {
     zoom = css_property_parser_helpers::ConsumePercent(range,
                                                        kValueRangeNonNegative);
@@ -28,7 +29,7 @@
     }
   }
   if (zoom) {
-    if (!(token.Id() == CSSValueNormal ||
+    if (!(token.Id() == CSSValueID::kNormal ||
           (token.GetType() == kNumberToken &&
            To<CSSPrimitiveValue>(zoom)->GetDoubleValue() == 1) ||
           (token.GetType() == kPercentageToken &&
@@ -60,7 +61,7 @@
   SECURITY_DCHECK(value.IsPrimitiveValue() || value.IsIdentifierValue());
 
   if (const auto* identifier_value = DynamicTo<CSSIdentifierValue>(value)) {
-    if (identifier_value->GetValueID() == CSSValueNormal) {
+    if (identifier_value->GetValueID() == CSSValueID::kNormal) {
       state.SetZoom(ComputedStyleInitialValues::InitialZoom());
     }
   } else if (const auto* primitive_value =