Remove usage of CSSParserValue in MediaQueryParser

Source/core/css/MediaQueryExp.cpp

 /*
  * CSS Media Query
  *
  * Copyright (C) 2006 Kimmo Kinnunen <kimmo.t.kinnunen@nokia.com>.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 2013 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:
@@ skipping 13 matching lines @@
  * 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 "config.h"
 #include "core/css/MediaQueryExp.h"
 
 #include "core/css/CSSPrimitiveValue.h"
-#include "core/css/parser/CSSParserValues.h"
+#include "core/css/parser/CSSParserToken.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "platform/Decimal.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace MediaFeatureNames;
 
-static inline bool featureWithCSSValueID(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithCSSValueID(const String& mediaFeature, const CSSValueID& id)
 {
-    if (!value->id)
+    if (!id)
         return false;
 
     return mediaFeature == displayModeMediaFeature
         || mediaFeature == orientationMediaFeature
         || mediaFeature == pointerMediaFeature
         || mediaFeature == anyPointerMediaFeature
         || mediaFeature == hoverMediaFeature
         || mediaFeature == anyHoverMediaFeature
         || mediaFeature == scanMediaFeature;
 }
@@ skipping 12 matching lines @@
     if (mediaFeature == hoverMediaFeature || mediaFeature == anyHoverMediaFeature)
         return ident == CSSValueNone || ident == CSSValueOnDemand || ident == CSSValueHover;
 
     if (mediaFeature == scanMediaFeature)
         return ident == CSSValueInterlace || ident == CSSValueProgressive;
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-static inline bool featureWithValidPositiveLength(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidPositiveLength(const String& mediaFeature, const CSSParserToken& token)
 {
-    if (!(CSSPrimitiveValue::isLength((CSSPrimitiveValue::UnitType)value->unit) || (value->unit == CSSPrimitiveValue::CSS_NUMBER && value->fValue == 0)) || value->fValue < 0)
+    if (!(CSSPrimitiveValue::isLength(token.unitType()) || (token.unitType() == CSSPrimitiveValue::CSS_NUMBER && token.numericValue() == 0)) || token.numericValue() < 0)
         return false;
 
 
     return mediaFeature == heightMediaFeature
         || mediaFeature == maxHeightMediaFeature
         || mediaFeature == minHeightMediaFeature
         || mediaFeature == widthMediaFeature
         || mediaFeature == maxWidthMediaFeature
         || mediaFeature == minWidthMediaFeature
         || mediaFeature == deviceHeightMediaFeature
         || mediaFeature == maxDeviceHeightMediaFeature
         || mediaFeature == minDeviceHeightMediaFeature
         || mediaFeature == deviceWidthMediaFeature
         || mediaFeature == minDeviceWidthMediaFeature
         || mediaFeature == maxDeviceWidthMediaFeature;
 }
 
-static inline bool featureWithValidDensity(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidDensity(const String& mediaFeature, const CSSParserToken& token)
 {
-    if ((value->unit != CSSPrimitiveValue::CSS_DPPX && value->unit != CSSPrimitiveValue::CSS_DPI && value->unit != CSSPrimitiveValue::CSS_DPCM) || value->fValue <= 0)
+    if ((token.unitType() != CSSPrimitiveValue::CSS_DPPX && token.unitType() != CSSPrimitiveValue::CSS_DPI && token.unitType() != CSSPrimitiveValue::CSS_DPCM) || token.numericValue() <= 0)
         return false;
 
     return mediaFeature == resolutionMediaFeature
         || mediaFeature == minResolutionMediaFeature
         || mediaFeature == maxResolutionMediaFeature;
 }
 
-static inline bool featureWithPositiveInteger(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveInteger(const String& mediaFeature, const CSSParserToken& token)
 {
-    if (!value->isInt || value->fValue < 0)
+    if (token.numericValueType() != IntegerValueType || token.numericValue() < 0)
         return false;
 
     return mediaFeature == colorMediaFeature
         || mediaFeature == maxColorMediaFeature
         || mediaFeature == minColorMediaFeature
         || mediaFeature == colorIndexMediaFeature
         || mediaFeature == maxColorIndexMediaFeature
         || mediaFeature == minColorIndexMediaFeature
         || mediaFeature == monochromeMediaFeature
         || mediaFeature == maxMonochromeMediaFeature
         || mediaFeature == minMonochromeMediaFeature;
 }
 
-static inline bool featureWithPositiveNumber(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveNumber(const String& mediaFeature, const CSSParserToken& token)
 {
-    if (value->unit != CSSPrimitiveValue::CSS_NUMBER || value->fValue < 0)
+    if (token.unitType() != CSSPrimitiveValue::CSS_NUMBER || token.numericValue() < 0)
         return false;
 
     return mediaFeature == transform3dMediaFeature
         || mediaFeature == devicePixelRatioMediaFeature
         || mediaFeature == maxDevicePixelRatioMediaFeature
         || mediaFeature == minDevicePixelRatioMediaFeature;
 }
 
-static inline bool featureWithZeroOrOne(const String& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithZeroOrOne(const String& mediaFeature, const CSSParserToken& token)
 {
-    if (!value->isInt || !(value->fValue == 1 || !value->fValue))
+    if (token.numericValueType() != IntegerValueType || !(token.numericValue() == 1 || !token.numericValue()))
         return false;
 
     return mediaFeature == gridMediaFeature;
 }
 
 static inline bool featureWithAspectRatio(const String& mediaFeature)
 {
     return mediaFeature == aspectRatioMediaFeature
         || mediaFeature == deviceAspectRatioMediaFeature
         || mediaFeature == minAspectRatioMediaFeature
@@ skipping 47 matching lines @@
     , m_expValue(other.expValue())
 {
 }
 
 MediaQueryExp::MediaQueryExp(const String& mediaFeature, const MediaQueryExpValue& expValue)
     : m_mediaFeature(mediaFeature)
     , m_expValue(expValue)
 {
 }
 
-PassOwnPtrWillBeRawPtr<MediaQueryExp> MediaQueryExp::createIfValid(const String& mediaFeature, CSSParserValueList* valueList)
+CSSValueID cssValueKeywordID(const CSSParserString&);
+
+PassOwnPtrWillBeRawPtr<MediaQueryExp> MediaQueryExp::createIfValid(const String& mediaFeature, const Vector<CSSParserToken, 4>& tokenList)
 {
     ASSERT(!mediaFeature.isNull());
 
     MediaQueryExpValue expValue;
     bool isValid = false;
     String lowerMediaFeature = attemptStaticStringCreation(mediaFeature.lower());
 
     // Create value for media query expression that must have 1 or more values.
-    if (valueList && valueList->size() > 0) {
-        if (valueList->size() == 1) {
-            CSSParserValue* value = valueList->current();
-            ASSERT(value);
+    if (tokenList.size() > 0) {
+        if (tokenList.size() == 1) {
+            CSSParserToken token = tokenList.at(0);
+            CSSValueID id = token.type() == IdentToken ? cssValueKeywordID(token.value()) : CSSValueInvalid;
 
-            if (featureWithCSSValueID(lowerMediaFeature, value) && featureWithValidIdent(lowerMediaFeature, value->id)) {
+            if (featureWithCSSValueID(lowerMediaFeature, id) && featureWithValidIdent(lowerMediaFeature, id)) {
                 // Media features that use CSSValueIDs.
-                expValue.id = value->id;
+                expValue.id = id;
                 expValue.unit = CSSPrimitiveValue::CSS_VALUE_ID;
                 expValue.isID = true;
-            } else if (featureWithValidDensity(lowerMediaFeature, value)
-                || featureWithValidPositiveLength(lowerMediaFeature, value)) {
-                // Media features that must have non-negative <density>, ie. dppx, dpi or dpcm,
-                // or Media features that must have non-negative <length> or number value.
-                expValue.value = value->fValue;
-                expValue.unit = (CSSPrimitiveValue::UnitType)value->unit;
-                expValue.isValue = true;
-            } else if (featureWithPositiveInteger(lowerMediaFeature, value)
-                || featureWithPositiveNumber(lowerMediaFeature, value)
-                || featureWithZeroOrOne(lowerMediaFeature, value)) {
-                // Media features that must have non-negative integer value,
-                // or media features that must have non-negative number value,
-                // or media features that must have (0|1) value.
-                expValue.value = value->fValue;
-                expValue.unit = CSSPrimitiveValue::CSS_NUMBER;
-                expValue.isValue = true;
+            } else if (token.type() == NumberToken || token.type() == PercentageToken || token.type() == DimensionToken) {

[Yoav Weiss, 2015/06/15 21:46:27]

Does this add a functional change?

[rwlbuis, 2015/06/15 22:00:53]

I think I need this since calling numericValue() ASSERTs for the above three
types.

+                if (featureWithValidDensity(lowerMediaFeature, token)
+                    || featureWithValidPositiveLength(lowerMediaFeature, token)) {
+                    // Media features that must have non-negative <density>, ie. dppx, dpi or dpcm,
+                    // or Media features that must have non-negative <length> or number value.
+                    expValue.value = token.numericValue();
+                    expValue.unit = token.unitType();
+                    expValue.isValue = true;
+                } else if (featureWithPositiveInteger(lowerMediaFeature, token)
+                    || featureWithPositiveNumber(lowerMediaFeature, token)
+                    || featureWithZeroOrOne(lowerMediaFeature, token)) {
+                    // Media features that must have non-negative integer value,
+                    // or media features that must have non-negative number value,
+                    // or media features that must have (0|1) value.
+                    expValue.value = token.numericValue();
+                    expValue.unit = CSSPrimitiveValue::CSS_NUMBER;
+                    expValue.isValue = true;
+                }
             }
 
             isValid = (expValue.isID || expValue.isValue);
 
-        } else if (valueList->size() == 3 && featureWithAspectRatio(lowerMediaFeature)) {
+        } else if (tokenList.size() == 3 && featureWithAspectRatio(lowerMediaFeature)) {
             // Create list of values.
             // Currently accepts only <integer>/<integer>.
             // Applicable to device-aspect-ratio and aspec-ratio.
             isValid = true;
             float numeratorValue = 0;
             float denominatorValue = 0;
             // The aspect-ratio must be <integer> (whitespace)? / (whitespace)? <integer>.
-            for (unsigned i = 0; i < 3; ++i, valueList->next()) {
-                const CSSParserValue* value = valueList->current();
-                if (i != 1 && value->unit == CSSPrimitiveValue::CSS_NUMBER && value->fValue > 0 && value->isInt) {
+            for (unsigned i = 0; i < 3; ++i) {
+                const CSSParserToken& token = tokenList.at(i);
+                if (i != 1 && token.unitType() == CSSPrimitiveValue::CSS_NUMBER && token.numericValue() > 0 && token.numericValueType() == IntegerValueType) {
                     if (!i)
-                        numeratorValue = value->fValue;
+                        numeratorValue = token.numericValue();
                     else
-                        denominatorValue = value->fValue;
-                } else if (i == 1 && value->unit == CSSParserValue::Operator && value->iValue == '/') {
+                        denominatorValue = token.numericValue();
+                } else if (i == 1 && token.type() == DelimiterToken && token.delimiter() == '/') {
                     continue;
                 } else {
                     isValid = false;
                     break;
                 }
             }
 
             if (isValid) {
                 expValue.numerator = (unsigned)numeratorValue;
                 expValue.denominator = (unsigned)denominatorValue;
@@ skipping 51 matching lines @@
         output.append('/');
         output.append(printNumber(denominator));
     } else if (isID) {
         output.append(getValueName(id));
     }
 
     return output.toString();
 }
 
 } // namespace