Remove outdated list style types

Source/core/layout/LayoutListMarker.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2010 Daniel Bates (dbates@intudata.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 388 matching lines @@
     return String(characters, length);
 }
 
 static EListStyleType effectiveListMarkerType(EListStyleType type, int value)
 {
     // Note, the following switch statement has been explicitly grouped
     // by list-style-type ordinal range.
     switch (type) {
     case ArabicIndic:
     case Bengali:
-    case BinaryListStyle:
     case Cambodian:
     case Circle:
     case DecimalLeadingZero:
     case DecimalListStyle:
     case Devanagari:
     case Disc:
     case Gujarati:
     case Gurmukhi:
     case Kannada:
     case Khmer:
     case Lao:
-    case LowerHexadecimal:
     case Malayalam:
     case Mongolian:
     case Myanmar:
     case NoneListStyle:
-    case Octal:
     case Oriya:
     case Persian:
     case Square:
     case Telugu:
     case Thai:
     case Tibetan:
-    case UpperHexadecimal:
     case Urdu:
         return type; // Can represent all ordinals.
     case Armenian:
         return (value < 1 || value > 99999999) ? DecimalListStyle : type;
     case CJKIdeographic:
         return (value < 0) ? DecimalListStyle : type;
     case Georgian:
         return (value < 1 || value > 19999) ? DecimalListStyle : type;
     case Hebrew:
         return (value < 0 || value > 999999) ? DecimalListStyle : type;
     case LowerRoman:
     case UpperRoman:
         return (value < 1 || value > 3999) ? DecimalListStyle : type;
-    case Afar:
-    case Amharic:
-    case AmharicAbegede:
-    case Asterisks:
     case CjkEarthlyBranch:
     case CjkHeavenlyStem:
-    case Ethiopic:
-    case EthiopicAbegede:
-    case EthiopicAbegedeAmEt:
-    case EthiopicAbegedeGez:
-    case EthiopicAbegedeTiEr:
-    case EthiopicAbegedeTiEt:
-    case EthiopicHalehameAaEr:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAmEt:
-    case EthiopicHalehameGez:
-    case EthiopicHalehameOmEt:
-    case EthiopicHalehameSidEt:
-    case EthiopicHalehameSoEt:
+    case EthiopicHalehameAm:
+    case EthiopicHalehame:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
-    case EthiopicHalehameTig:
-    case Footnotes:
     case Hangul:
     case HangulConsonant:
     case Hiragana:
     case HiraganaIroha:
     case Katakana:
     case KatakanaIroha:
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
     case LowerLatin:
-    case LowerNorwegian:
-    case Oromo:
-    case Sidama:
-    case Somali:
-    case Tigre:
-    case TigrinyaEr:
-    case TigrinyaErAbegede:
-    case TigrinyaEt:
-    case TigrinyaEtAbegede:
     case UpperAlpha:
     case UpperArmenian:
-    case UpperGreek:
     case UpperLatin:
-    case UpperNorwegian:
         return (value < 1) ? DecimalListStyle : type;
     }
 
     ASSERT_NOT_REACHED();
     return type;
 }
 
 UChar LayoutListMarker::listMarkerSuffix(EListStyleType type, int value)
 {
     // If the list-style-type cannot represent |value| because it's outside its
     // ordinal range then we fall back to some list style that can represent |value|.
     EListStyleType effectiveType = effectiveListMarkerType(type, value);
 
     // Note, the following switch statement has been explicitly
     // grouped by list-style-type suffix.
     switch (effectiveType) {
-    case Asterisks:
     case Circle:
     case Disc:
-    case Footnotes:
     case NoneListStyle:
     case Square:
         return ' ';
-    case Afar:
-    case Amharic:
-    case AmharicAbegede:
-    case Ethiopic:
-    case EthiopicAbegede:
-    case EthiopicAbegedeAmEt:
-    case EthiopicAbegedeGez:
-    case EthiopicAbegedeTiEr:
-    case EthiopicAbegedeTiEt:
-    case EthiopicHalehameAaEr:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAmEt:
-    case EthiopicHalehameGez:
-    case EthiopicHalehameOmEt:
-    case EthiopicHalehameSidEt:
-    case EthiopicHalehameSoEt:
+    case EthiopicHalehame:
+    case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
-    case EthiopicHalehameTig:
-    case Oromo:
-    case Sidama:
-    case Somali:
-    case Tigre:
-    case TigrinyaEr:
-    case TigrinyaErAbegede:
-    case TigrinyaEt:
-    case TigrinyaEtAbegede:
         return ethiopicPrefaceColonCharacter;
     case Armenian:
     case ArabicIndic:
     case Bengali:
-    case BinaryListStyle:
     case Cambodian:
     case CJKIdeographic:
     case CjkEarthlyBranch:
     case CjkHeavenlyStem:
     case DecimalLeadingZero:
     case DecimalListStyle:
     case Devanagari:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
-    case LowerHexadecimal:
     case LowerLatin:
-    case LowerNorwegian:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
-    case Octal:
     case Oriya:
     case Persian:
     case Telugu:
     case Thai:
     case Tibetan:
     case UpperAlpha:
     case UpperArmenian:
-    case UpperGreek:
-    case UpperHexadecimal:
     case UpperLatin:
-    case UpperNorwegian:
     case UpperRoman:
     case Urdu:
         return '.';
     }
 
     ASSERT_NOT_REACHED();
     return '.';
 }
 
 String listMarkerText(EListStyleType type, int value)
 {
     // If the list-style-type, say hebrew, cannot represent |value| because it's outside
     // its ordinal range then we fallback to some list style that can represent |value|.
     switch (effectiveListMarkerType(type, value)) {
     case NoneListStyle:
         return "";
 
-    case Asterisks: {
-        static const LChar asterisksSymbols[1] = {
-            0x2A
-        };
-        return toSymbolic(value, asterisksSymbols);
-    }
     // We use the same characters for text security.
     // See LayoutText::setInternalString.
     case Circle:
         return String(&whiteBulletCharacter, 1);
     case Disc:
         return String(&bulletCharacter, 1);
-    case Footnotes: {
-        static const UChar footnotesSymbols[4] = {
-            0x002A, 0x2051, 0x2020, 0x2021
-        };
-        return toSymbolic(value, footnotesSymbols);
-    }
     case Square:
         // The CSS 2.1 test suite uses U+25EE BLACK MEDIUM SMALL SQUARE
         // instead, but I think this looks better.
         return String(&blackSquareCharacter, 1);
 
     case DecimalListStyle:
         return String::number(value);
     case DecimalLeadingZero:
         if (value < -9 || value > 9)
             return String::number(value);
         if (value < 0)
             return "-0" + String::number(-value); // -01 to -09
         return "0" + String::number(value); // 00 to 09
 
     case ArabicIndic: {
         static const UChar arabicIndicNumerals[10] = {
             0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667, 0x0668, 0x0669
         };
         return toNumeric(value, arabicIndicNumerals);
     }
-    case BinaryListStyle: {
-        static const LChar binaryNumerals[2] = {
-            '0', '1'
-        };
-        return toNumeric(value, binaryNumerals);
-    }
     case Bengali: {
         static const UChar bengaliNumerals[10] = {
             0x09E6, 0x09E7, 0x09E8, 0x09E9, 0x09EA, 0x09EB, 0x09EC, 0x09ED, 0x09EE, 0x09EF
         };
         return toNumeric(value, bengaliNumerals);
     }
     case Cambodian:
     case Khmer: {
         static const UChar khmerNumerals[10] = {
             0x17E0, 0x17E1, 0x17E2, 0x17E3, 0x17E4, 0x17E5, 0x17E6, 0x17E7, 0x17E8, 0x17E9
@@ skipping 17 matching lines @@
             0x0A66, 0x0A67, 0x0A68, 0x0A69, 0x0A6A, 0x0A6B, 0x0A6C, 0x0A6D, 0x0A6E, 0x0A6F
         };
         return toNumeric(value, gurmukhiNumerals);
     }
     case Kannada: {
         static const UChar kannadaNumerals[10] = {
             0x0CE6, 0x0CE7, 0x0CE8, 0x0CE9, 0x0CEA, 0x0CEB, 0x0CEC, 0x0CED, 0x0CEE, 0x0CEF
         };
         return toNumeric(value, kannadaNumerals);
     }
-    case LowerHexadecimal: {
-        static const LChar lowerHexadecimalNumerals[16] = {
-            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-        };
-        return toNumeric(value, lowerHexadecimalNumerals);
-    }
     case Lao: {
         static const UChar laoNumerals[10] = {
             0x0ED0, 0x0ED1, 0x0ED2, 0x0ED3, 0x0ED4, 0x0ED5, 0x0ED6, 0x0ED7, 0x0ED8, 0x0ED9
         };
         return toNumeric(value, laoNumerals);
     }
     case Malayalam: {
         static const UChar malayalamNumerals[10] = {
             0x0D66, 0x0D67, 0x0D68, 0x0D69, 0x0D6A, 0x0D6B, 0x0D6C, 0x0D6D, 0x0D6E, 0x0D6F
         };
         return toNumeric(value, malayalamNumerals);
     }
     case Mongolian: {
         static const UChar mongolianNumerals[10] = {
             0x1810, 0x1811, 0x1812, 0x1813, 0x1814, 0x1815, 0x1816, 0x1817, 0x1818, 0x1819
         };
         return toNumeric(value, mongolianNumerals);
     }
     case Myanmar: {
         static const UChar myanmarNumerals[10] = {
             0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049
         };
         return toNumeric(value, myanmarNumerals);
     }
-    case Octal: {
-        static const LChar octalNumerals[8] = {
-            '0', '1', '2', '3', '4', '5', '6', '7'
-        };
-        return toNumeric(value, octalNumerals);
-    }
     case Oriya: {
         static const UChar oriyaNumerals[10] = {
             0x0B66, 0x0B67, 0x0B68, 0x0B69, 0x0B6A, 0x0B6B, 0x0B6C, 0x0B6D, 0x0B6E, 0x0B6F
         };
         return toNumeric(value, oriyaNumerals);
     }
     case Persian:
     case Urdu: {
         static const UChar urduNumerals[10] = {
             0x06F0, 0x06F1, 0x06F2, 0x06F3, 0x06F4, 0x06F5, 0x06F6, 0x06F7, 0x06F8, 0x06F9
@@ skipping 11 matching lines @@
             0x0F20, 0x0F21, 0x0F22, 0x0F23, 0x0F24, 0x0F25, 0x0F26, 0x0F27, 0x0F28, 0x0F29
         };
         return toNumeric(value, tibetanNumerals);
     }
     case Thai: {
         static const UChar thaiNumerals[10] = {
             0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59
         };
         return toNumeric(value, thaiNumerals);
     }
-    case UpperHexadecimal: {
-        static const LChar upperHexadecimalNumerals[16] = {
-            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
-        };
-        return toNumeric(value, upperHexadecimalNumerals);
-    }
 
     case LowerAlpha:
     case LowerLatin: {
         static const LChar lowerLatinAlphabet[26] = {
             'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
             'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
         };
         return toAlphabetic(value, lowerLatinAlphabet);
     }
     case UpperAlpha:
@@ skipping 59 matching lines @@
             0x30A4, 0x30ED, 0x30CF, 0x30CB, 0x30DB, 0x30D8, 0x30C8, 0x30C1,
             0x30EA, 0x30CC, 0x30EB, 0x30F2, 0x30EF, 0x30AB, 0x30E8, 0x30BF,
             0x30EC, 0x30BD, 0x30C4, 0x30CD, 0x30CA, 0x30E9, 0x30E0, 0x30A6,
             0x30F0, 0x30CE, 0x30AA, 0x30AF, 0x30E4, 0x30DE, 0x30B1, 0x30D5,
             0x30B3, 0x30A8, 0x30C6, 0x30A2, 0x30B5, 0x30AD, 0x30E6, 0x30E1,
             0x30DF, 0x30B7, 0x30F1, 0x30D2, 0x30E2, 0x30BB, 0x30B9
         };
         return toAlphabetic(value, katakanaIrohaAlphabet);
     }
 
