Enable MQ evaluation off the main thread

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 21 matching lines @@
 
 #include "CSSValueKeywords.h"
 #include "core/css/CSSAspectRatioValue.h"
 #include "core/css/CSSParser.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
-static inline bool featureWithCSSValueID(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithCSSValueID(const String& mediaFeature, const CSSParserValue* value)
 {
     if (!value->id)
         return false;
 
     return mediaFeature == MediaFeatureNames::orientationMediaFeature
         || mediaFeature == MediaFeatureNames::viewModeMediaFeature
         || mediaFeature == MediaFeatureNames::pointerMediaFeature
         || mediaFeature == MediaFeatureNames::scanMediaFeature;
 }
 
-static inline bool featureWithValidIdent(const AtomicString& mediaFeature, CSSValueID ident)
+static inline bool featureWithValidIdent(const String& mediaFeature, CSSValueID ident)
 {
     if (mediaFeature == MediaFeatureNames::orientationMediaFeature)
         return ident == CSSValuePortrait || ident == CSSValueLandscape;
 
     if (mediaFeature == MediaFeatureNames::viewModeMediaFeature) {
         switch (ident) {
         case CSSValueWindowed:
         case CSSValueFloating:
         case CSSValueFullscreen:
         case CSSValueMaximized:
         case CSSValueMinimized:
             return true;
         default:
             return false;
         }
     }
 
     if (mediaFeature == MediaFeatureNames::pointerMediaFeature)
         return ident == CSSValueNone || ident == CSSValueCoarse || ident == CSSValueFine;
 
     if (mediaFeature == MediaFeatureNames::scanMediaFeature)
         return ident == CSSValueInterlace || ident == CSSValueProgressive;
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-static inline bool featureWithValidPositiveLenghtOrNumber(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidPositiveLenghtOrNumber(const String& mediaFeature, 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)
         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;
 }
 
-static inline bool featureWithValidDensity(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithValidDensity(const String& mediaFeature, 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;
 }
 
-static inline bool featureWithPositiveInteger(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveInteger(const String& mediaFeature, 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;
 }
 
-static inline bool featureWithPositiveNumber(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithPositiveNumber(const String& mediaFeature, const CSSParserValue* value)
 {
     if (value->unit != CSSPrimitiveValue::CSS_NUMBER || value->fValue < 0)
         return false;
 
     return mediaFeature == MediaFeatureNames::transform2dMediaFeature
         || mediaFeature == MediaFeatureNames::transform3dMediaFeature
         || mediaFeature == MediaFeatureNames::deprecatedTransitionMediaFeature
         || mediaFeature == MediaFeatureNames::animationMediaFeature
         || mediaFeature == MediaFeatureNames::devicePixelRatioMediaFeature
         || mediaFeature == MediaFeatureNames::maxDevicePixelRatioMediaFeature
         || mediaFeature == MediaFeatureNames::minDevicePixelRatioMediaFeature;
 }
 
-static inline bool featureWithZeroOrOne(const AtomicString& mediaFeature, const CSSParserValue* value)
+static inline bool featureWithZeroOrOne(const String& mediaFeature, const CSSParserValue* value)
 {
     if (!value->isInt || !(value->fValue == 1 || !value->fValue))
         return false;
 
     return mediaFeature == MediaFeatureNames::gridMediaFeature
         || mediaFeature == MediaFeatureNames::hoverMediaFeature;
 }
 
-static inline bool featureWithAspectRatio(const AtomicString& mediaFeature)
+static inline bool featureWithAspectRatio(const String& mediaFeature)
 {
     return mediaFeature == MediaFeatureNames::aspectRatioMediaFeature
         || mediaFeature == MediaFeatureNames::deviceAspectRatioMediaFeature
         || mediaFeature == MediaFeatureNames::minAspectRatioMediaFeature
         || mediaFeature == MediaFeatureNames::maxAspectRatioMediaFeature
         || mediaFeature == MediaFeatureNames::minDeviceAspectRatioMediaFeature
         || mediaFeature == MediaFeatureNames::maxDeviceAspectRatioMediaFeature;
 }
 
-static inline bool featureWithoutValue(const AtomicString& mediaFeature)
+static inline bool featureWithoutValue(const String& mediaFeature)
 {
     // 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
@@ skipping 16 matching lines @@
 {
     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::maxAspectRatioMediaFeature;

[abarth-chromium, 2013/07/08 15:12:31]

not lgtm

We use AtomicStrings here for two reasons:

1) To make these comparisons fast.
2) To save memory by reducing duplicate strings.

 }
 
-MediaQueryExp::MediaQueryExp(const AtomicString& mediaFeature, PassRefPtr<CSSValue> value)
+MediaQueryExp::MediaQueryExp(const String& mediaFeature, PassRefPtr<CSSValue> value)
     : m_mediaFeature(mediaFeature)
     , 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;
 
     // Create value for media query expression that must have 1 or more values.
     if (valueList) {
         if (valueList->size() == 1) {
             CSSParserValue* value = valueList->current();
 
             if (featureWithCSSValueID(mediaFeature, value)) {
@@ skipping 75 matching lines @@
 }
 
 void MediaQueryExp::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
     info.addMember(m_mediaFeature, "mediaFeature");
     info.addMember(m_value, "value");
 }
 
 } // namespace