Attachment #446694 for bug #234135

View Details Raw Unified Return to Bug 234135

| Differences between



2021-12-10  Antti Koivisto  <antti@apple.com>

        [CSS Container Queries] Basic @container parsing  support
        https://bugs.webkit.org/show_bug.cgi?id=234135

        Reviewed by NOBODY (OOPS!).

        * Scripts/Preferences/WebPreferencesExperimental.yaml:

        Add preference for container queries, disabled by default.

2021-12-09  Alan Bujtas  <zalan@apple.com>

        Enable the CSS Contain property by default



2021-12-10  Antti Koivisto  <antti@apple.com>

        [CSS Container Queries] Basic @container rule parsing support
        https://bugs.webkit.org/show_bug.cgi?id=234135

        Reviewed by NOBODY (OOPS!).

        Implement basic support for parsing @container at-rules.
        This patch doesn't yet parse the queries themselves.
        
        Disabled by default.

        * css/StyleRule.cpp:
        (WebCore::StyleRuleBase::destroy):
        (WebCore::StyleRuleBase::copy const):
        (WebCore::StyleRuleBase::createCSSOMWrapper const):
        (WebCore::StyleRuleContainer::StyleRuleContainer):
        (WebCore::StyleRuleContainer::create):
        * css/StyleRule.h:
        (WebCore::StyleRuleBase::isContainerRule const):
        (isType):
        * css/StyleRuleType.h:
        * css/StyleSheetContents.cpp:
        (WebCore::traverseRulesInVector):
        (WebCore::StyleSheetContents::traverseSubresources const):
        * css/parser/CSSAtRuleID.cpp:
        (WebCore::cssAtRuleID):
        * css/parser/CSSAtRuleID.h:
        * css/parser/CSSParserContext.cpp:
        (WebCore::operator==):
        (WebCore::add):
        * css/parser/CSSParserContext.h:
        * css/parser/CSSParserImpl.cpp:
        (WebCore::CSSParserImpl::consumeAtRule):
        (WebCore::CSSParserImpl::consumeContainerRule):
        * css/parser/CSSParserImpl.h:

2021-12-10  Kimmo Kinnunen  <kkinnunen@apple.com>

        IOSurface memory attribution is hard to use in constructors



    WebCore:
      default: false

CSSContainerQueriesEnabled:
  type: bool
  humanReadableName: "CSS Container Queries"
  humanReadableDescription: "Enable CSS Container Queries"
  defaultValue:
    WebKitLegacy:
      default: false
    WebKit:
      default: false
    WebCore:
      default: false

CSSContainmentEnabled:
  type: bool
  humanReadableName: "CSS Containment"

Lines 104-109 void StyleRuleBase::destroy() a/Source/WebCore/css/StyleRule.cpp_sec1
- a/Source/WebCore/css/StyleRule.cpp +38 lines
104	case StyleRuleType::LayerStatement:	104	case StyleRuleType::LayerStatement:
105	delete downcast<StyleRuleLayer>(this);	105	delete downcast<StyleRuleLayer>(this);
106	return;	106	return;
		107	case StyleRuleType::Container:
		108	delete downcast<StyleRuleContainer>(this);
		109	return;
107	case StyleRuleType::Unknown:	110	case StyleRuleType::Unknown:
108	ASSERT_NOT_REACHED();	111	ASSERT_NOT_REACHED();
109	return;	112	return;
Lines 133-138 Ref<StyleRuleBase> StyleRuleBase::copy() const a/Source/WebCore/css/StyleRule.cpp_sec2
133	case StyleRuleType::LayerBlock:	136	case StyleRuleType::LayerBlock:
134	case StyleRuleType::LayerStatement:	137	case StyleRuleType::LayerStatement:
135	return downcast<StyleRuleLayer>(*this).copy();	138	return downcast<StyleRuleLayer>(*this).copy();
		139	case StyleRuleType::Container:
		140	return downcast<StyleRuleContainer>(*this).copy();
136	case StyleRuleType::Import:	141	case StyleRuleType::Import:
137	case StyleRuleType::Namespace:	142	case StyleRuleType::Namespace:
138	// FIXME: Copy import and namespace rules.	143	// FIXME: Copy import and namespace rules.
Lines 186-191 Ref<CSSRule> StyleRuleBase::createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRu a/Source/WebCore/css/StyleRule.cpp_sec3
186	case StyleRuleType::LayerStatement:	191	case StyleRuleType::LayerStatement:
187	rule = CSSLayerStatementRule::create(downcast<StyleRuleLayer>(self), parentSheet);	192	rule = CSSLayerStatementRule::create(downcast<StyleRuleLayer>(self), parentSheet);
188	break;	193	break;
		194	case StyleRuleType::Container:
		195	// FIXME: Implement CSSOM.
		196	break;
