Remove all ordering requirements in CSSValueKeywords.in (WIP)

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 598 matching lines @@
   } while (consumeCommaIncludingWhitespace(range));
 
   if (values->length())
     return values;
 
   return nullptr;
 }
 
 static CSSIdentifierValue* consumeFontWeight(CSSParserTokenRange& range) {
   const CSSParserToken& token = range.peek();
-  if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter)
+  if (token.id() == CSSValueNormal || token.id() == CSSValueBold ||
+      token.id() == CSSValueBolder || token.id() == CSSValueLighter)
     return consumeIdent(range);
   if (token.type() != NumberToken ||
       token.numericValueType() != IntegerValueType)
     return nullptr;
   int weight = static_cast<int>(token.numericValue());
   if ((weight % 100) || weight < 100 || weight > 900)
     return nullptr;
   range.consumeIncludingWhitespace();
-  return CSSIdentifierValue::create(
-      static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1));
+  switch (weight) {
+    case 100:
+      return CSSIdentifierValue::create(CSSValue100);
+    case 200:
+      return CSSIdentifierValue::create(CSSValue200);
+    case 300:
+      return CSSIdentifierValue::create(CSSValue300);
+    case 400:
+      return CSSIdentifierValue::create(CSSValue400);
+    case 500:
+      return CSSIdentifierValue::create(CSSValue500);
+    case 600:
+      return CSSIdentifierValue::create(CSSValue600);
+    case 700:
+      return CSSIdentifierValue::create(CSSValue700);
+    case 800:
+      return CSSIdentifierValue::create(CSSValue800);
+    case 900:
+      return CSSIdentifierValue::create(CSSValue900);
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
 }
 
 static String concatenateFamilyName(CSSParserTokenRange& range) {
   StringBuilder builder;
   bool addedSpace = false;
   const CSSParserToken& firstToken = range.peek();
   while (range.peek().type() == IdentToken) {
     if (!builder.isEmpty()) {
       builder.append(' ');
       addedSpace = true;
@@ skipping 62 matching lines @@
     return consumeIdent(range);
   if (range.peek().id() == CSSValueNone)
     return consumeIdent(range);
   return consumePercent(range, ValueRangeNonNegative);
 }
 
 static CSSValue* consumeFontSize(
     CSSParserTokenRange& range,
     CSSParserMode cssParserMode,
     UnitlessQuirk unitless = UnitlessQuirk::Forbid) {
-  if (range.peek().id() >= CSSValueXxSmall &&
-      range.peek().id() <= CSSValueLarger)
-    return consumeIdent(range);
-  return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative,
-                                unitless);
+  switch (range.peek().id()) {
+    case CSSValueXxSmall:
+    case CSSValueXSmall:
+    case CSSValueSmall:
+    case CSSValueMedium:
+    case CSSValueLarge:
+    case CSSValueXLarge:
+    case CSSValueXxLarge:
+    case CSSValueWebkitXxxLarge:
+    case CSSValueSmaller:
+    case CSSValueLarger:
+      return consumeIdent(range);
+    default:
+      return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative,
+                                    unitless);
+  }
 }
 
 static CSSValue* consumeLineHeight(CSSParserTokenRange& range,
                                    CSSParserMode cssParserMode) {
   if (range.peek().id() == CSSValueNormal)
     return consumeIdent(range);
 
   CSSPrimitiveValue* lineHeight = consumeNumber(range, ValueRangeNonNegative);
   if (lineHeight)
     return lineHeight;
@@ skipping 702 matching lines @@
     else
       return nullptr;
   } while (consumeCommaIncludingWhitespace(range));
   return shadowValueList;
 }
 
 static CSSFunctionValue* consumeFilterFunction(
     CSSParserTokenRange& range,
     const CSSParserContext& context) {
   CSSValueID filterType = range.peek().functionId();
-  if (filterType < CSSValueInvert || filterType > CSSValueDropShadow)
+  if (filterType != CSSValueInvert && filterType != CSSValueGrayscale &&
+      filterType != CSSValueSepia && filterType != CSSValueSaturate &&
+      filterType != CSSValueHueRotate && filterType != CSSValueOpacity &&
+      filterType != CSSValueBrightness && filterType != CSSValueContrast &&
+      filterType != CSSValueBlur && filterType != CSSValueDropShadow)
     return nullptr;
   CSSParserTokenRange args = consumeFunction(range);
   CSSFunctionValue* filterValue = CSSFunctionValue::create(filterType);
   CSSValue* parsedValue = nullptr;
 
   if (filterType == CSSValueDropShadow) {
     parsedValue = parseSingleShadow(args, context.mode(), false, false);
   } else {
     if (args.atEnd()) {
       if (context.useCounter())
@@ skipping 639 matching lines @@
       context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);
     else if (id == CSSValueWebkitZoomOut)
       context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
   }
   CSSValue* cursorType = nullptr;
   if (id == CSSValueHand) {
     if (!inQuirksMode)  // Non-standard behavior
       return nullptr;
     cursorType = CSSIdentifierValue::create(CSSValuePointer);
     range.consumeIncludingWhitespace();
-  } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) ||
+  } else if (
+    id == CSSValueAuto ||
+    id == CSSValueCrosshair ||
+    id == CSSValueDefault ||
+    id == CSSValuePointer ||
+    id == CSSValueMove ||
+    id == CSSValueVerticalText ||
+    id == CSSValueCell ||
+    id == CSSValueContextMenu ||
+    id == CSSValueAlias ||
+    id == CSSValueProgress ||
+    id == CSSValueNoDrop ||
+    id == CSSValueNotAllowed ||
+    id == CSSValueZoomIn ||
+    id == CSSValueZoomOut ||
+    id == CSSValueEResize ||
+    id == CSSValueNeResize ||
+    id == CSSValueNwResize ||
+    id == CSSValueNResize ||
+    id == CSSValueSeResize ||
+    id == CSSValueSwResize ||
+    id == CSSValueSResize ||
+    id == CSSValueWResize ||
+    id == CSSValueEwResize ||
+    id == CSSValueNsResize ||
+    id == CSSValueNeswResize ||
+    id == CSSValueNwseResize ||
+    id == CSSValueColResize ||
+    id == CSSValueRowResize ||
+    id == CSSValueText ||
+    id == CSSValueWait ||
+    id == CSSValueHelp ||
+    id == CSSValueAllScroll ||
+    id == CSSValueWebkitGrab ||
+    id == CSSValueWebkitGrabbing ||
+    id == CSSValueWebkitZoomIn ||
+    id == CSSValueWebkitZoomOut ||
              id == CSSValueCopy || id == CSSValueNone) {
     cursorType = consumeIdent(range);
   } else {
     return nullptr;
   }
 
   if (!list)
     return cursorType;
   list->append(*cursorType);
   return list;
