Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(494)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/core/css/MediaQueryExp.cpp

Issue 171383002: A thread-safe Media Query Parser (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Refactored and passes tests Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « Source/core/css/MediaQueryExp.h ('k') | Source/core/css/parser/CSSInputStream.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/core/css/MediaQueryExp.cpp
diff --git a/Source/core/css/MediaQueryExp.cpp b/Source/core/css/MediaQueryExp.cpp
index a7c5cf5535ec40932f0dd6a87fe1801c0f22f389..4fae73a48f498de8c37ef0f9ee8da968df5c424c 100644
--- a/Source/core/css/MediaQueryExp.cpp
+++ b/Source/core/css/MediaQueryExp.cpp
@@ -34,27 +34,29 @@
#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 take
+ || 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:
@@ -67,175 +69,181 @@ static inline bool featureWithValidIdent(const AtomicString& mediaFeature, CSSVa
}
}
- 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.
@@ -261,14 +269,14 @@ PassOwnPtr<MediaQueryExp> MediaQueryExp::create(const AtomicString& mediaFeature
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()
« no previous file with comments | « Source/core/css/MediaQueryExp.h ('k') | Source/core/css/parser/CSSInputStream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698