diff options
Diffstat (limited to 'Source/WebCore/css/StyleRule.cpp')
| -rw-r--r-- | Source/WebCore/css/StyleRule.cpp | 282 |
1 files changed, 184 insertions, 98 deletions
diff --git a/Source/WebCore/css/StyleRule.cpp b/Source/WebCore/css/StyleRule.cpp index 172498507..60d1dbb42 100644 --- a/Source/WebCore/css/StyleRule.cpp +++ b/Source/WebCore/css/StyleRule.cpp @@ -22,84 +22,85 @@ #include "config.h" #include "StyleRule.h" -#include "CSSCharsetRule.h" +#include "CSSDeferredParser.h" #include "CSSFontFaceRule.h" -#include "CSSHostRule.h" #include "CSSImportRule.h" +#include "CSSKeyframeRule.h" +#include "CSSKeyframesRule.h" #include "CSSMediaRule.h" +#include "CSSNamespaceRule.h" #include "CSSPageRule.h" #include "CSSStyleRule.h" #include "CSSSupportsRule.h" #include "CSSUnknownRule.h" +#include "MediaList.h" #include "StyleProperties.h" #include "StyleRuleImport.h" -#include "WebKitCSSKeyframeRule.h" -#include "WebKitCSSKeyframesRule.h" #include "WebKitCSSRegionRule.h" #include "WebKitCSSViewportRule.h" namespace WebCore { struct SameSizeAsStyleRuleBase : public WTF::RefCountedBase { - unsigned bitfields; + unsigned bitfields : 5; }; COMPILE_ASSERT(sizeof(StyleRuleBase) == sizeof(SameSizeAsStyleRuleBase), StyleRuleBase_should_stay_small); -PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const +RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet) const { - return createCSSOMWrapper(parentSheet, 0); + return createCSSOMWrapper(parentSheet, nullptr); } -PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const +RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSRule* parentRule) const { - return createCSSOMWrapper(0, parentRule); + return createCSSOMWrapper(nullptr, parentRule); } void StyleRuleBase::destroy() { switch (type()) { case Style: - delete static_cast<StyleRule*>(this); + delete downcast<StyleRule>(this); return; case Page: - delete static_cast<StyleRulePage*>(this); + delete downcast<StyleRulePage>(this); return; case FontFace: - delete static_cast<StyleRuleFontFace*>(this); + delete downcast<StyleRuleFontFace>(this); return; case Media: - delete static_cast<StyleRuleMedia*>(this); + delete downcast<StyleRuleMedia>(this); return; -#if ENABLE(CSS3_CONDITIONAL_RULES) case Supports: - delete static_cast<StyleRuleSupports*>(this); + delete downcast<StyleRuleSupports>(this); return; -#endif #if ENABLE(CSS_REGIONS) case Region: - delete static_cast<StyleRuleRegion*>(this); + delete downcast<StyleRuleRegion>(this); return; #endif case Import: - delete static_cast<StyleRuleImport*>(this); + delete downcast<StyleRuleImport>(this); return; case Keyframes: - delete static_cast<StyleRuleKeyframes*>(this); - return; -#if ENABLE(SHADOW_DOM) - case HostInternal: - delete static_cast<StyleRuleHost*>(this); + delete downcast<StyleRuleKeyframes>(this); return; -#endif #if ENABLE(CSS_DEVICE_ADAPTATION) case Viewport: - delete static_cast<StyleRuleViewport*>(this); + delete downcast<StyleRuleViewport>(this); return; #endif - case Unknown: - case Charset: + case Namespace: + delete downcast<StyleRuleNamespace>(this); + return; case Keyframe: + delete downcast<StyleRuleKeyframe>(this); + return; + case Charset: + delete downcast<StyleRuleCharset>(this); + return; + case Unknown: #if !ENABLE(CSS_REGIONS) case Region: #endif @@ -109,37 +110,32 @@ void StyleRuleBase::destroy() ASSERT_NOT_REACHED(); } -PassRef<StyleRuleBase> StyleRuleBase::copy() const +Ref<StyleRuleBase> StyleRuleBase::copy() const { switch (type()) { case Style: - return static_cast<const StyleRule*>(this)->copy(); + return downcast<StyleRule>(*this).copy(); case Page: - return static_cast<const StyleRulePage*>(this)->copy(); + return downcast<StyleRulePage>(*this).copy(); case FontFace: - return static_cast<const StyleRuleFontFace*>(this)->copy(); + return downcast<StyleRuleFontFace>(*this).copy(); case Media: - return static_cast<const StyleRuleMedia*>(this)->copy(); -#if ENABLE(CSS3_CONDITIONAL_RULES) + return downcast<StyleRuleMedia>(*this).copy(); case Supports: - return static_cast<const StyleRuleSupports*>(this)->copy(); -#endif + return downcast<StyleRuleSupports>(*this).copy(); #if ENABLE(CSS_REGIONS) case Region: - return static_cast<const StyleRuleRegion*>(this)->copy(); + return downcast<StyleRuleRegion>(*this).copy(); #endif case Keyframes: - return static_cast<const StyleRuleKeyframes*>(this)->copy(); -#if ENABLE(SHADOW_DOM) - case HostInternal: - return static_cast<const StyleRuleHost*>(this)->copy(); -#endif + return downcast<StyleRuleKeyframes>(*this).copy(); #if ENABLE(CSS_DEVICE_ADAPTATION) case Viewport: - return static_cast<const StyleRuleViewport*>(this)->copy(); + return downcast<StyleRuleViewport>(*this).copy(); #endif case Import: - // FIXME: Copy import rules. + case Namespace: + // FIXME: Copy import and namespace rules. break; case Unknown: case Charset: @@ -150,53 +146,47 @@ PassRef<StyleRuleBase> StyleRuleBase::copy() const break; } CRASH(); - // HACK: EFL won't build without this (old GCC with crappy -Werror=return-type) - return PassRef<StyleRuleBase>(*static_cast<StyleRuleBase*>(nullptr)); } -PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const +RefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const { RefPtr<CSSRule> rule; - StyleRuleBase* self = const_cast<StyleRuleBase*>(this); + StyleRuleBase& self = const_cast<StyleRuleBase&>(*this); switch (type()) { case Style: - rule = CSSStyleRule::create(static_cast<StyleRule*>(self), parentSheet); + rule = CSSStyleRule::create(downcast<StyleRule>(self), parentSheet); break; case Page: - rule = CSSPageRule::create(static_cast<StyleRulePage*>(self), parentSheet); + rule = CSSPageRule::create(downcast<StyleRulePage>(self), parentSheet); break; case FontFace: - rule = CSSFontFaceRule::create(static_cast<StyleRuleFontFace*>(self), parentSheet); + rule = CSSFontFaceRule::create(downcast<StyleRuleFontFace>(self), parentSheet); break; case Media: - rule = CSSMediaRule::create(static_cast<StyleRuleMedia*>(self), parentSheet); + rule = CSSMediaRule::create(downcast<StyleRuleMedia>(self), parentSheet); break; -#if ENABLE(CSS3_CONDITIONAL_RULES) case Supports: - rule = CSSSupportsRule::create(static_cast<StyleRuleSupports*>(self), parentSheet); + rule = CSSSupportsRule::create(downcast<StyleRuleSupports>(self), parentSheet); break; -#endif #if ENABLE(CSS_REGIONS) case Region: - rule = WebKitCSSRegionRule::create(static_cast<StyleRuleRegion*>(self), parentSheet); + rule = WebKitCSSRegionRule::create(downcast<StyleRuleRegion>(self), parentSheet); break; #endif case Import: - rule = CSSImportRule::create(static_cast<StyleRuleImport*>(self), parentSheet); + rule = CSSImportRule::create(downcast<StyleRuleImport>(self), parentSheet); break; case Keyframes: - rule = WebKitCSSKeyframesRule::create(static_cast<StyleRuleKeyframes*>(self), parentSheet); + rule = CSSKeyframesRule::create(downcast<StyleRuleKeyframes>(self), parentSheet); break; #if ENABLE(CSS_DEVICE_ADAPTATION) case Viewport: - rule = WebKitCSSViewportRule::create(static_cast<StyleRuleViewport*>(self), parentSheet); + rule = WebKitCSSViewportRule::create(downcast<StyleRuleViewport>(self), parentSheet); break; #endif -#if ENABLE(SHADOW_DOM) - case HostInternal: - rule = CSSHostRule::create(static_cast<StyleRuleHost*>(self), parentSheet); + case Namespace: + rule = CSSNamespaceRule::create(downcast<StyleRuleNamespace>(self), parentSheet); break; -#endif case Unknown: case Charset: case Keyframe: @@ -204,11 +194,11 @@ PassRefPtr<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet case Region: #endif ASSERT_NOT_REACHED(); - return 0; + return nullptr; } if (parentRule) rule->setParentRule(parentRule); - return rule.release(); + return rule; } unsigned StyleRule::averageSizeInBytes() @@ -216,15 +206,15 @@ unsigned StyleRule::averageSizeInBytes() return sizeof(StyleRule) + sizeof(CSSSelector) + StyleProperties::averageSizeInBytes(); } -StyleRule::StyleRule(int sourceLine, PassRef<StyleProperties> properties) - : StyleRuleBase(Style, sourceLine) - , m_properties(std::move(properties)) +StyleRule::StyleRule(Ref<StylePropertiesBase>&& properties) + : StyleRuleBase(Style) + , m_properties(WTFMove(properties)) { } StyleRule::StyleRule(const StyleRule& o) : StyleRuleBase(o) - , m_properties(o.m_properties->mutableCopy()) + , m_properties(o.properties().mutableCopy()) , m_selectorList(o.m_selectorList) { } @@ -233,21 +223,28 @@ StyleRule::~StyleRule() { } +const StyleProperties& StyleRule::properties() const +{ + if (m_properties->type() == DeferredPropertiesType) + m_properties = downcast<DeferredStyleProperties>(m_properties.get()).parseDeferredProperties(); + return downcast<StyleProperties>(m_properties.get()); +} + MutableStyleProperties& StyleRule::mutableProperties() { - if (!m_properties->isMutable()) - m_properties = m_properties->mutableCopy(); - return static_cast<MutableStyleProperties&>(m_properties.get()); + if (!is<MutableStyleProperties>(m_properties.get())) + m_properties = properties().mutableCopy(); + return downcast<MutableStyleProperties>(m_properties.get()); } -PassRef<StyleRule> StyleRule::create(int sourceLine, const Vector<const CSSSelector*>& selectors, PassRef<StyleProperties> properties) +Ref<StyleRule> StyleRule::create(const Vector<const CSSSelector*>& selectors, Ref<StyleProperties>&& properties) { ASSERT_WITH_SECURITY_IMPLICATION(!selectors.isEmpty()); CSSSelector* selectorListArray = reinterpret_cast<CSSSelector*>(fastMalloc(sizeof(CSSSelector) * selectors.size())); for (unsigned i = 0; i < selectors.size(); ++i) new (NotNull, &selectorListArray[i]) CSSSelector(*selectors.at(i)); selectorListArray[selectors.size() - 1].setLastInSelectorList(); - auto rule = StyleRule::create(sourceLine, std::move(properties)); + auto rule = StyleRule::create(WTFMove(properties)); rule.get().parserAdoptSelectorArray(selectorListArray); return rule; } @@ -265,7 +262,7 @@ Vector<RefPtr<StyleRule>> StyleRule::splitIntoMultipleRulesWithMaximumSelectorCo componentsInThisSelector.append(component); if (componentsInThisSelector.size() + componentsSinceLastSplit.size() > maxCount && !componentsSinceLastSplit.isEmpty()) { - rules.append(create(sourceLine(), componentsSinceLastSplit, const_cast<StyleProperties&>(m_properties.get()))); + rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties()))); componentsSinceLastSplit.clear(); } @@ -273,14 +270,14 @@ Vector<RefPtr<StyleRule>> StyleRule::splitIntoMultipleRulesWithMaximumSelectorCo } if (!componentsSinceLastSplit.isEmpty()) - rules.append(create(sourceLine(), componentsSinceLastSplit, const_cast<StyleProperties&>(m_properties.get()))); + rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties()))); return rules; } -StyleRulePage::StyleRulePage(PassRef<StyleProperties> properties) +StyleRulePage::StyleRulePage(Ref<StyleProperties>&& properties) : StyleRuleBase(Page) - , m_properties(std::move(properties)) + , m_properties(WTFMove(properties)) { } @@ -297,14 +294,14 @@ StyleRulePage::~StyleRulePage() MutableStyleProperties& StyleRulePage::mutableProperties() { - if (!m_properties->isMutable()) + if (!is<MutableStyleProperties>(m_properties.get())) m_properties = m_properties->mutableCopy(); - return static_cast<MutableStyleProperties&>(m_properties.get()); + return downcast<MutableStyleProperties>(m_properties.get()); } -StyleRuleFontFace::StyleRuleFontFace(PassRef<StyleProperties> properties) - : StyleRuleBase(FontFace, 0) - , m_properties(std::move(properties)) +StyleRuleFontFace::StyleRuleFontFace(Ref<StyleProperties>&& properties) + : StyleRuleBase(FontFace) + , m_properties(WTFMove(properties)) { } @@ -320,39 +317,85 @@ StyleRuleFontFace::~StyleRuleFontFace() MutableStyleProperties& StyleRuleFontFace::mutableProperties() { - if (!m_properties->isMutable()) + if (!is<MutableStyleProperties>(m_properties.get())) m_properties = m_properties->mutableCopy(); - return static_cast<MutableStyleProperties&>(m_properties.get()); + return downcast<MutableStyleProperties>(m_properties.get()); +} + +DeferredStyleGroupRuleList::DeferredStyleGroupRuleList(const CSSParserTokenRange& range, CSSDeferredParser& parser) + : m_parser(parser) +{ + size_t length = range.end() - range.begin(); + m_tokens.reserveCapacity(length); + m_tokens.append(range.begin(), length); +} + +void DeferredStyleGroupRuleList::parseDeferredRules(Vector<RefPtr<StyleRuleBase>>& childRules) +{ + m_parser->parseRuleList(m_tokens, childRules); } +void DeferredStyleGroupRuleList::parseDeferredKeyframes(StyleRuleKeyframes& keyframesRule) +{ + m_parser->parseKeyframeList(m_tokens, keyframesRule); +} + StyleRuleGroup::StyleRuleGroup(Type type, Vector<RefPtr<StyleRuleBase>>& adoptRule) - : StyleRuleBase(type, 0) + : StyleRuleBase(type) { m_childRules.swap(adoptRule); } +StyleRuleGroup::StyleRuleGroup(Type type, std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules) + : StyleRuleBase(type) + , m_deferredRules(WTFMove(deferredRules)) +{ +} + StyleRuleGroup::StyleRuleGroup(const StyleRuleGroup& o) : StyleRuleBase(o) { - m_childRules.reserveInitialCapacity(o.m_childRules.size()); - for (unsigned i = 0, size = o.m_childRules.size(); i < size; ++i) - m_childRules.uncheckedAppend(o.m_childRules[i]->copy()); + m_childRules.reserveInitialCapacity(o.childRules().size()); + for (auto& childRule : o.childRules()) + m_childRules.uncheckedAppend(childRule->copy()); +} + +const Vector<RefPtr<StyleRuleBase>>& StyleRuleGroup::childRules() const +{ + parseDeferredRulesIfNeeded(); + return m_childRules; } -void StyleRuleGroup::wrapperInsertRule(unsigned index, PassRef<StyleRuleBase> rule) +void StyleRuleGroup::wrapperInsertRule(unsigned index, Ref<StyleRuleBase>&& rule) { - m_childRules.insert(index, std::move(rule)); + parseDeferredRulesIfNeeded(); + m_childRules.insert(index, WTFMove(rule)); } void StyleRuleGroup::wrapperRemoveRule(unsigned index) { + parseDeferredRulesIfNeeded(); m_childRules.remove(index); } - -StyleRuleMedia::StyleRuleMedia(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase>>& adoptRules) +void StyleRuleGroup::parseDeferredRulesIfNeeded() const +{ + if (!m_deferredRules) + return; + + m_deferredRules->parseDeferredRules(m_childRules); + m_deferredRules = nullptr; +} + +StyleRuleMedia::StyleRuleMedia(Ref<MediaQuerySet>&& media, Vector<RefPtr<StyleRuleBase>>& adoptRules) : StyleRuleGroup(Media, adoptRules) - , m_mediaQueries(media) + , m_mediaQueries(WTFMove(media)) +{ +} + +StyleRuleMedia::StyleRuleMedia(Ref<MediaQuerySet>&& media, std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules) + : StyleRuleGroup(Media, WTFMove(deferredRules)) + , m_mediaQueries(WTFMove(media)) { } @@ -364,7 +407,6 @@ StyleRuleMedia::StyleRuleMedia(const StyleRuleMedia& o) } -#if ENABLE(CSS3_CONDITIONAL_RULES) StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase>>& adoptRules) : StyleRuleGroup(Supports, adoptRules) , m_conditionText(conditionText) @@ -372,20 +414,32 @@ StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool condition { } +StyleRuleSupports::StyleRuleSupports(const String& conditionText, bool conditionIsSupported, std::unique_ptr<DeferredStyleGroupRuleList>&& deferredRules) + : StyleRuleGroup(Supports, WTFMove(deferredRules)) + , m_conditionText(conditionText) + , m_conditionIsSupported(conditionIsSupported) +{ +} + StyleRuleSupports::StyleRuleSupports(const StyleRuleSupports& o) : StyleRuleGroup(o) , m_conditionText(o.m_conditionText) , m_conditionIsSupported(o.m_conditionIsSupported) { } -#endif -StyleRuleRegion::StyleRuleRegion(Vector<OwnPtr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules) +StyleRuleRegion::StyleRuleRegion(Vector<std::unique_ptr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules) : StyleRuleGroup(Region, adoptRules) { m_selectorList.adoptSelectorVector(*selectors); } +StyleRuleRegion::StyleRuleRegion(CSSSelectorList& selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules) + : StyleRuleGroup(Region, adoptRules) + , m_selectorList(WTFMove(selectors)) +{ +} + StyleRuleRegion::StyleRuleRegion(const StyleRuleRegion& o) : StyleRuleGroup(o) , m_selectorList(o.m_selectorList) @@ -394,9 +448,9 @@ StyleRuleRegion::StyleRuleRegion(const StyleRuleRegion& o) #if ENABLE(CSS_DEVICE_ADAPTATION) -StyleRuleViewport::StyleRuleViewport(PassRef<StyleProperties> properties) +StyleRuleViewport::StyleRuleViewport(Ref<StyleProperties>&& properties) : StyleRuleBase(Viewport, 0) - , m_properties(std::move(properties)) + , m_properties(WTFMove(properties)) { } @@ -418,4 +472,36 @@ MutableStyleProperties& StyleRuleViewport::mutableProperties() } #endif // ENABLE(CSS_DEVICE_ADAPTATION) +StyleRuleCharset::StyleRuleCharset() + : StyleRuleBase(Charset) +{ +} + +StyleRuleCharset::StyleRuleCharset(const StyleRuleCharset& o) + : StyleRuleBase(o) +{ +} + +StyleRuleCharset::~StyleRuleCharset() +{ +} + +StyleRuleNamespace::StyleRuleNamespace(AtomicString prefix, AtomicString uri) + : StyleRuleBase(Namespace) + , m_prefix(prefix) + , m_uri(uri) +{ +} + +StyleRuleNamespace::StyleRuleNamespace(const StyleRuleNamespace& o) + : StyleRuleBase(o) + , m_prefix(o.m_prefix) + , m_uri(o.m_uri) +{ +} + +StyleRuleNamespace::~StyleRuleNamespace() +{ +} + } // namespace WebCore |