189	case StyleRuleType::Unknown:	197	case StyleRuleType::Unknown:
190	case StyleRuleType::Charset:	198	case StyleRuleType::Charset:
191	case StyleRuleType::Keyframe:	199	case StyleRuleType::Keyframe:
Lines 362-367 DeferredStyleGroupRuleList::DeferredStyleGroupRuleList(const CSSParserTokenRange a/Source/WebCore/css/StyleRule.cpp_sec4
362	m_tokens.append(range.begin(), length);	370	m_tokens.append(range.begin(), length);
363	}	371	}
364		372
		373	DeferredStyleGroupRuleList::~DeferredStyleGroupRuleList() = default;
		374
365	void DeferredStyleGroupRuleList::parseDeferredRules(Vector<RefPtr<StyleRuleBase>>& childRules)	375	void DeferredStyleGroupRuleList::parseDeferredRules(Vector<RefPtr<StyleRuleBase>>& childRules)
366	{	376	{
367	m_parser->parseRuleList(m_tokens, childRules);	377	m_parser->parseRuleList(m_tokens, childRules);
Lines 523-528 Ref<StyleRuleLayer> StyleRuleLayer::createBlock(CascadeLayerName&& name, std::un a/Source/WebCore/css/StyleRule.cpp_sec5
523	return adoptRef(*new StyleRuleLayer(WTFMove(name), WTFMove(rules)));	533	return adoptRef(*new StyleRuleLayer(WTFMove(name), WTFMove(rules)));
524	}	534	}
525		535
		536	StyleRuleContainer::StyleRuleContainer(ContainerQuery&& query, Vector<RefPtr<StyleRuleBase>>&& rules)
		537	: StyleRuleGroup(StyleRuleType::Container, WTFMove(rules))
		538	, m_query(WTFMove(query))
		539	{
		540	}
		541
		542	StyleRuleContainer::StyleRuleContainer(ContainerQuery&& query, std::unique_ptr<DeferredStyleGroupRuleList>&& rules)
		543	: StyleRuleGroup(StyleRuleType::Container, WTFMove(rules))
		544	, m_query(WTFMove(query))
		545	{
		546	}
		547
		548	StyleRuleContainer::StyleRuleContainer(const StyleRuleContainer& other)
		549	: StyleRuleGroup(other)
		550	, m_query(other.m_query)
		551	{
		552	}
		553
		554	Ref<StyleRuleContainer> StyleRuleContainer::create(ContainerQuery&& query, Vector<RefPtr<StyleRuleBase>>&& rules)
		555	{
		556	return adoptRef(*new StyleRuleContainer(WTFMove(query), WTFMove(rules)));
		557	}
		558
		559	Ref<StyleRuleContainer> StyleRuleContainer::create(ContainerQuery&& query, std::unique_ptr<DeferredStyleGroupRuleList>&& rules)
		560	{
		561	return adoptRef(*new StyleRuleContainer(WTFMove(query), WTFMove(rules)));
		562	}
		563
526	StyleRuleCharset::StyleRuleCharset()	564	StyleRuleCharset::StyleRuleCharset()
527	: StyleRuleBase(StyleRuleType::Charset)	565	: StyleRuleBase(StyleRuleType::Charset)
528	{	566	{



    bool isMediaRule() const { return type() == StyleRuleType::Media; }
    bool isPageRule() const { return type() == StyleRuleType::Page; }
    bool isStyleRule() const { return type() == StyleRuleType::Style; }
    bool isGroupRule() const { return type() == StyleRuleType::Media || type() == StyleRuleType::Supports || type() == StyleRuleType::LayerBlock || type() == StyleRuleType::Container; }
    bool isSupportsRule() const { return type() == StyleRuleType::Supports; }
    bool isImportRule() const { return type() == StyleRuleType::Import; }
    bool isLayerRule() const { return type() == StyleRuleType::LayerBlock || type() == StyleRuleType::LayerStatement; }
    bool isContainerRule() const { return type() == StyleRuleType::Container; }

    Ref<StyleRuleBase> copy() const;


    WTF_MAKE_FAST_ALLOCATED;
public:
    DeferredStyleGroupRuleList(const CSSParserTokenRange&, CSSDeferredParser&);
    ~DeferredStyleGroupRuleList();
    
    void parseDeferredRules(Vector<RefPtr<StyleRuleBase>>&);
    void parseDeferredKeyframes(StyleRuleKeyframes&);

    std::variant<CascadeLayerName, Vector<CascadeLayerName>> m_nameVariant;
};

struct ContainerQuery { };

class StyleRuleContainer final : public StyleRuleGroup {
public:
    static Ref<StyleRuleContainer> create(ContainerQuery&&, Vector<RefPtr<StyleRuleBase>>&&);
    static Ref<StyleRuleContainer> create(ContainerQuery&&, std::unique_ptr<DeferredStyleGroupRuleList>&&);
    Ref<StyleRuleContainer> copy() const { return adoptRef(*new StyleRuleContainer(*this)); }

    const ContainerQuery& query() const { return m_query; }

private:
    StyleRuleContainer(ContainerQuery&&, Vector<RefPtr<StyleRuleBase>>&&);
    StyleRuleContainer(ContainerQuery&&, std::unique_ptr<DeferredStyleGroupRuleList>&&);
    StyleRuleContainer(const StyleRuleContainer&);

    ContainerQuery m_query;
};

// This is only used by the CSS parser.
class StyleRuleCharset final : public StyleRuleBase {
public:

SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleLayer)
    static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isLayerRule(); }
SPECIALIZE_TYPE_TRAITS_END()

SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleContainer)
    static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isContainerRule(); }
