A thread-safe Media Query Parser

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 16 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/css/MediaQueryExp.h"
 
 #include "CSSValueKeywords.h"
 #include "core/css/CSSAspectRatioValue.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/CSSPrimitiveValue.h"
+#include "core/html/parser/HTMLParserIdioms.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
-static inline bool featureWithCSSValueID(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithCSSValueID(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
+    // FIXME - We have no more IDs, since the CSSValuePool is a singleton!!!
     if (!value->id)
         return false;
 
-    return mediaFeature == MediaFeatureNames::orientationMediaFeature
-        || mediaFeature == MediaFeatureNames::viewModeMediaFeature
-        || mediaFeature == MediaFeatureNames::pointerMediaFeature
-        || mediaFeature == MediaFeatureNames::scanMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::orientationMediaFeature.impl()->existingHash()

[eseidel, 2014/02/26 10:18:41]

Consider writing an hashEquals() helper which takes a String and a hash and
makes these lines shorter. :)

hashEquals(orientationMediaFeature, featureHash)

+        || mediaFeatureHash == MediaFeatureNames::viewModeMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::pointerMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::scanMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithValidIdent(const AtomicString& mediaFeature, CSSValueID ident)
+static inline bool featureWithValidIdent(const unsigned mediaFeatureHash, CSSValueID ident)
 {
-    if (mediaFeature == MediaFeatureNames::orientationMediaFeature)
+    if (mediaFeatureHash == MediaFeatureNames::orientationMediaFeature.impl()->existingHash())
         return ident == CSSValuePortrait || ident == CSSValueLandscape;
 
-    if (mediaFeature == MediaFeatureNames::viewModeMediaFeature) {
+    if (mediaFeatureHash == MediaFeatureNames::viewModeMediaFeature.impl()->existingHash()) {
         switch (ident) {
         case CSSValueWindowed:
         case CSSValueFloating:
         case CSSValueFullscreen:
         case CSSValueMaximized:
         case CSSValueMinimized:
             return true;
         default:
             return false;
         }
     }
 
-    if (mediaFeature == MediaFeatureNames::pointerMediaFeature)
+    if (mediaFeatureHash == MediaFeatureNames::pointerMediaFeature.impl()->existingHash())
         return ident == CSSValueNone || ident == CSSValueCoarse || ident == CSSValueFine;
 
-    if (mediaFeature == MediaFeatureNames::scanMediaFeature)
+    if (mediaFeatureHash == MediaFeatureNames::scanMediaFeature.impl()->existingHash())
         return ident == CSSValueInterlace || ident == CSSValueProgressive;
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-static inline bool featureWithValidPositiveLenghtOrNumber(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidPositiveLengthOrNumber(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
-    if (!(((value->unit >= CSSPrimitiveValue::CSS_EMS && value->unit <= CSSPrimitiveValue::CSS_PC) || value->unit == CSSPrimitiveValue::CSS_REMS) || value->unit == CSSPrimitiveValue::CSS_NUMBER) || value->fValue < 0)
+    if (!(((value->unit >= CSSPrimitiveValue::CSS_PERCENTAGE && value->unit <= CSSPrimitiveValue::CSS_PC) || value->unit == CSSPrimitiveValue::CSS_REMS) || value->unit == CSSPrimitiveValue::CSS_NUMBER) || value->fValue < 0)
         return false;
 
-    return mediaFeature == MediaFeatureNames::heightMediaFeature
-        || mediaFeature == MediaFeatureNames::maxHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::minHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::widthMediaFeature
-        || mediaFeature == MediaFeatureNames::maxWidthMediaFeature
-        || mediaFeature == MediaFeatureNames::minWidthMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::maxDeviceHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::minDeviceHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceWidthMediaFeature
-        || mediaFeature == MediaFeatureNames::maxDeviceWidthMediaFeature
-        || mediaFeature == MediaFeatureNames::minDeviceWidthMediaFeature;
+
+    return mediaFeatureHash == MediaFeatureNames::heightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::widthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxWidthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minWidthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxDeviceHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minDeviceHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceWidthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxDeviceWidthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minDeviceWidthMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithValidDensity(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidDensity(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
     if ((value->unit != CSSPrimitiveValue::CSS_DPPX && value->unit != CSSPrimitiveValue::CSS_DPI && value->unit != CSSPrimitiveValue::CSS_DPCM) || value->fValue <= 0)
         return false;
 
-    return mediaFeature == MediaFeatureNames::resolutionMediaFeature
-        || mediaFeature == MediaFeatureNames::maxResolutionMediaFeature
-        || mediaFeature == MediaFeatureNames::minResolutionMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::resolutionMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxResolutionMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minResolutionMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithPositiveInteger(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveInteger(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
     if (!value->isInt || value->fValue < 0)
         return false;
 
-    return mediaFeature == MediaFeatureNames::colorMediaFeature
-        || mediaFeature == MediaFeatureNames::maxColorMediaFeature
-        || mediaFeature == MediaFeatureNames::minColorMediaFeature
-        || mediaFeature == MediaFeatureNames::colorIndexMediaFeature
-        || mediaFeature == MediaFeatureNames::maxColorIndexMediaFeature
-        || mediaFeature == MediaFeatureNames::minColorIndexMediaFeature
-        || mediaFeature == MediaFeatureNames::monochromeMediaFeature
-        || mediaFeature == MediaFeatureNames::minMonochromeMediaFeature
-        || mediaFeature == MediaFeatureNames::maxMonochromeMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::colorMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxColorMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minColorMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::colorIndexMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxColorIndexMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minColorIndexMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::monochromeMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minMonochromeMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxMonochromeMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithPositiveNumber(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveNumber(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
     if (value->unit != CSSPrimitiveValue::CSS_NUMBER || value->fValue < 0)
         return false;
 
-    return mediaFeature == MediaFeatureNames::transform2dMediaFeature
-        || mediaFeature == MediaFeatureNames::transform3dMediaFeature
-        || mediaFeature == MediaFeatureNames::animationMediaFeature
-        || mediaFeature == MediaFeatureNames::devicePixelRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::maxDevicePixelRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::minDevicePixelRatioMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::transform2dMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::transform3dMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::animationMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::devicePixelRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxDevicePixelRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minDevicePixelRatioMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithZeroOrOne(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithZeroOrOne(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
     if (!value->isInt || !(value->fValue == 1 || !value->fValue))
         return false;
 
-    return mediaFeature == MediaFeatureNames::gridMediaFeature
-        || mediaFeature == MediaFeatureNames::hoverMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::gridMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::hoverMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithAspectRatio(const AtomicString& mediaFeature)
+static inline bool featureWithAspectRatio(const unsigned mediaFeatureHash)
 {
-    return mediaFeature == MediaFeatureNames::aspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceAspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::minAspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::maxAspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::minDeviceAspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::maxDeviceAspectRatioMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::aspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceAspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minAspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxAspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::minDeviceAspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::maxDeviceAspectRatioMediaFeature.impl()->existingHash();
 }
 
-static inline bool featureWithoutValue(const AtomicString& mediaFeature)
+static inline bool featureWithoutValue(const unsigned mediaFeatureHash)
 {
     // Media features that are prefixed by min/max cannot be used without a value.
-    return mediaFeature == MediaFeatureNames::monochromeMediaFeature
-        || mediaFeature == MediaFeatureNames::colorMediaFeature
-        || mediaFeature == MediaFeatureNames::colorIndexMediaFeature
-        || mediaFeature == MediaFeatureNames::gridMediaFeature
-        || mediaFeature == MediaFeatureNames::heightMediaFeature
-        || mediaFeature == MediaFeatureNames::widthMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceHeightMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceWidthMediaFeature
-        || mediaFeature == MediaFeatureNames::orientationMediaFeature
-        || mediaFeature == MediaFeatureNames::aspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::deviceAspectRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::hoverMediaFeature
-        || mediaFeature == MediaFeatureNames::transform2dMediaFeature
-        || mediaFeature == MediaFeatureNames::transform3dMediaFeature
-        || mediaFeature == MediaFeatureNames::animationMediaFeature
-        || mediaFeature == MediaFeatureNames::viewModeMediaFeature
-        || mediaFeature == MediaFeatureNames::pointerMediaFeature
-        || mediaFeature == MediaFeatureNames::devicePixelRatioMediaFeature
-        || mediaFeature == MediaFeatureNames::resolutionMediaFeature
-        || mediaFeature == MediaFeatureNames::scanMediaFeature;
+    return mediaFeatureHash == MediaFeatureNames::monochromeMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::colorMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::colorIndexMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::gridMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::heightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::widthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceHeightMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceWidthMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::orientationMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::aspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::deviceAspectRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::hoverMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::transform2dMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::transform3dMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::animationMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::viewModeMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::pointerMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::devicePixelRatioMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::resolutionMediaFeature.impl()->existingHash()
+        || mediaFeatureHash == MediaFeatureNames::scanMediaFeature.impl()->existingHash();
 }
 
 bool MediaQueryExp::isViewportDependent() const
 {
-    return m_mediaFeature == MediaFeatureNames::widthMediaFeature
-        || m_mediaFeature == MediaFeatureNames::heightMediaFeature
-        || m_mediaFeature == MediaFeatureNames::minWidthMediaFeature
-        || m_mediaFeature == MediaFeatureNames::minHeightMediaFeature
-        || m_mediaFeature == MediaFeatureNames::maxWidthMediaFeature
-        || m_mediaFeature == MediaFeatureNames::maxHeightMediaFeature
-        || m_mediaFeature == MediaFeatureNames::orientationMediaFeature
-        || m_mediaFeature == MediaFeatureNames::aspectRatioMediaFeature
-        || m_mediaFeature == MediaFeatureNames::minAspectRatioMediaFeature
-        || m_mediaFeature == MediaFeatureNames::devicePixelRatioMediaFeature
-        || m_mediaFeature == MediaFeatureNames::resolutionMediaFeature
-        || m_mediaFeature == MediaFeatureNames::maxAspectRatioMediaFeature;
+    return m_mediaFeatureHash == MediaFeatureNames::widthMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::heightMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::minWidthMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::minHeightMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::maxWidthMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::maxHeightMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::orientationMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::aspectRatioMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::minAspectRatioMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::devicePixelRatioMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::resolutionMediaFeature.impl()->existingHash()
+        || m_mediaFeatureHash == MediaFeatureNames::maxAspectRatioMediaFeature.impl()->existingHash();
 }
 
-MediaQueryExp::MediaQueryExp(const AtomicString& mediaFeature, PassRefPtr<CSSValue> value)
-    : m_mediaFeature(mediaFeature)
+MediaQueryExp::MediaQueryExp(StringImpl* mediaFeatureImpl, PassRefPtr<CSSValue> value)
+    : m_mediaFeature(mediaFeatureImpl)
+    , m_mediaFeatureHash(mediaFeatureImpl->existingHash())
     , m_value(value)
 {
 }
 
-PassOwnPtr<MediaQueryExp> MediaQueryExp::create(const AtomicString& mediaFeature, CSSParserValueList* valueList)
+PassOwnPtr<MediaQueryExp> MediaQueryExp::create(const String& mediaFeature, CSSParserValueList* valueList)
 {
     RefPtr<CSSValue> cssValue;
     bool isValid = false;
+    String mediaFeatureLower(mediaFeature.lower());
+    mediaFeatureLower.ensure16Bit();
+    StringImpl* mediaFeatureImpl = attemptStaticStringCreation(mediaFeatureLower, Likely8Bit).impl();
+    unsigned mediaFeatureHash = mediaFeatureImpl->existingHash();
 
     // Create value for media query expression that must have 1 or more values.
-    if (valueList) {
+    if (valueList && valueList->size() > 0) {
         if (valueList->size() == 1) {
             CSSParserValue* value = valueList->current();
 
-            if (featureWithCSSValueID(mediaFeature, value)) {
+            if (featureWithCSSValueID(mediaFeatureHash, value)) {
                 // Media features that use CSSValueIDs.
                 cssValue = CSSPrimitiveValue::createIdentifier(value->id);
-                if (!featureWithValidIdent(mediaFeature, toCSSPrimitiveValue(cssValue.get())->getValueID()))
+                if (!featureWithValidIdent(mediaFeatureHash, toCSSPrimitiveValue(cssValue.get())->getValueID()))
                     cssValue.clear();
-            } else if (featureWithValidDensity(mediaFeature, value)) {
+            } else if (featureWithValidDensity(mediaFeatureHash, value)) {
                 // Media features that must have non-negative <density>, ie. dppx, dpi or dpcm.
                 cssValue = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
-            } else if (featureWithValidPositiveLenghtOrNumber(mediaFeature, value)) {
+            } else if (featureWithValidPositiveLengthOrNumber(mediaFeatureHash, value)) {
                 // Media features that must have non-negative <lenght> or number value.
                 cssValue = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
-            } else if (featureWithPositiveInteger(mediaFeature, value)) {
+            } else if (featureWithPositiveInteger(mediaFeatureHash, value)) {
                 // Media features that must have non-negative integer value.
                 cssValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_NUMBER);
-            } else if (featureWithPositiveNumber(mediaFeature, value)) {
+            } else if (featureWithPositiveNumber(mediaFeatureHash, value)) {
                 // Media features that must have non-negative number value.
                 cssValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_NUMBER);
-            } else if (featureWithZeroOrOne(mediaFeature, value)) {
+            } else if (featureWithZeroOrOne(mediaFeatureHash, value)) {
                 // Media features that must have (0|1) value.
                 cssValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_NUMBER);
             }
 
             isValid = cssValue;
 
-        } else if (valueList->size() == 3 && featureWithAspectRatio(mediaFeature)) {
+        } else if (valueList->size() == 3 && featureWithAspectRatio(mediaFeatureHash)) {
             // 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) {
                     if (!i)
                         numeratorValue = value->fValue;
                     else
                         denominatorValue = value->fValue;
                 } else if (i == 1 && value->unit == CSSParserValue::Operator && value->iValue == '/') {
                     continue;
                 } else {
                     isValid = false;
                     break;
                 }
             }
 
             if (isValid)
                 cssValue = CSSAspectRatioValue::create(numeratorValue, denominatorValue);
         }
-    } else if (featureWithoutValue(mediaFeature)) {
+    } else if (featureWithoutValue(mediaFeatureHash)) {
         isValid = true;
     }
 
     if (!isValid)
         return nullptr;
 
-    return adoptPtr(new MediaQueryExp(mediaFeature, cssValue));
+    return adoptPtr(new MediaQueryExp(mediaFeatureImpl, cssValue));
 }
 
 MediaQueryExp::~MediaQueryExp()
 {
 }
 
 String MediaQueryExp::serialize() const
 {
     StringBuilder result;
     result.append("(");
     result.append(m_mediaFeature.lower());
     if (m_value) {
         result.append(": ");
         result.append(m_value->cssText());
     }
     result.append(")");
 
     return result.toString();
 }
 
 } // namespace