-    case Afar:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAaEr: {
-        static const UChar ethiopicHalehameAaErAlphabet[18] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1260, 0x1270, 0x1290,
-            0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12E8, 0x12F0, 0x1308, 0x1338, 0x1348
-        };
-        return toAlphabetic(value, ethiopicHalehameAaErAlphabet);
-    }
-    case Amharic:
-    case EthiopicHalehameAmEt: {
-        static const UChar ethiopicHalehameAmEtAlphabet[33] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
-            0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12B8,
-            0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308, 0x1320,
-            0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
-        };
-        return toAlphabetic(value, ethiopicHalehameAmEtAlphabet);
-    }
-    case AmharicAbegede:
-    case EthiopicAbegedeAmEt: {
-        static const UChar ethiopicAbegedeAmEtAlphabet[33] = {
-            0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
-            0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
-            0x1298, 0x1220, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1228, 0x1230, 0x1238,
-            0x1270, 0x1278, 0x1280, 0x1340, 0x1330, 0x1350
-        };
-        return toAlphabetic(value, ethiopicAbegedeAmEtAlphabet);
-    }
     case CjkEarthlyBranch: {
         static const UChar cjkEarthlyBranchAlphabet[12] = {
             0x5B50, 0x4E11, 0x5BC5, 0x536F, 0x8FB0, 0x5DF3, 0x5348, 0x672A, 0x7533,
             0x9149, 0x620C, 0x4EA5
         };
         return toAlphabetic(value, cjkEarthlyBranchAlphabet);
     }
     case CjkHeavenlyStem: {
         static const UChar cjkHeavenlyStemAlphabet[10] = {
             0x7532, 0x4E59, 0x4E19, 0x4E01, 0x620A, 0x5DF1, 0x5E9A, 0x8F9B, 0x58EC,
             0x7678
         };
         return toAlphabetic(value, cjkHeavenlyStemAlphabet);
     }