SPECIALIZE_TYPE_TRAITS_END()

Lines 42-47 enum class StyleRuleType : uint8_t { a/Source/WebCore/css/StyleRuleType.h_sec1
- a/Source/WebCore/css/StyleRuleType.h +1 lines
42	Supports = 12,	42	Supports = 12,
43	LayerBlock = 16,	43	LayerBlock = 16,
44	LayerStatement = 17,	44	LayerStatement = 17,
		45	Container = 18,
45	FontPaletteValues = 19,	46	FontPaletteValues = 19,
46	};	47	};
47		48



        switch (rule->type()) {
        case StyleRuleType::Media:
        case StyleRuleType::Supports:
        case StyleRuleType::LayerBlock:
        case StyleRuleType::Container: {
            auto* childRules = downcast<StyleRuleGroup>(*rule).childRulesWithoutDeferredParsing();
            if (childRules && traverseRulesInVector(*childRules, handler))
                return true;

        case StyleRuleType::Supports:
        case StyleRuleType::LayerBlock:
        case StyleRuleType::LayerStatement:
        case StyleRuleType::Container:
        case StyleRuleType::FontPaletteValues:
            return false;
        };



        return CSSAtRuleViewport;
    if (equalIgnoringASCIICase(name, "-webkit-keyframes"))
        return CSSAtRuleWebkitKeyframes;
    if (equalIgnoringASCIICase(name, "apply"))
        return CSSAtRuleApply;
    if (equalIgnoringASCIICase(name, "counter-style"))
        return CSSAtRuleCounterStyle;
    if (equalIgnoringASCIICase(name, "layer"))
        return CSSAtRuleLayer;
    if (equalIgnoringASCIICase(name, "container"))
        return CSSAtRuleContainer;
    return CSSAtRuleInvalid;
}




enum CSSAtRuleID {
    CSSAtRuleInvalid = 0,

    CSSAtRuleCharset,
    CSSAtRuleFontFace,
    CSSAtRuleImport,
    CSSAtRuleKeyframes,
    CSSAtRuleMedia,
    CSSAtRuleNamespace,
    CSSAtRulePage,
    CSSAtRuleSupports,
    CSSAtRuleViewport,

    CSSAtRuleWebkitKeyframes,
    CSSAtRuleCounterStyle,
    CSSAtRuleLayer,
    CSSAtRuleContainer,

    CSSAtRuleFontPaletteValues,
};

CSSAtRuleID cssAtRuleID(StringView name);



    , focusVisibleEnabled { document.settings().focusVisibleEnabled() }
    , hasPseudoClassEnabled { document.settings().hasPseudoClassEnabled() }
    , cascadeLayersEnabled { document.settings().cssCascadeLayersEnabled() }
    , containerQueriesEnabled { document.settings().cssContainerQueriesEnabled() }
#if ENABLE(ATTACHMENT_ELEMENT)
    , attachmentEnabled { RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled() }
#endif

        && a.focusVisibleEnabled == b.focusVisibleEnabled
        && a.hasPseudoClassEnabled == b.hasPseudoClassEnabled
        && a.cascadeLayersEnabled == b.cascadeLayersEnabled
        && a.containerQueriesEnabled == b.containerQueriesEnabled
#if ENABLE(ATTACHMENT_ELEMENT)
        && a.attachmentEnabled == b.attachmentEnabled
#endif

        | context.focusVisibleEnabled                       << 21
        | context.hasPseudoClassEnabled                     << 22
        | context.cascadeLayersEnabled                      << 23
        | context.containerQueriesEnabled                   << 24
