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 14 matching lines @@
  * 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 "CSSValueKeywords.h"
 #include "core/css/CSSAspectRatioValue.h"
-#include "core/css/parser/BisonCSSParser.h"
+#include "core/css/CSSParserValues.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)
+using namespace MediaFeatureNames;
+
+static inline bool hashEquals(const unsigned mediaFeatureHash, const String& mediaFeature)
+{
+    return (mediaFeatureHash == mediaFeature.impl()->existingHash());
+}
+
+static inline bool featureWithCSSValueID(const unsigned mediaFeatureHash, const CSSParserValue* value)
 {
     if (!value->id)
         return false;
 
-    return mediaFeature == MediaFeatureNames::orientationMediaFeature
-        || mediaFeature == MediaFeatureNames::viewModeMediaFeature
-        || mediaFeature == MediaFeatureNames::pointerMediaFeature
-        || mediaFeature == MediaFeatureNames::scanMediaFeature;
+    return hashEquals(mediaFeatureHash, orientationMediaFeature)
+        || hashEquals(mediaFeatureHash, viewModeMediaFeature)
+        || hashEquals(mediaFeatureHash, pointerMediaFeature)
+        || hashEquals(mediaFeatureHash, scanMediaFeature);

[abarth-chromium, 2014/03/01 07:28:25]

Where do these strings come from?  We can make them StaticStrings too using
make_names.py and then you won't need to do all this work.

 }
 
-static inline bool featureWithValidIdent(const AtomicString& mediaFeature, CSSValueID ident)
+static inline bool featureWithValidIdent(const unsigned mediaFeatureHash, CSSValueID ident)
 {
-    if (mediaFeature == MediaFeatureNames::orientationMediaFeature)
+    if (hashEquals(mediaFeatureHash, orientationMediaFeature))
         return ident == CSSValuePortrait || ident == CSSValueLandscape;
 
-    if (mediaFeature == MediaFeatureNames::viewModeMediaFeature) {
+    if (hashEquals(mediaFeatureHash, viewModeMediaFeature)) {
         switch (ident) {
         case CSSValueWindowed:
         case CSSValueFloating:
         case CSSValueFullscreen:
         case CSSValueMaximized:
         case CSSValueMinimized:
             return true;
         default:
             return false;
         }
     }
 
-    if (mediaFeature == MediaFeatureNames::pointerMediaFeature)
+    if (hashEquals(mediaFeatureHash, pointerMediaFeature))
         return ident == CSSValueNone || ident == CSSValueCoarse || ident == CSSValueFine;
 
-    if (mediaFeature == MediaFeatureNames::scanMediaFeature)
+    if (hashEquals(mediaFeatureHash, scanMediaFeature))
         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 hashEquals(mediaFeatureHash, heightMediaFeature)
+        || hashEquals(mediaFeatureHash, maxHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, minHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, widthMediaFeature)
+        || hashEquals(mediaFeatureHash, maxWidthMediaFeature)
+        || hashEquals(mediaFeatureHash, minWidthMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, maxDeviceHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, minDeviceHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceWidthMediaFeature)
+        || hashEquals(mediaFeatureHash, minDeviceWidthMediaFeature)
+        || hashEquals(mediaFeatureHash, maxDeviceWidthMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, resolutionMediaFeature)
+        || hashEquals(mediaFeatureHash, minResolutionMediaFeature)
+        || hashEquals(mediaFeatureHash, maxResolutionMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, colorMediaFeature)
+        || hashEquals(mediaFeatureHash, maxColorMediaFeature)
+        || hashEquals(mediaFeatureHash, minColorMediaFeature)
+        || hashEquals(mediaFeatureHash, colorIndexMediaFeature)
+        || hashEquals(mediaFeatureHash, maxColorIndexMediaFeature)
+        || hashEquals(mediaFeatureHash, minColorIndexMediaFeature)
+        || hashEquals(mediaFeatureHash, monochromeMediaFeature)
+        || hashEquals(mediaFeatureHash, maxMonochromeMediaFeature)
+        || hashEquals(mediaFeatureHash, minMonochromeMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, transform2dMediaFeature)
+        || hashEquals(mediaFeatureHash, transform3dMediaFeature)
+        || hashEquals(mediaFeatureHash, animationMediaFeature)
+        || hashEquals(mediaFeatureHash, devicePixelRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, maxDevicePixelRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, minDevicePixelRatioMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, gridMediaFeature)
+        || hashEquals(mediaFeatureHash, hoverMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, aspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceAspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, minAspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, maxAspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, minDeviceAspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, maxDeviceAspectRatioMediaFeature);
 }
 
-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 hashEquals(mediaFeatureHash, monochromeMediaFeature)
+        || hashEquals(mediaFeatureHash, colorMediaFeature)
+        || hashEquals(mediaFeatureHash, colorIndexMediaFeature)
+        || hashEquals(mediaFeatureHash, gridMediaFeature)
+        || hashEquals(mediaFeatureHash, heightMediaFeature)
+        || hashEquals(mediaFeatureHash, widthMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceHeightMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceWidthMediaFeature)
+        || hashEquals(mediaFeatureHash, orientationMediaFeature)
+        || hashEquals(mediaFeatureHash, aspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, deviceAspectRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, hoverMediaFeature)
+        || hashEquals(mediaFeatureHash, transform2dMediaFeature)
+        || hashEquals(mediaFeatureHash, transform3dMediaFeature)
+        || hashEquals(mediaFeatureHash, animationMediaFeature)
+        || hashEquals(mediaFeatureHash, viewModeMediaFeature)
+        || hashEquals(mediaFeatureHash, pointerMediaFeature)
+        || hashEquals(mediaFeatureHash, devicePixelRatioMediaFeature)
+        || hashEquals(mediaFeatureHash, resolutionMediaFeature)
+        || hashEquals(mediaFeatureHash, scanMediaFeature);
 }
 
 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 hashEquals(m_mediaFeatureHash, widthMediaFeature)
+        || hashEquals(m_mediaFeatureHash, heightMediaFeature)
+        || hashEquals(m_mediaFeatureHash, minWidthMediaFeature)
+        || hashEquals(m_mediaFeatureHash, minHeightMediaFeature)
+        || hashEquals(m_mediaFeatureHash, maxWidthMediaFeature)
+        || hashEquals(m_mediaFeatureHash, maxHeightMediaFeature)
+        || hashEquals(m_mediaFeatureHash, orientationMediaFeature)
+        || hashEquals(m_mediaFeatureHash, aspectRatioMediaFeature)
+        || hashEquals(m_mediaFeatureHash, minAspectRatioMediaFeature)
+        || hashEquals(m_mediaFeatureHash, devicePixelRatioMediaFeature)
+        || hashEquals(m_mediaFeatureHash, resolutionMediaFeature)
+        || hashEquals(m_mediaFeatureHash, maxAspectRatioMediaFeature);
 }
 
-MediaQueryExp::MediaQueryExp(const AtomicString& mediaFeature, PassRefPtrWillBeRawPtr<CSSValue> value)
-    : m_mediaFeature(mediaFeature)
+MediaQueryExp::MediaQueryExp(StringImpl* mediaFeatureImpl, PassRefPtrWillBeRawPtr<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)
 {
     RefPtrWillBeRawPtr<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