Add number() static methods to AtomicString class

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
@@ skipping 10 matching lines @@
  * (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 "config.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 
 #include <limits>
 #include "core/dom/QualifiedName.h"
 #include "core/html/parser/HTMLIdentifier.h"
-#include "platform/Decimal.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
 template <typename CharType>
 static String stripLeadingAndTrailingHTMLSpaces(String string, const CharType* characters, unsigned length)
 {
     unsigned numLeadingSpaces = 0;
@@ skipping 66 matching lines @@
     // See HTML5 2.5.4.3 `Real numbers.'
     // FIXME: We should use numeric_limits<double>::max for number input type.
     const Decimal floatMax = Decimal::fromDouble(std::numeric_limits<float>::max());
     if (value < -floatMax || value > floatMax)
         return fallbackValue;
 
     // We return +0 for -0 case.
     return value.isZero() ? Decimal(0) : value;
 }
 
-Decimal parseToDecimalForNumberType(const String& string)
-{
-    return parseToDecimalForNumberType(string, Decimal::nan());
-}
-
 double parseToDoubleForNumberType(const String& string, double fallbackValue)
 {
     // See HTML5 2.5.4.3 `Real numbers.'
 
     // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
     UChar firstCharacter = string[0];
     if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter))
         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 single-precision floating point values.
     // See HTML5 2.5.4.3 `Real numbers.'
     if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max())
         return fallbackValue;
 
     // The following expression converts -0 to +0.
     return value ? value : 0;
 }
 
-double parseToDoubleForNumberType(const String& string)
-{
-    return parseToDoubleForNumberType(string, std::numeric_limits<double>::quiet_NaN());
-}
-
 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 125 matching lines @@
 {
     return threadSafeEqual(a.localName().impl(), b.localName().impl());
 }
 
 bool threadSafeMatch(const HTMLIdentifier& localName, const QualifiedName& qName)
 {
     return threadSafeEqual(localName.asStringImpl(), qName.localName().impl());
 }
 
 }