Clamp CSS numbers to float range at parsing.

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 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 "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 75 matching lines @@
         addProperty(property, value, important);
         return;
     }
 
     ShorthandScope scope(this, property);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
         addProperty(longhands[i], value, important);
 }
 
-static bool hasInvalidNumericValues(const CSSParserTokenRange& range)
-{
-    for (const CSSParserToken& token : range) {
-        CSSParserTokenType type = token.type();
-        if ((type == NumberToken || type == DimensionToken || type == PercentageToken)
-            && !CSSPropertyParser::isValidNumericValue(token.numericValue()))
-            return true;
-    }
-    return false;
-}
-
 bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
     const CSSParserTokenRange& range, const CSSParserContext& context,
     HeapVector<CSSProperty, 256>& parsedProperties, StyleRule::RuleType ruleType)
 {
-    if (hasInvalidNumericValues(range))
-        return false;
     int parsedPropertiesSize = parsedProperties.size();
 
     CSSPropertyParser parser(range, context, &parsedProperties);
     CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);
     bool parseSuccess;
 
     if (ruleType == StyleRule::Viewport) {
         parseSuccess = (RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(context.mode()))
             && parser.parseViewportDescriptor(resolvedProperty, important);
     } else if (ruleType == StyleRule::FontFace) {
         parseSuccess = parser.parseFontFaceDescriptor(resolvedProperty);
     } else {
         parseSuccess = parser.parseValueStart(unresolvedProperty, important);
     }
 
     // This doesn't count UA style sheets
     if (parseSuccess && context.useCounter())
         context.useCounter()->count(context.mode(), unresolvedProperty);
 
     if (!parseSuccess)
         parsedProperties.shrink(parsedPropertiesSize);
 
     return parseSuccess;
 }
 
 CSSValue* CSSPropertyParser::parseSingleValue(
     CSSPropertyID property, const CSSParserTokenRange& range, const CSSParserContext& context)
 {
-    if (hasInvalidNumericValues(range))
-        return nullptr;
     CSSPropertyParser parser(range, context, nullptr);
     CSSValue* value = parser.parseSingleValue(property);
     if (!value || !parser.m_range.atEnd())
         return nullptr;
     return value;
 }
 
-bool CSSPropertyParser::isValidNumericValue(double value)
-{
-    return std::isfinite(value)
-        && value >= -std::numeric_limits<float>::max()
-        && value <= std::numeric_limits<float>::max();
-}
-
 bool CSSPropertyParser::parseValueStart(CSSPropertyID unresolvedProperty, bool important)
 {
     if (consumeCSSWideKeyword(unresolvedProperty, important))
         return true;
 
     CSSParserTokenRange originalRange = m_range;
     CSSPropertyID propertyId = resolveCSSPropertyID(unresolvedProperty);
 
     if (isShorthandProperty(propertyId)) {
         if (parseShorthand(unresolvedProperty, important))
@@ skipping 4800 matching lines @@
         return consumeGridTemplateShorthand(important);
     case CSSPropertyGrid:
         return consumeGridShorthand(important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink