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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 178803006: Turn MQ classes into thread safe (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Rebased after MediaFeature generation landed 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
« Source/core/css/MediaQueryExp.h ('K') | « Source/core/css/MediaQueryExp.h ('k') | Source/core/html/parser/HTMLParserIdioms.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 8671a2e30e3debaafb6b9fb598eb357fc583e7fa..a909bb0924c245092d9e2190b66e2c56658e255a 100644
--- a/Source/core/css/MediaQueryExp.cpp
+++ b/Source/core/css/MediaQueryExp.cpp
@@ -32,29 +32,37 @@
#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());
+}
abarth-chromium 2014/03/06 08:03:57 Is this function necessary? operator== on Strings
+
+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);
}
-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:
@@ -67,181 +75,186 @@ static inline bool featureWithValidIdent(const AtomicString& mediaFeature, CSSVa
}
}
- 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 MediaQueryExp& other)
: m_mediaFeature(other.mediaFeature())
+ , m_mediaFeatureHash(other.mediaFeature().impl()->existingHash())
, m_value(other.value())
{
}
-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)
{
}
-PassOwnPtrWillBeRawPtr<MediaQueryExp> MediaQueryExp::create(const AtomicString& mediaFeature, CSSParserValueList* valueList)
+PassOwnPtrWillBeRawPtr<MediaQueryExp> MediaQueryExp::create(const String& mediaFeature, CSSParserValueList* valueList)
{
RefPtrWillBeRawPtr<CSSValue> cssValue;
bool isValid = false;
+ StringImpl* mediaFeatureImpl = attemptStaticStringCreation(mediaFeature.lower()).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.
@@ -267,14 +280,14 @@ PassOwnPtrWillBeRawPtr<MediaQueryExp> MediaQueryExp::create(const AtomicString&
if (isValid)
cssValue = CSSAspectRatioValue::create(numeratorValue, denominatorValue);
}
- } else if (featureWithoutValue(mediaFeature)) {
+ } else if (featureWithoutValue(mediaFeatureHash)) {
isValid = true;
}
if (!isValid)
return nullptr;
- return adoptPtrWillBeNoop(new MediaQueryExp(mediaFeature, cssValue));
+ return adoptPtrWillBeNoop(new MediaQueryExp(mediaFeatureImpl, cssValue));
}
MediaQueryExp::~MediaQueryExp()
« Source/core/css/MediaQueryExp.h ('K') | « Source/core/css/MediaQueryExp.h ('k') | Source/core/html/parser/HTMLParserIdioms.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698