From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- Source/WebCore/css/StyleRule.h | 299 ++++++++++++++++++++++++++--------------- 1 file changed, 189 insertions(+), 110 deletions(-) (limited to 'Source/WebCore/css/StyleRule.h') diff --git a/Source/WebCore/css/StyleRule.h b/Source/WebCore/css/StyleRule.h index 91df4c337..e768efe84 100644 --- a/Source/WebCore/css/StyleRule.h +++ b/Source/WebCore/css/StyleRule.h @@ -19,22 +19,24 @@ * Boston, MA 02110-1301, USA. */ -#ifndef StyleRule_h -#define StyleRule_h +#pragma once #include "CSSSelectorList.h" -#include "MediaList.h" #include "StyleProperties.h" #include +#include namespace WebCore { class CSSRule; class CSSStyleRule; class CSSStyleSheet; +class MediaQuerySet; class MutableStyleProperties; +class StyleRuleKeyframe; class StyleProperties; - +class StyleRuleKeyframes; + class StyleRuleBase : public WTF::RefCountedBase { WTF_MAKE_FAST_ALLOCATED; public: @@ -47,17 +49,13 @@ public: FontFace, Page, Keyframes, - Keyframe, // Not used. These are internally non-rule StyleKeyframe objects. -#if ENABLE(CSS3_CONDITIONAL_RULES) + Keyframe, // Not used. These are internally non-rule StyleRuleKeyframe objects. + Namespace, Supports = 12, -#endif #if ENABLE(CSS_DEVICE_ADAPTATION) Viewport = 15, #endif Region = 16, -#if ENABLE(SHADOW_DOM) - HostInternal = 18, // Spec says Host = 1001, but we can use only 5 bit for type(). -#endif }; Type type() const { return static_cast(m_type); } @@ -65,24 +63,19 @@ public: bool isCharsetRule() const { return type() == Charset; } bool isFontFaceRule() const { return type() == FontFace; } bool isKeyframesRule() const { return type() == Keyframes; } + bool isKeyframeRule() const { return type() == Keyframe; } + bool isNamespaceRule() const { return type() == Namespace; } bool isMediaRule() const { return type() == Media; } bool isPageRule() const { return type() == Page; } bool isStyleRule() const { return type() == Style; } bool isRegionRule() const { return type() == Region; } -#if ENABLE(CSS3_CONDITIONAL_RULES) bool isSupportsRule() const { return type() == Supports; } -#endif #if ENABLE(CSS_DEVICE_ADAPTATION) bool isViewportRule() const { return type() == Viewport; } #endif bool isImportRule() const { return type() == Import; } -#if ENABLE(SHADOW_DOM) - bool isHostRule() const { return type() == HostInternal; } -#endif - PassRef copy() const; - - int sourceLine() const { return m_sourceLine; } + Ref copy() const; void deref() { @@ -91,234 +84,320 @@ public: } // FIXME: There shouldn't be any need for the null parent version. - PassRefPtr createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const; - PassRefPtr createCSSOMWrapper(CSSRule* parentRule) const; + RefPtr createCSSOMWrapper(CSSStyleSheet* parentSheet = nullptr) const; + RefPtr createCSSOMWrapper(CSSRule* parentRule) const; protected: - StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { } - StyleRuleBase(const StyleRuleBase& o) : WTF::RefCountedBase(), m_type(o.m_type), m_sourceLine(o.m_sourceLine) { } + StyleRuleBase(Type type) + : m_type(type) + { } + + StyleRuleBase(const StyleRuleBase& o) + : WTF::RefCountedBase() + , m_type(o.m_type) + { } ~StyleRuleBase() { } private: - void destroy(); + WEBCORE_EXPORT void destroy(); - PassRefPtr createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const; + RefPtr createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const; unsigned m_type : 5; - signed m_sourceLine : 27; }; -class StyleRule : public StyleRuleBase { +class StyleRule final : public StyleRuleBase { WTF_MAKE_FAST_ALLOCATED; public: - static PassRef create(int sourceLine, PassRef properties) + static Ref create(Ref&& properties) { - return adoptRef(*new StyleRule(sourceLine, std::move(properties))); + return adoptRef(*new StyleRule(WTFMove(properties))); } ~StyleRule(); const CSSSelectorList& selectorList() const { return m_selectorList; } - const StyleProperties& properties() const { return m_properties.get(); } - MutableStyleProperties& mutableProperties(); - void parserAdoptSelectorVector(Vector>& selectors) { m_selectorList.adoptSelectorVector(selectors); } - void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); } + const StyleProperties& properties() const; + MutableStyleProperties& mutableProperties(); + const StyleProperties* propertiesWithoutDeferredParsing() const; + + void parserAdoptSelectorVector(Vector>& selectors) { m_selectorList.adoptSelectorVector(selectors); } + void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList = WTFMove(selectors); } void parserAdoptSelectorArray(CSSSelector* selectors) { m_selectorList.adoptSelectorArray(selectors); } - PassRef copy() const { return adoptRef(*new StyleRule(*this)); } + Ref copy() const { return adoptRef(*new StyleRule(*this)); } Vector> splitIntoMultipleRulesWithMaximumSelectorComponentCount(unsigned) const; static unsigned averageSizeInBytes(); private: - StyleRule(int sourceLine, PassRef); + StyleRule(Ref&&); StyleRule(const StyleRule&); - static PassRef create(int sourceLine, const Vector&, PassRef); + static Ref create(const Vector&, Ref&&); - Ref m_properties; + mutable Ref m_properties; CSSSelectorList m_selectorList; }; -inline const StyleRule* toStyleRule(const StyleRuleBase* rule) +inline const StyleProperties* StyleRule::propertiesWithoutDeferredParsing() const { - ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isStyleRule()); - return static_cast(rule); + return m_properties->type() != DeferredPropertiesType ? &downcast(m_properties.get()) : nullptr; } -class StyleRuleFontFace : public StyleRuleBase { +class StyleRuleFontFace final : public StyleRuleBase { public: - static PassRef create(PassRef properties) { return adoptRef(*new StyleRuleFontFace(std::move(properties))); } + static Ref create(Ref&& properties) { return adoptRef(*new StyleRuleFontFace(WTFMove(properties))); } ~StyleRuleFontFace(); - const StyleProperties& properties() const { return m_properties.get(); } + const StyleProperties& properties() const { return m_properties; } MutableStyleProperties& mutableProperties(); - PassRef copy() const { return adoptRef(*new StyleRuleFontFace(*this)); } - + Ref copy() const { return adoptRef(*new StyleRuleFontFace(*this)); } private: - StyleRuleFontFace(PassRef); + explicit StyleRuleFontFace(Ref&&); StyleRuleFontFace(const StyleRuleFontFace&); Ref m_properties; }; -class StyleRulePage : public StyleRuleBase { +class StyleRulePage final : public StyleRuleBase { public: - static PassRef create(PassRef properties) { return adoptRef(*new StyleRulePage(std::move(properties))); } + static Ref create(Ref&& properties) { return adoptRef(*new StyleRulePage(WTFMove(properties))); } ~StyleRulePage(); const CSSSelector* selector() const { return m_selectorList.first(); } - const StyleProperties& properties() const { return m_properties.get(); } + const StyleProperties& properties() const { return m_properties; } MutableStyleProperties& mutableProperties(); - void parserAdoptSelectorVector(Vector>& selectors) { m_selectorList.adoptSelectorVector(selectors); } - void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); } + void parserAdoptSelectorVector(Vector>& selectors) { m_selectorList.adoptSelectorVector(selectors); } + void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList = WTFMove(selectors); } - PassRef copy() const { return adoptRef(*new StyleRulePage(*this)); } + Ref copy() const { return adoptRef(*new StyleRulePage(*this)); } private: - StyleRulePage(PassRef); + explicit StyleRulePage(Ref&&); StyleRulePage(const StyleRulePage&); Ref m_properties; CSSSelectorList m_selectorList; }; -class StyleRuleGroup : public StyleRuleBase { +class DeferredStyleGroupRuleList final { public: - const Vector>& childRules() const { return m_childRules; } + DeferredStyleGroupRuleList(const CSSParserTokenRange&, CSSDeferredParser&); - void wrapperInsertRule(unsigned, PassRef); + void parseDeferredRules(Vector>&); + void parseDeferredKeyframes(StyleRuleKeyframes&); + +private: + Vector m_tokens; + Ref m_parser; +}; + +class StyleRuleGroup : public StyleRuleBase { +public: + const Vector>& childRules() const; + const Vector>* childRulesWithoutDeferredParsing() const; + + void wrapperInsertRule(unsigned, Ref&&); void wrapperRemoveRule(unsigned); protected: - StyleRuleGroup(Type, Vector>& adoptRule); + StyleRuleGroup(Type, Vector>&); + StyleRuleGroup(Type, std::unique_ptr&&); StyleRuleGroup(const StyleRuleGroup&); private: - Vector> m_childRules; + void parseDeferredRulesIfNeeded() const; + + mutable Vector> m_childRules; + mutable std::unique_ptr m_deferredRules; }; -class StyleRuleMedia : public StyleRuleGroup { +inline const Vector>* StyleRuleGroup::childRulesWithoutDeferredParsing() const +{ + return !m_deferredRules ? &m_childRules : nullptr; +} + +class StyleRuleMedia final : public StyleRuleGroup { public: - static PassRef create(PassRefPtr media, Vector>& adoptRules) + static Ref create(Ref&& media, Vector>& adoptRules) { - return adoptRef(*new StyleRuleMedia(media, adoptRules)); + return adoptRef(*new StyleRuleMedia(WTFMove(media), adoptRules)); + } + + static Ref create(Ref&& media, std::unique_ptr&& deferredChildRules) + { + return adoptRef(*new StyleRuleMedia(WTFMove(media), WTFMove(deferredChildRules))); } MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); } - PassRef copy() const { return adoptRef(*new StyleRuleMedia(*this)); } + Ref copy() const { return adoptRef(*new StyleRuleMedia(*this)); } private: - StyleRuleMedia(PassRefPtr, Vector>& adoptRules); + StyleRuleMedia(Ref&&, Vector>& adoptRules); + StyleRuleMedia(Ref&&, std::unique_ptr&&); StyleRuleMedia(const StyleRuleMedia&); RefPtr m_mediaQueries; }; -#if ENABLE(CSS3_CONDITIONAL_RULES) -class StyleRuleSupports : public StyleRuleGroup { +class StyleRuleSupports final : public StyleRuleGroup { public: - static PassRef create(const String& conditionText, bool conditionIsSupported, Vector>& adoptRules) + static Ref create(const String& conditionText, bool conditionIsSupported, Vector>& adoptRules) { return adoptRef(*new StyleRuleSupports(conditionText, conditionIsSupported, adoptRules)); } + + static Ref create(const String& conditionText, bool conditionIsSupported, std::unique_ptr&& deferredChildRules) + { + return adoptRef(*new StyleRuleSupports(conditionText, conditionIsSupported, WTFMove(deferredChildRules))); + } String conditionText() const { return m_conditionText; } bool conditionIsSupported() const { return m_conditionIsSupported; } - PassRef copy() const { return adoptRef(*new StyleRuleSupports(*this)); } + Ref copy() const { return adoptRef(*new StyleRuleSupports(*this)); } private: StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector>& adoptRules); + StyleRuleSupports(const String& conditionText, bool conditionIsSupported, std::unique_ptr&&); + StyleRuleSupports(const StyleRuleSupports&); String m_conditionText; bool m_conditionIsSupported; }; -#endif -class StyleRuleRegion : public StyleRuleGroup { +class StyleRuleRegion final : public StyleRuleGroup { public: - static PassRef create(Vector>* selectors, Vector>& adoptRules) + static Ref create(Vector>* selectors, Vector>& adoptRules) { return adoptRef(*new StyleRuleRegion(selectors, adoptRules)); } - + + static Ref create(CSSSelectorList& selectors, Vector>& adoptRules) + { + return adoptRef(*new StyleRuleRegion(selectors, adoptRules)); + } + const CSSSelectorList& selectorList() const { return m_selectorList; } - PassRef copy() const { return adoptRef(*new StyleRuleRegion(*this)); } + Ref copy() const { return adoptRef(*new StyleRuleRegion(*this)); } private: - StyleRuleRegion(Vector>*, Vector>& adoptRules); + StyleRuleRegion(Vector>*, Vector>& adoptRules); + StyleRuleRegion(CSSSelectorList&, Vector>&); + StyleRuleRegion(const StyleRuleRegion&); CSSSelectorList m_selectorList; }; -#if ENABLE(SHADOW_DOM) -class StyleRuleHost : public StyleRuleGroup { -public: - static PassRef create(Vector>& adoptRules) - { - return adoptRef(*new StyleRuleHost(adoptRules)); - } - - PassRef copy() const { return adoptRef(*new StyleRuleHost(*this)); } - -private: - StyleRuleHost(Vector>& adoptRules) : StyleRuleGroup(HostInternal, adoptRules) { } - StyleRuleHost(const StyleRuleHost& o) : StyleRuleGroup(o) { } -}; -#endif - #if ENABLE(CSS_DEVICE_ADAPTATION) -class StyleRuleViewport : public StyleRuleBase { +class StyleRuleViewport final : public StyleRuleBase { public: - static PassRef create(PassRef properties) { return adoptRef(*new StyleRuleViewport(std::move(properties))); } + static Ref create(Ref&& properties) { return adoptRef(*new StyleRuleViewport(WTFMove(properties))); } ~StyleRuleViewport(); const StyleProperties& properties() const { return m_properties.get(); } MutableStyleProperties& mutableProperties(); - PassRef copy() const { return adoptRef(*new StyleRuleViewport(*this)); } + Ref copy() const { return adoptRef(*new StyleRuleViewport(*this)); } private: - StyleRuleViewport(PassRef); + explicit StyleRuleViewport(Ref&&); StyleRuleViewport(const StyleRuleViewport&); Ref m_properties; }; #endif // ENABLE(CSS_DEVICE_ADAPTATION) -inline const StyleRuleMedia* toStyleRuleMedia(const StyleRuleGroup* rule) -{ - ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isMediaRule()); - return static_cast(rule); -} +// This is only used by the CSS parser. +class StyleRuleCharset final : public StyleRuleBase { +public: + static Ref create() { return adoptRef(*new StyleRuleCharset()); } + + ~StyleRuleCharset(); + + Ref copy() const { return adoptRef(*new StyleRuleCharset(*this)); } -#if ENABLE(CSS3_CONDITIONAL_RULES) -inline const StyleRuleSupports* toStyleRuleSupports(const StyleRuleGroup* rule) -{ - ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isSupportsRule()); - return static_cast(rule); -} -#endif +private: + explicit StyleRuleCharset(); + StyleRuleCharset(const StyleRuleCharset&); +}; -inline const StyleRuleRegion* toStyleRuleRegion(const StyleRuleGroup* rule) -{ - ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isRegionRule()); - return static_cast(rule); -} +class StyleRuleNamespace final : public StyleRuleBase { +public: + static Ref create(AtomicString prefix, AtomicString uri) + { + return adoptRef(*new StyleRuleNamespace(prefix, uri)); + } + + ~StyleRuleNamespace(); + Ref copy() const { return adoptRef(*new StyleRuleNamespace(*this)); } + + AtomicString prefix() const { return m_prefix; } + AtomicString uri() const { return m_uri; } + +private: + StyleRuleNamespace(AtomicString prefix, AtomicString uri); + StyleRuleNamespace(const StyleRuleNamespace&); + + AtomicString m_prefix; + AtomicString m_uri; +}; + } // namespace WebCore -#endif // StyleRule_h +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRule) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isStyleRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleFontFace) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isFontFaceRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleMedia) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isMediaRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRulePage) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isPageRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleSupports) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isSupportsRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleRegion) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isRegionRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +#if ENABLE(CSS_DEVICE_ADAPTATION) +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleViewport) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isViewportRule(); } +SPECIALIZE_TYPE_TRAITS_END() +#endif // ENABLE(CSS_DEVICE_ADAPTATION) + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleNamespace) + static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isNamespaceRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleKeyframe) +static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isKeyframeRule(); } +SPECIALIZE_TYPE_TRAITS_END() + +SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleCharset) +static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isCharsetRule(); } +SPECIALIZE_TYPE_TRAITS_END() + -- cgit v1.2.1