Implement specced parsing algorithm for <area coords>

third_party/WebKit/Source/core/html/parser/HTMLParserIdioms.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/parser/HTMLParserIdioms.h"
 
 #include "core/HTMLNames.h"
-#include <limits>
+#include "platform/ParsingUtilities.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/TextEncoding.h"
 
+#include <limits>
+
 namespace blink {
 
 using namespace HTMLNames;
 
 template <typename CharType>
 static String stripLeadingAndTrailingHTMLSpaces(String string, const CharType* characters, unsigned length)
 {
     unsigned numLeadingSpaces = 0;
     unsigned numTrailingSpaces = 0;
 
@@ skipping 61 matching lines @@
 
     // Numbers are considered finite IEEE 754 Double-precision floating point values.
     const Decimal doubleMax = Decimal::fromDouble(std::numeric_limits<double>::max());
     if (value < -doubleMax || value > doubleMax)
         return fallbackValue;
 
     // We return +0 for -0 case.
     return value.isZero() ? Decimal(0) : value;
 }
 
-double parseToDoubleForNumberType(const String& string, double fallbackValue)
+static double checkDoubleValue(double value, bool valid, double fallbackValue)
 {
-    // http://www.whatwg.org/specs/web-apps/current-work/#floating-point-numbers
-    // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
-    UChar firstCharacter = string[0];
-    if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
-        return fallbackValue;
-    if (string.endsWith('.'))
-        return fallbackValue;
-
-    bool valid = false;
-    double value = string.toDouble(&valid);
     if (!valid)
         return fallbackValue;
 
     // NaN and infinity are considered valid by String::toDouble, but not valid here.
     if (!std::isfinite(value))
         return fallbackValue;
 
     // Numbers are considered finite IEEE 754 Double-precision floating point values.
     if (-std::numeric_limits<double>::max() > value || value > std::numeric_limits<double>::max())
         return fallbackValue;
 
     // The following expression converts -0 to +0.
     return value ? value : 0;
 }
 
+double parseToDoubleForNumberType(const String& string, double fallbackValue)
+{
+    // http://www.whatwg.org/specs/web-apps/current-work/#floating-point-numbers
+    // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
+    UChar firstCharacter = string[0];
+    if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
+        return fallbackValue;
+    if (string.endsWith('.'))
+        return fallbackValue;
+
+    bool valid = false;
+    double value = string.toDouble(&valid);
+    return checkDoubleValue(value, valid, fallbackValue);
+}
+
 template <typename CharacterType>
 static bool parseHTMLIntegerInternal(const CharacterType* position, const CharacterType* end, int& value)
 {
     // Step 3
     int sign = 1;
 
     // Step 4
     while (position < end) {
         if (!isHTMLSpace<CharacterType>(*position))
             break;
@@ skipping 105 matching lines @@
     unsigned length = input.length();
     if (length && input.is8Bit()) {
         const LChar* start = input.characters8();
         return parseHTMLNonNegativeIntegerInternal(start, start + length, value);
     }
 
     const UChar* start = input.characters16();
     return parseHTMLNonNegativeIntegerInternal(start, start + length, value);
 }
 
+template<typename CharacterType>
+static bool isSpaceOrDelimiter(CharacterType c)
+{
+    return isHTMLSpace(c) || c == ',' || c == ';';
+}
+
+template<typename CharacterType>
+static bool isNotSpaceDelimiterOrNumberStart(CharacterType c)
+{
+    return !(isSpaceOrDelimiter(c) || isASCIIDigit(c) || c == '.' || c == '-');
+}
+
+template<typename CharacterType>
+static Vector<double> parseHTMLListOfFloatingPointNumbersInternal(
+    const CharacterType* position, const CharacterType* end)
+{
+    Vector<double> numbers;
+    skipWhile<CharacterType, isSpaceOrDelimiter>(position, end);
+
+    while (position < end) {
+        skipWhile<CharacterType, isNotSpaceDelimiterOrNumberStart>(position, end);
+
+        const CharacterType* unparsedNumberStart = position;
+        skipUntil<CharacterType, isSpaceOrDelimiter>(position, end);
+
+        size_t parsedLength = 0;
+        double number = charactersToDouble(unparsedNumberStart, position - unparsedNumberStart, parsedLength);
+        numbers.append(checkDoubleValue(number, parsedLength != 0, 0));
+
+        skipWhile<CharacterType, isSpaceOrDelimiter>(position, end);
+    }
+    return numbers;
+}
+
+// https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-a-list-of-floating-point-numbers
+Vector<double> parseHTMLListOfFloatingPointNumbers(const String& input)
+{
+    if (input.is8Bit())
+        return parseHTMLListOfFloatingPointNumbersInternal(input.characters8(), input.characters8() + input.length());
+    return parseHTMLListOfFloatingPointNumbersInternal(input.characters16(), input.characters16() + input.length());
+}
+
 static const char charsetString[] = "charset";
 static const size_t charsetLength = sizeof("charset") - 1;
 
 String extractCharset(const String& value)
 {
     size_t pos = 0;
     unsigned length = value.length();
 
     while (pos < length) {
         pos = value.find(charsetString, pos, TextCaseInsensitive);
@@ skipping 132 matching lines @@
         string = StringImpl::create8BitIfPossible(characters, size);
     else if (width == Force8Bit)
         string = String::make8BitFrom16BitSource(characters, size);
     else
         string = String(characters, size);
 
     return string;
 }
 
 } // namespace blink