Remove SVG fonts

Source/core/svg/SVGParserUtilities.cpp

 /*
  * Copyright (C) 2002, 2003 The Karbon Developers
  * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007, 2009, 2013 Apple Inc. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 233 matching lines @@
     if (string.is8Bit()) {
         const LChar* ptr = string.characters8();
         const LChar* end = ptr + string.length();
         return genericParseNumberOrPercentage(ptr, end, number);
     }
     const UChar* ptr = string.characters16();
     const UChar* end = ptr + string.length();
     return genericParseNumberOrPercentage(ptr, end, number);
 }
 
-#if ENABLE(SVG_FONTS)
-template<typename CharType>
-static bool parseGlyphName(const CharType*& ptr, const CharType* end, HashSet<String>& values)
-{
-    skipOptionalSVGSpaces(ptr, end);
-
-    while (ptr < end) {
-        // Leading and trailing white space, and white space before and after separators, will be ignored.
-        const CharType* inputStart = ptr;
-        while (ptr < end && *ptr != ',')
-            ++ptr;
-
-        if (ptr == inputStart)
-            break;
-
-        // walk backwards from the ; to ignore any whitespace
-        const CharType* inputEnd = ptr - 1;
-        while (inputStart < inputEnd && isHTMLSpace<CharType>(*inputEnd))
-            --inputEnd;
-
-        values.add(String(inputStart, inputEnd - inputStart + 1));
-        skipOptionalSVGSpacesOrDelimiter(ptr, end, ',');
-    }
-
-    return true;
-}
-
-bool parseGlyphName(const String& input, HashSet<String>& values)
-{
-    // FIXME: Parsing error detection is missing.
-    values.clear();
-    if (input.isEmpty())
-        return true;
-    if (input.is8Bit()) {
-        const LChar* ptr = input.characters8();
-        const LChar* end = ptr + input.length();
-        return parseGlyphName(ptr, end, values);
-    }
-    const UChar* ptr = input.characters16();
-    const UChar* end = ptr + input.length();
-    return parseGlyphName(ptr, end, values);
-}
-
-template<typename CharType>
-static bool parseUnicodeRange(const CharType* characters, unsigned length, UnicodeRange& range)
-{
-    if (length < 2 || characters[0] != 'U' || characters[1] != '+')
-        return false;
-
-    // Parse the starting hex number (or its prefix).
-    unsigned startRange = 0;
-    unsigned startLength = 0;
-
-    const CharType* ptr = characters + 2;
-    const CharType* end = characters + length;
-    while (ptr < end) {
-        if (!isASCIIHexDigit(*ptr))
-            break;
-        ++startLength;
-        if (startLength > 6)
-            return false;
-        startRange = (startRange << 4) | toASCIIHexValue(*ptr);
-        ++ptr;
-    }
-
-    // Handle the case of ranges separated by "-" sign.
-    if (2 + startLength < length && *ptr == '-') {
-        if (!startLength)
-            return false;
-
-        // Parse the ending hex number (or its prefix).
-        unsigned endRange = 0;
-        unsigned endLength = 0;
-        ++ptr;
-        while (ptr < end) {
-            if (!isASCIIHexDigit(*ptr))
-                break;
-            ++endLength;
-            if (endLength > 6)
-                return false;
-            endRange = (endRange << 4) | toASCIIHexValue(*ptr);
-            ++ptr;
-        }
-
-        if (!endLength)
-            return false;
-
-        range.first = startRange;
-        range.second = endRange;
-        return true;
-    }
-
-    // Handle the case of a number with some optional trailing question marks.
-    unsigned endRange = startRange;
-    while (ptr < end) {
-        if (*ptr != '?')
-            break;
-        ++startLength;
-        if (startLength > 6)
-            return false;
-        startRange <<= 4;
-        endRange = (endRange << 4) | 0xF;
-        ++ptr;
-    }
-
-    if (!startLength)
-        return false;
-
-    range.first = startRange;
-    range.second = endRange;
-    return true;
-}
-
-template<typename CharType>
-static bool genericParseKerningUnicodeString(const CharType*& ptr, const CharType* end, UnicodeRanges& rangeList, HashSet<String>& stringList)
-{
-    while (ptr < end) {
-        const CharType* inputStart = ptr;
-        while (ptr < end && *ptr != ',')
-            ++ptr;
-
-        if (ptr == inputStart)
-            break;
-
-        // Try to parse unicode range first
-        UnicodeRange range;
-        if (parseUnicodeRange(inputStart, ptr - inputStart, range))
-            rangeList.append(range);
-        else
-            stringList.add(String(inputStart, ptr - inputStart));
-        ++ptr;
-    }
-
-    return true;
-}
-
-bool parseKerningUnicodeString(const String& input, UnicodeRanges& rangeList, HashSet<String>& stringList)
-{
-    // FIXME: Parsing error detection is missing.
-    if (input.isEmpty())
-        return true;
-    if (input.is8Bit()) {
-        const LChar* ptr = input.characters8();
-        const LChar* end = ptr + input.length();
-        return genericParseKerningUnicodeString(ptr, end, rangeList, stringList);
-    }
-    const UChar* ptr = input.characters16();
-    const UChar* end = ptr + input.length();
-    return genericParseKerningUnicodeString(ptr, end, rangeList, stringList);
-}
-
-template<typename CharType>
-static Vector<String> genericParseDelimitedString(const CharType*& ptr, const CharType* end, const char seperator)
-{
-    Vector<String> values;
-
-    skipOptionalSVGSpaces(ptr, end);
-
-    while (ptr < end) {
-        // Leading and trailing white space, and white space before and after semicolon separators, will be ignored.
-        const CharType* inputStart = ptr;
-        while (ptr < end && *ptr != seperator) // careful not to ignore whitespace inside inputs
-            ptr++;
-
-        if (ptr == inputStart)
-            break;
-
-        // walk backwards from the ; to ignore any whitespace
-        const CharType* inputEnd = ptr - 1;
-        while (inputStart < inputEnd && isHTMLSpace<CharType>(*inputEnd))
-            inputEnd--;
-
-        values.append(String(inputStart, inputEnd - inputStart + 1));
-        skipOptionalSVGSpacesOrDelimiter(ptr, end, seperator);
-    }
-
-    return values;
-}
-
-Vector<String> parseDelimitedString(const String& input, const char seperator)
-{
-    if (input.isEmpty())
-        return Vector<String>();
-    if (input.is8Bit()) {
-        const LChar* ptr = input.characters8();
-        const LChar* end = ptr + input.length();
-        return genericParseDelimitedString(ptr, end, seperator);
-    }
-    const UChar* ptr = input.characters16();
-    const UChar* end = ptr + input.length();
-    return genericParseDelimitedString(ptr, end, seperator);
-}
-#endif
-
 template <typename CharType>
 bool parseFloatPoint(const CharType*& current, const CharType* end, FloatPoint& point)
 {
     float x;
     float y;
     if (!parseNumber(current, end, x)
         || !parseNumber(current, end, y))
         return false;
     point = FloatPoint(x, y);
     return true;
@@ skipping 95 matching lines @@
         parseAndSkipTransformType(ptr, end, type);
     } else {
         const UChar* ptr = string.characters16();
         const UChar* end = ptr + string.length();
         parseAndSkipTransformType(ptr, end, type);
     }
     return type;
 }
 
 }