@@ skipping 31 matching lines @@
     if (!consumeCommaIncludingWhitespace(args) ||
         args.peek().type() != StringToken)
       return nullptr;
     separator = CSSStringValue::create(
         args.consumeIncludingWhitespace().value().toString());
   }
 
   CSSIdentifierValue* listStyle = nullptr;
   if (consumeCommaIncludingWhitespace(args)) {
     CSSValueID id = args.peek().id();
-    if ((id != CSSValueNone &&
-         (id < CSSValueDisc || id > CSSValueKatakanaIroha)))
-      return nullptr;
-    listStyle = consumeIdent(args);
+    if (id != CSSValueNone &&
+      id != CSSValueDisc &&
+      id != CSSValueCircle &&
+      id != CSSValueSquare &&
+      id != CSSValueDecimal &&
+      id != CSSValueDecimalLeadingZero &&
+      id != CSSValueArabicIndic &&
+      id != CSSValueBengali &&
+      id != CSSValueCambodian &&
+      id != CSSValueKhmer &&
+      id != CSSValueDevanagari &&
+      id != CSSValueGujarati &&
+      id != CSSValueGurmukhi &&
+      id != CSSValueKannada &&
+      id != CSSValueLao &&
+      id != CSSValueMalayalam &&
+      id != CSSValueMongolian &&
+      id != CSSValueMyanmar &&
+      id != CSSValueOriya &&
+      id != CSSValuePersian &&
+      id != CSSValueUrdu &&
+      id != CSSValueTelugu &&
+      id != CSSValueTibetan &&
+      id != CSSValueThai &&
+      id != CSSValueLowerRoman &&
+      id != CSSValueUpperRoman &&
+      id != CSSValueLowerGreek &&
+      id != CSSValueLowerAlpha &&
+      id != CSSValueLowerLatin &&
+      id != CSSValueUpperAlpha &&
+      id != CSSValueUpperLatin &&
+      id != CSSValueCjkEarthlyBranch &&
+      id != CSSValueCjkHeavenlyStem &&
+      id != CSSValueEthiopicHalehame &&
+      id != CSSValueEthiopicHalehameAm &&
+      id != CSSValueEthiopicHalehameTiEr &&
+      id != CSSValueEthiopicHalehameTiEt &&
+      id != CSSValueHangul &&
+      id != CSSValueHangulConsonant &&
+      id != CSSValueKoreanHangulFormal &&
+      id != CSSValueKoreanHanjaFormal &&
+      id != CSSValueKoreanHanjaInformal &&
+      id != CSSValueHebrew &&
+      id != CSSValueArmenian &&
+      id != CSSValueLowerArmenian &&
+      id != CSSValueUpperArmenian &&
+      id != CSSValueGeorgian &&
+      id != CSSValueCjkIdeographic &&
+      id != CSSValueSimpChineseFormal &&
+      id != CSSValueSimpChineseInformal &&
+      id != CSSValueTradChineseFormal &&
+      id != CSSValueTradChineseInformal &&
+      id != CSSValueHiragana &&
+      id != CSSValueKatakana &&
+      id != CSSValueHiraganaIroha &&
+      id != CSSValueKatakanaIroha) {
+        return nullptr;
+      }
+      listStyle = consumeIdent(args);
   } else {
     listStyle = CSSIdentifierValue::create(CSSValueDecimal);
   }
 
   if (!args.atEnd())
     return nullptr;
   return CSSCounterValue::create(identifier, listStyle, separator);
 }
 
 static CSSValue* consumeContent(CSSParserTokenRange& range,
@@ skipping 583 matching lines @@
     CSSPrimitiveValue* angle = consumeAngle(range);
     if (angle && angle->getDoubleValue() == 0)
       return angle;
   }
   return nullptr;
 }
 
 static CSSValue* consumeBackgroundBlendMode(CSSParserTokenRange& range) {
   CSSValueID id = range.peek().id();
   if (id == CSSValueNormal || id == CSSValueOverlay ||
-      (id >= CSSValueMultiply && id <= CSSValueLuminosity))
+    id == CSSValueMultiply ||
+    id == CSSValueScreen ||
+    id == CSSValueDarken ||
+    id == CSSValueLighten ||
+    id == CSSValueColorDodge ||
+    id == CSSValueColorBurn ||
+    id == CSSValueHardLight ||
+    id == CSSValueSoftLight ||
+    id == CSSValueDifference ||
+    id == CSSValueExclusion ||
+    id == CSSValueHue ||
+    id == CSSValueSaturation ||
+    id == CSSValueColor ||
+    id == CSSValueLuminosity)
     return consumeIdent(range);
   return nullptr;
 }
 
 static CSSValue* consumeBackgroundAttachment(CSSParserTokenRange& range) {
   return consumeIdent<CSSValueScroll, CSSValueFixed, CSSValueLocal>(range);
 }
 
 static CSSValue* consumeBackgroundBox(CSSParserTokenRange& range) {
   return consumeIdent<CSSValueBorderBox, CSSValuePaddingBox,
@@ skipping 1200 matching lines @@
       break;
   }
 
   if (!parsedValue || !m_range.atEnd())
     return false;
 
   addProperty(propId, CSSPropertyInvalid, *parsedValue, false);
   return true;
 }
 