-    case Ethiopic:
-    case EthiopicHalehameGez: {
-        static const UChar ethiopicHalehameGezAlphabet[26] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1240, 0x1260,
-            0x1270, 0x1280, 0x1290, 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12D8, 0x12E8,
-            0x12F0, 0x1308, 0x1320, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
-        };
-        return toAlphabetic(value, ethiopicHalehameGezAlphabet);
-    }
-    case EthiopicAbegede:
-    case EthiopicAbegedeGez: {
-        static const UChar ethiopicAbegedeGezAlphabet[26] = {
-            0x12A0, 0x1260, 0x1308, 0x12F0, 0x1200, 0x12C8, 0x12D8, 0x1210, 0x1320,
-            0x12E8, 0x12A8, 0x1208, 0x1218, 0x1290, 0x1220, 0x12D0, 0x1348, 0x1338,
-            0x1240, 0x1228, 0x1230, 0x1270, 0x1280, 0x1340, 0x1330, 0x1350
-        };
-        return toAlphabetic(value, ethiopicAbegedeGezAlphabet);
-    }
     case HangulConsonant: {
         static const UChar hangulConsonantAlphabet[14] = {
             0x3131, 0x3134, 0x3137, 0x3139, 0x3141, 0x3142, 0x3145, 0x3147, 0x3148,
             0x314A, 0x314B, 0x314C, 0x314D, 0x314E
         };
         return toAlphabetic(value, hangulConsonantAlphabet);
     }
     case Hangul: {
         static const UChar hangulAlphabet[14] = {
             0xAC00, 0xB098, 0xB2E4, 0xB77C, 0xB9C8, 0xBC14, 0xC0AC, 0xC544, 0xC790,
             0xCC28, 0xCE74, 0xD0C0, 0xD30C, 0xD558
         };
         return toAlphabetic(value, hangulAlphabet);
     }