#if ENABLE(ATTACHMENT_ELEMENT)
        | context.attachmentEnabled                         << 25
#endif
        | context.overflowClipEnabled                       << 26
        | context.accentColorEnabled                        << 27
        | context.mode                                      << 28; // This is multiple bits, so keep it last.
    add(hasher, context.baseURL, context.charset, bits);
}


Lines 84-89 struct CSSParserContext { a/Source/WebCore/css/parser/CSSParserContext.h_sec1
- a/Source/WebCore/css/parser/CSSParserContext.h +1 lines
84	bool focusVisibleEnabled { false };	84	bool focusVisibleEnabled { false };
85	bool hasPseudoClassEnabled { false };	85	bool hasPseudoClassEnabled { false };
86	bool cascadeLayersEnabled { false };	86	bool cascadeLayersEnabled { false };
		87	bool containerQueriesEnabled { false };
87		88
88	// RuntimeEnabledFeatures.	89	// RuntimeEnabledFeatures.
89	#if ENABLE(ATTACHMENT_ELEMENT)	90	#if ENABLE(ATTACHMENT_ELEMENT)



        return consumeCounterStyleRule(prelude, block);
    case CSSAtRuleLayer:
        return consumeLayerRule(prelude, block);
    case CSSAtRuleContainer:
        return consumeContainerRule(prelude, block);
    default:
        return nullptr; // Parse error, unrecognised at-rule with block
    }

    return StyleRuleLayer::createBlock(WTFMove(*name), WTFMove(rules));
}

RefPtr<StyleRuleContainer> CSSParserImpl::consumeContainerRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
/*void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude)
{
    if (!m_context.containerQueriesEnabled)
        return nullptr;

    if (m_deferredParser)
        return StyleRuleContainer::create({ }, makeUnique<DeferredStyleGroupRuleList>(block, *m_deferredParser));

    Vector<RefPtr<StyleRuleBase>> rules;

    if (m_observerWrapper) {
        m_observerWrapper->observer().startRuleHeader(StyleRuleType::Container, m_observerWrapper->startOffset(prelude));
        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
        m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));
    }

    consumeRuleList(block, RegularRuleList, [&rules](RefPtr<StyleRuleBase> rule) {
        rules.append(rule);
    });
    rules.shrinkToFit();

    if (m_observerWrapper)
        m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));

    return StyleRuleContainer::create({ }, WTFMove(rules));
}
*/
    
RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
{



    RefPtr<StyleRulePage> consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
    RefPtr<StyleRuleCounterStyle> consumeCounterStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
    RefPtr<StyleRuleLayer> consumeLayerRule(CSSParserTokenRange prelude, std::optional<CSSParserTokenRange> block);
    RefPtr<StyleRuleContainer> consumeContainerRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
    // FIXME-NEWPARSER: Support "apply"
    // void consumeApplyRule(CSSParserTokenRange prelude);

    RefPtr<StyleRuleKeyframe> consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
    RefPtr<StyleRule> consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

Return to Bug 234135

Lines 224-229 CSSColorMixEnabled: a/Source/WTF/Scripts/Preferences/WebPreferencesExperimental.yaml_sec1
- a/Source/WTF/Scripts/Preferences/WebPreferencesExperimental.yaml +12 lines
224	WebCore:	224	WebCore:
225	default: false	225	default: false
226		226
		227	CSSContainerQueriesEnabled:
		228	type: bool
		229	humanReadableName: "CSS Container Queries"
		230	humanReadableDescription: "Enable CSS Container Queries"
		231	defaultValue:
		232	WebKitLegacy:
		233	default: false
		234	WebKit:
		235	default: false
		236	WebCore:
		237	default: false
		238
227	CSSContainmentEnabled:	239	CSSContainmentEnabled:
228	type: bool	240	type: bool
229	humanReadableName: "CSS Containment"	241	humanReadableName: "CSS Containment"

Lines 465-470 RefPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, A a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserImpl.cpp -9 / +26 lines
465	return consumeCounterStyleRule(prelude, block);	465	return consumeCounterStyleRule(prelude, block);
466	case CSSAtRuleLayer:	466	case CSSAtRuleLayer:
467	return consumeLayerRule(prelude, block);	467	return consumeLayerRule(prelude, block);
		468	case CSSAtRuleContainer:
		469	return consumeContainerRule(prelude, block);
468	default:	470	default:
469	return nullptr; // Parse error, unrecognised at-rule with block	471	return nullptr; // Parse error, unrecognised at-rule with block
470	}	472	}
Lines 855-871 RefPtr<StyleRuleLayer> CSSParserImpl::consumeLayerRule(CSSParserTokenRange prelu a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec2
855	return StyleRuleLayer::createBlock(WTFMove(*name), WTFMove(rules));	857	return StyleRuleLayer::createBlock(WTFMove(*name), WTFMove(rules));
856	}	858	}
857		859
858	// FIXME-NEWPARSER: Support "apply"	860	RefPtr<StyleRuleContainer> CSSParserImpl::consumeContainerRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
859	/*void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude)
860	{	861	{
861	const CSSParserToken& ident = prelude.consumeIncludingWhitespace();	862	if (!m_context.containerQueriesEnabled)
862	if (!prelude.atEnd() \|\| !CSSVariableParser::isValidVariableName(ident))	863	return nullptr;
863	return; // Parse error, expected a single custom property name	864
864	m_parsedProperties.append(CSSProperty(	865	if (m_deferredParser)
865	CSSPropertyApplyAtRule,	866	return StyleRuleContainer::create({ }, makeUnique<DeferredStyleGroupRuleList>(block, *m_deferredParser));
866	*CSSCustomIdentValue::create(ident.value().toString())));	867
		868	Vector<RefPtr<StyleRuleBase>> rules;
		869
		870	if (m_observerWrapper) {
		871	m_observerWrapper->observer().startRuleHeader(StyleRuleType::Container, m_observerWrapper->startOffset(prelude));
		872	m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
		873	m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));
		874	}
		875
		876	consumeRuleList(block, RegularRuleList, [&rules](RefPtr<StyleRuleBase> rule) {
		877	rules.append(rule);
		878	});
		879	rules.shrinkToFit();
		880
		881	if (m_observerWrapper)
		882	m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));
		883
		884	return StyleRuleContainer::create({ }, WTFMove(rules));
867	}	885	}
868	*/
869		886
870	RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)	887	RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
871	{	888	{

Lines 1-3 a/Source/WTF/ChangeLog_sec1
- a/Source/WTF/ChangeLog +11 lines
		1	2021-12-10 Antti Koivisto <antti@apple.com>
		2
		3	[CSS Container Queries] Basic @container parsing support
		4	https://bugs.webkit.org/show_bug.cgi?id=234135
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* Scripts/Preferences/WebPreferencesExperimental.yaml:
		9
		10	Add preference for container queries, disabled by default.
		11
1	2021-12-09 Alan Bujtas <zalan@apple.com>	12	2021-12-09 Alan Bujtas <zalan@apple.com>
2		13
3	Enable the CSS Contain property by default	14	Enable the CSS Contain property by default

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +37 lines
		1	2021-12-10 Antti Koivisto <antti@apple.com>
		2
		3	[CSS Container Queries] Basic @container rule parsing support
		4	https://bugs.webkit.org/show_bug.cgi?id=234135
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Implement basic support for parsing @container at-rules.
		9	This patch doesn't yet parse the queries themselves.
		10
		11	Disabled by default.
		12
		13	* css/StyleRule.cpp:
		14	(WebCore::StyleRuleBase::destroy):
		15	(WebCore::StyleRuleBase::copy const):
		16	(WebCore::StyleRuleBase::createCSSOMWrapper const):
		17	(WebCore::StyleRuleContainer::StyleRuleContainer):
		18	(WebCore::StyleRuleContainer::create):
		19	* css/StyleRule.h:
		20	(WebCore::StyleRuleBase::isContainerRule const):
		21	(isType):
		22	* css/StyleRuleType.h:
		23	* css/StyleSheetContents.cpp:
		24	(WebCore::traverseRulesInVector):
		25	(WebCore::StyleSheetContents::traverseSubresources const):
		26	* css/parser/CSSAtRuleID.cpp:
		27	(WebCore::cssAtRuleID):
		28	* css/parser/CSSAtRuleID.h:
		29	* css/parser/CSSParserContext.cpp:
		30	(WebCore::operator==):
		31	(WebCore::add):
		32	* css/parser/CSSParserContext.h:
		33	* css/parser/CSSParserImpl.cpp:
		34	(WebCore::CSSParserImpl::consumeAtRule):
		35	(WebCore::CSSParserImpl::consumeContainerRule):
		36	* css/parser/CSSParserImpl.h:
		37
1	2021-12-10 Kimmo Kinnunen <kkinnunen@apple.com>	38	2021-12-10 Kimmo Kinnunen <kkinnunen@apple.com>
2		39
3	IOSurface memory attribution is hard to use in constructors	40	IOSurface memory attribution is hard to use in constructors

Lines 60-69 public: a/Source/WebCore/css/StyleRule.h_sec1
- a/Source/WebCore/css/StyleRule.h -1 / +25 lines
60	bool isMediaRule() const { return type() == StyleRuleType::Media; }	60	bool isMediaRule() const { return type() == StyleRuleType::Media; }
61	bool isPageRule() const { return type() == StyleRuleType::Page; }	61	bool isPageRule() const { return type() == StyleRuleType::Page; }
62	bool isStyleRule() const { return type() == StyleRuleType::Style; }	62	bool isStyleRule() const { return type() == StyleRuleType::Style; }
63	bool isGroupRule() const { return type() == StyleRuleType::Media \|\| type() == StyleRuleType::Supports \|\| type() == StyleRuleType::LayerBlock; }	63	bool isGroupRule() const { return type() == StyleRuleType::Media \|\| type() == StyleRuleType::Supports \|\| type() == StyleRuleType::LayerBlock \|\| type() == StyleRuleType::Container; }
64	bool isSupportsRule() const { return type() == StyleRuleType::Supports; }	64	bool isSupportsRule() const { return type() == StyleRuleType::Supports; }
65	bool isImportRule() const { return type() == StyleRuleType::Import; }	65	bool isImportRule() const { return type() == StyleRuleType::Import; }
66	bool isLayerRule() const { return type() == StyleRuleType::LayerBlock \|\| type() == StyleRuleType::LayerStatement; }	66	bool isLayerRule() const { return type() == StyleRuleType::LayerBlock \|\| type() == StyleRuleType::LayerStatement; }
		67	bool isContainerRule() const { return type() == StyleRuleType::Container; }
67		68
68	Ref<StyleRuleBase> copy() const;	69	Ref<StyleRuleBase> copy() const;
69		70
Lines 228-233 class DeferredStyleGroupRuleList final { a/Source/WebCore/css/StyleRule.h_sec2
228	WTF_MAKE_FAST_ALLOCATED;	229	WTF_MAKE_FAST_ALLOCATED;
229	public:	230	public:
230	DeferredStyleGroupRuleList(const CSSParserTokenRange&, CSSDeferredParser&);	231	DeferredStyleGroupRuleList(const CSSParserTokenRange&, CSSDeferredParser&);
		232	~DeferredStyleGroupRuleList();
231		233
232	void parseDeferredRules(Vector<RefPtr<StyleRuleBase>>&);	234	void parseDeferredRules(Vector<RefPtr<StyleRuleBase>>&);
233	void parseDeferredKeyframes(StyleRuleKeyframes&);	235	void parseDeferredKeyframes(StyleRuleKeyframes&);
Lines 312-317 private: a/Source/WebCore/css/StyleRule.h_sec3
312	std::variant<CascadeLayerName, Vector<CascadeLayerName>> m_nameVariant;	314	std::variant<CascadeLayerName, Vector<CascadeLayerName>> m_nameVariant;
313	};	315	};
314		316
		317	struct ContainerQuery { };
		318
		319	class StyleRuleContainer final : public StyleRuleGroup {
		320	public:
		321	static Ref<StyleRuleContainer> create(ContainerQuery&&, Vector<RefPtr<StyleRuleBase>>&&);
		322	static Ref<StyleRuleContainer> create(ContainerQuery&&, std::unique_ptr<DeferredStyleGroupRuleList>&&);
		323	Ref<StyleRuleContainer> copy() const { return adoptRef(new StyleRuleContainer(this)); }
		324
		325	const ContainerQuery& query() const { return m_query; }
		326
		327	private:
		328	StyleRuleContainer(ContainerQuery&&, Vector<RefPtr<StyleRuleBase>>&&);
		329	StyleRuleContainer(ContainerQuery&&, std::unique_ptr<DeferredStyleGroupRuleList>&&);
		330	StyleRuleContainer(const StyleRuleContainer&);
		331
		332	ContainerQuery m_query;
		333	};
		334
315	// This is only used by the CSS parser.	335	// This is only used by the CSS parser.
316	class StyleRuleCharset final : public StyleRuleBase {	336	class StyleRuleCharset final : public StyleRuleBase {
317	public:	337	public:
Lines 435-437 SPECIALIZE_TYPE_TRAITS_END() a/Source/WebCore/css/StyleRule.h_sec4
435	SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleLayer)	455	SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleLayer)
436	static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isLayerRule(); }	456	static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isLayerRule(); }
437	SPECIALIZE_TYPE_TRAITS_END()	457	SPECIALIZE_TYPE_TRAITS_END()
		458
		459	SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleContainer)
		460	static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isContainerRule(); }
		461	SPECIALIZE_TYPE_TRAITS_END()