+static bool isValidSystemFontValue(CSSValueID systemFontID) {
+  return systemFontID == CSSValueCaption ||
+    systemFontID == CSSValueIcon ||
+    systemFontID == CSSValueMenu ||
+    systemFontID == CSSValueMessageBox ||
+    systemFontID == CSSValueSmallCaption ||
+    systemFontID == CSSValueWebkitMiniControl ||
+    systemFontID == CSSValueWebkitSmallControl ||
+    systemFontID == CSSValueWebkitControl ||
+    systemFontID == CSSValueStatusBar;
+}
+
 bool CSSPropertyParser::consumeSystemFont(bool important) {
   CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id();
-  ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
+  ASSERT(isValidSystemFontValue(systemFontID));
   if (!m_range.atEnd())
     return false;
 
   FontStyle fontStyle = FontStyleNormal;
   FontWeight fontWeight = FontWeightNormal;
   float fontSize = 0;
   AtomicString fontFamily;
   LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize,
                                   fontFamily);
 
@@ skipping 1149 matching lines @@
       else
         overflowXValue = overflowYValue;
       addProperty(CSSPropertyOverflowX, CSSPropertyOverflow, *overflowXValue,
                   important);
       addProperty(CSSPropertyOverflowY, CSSPropertyOverflow, *overflowYValue,
                   important);
       return true;
     }
     case CSSPropertyFont: {
       const CSSParserToken& token = m_range.peek();
-      if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar)
+      if (isValidSystemFontValue(token.id()))
         return consumeSystemFont(important);
       return consumeFont(important);
     }
     case CSSPropertyFontVariant:
       return consumeFontVariantShorthand(important);
     case CSSPropertyBorderSpacing:
       return consumeBorderSpacing(important);
     case CSSPropertyColumns:
       return consumeColumns(important);
     case CSSPropertyAnimation:
@@ skipping 162 matching lines @@
     case CSSPropertyGridTemplate:
       return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
       return consumeGridShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink