Simplify CSSParserToken::textForUnitTests by using more WTF helpers

Source/core/css/parser/CSSParserToken.cpp

 // Copyright 2014 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 "config.h"
 #include "core/css/parser/CSSParserToken.h"
 
 #include "wtf/HashMap.h"
 #include "wtf/text/StringHash.h"
 #include <limits.h>
@@ skipping 53 matching lines @@
 {
     ASSERT(m_type == NumberToken);
     m_type = PercentageToken;
     m_unit = CSSPrimitiveValue::CSS_PERCENTAGE;
 }
 
 // This function is used only for testing
 // FIXME - This doesn't cover all possible Token types, but it's enough for current testing.
 String CSSParserToken::textForUnitTests() const
 {
-    char buffer[std::numeric_limits<float>::digits];
     if (!m_value.isNull())
         return m_value;
     if (m_type == LeftParenthesisToken)
-        return String("(");
+        return "(";
     if (m_type == RightParenthesisToken)
-        return String(")");
+        return ")";
     if (m_type == ColonToken)
-        return String(":");
+        return ":";
     if (m_type == WhitespaceToken)
-        return String(" ");
+        return " ";
+    if (m_delimiter)
+        return String("'") + m_delimiter + '\'';
 
-    if (m_delimiter) {
-        sprintf(buffer, "'%c'", m_delimiter);
-        return String(buffer, strlen(buffer));
-    }
     if (m_numericValue) {
-        static const unsigned maxUnitBufferLength = 6;
-        char unitBuffer[maxUnitBufferLength] = {0};
+        String unit;
         if (m_unit == CSSPrimitiveValue::CSS_PERCENTAGE)
-            sprintf(unitBuffer, "%s", "%");
+            unit = "%";
         else if (m_unit == CSSPrimitiveValue::CSS_PX)
-            sprintf(unitBuffer, "%s", "px");
+            unit = "px";
         else if (m_unit == CSSPrimitiveValue::CSS_EMS)
-            sprintf(unitBuffer, "%s", "em");
+            unit = "em";
         else if (m_unit != CSSPrimitiveValue::CSS_NUMBER)
-            sprintf(unitBuffer, "%s", "other");
+            unit = "other";
         if (m_numericValueType == IntegerValueType)
-            sprintf(buffer, "%d%s", static_cast<int>(m_numericValue), unitBuffer);
-        else
-            sprintf(buffer, "%f%s", m_numericValue, unitBuffer);
-
-        return String(buffer, strlen(buffer));
+            return String::number(static_cast<int>(m_numericValue)) + unit;
+        return String::number(m_numericValue, 6, KeepTrailingZeros) + unit;

[Yoav Weiss, 2014/10/20 08:04:43]

If I understand correctly the intention here is to leave 6 fractional digits. It
might be better to add that value as a const.

Otherwise, trying this patch along with
https://codereview.chromium.org/662343002/ it seems to truncate the overall
number to 6 digit precision, not just the fractional part. I took a quick look
into dtoa to see why this is happening, but it seems it requires more than a
quick look.

[Timothy Loh, 2014/10/20 08:16:38]

Would it be clearer with "const int significantDigits = 6"? I don't think it
matters much whether we have 6 fractional digits or 6 significant digits (or
some other number of digits).

The other patch will of course need to be update to expect "500.000", etc.

[Yoav Weiss, 2014/10/20 08:38:24]

Maybe replace this line with 'return
String::numberToStringFixedWidth(m_numericValue, fractionalDigits) + unit;' ?
(while adding a fractionalDigits const)

That seems to give us a fixed number of fractional digits.

[Timothy Loh, 2014/10/20 10:52:32]

Done.

     }
     return String();
 }
 
 UChar CSSParserToken::delimiter() const
 {
     ASSERT(m_type == DelimiterToken);
     return m_delimiter;
 }
 
 NumericValueType CSSParserToken::numericValueType() const
 {
     ASSERT(m_type == NumberToken || m_type == PercentageToken || m_type == DimensionToken);
     return m_numericValueType;
 }
 
 double CSSParserToken::numericValue() const
 {
     ASSERT(m_type == NumberToken || m_type == PercentageToken || m_type == DimensionToken);
     return m_numericValue;
 }
 
 } // namespace blink