-    case Oromo:
-    case EthiopicHalehameOmEt: {
-        static const UChar ethiopicHalehameOmEtAlphabet[25] = {
-            0x1200, 0x1208, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260, 0x1270,
-            0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12C8, 0x12E8, 0x12F0, 0x12F8,
-            0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348
+    case EthiopicHalehame: {
+        static const UChar ethiopicHalehameGezAlphabet[26] = {
+            0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1240, 0x1260,
+            0x1270, 0x1280, 0x1290, 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12D8, 0x12E8,
+            0x12F0, 0x1308, 0x1320, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
         };
-        return toAlphabetic(value, ethiopicHalehameOmEtAlphabet);
+        return toAlphabetic(value, ethiopicHalehameGezAlphabet);
     }
-    case Sidama:
-    case EthiopicHalehameSidEt: {
-        static const UChar ethiopicHalehameSidEtAlphabet[26] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
-            0x1270, 0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12C8, 0x12E8, 0x12F0,
-            0x12F8, 0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348
+    case EthiopicHalehameAm: {
+        static const UChar ethiopicHalehameAmAlphabet[33] = {
+            0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
+            0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12B8,
+            0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308, 0x1320,
+            0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
         };
-        return toAlphabetic(value, ethiopicHalehameSidEtAlphabet);
+        return toAlphabetic(value, ethiopicHalehameAmAlphabet);
     }
-    case Somali:
-    case EthiopicHalehameSoEt: {
-        static const UChar ethiopicHalehameSoEtAlphabet[22] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
-            0x1270, 0x1290, 0x12A0, 0x12A8, 0x12B8, 0x12C8, 0x12D0, 0x12E8, 0x12F0,
-            0x1300, 0x1308, 0x1338, 0x1348
-        };
-        return toAlphabetic(value, ethiopicHalehameSoEtAlphabet);
-    }
-    case Tigre:
-    case EthiopicHalehameTig: {
-        static const UChar ethiopicHalehameTigAlphabet[27] = {
-            0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1260,
-            0x1270, 0x1278, 0x1290, 0x12A0, 0x12A8, 0x12C8, 0x12D0, 0x12D8, 0x12E8,
-            0x12F0, 0x1300, 0x1308, 0x1320, 0x1328, 0x1338, 0x1330, 0x1348, 0x1350
-        };
-        return toAlphabetic(value, ethiopicHalehameTigAlphabet);
-    }
-    case TigrinyaEr:
     case EthiopicHalehameTiEr: {
         static const UChar ethiopicHalehameTiErAlphabet[31] = {
             0x1200, 0x1208, 0x1210, 0x1218, 0x1228, 0x1230, 0x1238, 0x1240, 0x1250,
             0x1260, 0x1270, 0x1278, 0x1290, 0x1298, 0x12A0, 0x12A8, 0x12B8, 0x12C8,
             0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308, 0x1320, 0x1328,
             0x1330, 0x1338, 0x1348, 0x1350
         };
         return toAlphabetic(value, ethiopicHalehameTiErAlphabet);
     }
-    case TigrinyaErAbegede:
-    case EthiopicAbegedeTiEr: {
-        static const UChar ethiopicAbegedeTiErAlphabet[31] = {
-            0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
-            0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
-            0x1298, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1250, 0x1228, 0x1230, 0x1238,
-            0x1270, 0x1278, 0x1330, 0x1350
-        };
-        return toAlphabetic(value, ethiopicAbegedeTiErAlphabet);
-    }
-    case TigrinyaEt:
     case EthiopicHalehameTiEt: {
         static const UChar ethiopicHalehameTiEtAlphabet[34] = {
             0x1200, 0x1208, 0x1210, 0x1218, 0x1220, 0x1228, 0x1230, 0x1238, 0x1240,
             0x1250, 0x1260, 0x1270, 0x1278, 0x1280, 0x1290, 0x1298, 0x12A0, 0x12A8,
             0x12B8, 0x12C8, 0x12D0, 0x12D8, 0x12E0, 0x12E8, 0x12F0, 0x1300, 0x1308,
             0x1320, 0x1328, 0x1330, 0x1338, 0x1340, 0x1348, 0x1350
         };
         return toAlphabetic(value, ethiopicHalehameTiEtAlphabet);
     }
-    case TigrinyaEtAbegede:
-    case EthiopicAbegedeTiEt: {
-        static const UChar ethiopicAbegedeTiEtAlphabet[34] = {
-            0x12A0, 0x1260, 0x1308, 0x12F0, 0x1300, 0x1200, 0x12C8, 0x12D8, 0x12E0,
-            0x1210, 0x1320, 0x1328, 0x12E8, 0x12A8, 0x12B8, 0x1208, 0x1218, 0x1290,
-            0x1298, 0x1220, 0x12D0, 0x1348, 0x1338, 0x1240, 0x1250, 0x1228, 0x1230,
-            0x1238, 0x1270, 0x1278, 0x1280, 0x1340, 0x1330, 0x1350
-        };
-        return toAlphabetic(value, ethiopicAbegedeTiEtAlphabet);
-    }
-    case UpperGreek: {
-        static const UChar upperGreekAlphabet[24] = {
-            0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399,
-            0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3,
-            0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9
-        };
-        return toAlphabetic(value, upperGreekAlphabet);
-    }
-    case LowerNorwegian: {
-        static const LChar lowerNorwegianAlphabet[29] = {
-            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
-            0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
-            0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xE6,
-            0xF8, 0xE5
-        };
-        return toAlphabetic(value, lowerNorwegianAlphabet);
-    }
-    case UpperNorwegian: {
-        static const LChar upperNorwegianAlphabet[29] = {
-            0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
-            0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52,
-            0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xC6,
-            0xD8, 0xC5
-        };
-        return toAlphabetic(value, upperNorwegianAlphabet);
-    }
     case CJKIdeographic: {
         static const UChar traditionalChineseInformalTable[16] = {
             0x842C, 0x5104, 0x5146,
             0x5341, 0x767E, 0x5343,
             0x96F6, 0x4E00, 0x4E8C, 0x4E09, 0x56DB,
             0x4E94, 0x516D, 0x4E03, 0x516B, 0x4E5D
         };
         return toCJKIdeographic(value, traditionalChineseInformalTable);
     }
 
@@ skipping 164 matching lines @@
 
     EListStyleType type = style()->listStyleType();
     switch (type) {
     case NoneListStyle:
         break;
     case Circle:
     case Disc:
     case Square:
         m_text = listMarkerText(type, 0); // value is ignored for these types
         break;
-    case Asterisks:
-    case Footnotes:
-    case Afar:
-    case Amharic:
-    case AmharicAbegede:
     case ArabicIndic:
     case Armenian:
-    case BinaryListStyle:
     case Bengali:
     case Cambodian:
     case CJKIdeographic:
     case CjkEarthlyBranch:
     case CjkHeavenlyStem:
     case DecimalLeadingZero:
     case DecimalListStyle:
     case Devanagari:
-    case Ethiopic:
-    case EthiopicAbegede:
-    case EthiopicAbegedeAmEt:
-    case EthiopicAbegedeGez:
-    case EthiopicAbegedeTiEr:
-    case EthiopicAbegedeTiEt:
-    case EthiopicHalehameAaEr:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAmEt:
-    case EthiopicHalehameGez:
-    case EthiopicHalehameOmEt:
-    case EthiopicHalehameSidEt:
-    case EthiopicHalehameSoEt:
+    case EthiopicHalehame:
+    case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
-    case EthiopicHalehameTig:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
-    case LowerHexadecimal:
     case LowerLatin:
-    case LowerNorwegian:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
-    case Octal:
     case Oriya:
-    case Oromo:
     case Persian:
-    case Sidama:
-    case Somali:
     case Telugu:
     case Thai:
     case Tibetan:
-    case Tigre:
-    case TigrinyaEr:
-    case TigrinyaErAbegede:
-    case TigrinyaEt:
-    case TigrinyaEtAbegede:
     case UpperAlpha:
     case UpperArmenian:
-    case UpperGreek:
-    case UpperHexadecimal:
     case UpperLatin:
-    case UpperNorwegian:
     case UpperRoman:
     case Urdu:
         m_text = listMarkerText(type, m_listItem->value());
         break;
     }
 }
 
 void LayoutListMarker::computePreferredLogicalWidths()
 {
     ASSERT(preferredLogicalWidthsDirty());
     updateContent();
 
     if (isImage()) {
         LayoutSize imageSize = m_image->imageSize(this, style()->effectiveZoom());
         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = style()->isHorizontalWritingMode() ? imageSize.width() : imageSize.height();
         clearPreferredLogicalWidthsDirty();
         updateMargins();
         return;
     }
 
     const Font& font = style()->font();
 
     LayoutUnit logicalWidth = 0;
     EListStyleType type = style()->listStyleType();
     switch (type) {
     case NoneListStyle:
         break;
-    case Asterisks:
-    case Footnotes:
-        logicalWidth = font.width(m_text); // no suffix for these types
-        break;
     case Circle:
     case Disc:
     case Square:
         logicalWidth = (font.fontMetrics().ascent() * 2 / 3 + 1) / 2 + 2;
         break;
-    case Afar:
-    case Amharic:
-    case AmharicAbegede:
     case ArabicIndic:
     case Armenian:
-    case BinaryListStyle:
     case Bengali:
     case Cambodian:
     case CJKIdeographic:
     case CjkEarthlyBranch:
     case CjkHeavenlyStem:
     case DecimalLeadingZero:
     case DecimalListStyle:
     case Devanagari:
-    case Ethiopic:
-    case EthiopicAbegede:
-    case EthiopicAbegedeAmEt:
-    case EthiopicAbegedeGez:
-    case EthiopicAbegedeTiEr:
-    case EthiopicAbegedeTiEt:
-    case EthiopicHalehameAaEr:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAmEt:
-    case EthiopicHalehameGez:
-    case EthiopicHalehameOmEt:
-    case EthiopicHalehameSidEt:
-    case EthiopicHalehameSoEt:
+    case EthiopicHalehame:
+    case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
-    case EthiopicHalehameTig:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
-    case LowerHexadecimal:
     case LowerLatin:
-    case LowerNorwegian:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
-    case Octal:
     case Oriya:
-    case Oromo:
     case Persian:
-    case Sidama:
-    case Somali:
     case Telugu:
     case Thai:
     case Tibetan:
-    case Tigre:
-    case TigrinyaEr:
-    case TigrinyaErAbegede:
-    case TigrinyaEt:
-    case TigrinyaEtAbegede:
     case UpperAlpha:
     case UpperArmenian:
-    case UpperGreek:
-    case UpperHexadecimal:
     case UpperLatin:
-    case UpperNorwegian:
     case UpperRoman:
     case Urdu:
         if (m_text.isEmpty()) {
             logicalWidth = 0;
         } else {
             LayoutUnit itemWidth = font.width(m_text);
             UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem->value()), ' ' };
             LayoutUnit suffixSpaceWidth = font.width(constructTextRun(this, font, suffixSpace, 2, styleRef(), style()->direction()));
             logicalWidth = itemWidth + suffixSpaceWidth;
         }
@@ skipping 96 matching lines @@
 }
 
 IntRect LayoutListMarker::getRelativeMarkerRect()
 {
     if (isImage())
         return IntRect(0, 0, m_image->imageSize(this, style()->effectiveZoom()).width(), m_image->imageSize(this, style()->effectiveZoom()).height());
 
     IntRect relativeRect;
     EListStyleType type = style()->listStyleType();
     switch (type) {
-    case Asterisks:
-    case Footnotes: {
-        const Font& font = style()->font();
-        relativeRect = IntRect(0, 0, font.width(m_text), font.fontMetrics().height());
-        break;
-    }
     case Disc:
     case Circle:
     case Square: {
         // FIXME: Are these particular rounding rules necessary?
         const FontMetrics& fontMetrics = style()->fontMetrics();
         int ascent = fontMetrics.ascent();
         int bulletWidth = (ascent * 2 / 3 + 1) / 2;
         relativeRect = IntRect(1, 3 * (ascent - ascent * 2 / 3) / 2, bulletWidth, bulletWidth);
         break;
     }
     case NoneListStyle:
         return IntRect();
-    case Afar:
-    case Amharic:
-    case AmharicAbegede:
     case ArabicIndic:
     case Armenian:
-    case BinaryListStyle:
     case Bengali:
     case Cambodian:
     case CJKIdeographic:
     case CjkEarthlyBranch:
     case CjkHeavenlyStem:
     case DecimalLeadingZero:
     case DecimalListStyle:
     case Devanagari:
-    case Ethiopic:
-    case EthiopicAbegede:
-    case EthiopicAbegedeAmEt:
-    case EthiopicAbegedeGez:
-    case EthiopicAbegedeTiEr:
-    case EthiopicAbegedeTiEt:
-    case EthiopicHalehameAaEr:
-    case EthiopicHalehameAaEt:
-    case EthiopicHalehameAmEt:
-    case EthiopicHalehameGez:
-    case EthiopicHalehameOmEt:
-    case EthiopicHalehameSidEt:
-    case EthiopicHalehameSoEt:
+    case EthiopicHalehame:
+    case EthiopicHalehameAm:
     case EthiopicHalehameTiEr:
     case EthiopicHalehameTiEt:
-    case EthiopicHalehameTig:
     case Georgian:
     case Gujarati:
     case Gurmukhi:
     case Hangul:
     case HangulConsonant:
     case Hebrew:
     case Hiragana:
     case HiraganaIroha:
     case Kannada:
     case Katakana:
     case KatakanaIroha:
     case Khmer:
     case Lao:
     case LowerAlpha:
     case LowerArmenian:
     case LowerGreek:
-    case LowerHexadecimal:
     case LowerLatin:
-    case LowerNorwegian:
     case LowerRoman:
     case Malayalam:
     case Mongolian:
     case Myanmar:
-    case Octal:
     case Oriya:
-    case Oromo:
     case Persian:
-    case Sidama:
-    case Somali:
     case Telugu:
     case Thai:
     case Tibetan:
-    case Tigre:
-    case TigrinyaEr:
-    case TigrinyaErAbegede:
-    case TigrinyaEt:
-    case TigrinyaEtAbegede:
     case UpperAlpha:
     case UpperArmenian:
-    case UpperGreek:
-    case UpperHexadecimal:
     case UpperLatin:
-    case UpperNorwegian:
     case UpperRoman:
     case Urdu:
         if (m_text.isEmpty())
             return IntRect();
         const Font& font = style()->font();
         int itemWidth = font.width(m_text);
         UChar suffixSpace[2] = { listMarkerSuffix(type, m_listItem->value()), ' ' };
         int suffixSpaceWidth = font.width(constructTextRun(this, font, suffixSpace, 2, styleRef(), style()->direction()));
         relativeRect = IntRect(0, 0, itemWidth + suffixSpaceWidth, font.fontMetrics().height());
     }
@@ skipping 40 matching lines @@
     if (style()) {
         // Reuse the current margins. Otherwise resetting the margins to initial values
         // would trigger unnecessary layout.
         newStyle->setMarginStart(style()->marginStart());
         newStyle->setMarginEnd(style()->marginRight());
     }
     setStyle(newStyle.release());
 }
 
 } // namespace blink