Lines 458-464 static bool traverseRulesInVector(const Vector<RefPtr<StyleRuleBase>>& rules, co a/Source/WebCore/css/StyleSheetContents.cpp_sec1
- a/Source/WebCore/css/StyleSheetContents.cpp -1 / +3 lines
458	switch (rule->type()) {	458	switch (rule->type()) {
459	case StyleRuleType::Media:	459	case StyleRuleType::Media:
460	case StyleRuleType::Supports:	460	case StyleRuleType::Supports:
461	case StyleRuleType::LayerBlock: {	461	case StyleRuleType::LayerBlock:
		462	case StyleRuleType::Container: {
462	auto* childRules = downcast<StyleRuleGroup>(*rule).childRulesWithoutDeferredParsing();	463	auto* childRules = downcast<StyleRuleGroup>(*rule).childRulesWithoutDeferredParsing();
463	if (childRules && traverseRulesInVector(*childRules, handler))	464	if (childRules && traverseRulesInVector(*childRules, handler))
464	return true;	465	return true;
Lines 522-527 bool StyleSheetContents::traverseSubresources(const Function<bool(const CachedRe a/Source/WebCore/css/StyleSheetContents.cpp_sec2
522	case StyleRuleType::Supports:	523	case StyleRuleType::Supports:
523	case StyleRuleType::LayerBlock:	524	case StyleRuleType::LayerBlock:
524	case StyleRuleType::LayerStatement:	525	case StyleRuleType::LayerStatement:
		526	case StyleRuleType::Container:
525	case StyleRuleType::FontPaletteValues:	527	case StyleRuleType::FontPaletteValues:
526	return false;	528	return false;
527	};	529	};

Lines 56-67 CSSAtRuleID cssAtRuleID(StringView name) a/Source/WebCore/css/parser/CSSAtRuleID.cpp_sec1
- a/Source/WebCore/css/parser/CSSAtRuleID.cpp -2 / +2 lines
56	return CSSAtRuleViewport;	56	return CSSAtRuleViewport;
57	if (equalIgnoringASCIICase(name, "-webkit-keyframes"))	57	if (equalIgnoringASCIICase(name, "-webkit-keyframes"))
58	return CSSAtRuleWebkitKeyframes;	58	return CSSAtRuleWebkitKeyframes;
59	if (equalIgnoringASCIICase(name, "apply"))
60	return CSSAtRuleApply;
61	if (equalIgnoringASCIICase(name, "counter-style"))	59	if (equalIgnoringASCIICase(name, "counter-style"))
62	return CSSAtRuleCounterStyle;	60	return CSSAtRuleCounterStyle;
63	if (equalIgnoringASCIICase(name, "layer"))	61	if (equalIgnoringASCIICase(name, "layer"))
64	return CSSAtRuleLayer;	62	return CSSAtRuleLayer;
		63	if (equalIgnoringASCIICase(name, "container"))
		64	return CSSAtRuleContainer;
65	return CSSAtRuleInvalid;	65	return CSSAtRuleInvalid;
66	}	66	}
67		67

Lines 35-56 namespace WebCore { a/Source/WebCore/css/parser/CSSAtRuleID.h_sec1
- a/Source/WebCore/css/parser/CSSAtRuleID.h -16 / +16 lines
35	enum CSSAtRuleID {	35	enum CSSAtRuleID {
36	CSSAtRuleInvalid = 0,	36	CSSAtRuleInvalid = 0,
37		37
38	CSSAtRuleCharset = 1,	38	CSSAtRuleCharset,
39	CSSAtRuleFontFace = 2,	39	CSSAtRuleFontFace,
40	CSSAtRuleImport = 3,	40	CSSAtRuleImport,
41	CSSAtRuleKeyframes = 4,	41	CSSAtRuleKeyframes,
42	CSSAtRuleMedia = 5,	42	CSSAtRuleMedia,
43	CSSAtRuleNamespace = 6,	43	CSSAtRuleNamespace,
44	CSSAtRulePage = 7,	44	CSSAtRulePage,
45	CSSAtRuleSupports = 8,	45	CSSAtRuleSupports,
46	CSSAtRuleViewport = 9,	46	CSSAtRuleViewport,
47		47
48	CSSAtRuleWebkitKeyframes = 10,	48	CSSAtRuleWebkitKeyframes,
49	CSSAtRuleApply = 11,	49	CSSAtRuleCounterStyle,
50	CSSAtRuleCounterStyle = 12,	50	CSSAtRuleLayer,
51	CSSAtRuleLayer = 13,	51	CSSAtRuleContainer,
52		52
53	CSSAtRuleFontPaletteValues = 14,	53	CSSAtRuleFontPaletteValues,
54	};	54	};
55		55
56	CSSAtRuleID cssAtRuleID(StringView name);	56	CSSAtRuleID cssAtRuleID(StringView name);

Lines 105-110 CSSParserContext::CSSParserContext(const Document& document, const URL& sheetBas a/Source/WebCore/css/parser/CSSParserContext.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserContext.cpp -4 / +7 lines
105	, focusVisibleEnabled { document.settings().focusVisibleEnabled() }	105	, focusVisibleEnabled { document.settings().focusVisibleEnabled() }
106	, hasPseudoClassEnabled { document.settings().hasPseudoClassEnabled() }	106	, hasPseudoClassEnabled { document.settings().hasPseudoClassEnabled() }
107	, cascadeLayersEnabled { document.settings().cssCascadeLayersEnabled() }	107	, cascadeLayersEnabled { document.settings().cssCascadeLayersEnabled() }
		108	, containerQueriesEnabled { document.settings().cssContainerQueriesEnabled() }
108	#if ENABLE(ATTACHMENT_ELEMENT)	109	#if ENABLE(ATTACHMENT_ELEMENT)
109	, attachmentEnabled { RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled() }	110	, attachmentEnabled { RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled() }
110	#endif	111	#endif
Lines 151-156 bool operator==(const CSSParserContext& a, const CSSParserContext& b) a/Source/WebCore/css/parser/CSSParserContext.cpp_sec2
151	&& a.focusVisibleEnabled == b.focusVisibleEnabled	152	&& a.focusVisibleEnabled == b.focusVisibleEnabled
152	&& a.hasPseudoClassEnabled == b.hasPseudoClassEnabled	153	&& a.hasPseudoClassEnabled == b.hasPseudoClassEnabled
153	&& a.cascadeLayersEnabled == b.cascadeLayersEnabled	154	&& a.cascadeLayersEnabled == b.cascadeLayersEnabled
		155	&& a.containerQueriesEnabled == b.containerQueriesEnabled
154	#if ENABLE(ATTACHMENT_ELEMENT)	156	#if ENABLE(ATTACHMENT_ELEMENT)
155	&& a.attachmentEnabled == b.attachmentEnabled	157	&& a.attachmentEnabled == b.attachmentEnabled
156	#endif	158	#endif
Lines 190-201 void add(Hasher& hasher, const CSSParserContext& context) a/Source/WebCore/css/parser/CSSParserContext.cpp_sec3
190	\| context.focusVisibleEnabled << 21	192	\| context.focusVisibleEnabled << 21
191	\| context.hasPseudoClassEnabled << 22	193	\| context.hasPseudoClassEnabled << 22
192	\| context.cascadeLayersEnabled << 23	194	\| context.cascadeLayersEnabled << 23
		195	\| context.containerQueriesEnabled << 24
193	#if ENABLE(ATTACHMENT_ELEMENT)	196	#if ENABLE(ATTACHMENT_ELEMENT)
194	\| context.attachmentEnabled << 24	197	\| context.attachmentEnabled << 25
195	#endif	198	#endif
196	\| context.overflowClipEnabled << 25	199	\| context.overflowClipEnabled << 26
197	\| context.accentColorEnabled << 26	200	\| context.accentColorEnabled << 27
198	\| context.mode << 27; // This is multiple bits, so keep it last.	201	\| context.mode << 28; // This is multiple bits, so keep it last.
199	add(hasher, context.baseURL, context.charset, bits);	202	add(hasher, context.baseURL, context.charset, bits);
200	}	203	}
201		204

Lines 140-148 private: a/Source/WebCore/css/parser/CSSParserImpl.h_sec1
- a/Source/WebCore/css/parser/CSSParserImpl.h -3 / +1 lines
140	RefPtr<StyleRulePage> consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block);	140	RefPtr<StyleRulePage> consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
141	RefPtr<StyleRuleCounterStyle> consumeCounterStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);	141	RefPtr<StyleRuleCounterStyle> consumeCounterStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
142	RefPtr<StyleRuleLayer> consumeLayerRule(CSSParserTokenRange prelude, std::optional<CSSParserTokenRange> block);	142	RefPtr<StyleRuleLayer> consumeLayerRule(CSSParserTokenRange prelude, std::optional<CSSParserTokenRange> block);
143		143	RefPtr<StyleRuleContainer> consumeContainerRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
144	// FIXME-NEWPARSER: Support "apply"
145	// void consumeApplyRule(CSSParserTokenRange prelude);
146		144
147	RefPtr<StyleRuleKeyframe> consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);	145	RefPtr<StyleRuleKeyframe> consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
148	RefPtr<StyleRule> consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);	146	RefPtr<StyleRule> consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);