Attachment #450141 for bug #235712

View Details Raw Unified Return to Bug 235712

| Differences between



2022-01-27  Antti Koivisto  <antti@apple.com>

        [CSS Container Queries] Basic parsing support for query syntax
        https://bugs.webkit.org/show_bug.cgi?id=235712

        Reviewed by Darin Adler.

        https://drafts.csswg.org/css-contain-3/#at-ruledef-container

        Use MediaQueryParser to parse the query syntax. Note that because the limitations
        of MediaQueryParser only simple non-nested queries can be parsed for now.

        * css/StyleRule.h:
        * css/parser/CSSParserImpl.cpp:
        (WebCore::filterProperties):
        (WebCore::CSSParserImpl::consumeAtRule):
        (WebCore::CSSParserImpl::consumeContainerRule):
        * css/parser/CSSPropertyParser.cpp:
        (WebCore::consumeContainerName):
        * css/parser/CSSPropertyParserHelpers.cpp:
        (WebCore::CSSPropertyParserHelpers::consumeSingleContainerName):
        * css/parser/CSSPropertyParserHelpers.h:
        * css/parser/MediaQueryParser.cpp:
        (WebCore::MediaQueryParser::parseContainerQuery):
        (WebCore::MediaQueryParser::MediaQueryParser):
        (WebCore::MediaQueryParser::readContainerQuery):
        (WebCore::MediaQueryParser::handleBlocks):
        (WebCore::MediaQueryParser::processToken):
        (WebCore::MediaQueryParser::parseInternal):
        * css/parser/MediaQueryParser.h:

2022-01-26  Antti Koivisto  <antti@apple.com>

        ASSERTION FAILED: !hasPendingSheets() under WebCore::Style::Scope::~Scope()

Lines 314-320 private: a/Source/WebCore/css/StyleRule.h_sec1
- a/Source/WebCore/css/StyleRule.h -1 / +4 lines
314	std::variant<CascadeLayerName, Vector<CascadeLayerName>> m_nameVariant;	314	std::variant<CascadeLayerName, Vector<CascadeLayerName>> m_nameVariant;
315	};	315	};
316		316
317	struct ContainerQuery { };	317	struct ContainerQuery {
		318	AtomString containerName;
		319	Ref<MediaQuerySet> query;
		320	};
318		321
319	class StyleRuleContainer final : public StyleRuleGroup {	322	class StyleRuleContainer final : public StyleRuleGroup {
320	public:	323	public:



            output[--unusedEntries] = property;
            continue;
        }
        
        // FIXME-NEWPARSER: We won't support @apply yet.
        /*else if (property.id() == CSSPropertyApplyAtRule) {
         // FIXME: Do we need to do anything here?
         } */
        

        if (seenProperties.test(propertyIDIndex))
            continue;

            return consumeNamespaceRule(prelude);
        if (allowedRules <= RegularRules && id == CSSAtRuleLayer)
            return consumeLayerRule(prelude, { });
        // FIXME-NEWPARSER: Support "apply"
        /*if (allowedRules == ApplyRules && id == CSSAtRuleApply) {
            consumeApplyRule(prelude);
            return nullptr; // consumeApplyRule just updates m_parsedProperties
        }*/
        return nullptr; // Parse error, unrecognised at-rule without block
    }


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

    return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude, { m_context }).releaseNonNull(), WTFMove(rules));
}

RefPtr<StyleRuleSupports> CSSParserImpl::consumeSupportsRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

    if (!m_context.containerQueriesEnabled)
        return nullptr;

    if (prelude.atEnd())
        return nullptr;

    auto consumeName = [&]() -> AtomString {
        if (prelude.peek().type() == LeftParenthesisToken || prelude.peek().type() == FunctionToken)
            return nullAtom();
        auto nameValue = CSSPropertyParserHelpers::consumeSingleContainerName(prelude);
        if (!nameValue)
            return nullAtom();
        return nameValue->stringValue();
    };

    auto name = consumeName();

    auto query = MediaQueryParser::parseContainerQuery(prelude, MediaQueryParserContext(m_context));
    if (!query)
        return nullptr;

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

    Vector<RefPtr<StyleRuleBase>> rules;


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

    return StyleRuleContainer::create({ name, query.releaseNonNull() }, WTFMove(rules));
}
    
RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)



    if (range.peek().id() == CSSValueNone)
        return consumeIdent(range);

    auto consumeName = [&]() -> RefPtr<CSSValue> {
        if (range.peek().id() == CSSValueNone)
            return nullptr;
        if (auto ident = consumeCustomIdent(range))
            return ident;
        if (auto string = consumeString(range))
            return string;
        return nullptr;
    };

    auto list = CSSValueList::createSpaceSeparated();
    do {
        auto name = consumeSingleContainerName(range);
        if (!name)
            return nullptr;
        list->append(name.releaseNonNull());



    return isPredefinedCounterStyle(nameToken.id()) ? name.convertToASCIILowercaseAtom() : name.toAtomString();
}

RefPtr<CSSPrimitiveValue> consumeSingleContainerName(CSSParserTokenRange& range)
{
    if (range.peek().id() == CSSValueNone)
        return nullptr;
    if (auto ident = consumeCustomIdent(range))
        return ident;
    if (auto string = consumeString(range))
        return string;
    return nullptr;
}

std::optional<CSSValueID> consumeFontVariantCSS21Raw(CSSParserTokenRange& range)
{
    return consumeIdentRaw<CSSValueNormal, CSSValueSmallCaps>(range);

Lines 193-198 struct FontRaw { a/Source/WebCore/css/parser/CSSPropertyParserHelpers.h_sec1
- a/Source/WebCore/css/parser/CSSPropertyParserHelpers.h +1 lines
193	bool isPredefinedCounterStyle(CSSValueID);	193	bool isPredefinedCounterStyle(CSSValueID);
194	RefPtr<CSSPrimitiveValue> consumeCounterStyleName(CSSParserTokenRange&);	194	RefPtr<CSSPrimitiveValue> consumeCounterStyleName(CSSParserTokenRange&);
195	AtomString consumeCounterStyleNameInPrelude(CSSParserTokenRange&);	195	AtomString consumeCounterStyleNameInPrelude(CSSParserTokenRange&);
		196	RefPtr<CSSPrimitiveValue> consumeSingleContainerName(CSSParserTokenRange&);
196		197
197	std::optional<CSSValueID> consumeFontVariantCSS21Raw(CSSParserTokenRange&);	198	std::optional<CSSValueID> consumeFontVariantCSS21Raw(CSSParserTokenRange&);
198	std::optional<CSSValueID> consumeFontWeightKeywordValueRaw(CSSParserTokenRange&);	199	std::optional<CSSValueID> consumeFontWeightKeywordValueRaw(CSSParserTokenRange&);



    return MediaQueryParser(MediaConditionParser, context).parseInternal(range);
}

RefPtr<MediaQuerySet> MediaQueryParser::parseContainerQuery(CSSParserTokenRange range, MediaQueryParserContext context)
{
    if (range.atEnd())
        return nullptr;
    if (range.peek().type() != LeftParenthesisToken && range.peek().type() != FunctionToken)
        return nullptr;
    return MediaQueryParser(ContainerQueryParser, context).parseInternal(range);
}

const MediaQueryParser::State MediaQueryParser::ReadRestrictor = &MediaQueryParser::readRestrictor;
const MediaQueryParser::State MediaQueryParser::ReadMediaNot = &MediaQueryParser::readMediaNot;
const MediaQueryParser::State MediaQueryParser::ReadContainerQuery = &MediaQueryParser::readContainerQuery;
const MediaQueryParser::State MediaQueryParser::ReadMediaType = &MediaQueryParser::readMediaType;
const MediaQueryParser::State MediaQueryParser::ReadAnd = &MediaQueryParser::readAnd;
const MediaQueryParser::State MediaQueryParser::ReadFeatureStart = &MediaQueryParser::readFeatureStart;

    , m_querySet(MediaQuerySet::create())
    
{
    switch (m_parserType) {
    case MediaQuerySetParser:
        m_state = &MediaQueryParser::readRestrictor;
        break;
    case MediaConditionParser:
        m_state = &MediaQueryParser::readMediaNot;
        break;
    case ContainerQueryParser:
        m_state = &MediaQueryParser::readContainerQuery;
        break;
    }
}

MediaQueryParser::~MediaQueryParser() = default;

        readFeatureStart(type, token, range);
}

void MediaQueryParser::readContainerQuery(CSSParserTokenType type, const CSSParserToken&, CSSParserTokenRange&)
{
    if (type == FunctionToken || type == LeftParenthesisToken)
        m_state = ReadFeature;
}

static bool isRestrictorOrLogicalOperator(const CSSParserToken& token)
{
    // FIXME: it would be more efficient to use lower-case always for tokenValue.


void MediaQueryParser::handleBlocks(const CSSParserToken& token)
{
    if (token.getBlockType() != CSSParserToken::BlockStart)
        return;
    auto shouldSkipBlock = [&] {
        // FIXME: Nested blocks should be supported.
        if (m_blockWatcher.blockLevel())
            return true;
        if (token.type() == LeftParenthesisToken)
            return false;
        if (m_parserType == ContainerQueryParser && token.type() == FunctionToken)
            return !equalLettersIgnoringASCIICase(token.value(), "size");
        return true;
    }();
    if (shouldSkipBlock)
        m_state = SkipUntilBlockEnd;
}

void MediaQueryParser::processToken(const CSSParserToken& token, CSSParserTokenRange& range)
{
    CSSParserTokenType type = token.type();

    if (type == WhitespaceToken) {
        range.consume();
        return;
    }

    if (m_state != ReadFeatureValue) {
        handleBlocks(token);
        m_blockWatcher.handleToken(token);
        range.consume();
    }

    // Call the function that handles current state
    ((this)->*(m_state))(type, token, range);
        ((this)->*(m_state))(type, token, range);
}

// The state machine loop
RefPtr<MediaQuerySet> MediaQueryParser::parseInternal(CSSParserTokenRange& range)
{
    
    while (!range.atEnd())
        processToken(range.peek(), range);




    static RefPtr<MediaQuerySet> parseMediaQuerySet(const String&, MediaQueryParserContext);
    static RefPtr<MediaQuerySet> parseMediaQuerySet(CSSParserTokenRange, MediaQueryParserContext);
    static RefPtr<MediaQuerySet> parseMediaCondition(CSSParserTokenRange, MediaQueryParserContext);
    static RefPtr<MediaQuerySet> parseContainerQuery(CSSParserTokenRange, MediaQueryParserContext);

private:
    enum ParserType {
        MediaQuerySetParser,
        MediaConditionParser,
        ContainerQueryParser,
    };

    MediaQueryParser(ParserType, MediaQueryParserContext);
    virtual ~MediaQueryParser();

    RefPtr<MediaQuerySet> parseInternal(CSSParserTokenRange&);

    void processToken(const CSSParserToken&, CSSParserTokenRange&);

    void readRestrictor(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
    void readMediaNot(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
    void readContainerQuery(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
    void readMediaType(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
    void readAnd(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
    void readFeatureStart(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);


    const static State ReadRestrictor;
    const static State ReadMediaNot;
    const static State ReadContainerQuery;
    const static State ReadMediaType;
    const static State ReadAnd;
    const static State ReadFeatureStart;



2022-01-27  Antti Koivisto  <antti@apple.com>

        [CSS Container Queries] Basic parsing support for query syntax
        https://bugs.webkit.org/show_bug.cgi?id=235712

        Reviewed by Darin Adler.

        * web-platform-tests/css/css-contain/container-queries/at-container-parsing-expected.txt:

2022-01-26  Youenn Fablet  <youenn@apple.com>

        Rebase WPT streams tests up to 8d1dc42



PASS (color-index >= 1)
PASS size(grid)
PASS (grid)
PASS screen
PASS print
PASS not print
PASS only print
PASS screen and (width: 100px)
PASS screen or (width: 100px)
PASS not screen and (width: 100px)
PASS not screen or (width: 100px)
FAIL (width: 100px), (height: 100px) assert_equals: expected 0 but got 1
PASS Container selector:  foo
PASS Container selector:  foo

PASS Container selector: type(block-size)
PASS Container selector: name(bar) type(block-size)
PASS Container selector: type(block-size) name(bar)
PASS Container selector: foo foo
PASS Container selector: 1px
PASS Container selector: 50gil
FAIL Container selector: name(1px) assert_equals: expected 0 but got 1
FAIL Container selector: type(1px) assert_equals: expected 0 but got 1
FAIL Container selector: type(red) assert_equals: expected 0 but got 1

Return to Bug 235712

Lines 123-134 static inline void filterProperties(bool important, const ParsedPropertyVector& a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec1
- a/Source/WebCore/css/parser/CSSParserImpl.cpp -14 / +21 lines
123	output[--unusedEntries] = property;	123	output[--unusedEntries] = property;
124	continue;	124	continue;
125	}	125	}
126
127	// FIXME-NEWPARSER: We won't support @apply yet.
128	/*else if (property.id() == CSSPropertyApplyAtRule) {
129	// FIXME: Do we need to do anything here?
130	} */
131
132		126
133	if (seenProperties.test(propertyIDIndex))	127	if (seenProperties.test(propertyIDIndex))
134	continue;	128	continue;
Lines 430-440 RefPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, A a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec2
430	return consumeNamespaceRule(prelude);	424	return consumeNamespaceRule(prelude);
431	if (allowedRules <= RegularRules && id == CSSAtRuleLayer)	425	if (allowedRules <= RegularRules && id == CSSAtRuleLayer)
432	return consumeLayerRule(prelude, { });	426	return consumeLayerRule(prelude, { });
433	// FIXME-NEWPARSER: Support "apply"
434	/*if (allowedRules == ApplyRules && id == CSSAtRuleApply) {
435	consumeApplyRule(prelude);
436	return nullptr; // consumeApplyRule just updates m_parsedProperties
437	}*/
438	return nullptr; // Parse error, unrecognised at-rule without block	427	return nullptr; // Parse error, unrecognised at-rule without block
439	}	428	}
440		429
Lines 623-629 RefPtr<StyleRuleMedia> CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelu a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec3
623	if (m_observerWrapper)	612	if (m_observerWrapper)
624	m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));	613	m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));
625		614
626	return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude, MediaQueryParserContext(m_context)).releaseNonNull(), WTFMove(rules));	615	return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude, { m_context }).releaseNonNull(), WTFMove(rules));
627	}	616	}
628		617
629	RefPtr<StyleRuleSupports> CSSParserImpl::consumeSupportsRule(CSSParserTokenRange prelude, CSSParserTokenRange block)	618	RefPtr<StyleRuleSupports> CSSParserImpl::consumeSupportsRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
Lines 862-869 RefPtr<StyleRuleContainer> CSSParserImpl::consumeContainerRule(CSSParserTokenRan a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec4
862	if (!m_context.containerQueriesEnabled)	851	if (!m_context.containerQueriesEnabled)
863	return nullptr;	852	return nullptr;
864		853
		854	if (prelude.atEnd())
		855	return nullptr;
		856
		857	auto consumeName = [&]() -> AtomString {
		858	if (prelude.peek().type() == LeftParenthesisToken \|\| prelude.peek().type() == FunctionToken)
		859	return nullAtom();
		860	auto nameValue = CSSPropertyParserHelpers::consumeSingleContainerName(prelude);
		861	if (!nameValue)
		862	return nullAtom();
		863	return nameValue->stringValue();
		864	};
		865
		866	auto name = consumeName();
		867
		868	auto query = MediaQueryParser::parseContainerQuery(prelude, MediaQueryParserContext(m_context));
		869	if (!query)
		870	return nullptr;
		871
865	if (m_deferredParser)	872	if (m_deferredParser)
866	return StyleRuleContainer::create({ }, makeUnique<DeferredStyleGroupRuleList>(block, *m_deferredParser));	873	return StyleRuleContainer::create({ name, query.releaseNonNull() }, makeUnique<DeferredStyleGroupRuleList>(block, *m_deferredParser));
867		874
868	Vector<RefPtr<StyleRuleBase>> rules;	875	Vector<RefPtr<StyleRuleBase>> rules;
869		876
Lines 881-887 RefPtr<StyleRuleContainer> CSSParserImpl::consumeContainerRule(CSSParserTokenRan a/Source/WebCore/css/parser/CSSParserImpl.cpp_sec5
881	if (m_observerWrapper)	888	if (m_observerWrapper)
882	m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));	889	m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(block));
883		890
884	return StyleRuleContainer::create({ }, WTFMove(rules));	891	return StyleRuleContainer::create({ name, query.releaseNonNull() }, WTFMove(rules));
885	}	892	}
886		893
887	RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)	894	RefPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

Lines 3806-3824 static RefPtr<CSSValue> consumeContainerName(CSSParserTokenRange& range) a/Source/WebCore/css/parser/CSSPropertyParser.cpp_sec1
- a/Source/WebCore/css/parser/CSSPropertyParser.cpp -11 / +1 lines
3806	if (range.peek().id() == CSSValueNone)	3806	if (range.peek().id() == CSSValueNone)
3807	return consumeIdent(range);	3807	return consumeIdent(range);
3808		3808
3809	auto consumeName = [&]() -> RefPtr<CSSValue> {
3810	if (range.peek().id() == CSSValueNone)
3811	return nullptr;
3812	if (auto ident = consumeCustomIdent(range))
3813	return ident;
3814	if (auto string = consumeString(range))
3815	return string;
3816	return nullptr;
3817	};
3818
3819	auto list = CSSValueList::createSpaceSeparated();	3809	auto list = CSSValueList::createSpaceSeparated();
3820	do {	3810	do {
3821	auto name = consumeName();	3811	auto name = consumeSingleContainerName(range);
3822	if (!name)	3812	if (!name)
3823	return nullptr;	3813	return nullptr;
3824	list->append(name.releaseNonNull());	3814	list->append(name.releaseNonNull());

Lines 4279-4284 AtomString consumeCounterStyleNameInPrelude(CSSParserTokenRange& prelude) a/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp_sec1
- a/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp +11 lines
4279	return isPredefinedCounterStyle(nameToken.id()) ? name.convertToASCIILowercaseAtom() : name.toAtomString();	4279	return isPredefinedCounterStyle(nameToken.id()) ? name.convertToASCIILowercaseAtom() : name.toAtomString();
4280	}	4280	}
4281		4281
		4282	RefPtr<CSSPrimitiveValue> consumeSingleContainerName(CSSParserTokenRange& range)
		4283	{
		4284	if (range.peek().id() == CSSValueNone)
		4285	return nullptr;
		4286	if (auto ident = consumeCustomIdent(range))
		4287	return ident;
		4288	if (auto string = consumeString(range))
		4289	return string;
		4290	return nullptr;
		4291	}
		4292
4282	std::optional<CSSValueID> consumeFontVariantCSS21Raw(CSSParserTokenRange& range)	4293	std::optional<CSSValueID> consumeFontVariantCSS21Raw(CSSParserTokenRange& range)
4283	{	4294	{
4284	return consumeIdentRaw<CSSValueNormal, CSSValueSmallCaps>(range);	4295	return consumeIdentRaw<CSSValueNormal, CSSValueSmallCaps>(range);

Lines 55-62 RefPtr<MediaQuerySet> MediaQueryParser::parseMediaCondition(CSSParserTokenRange a/Source/WebCore/css/parser/MediaQueryParser.cpp_sec1
- a/Source/WebCore/css/parser/MediaQueryParser.cpp -9 / +48 lines
55	return MediaQueryParser(MediaConditionParser, context).parseInternal(range);	55	return MediaQueryParser(MediaConditionParser, context).parseInternal(range);
56	}	56	}
57		57
		58	RefPtr<MediaQuerySet> MediaQueryParser::parseContainerQuery(CSSParserTokenRange range, MediaQueryParserContext context)
		59	{
		60	if (range.atEnd())
		61	return nullptr;
		62	if (range.peek().type() != LeftParenthesisToken && range.peek().type() != FunctionToken)
		63	return nullptr;
		64	return MediaQueryParser(ContainerQueryParser, context).parseInternal(range);
		65	}
		66
58	const MediaQueryParser::State MediaQueryParser::ReadRestrictor = &MediaQueryParser::readRestrictor;	67	const MediaQueryParser::State MediaQueryParser::ReadRestrictor = &MediaQueryParser::readRestrictor;
59	const MediaQueryParser::State MediaQueryParser::ReadMediaNot = &MediaQueryParser::readMediaNot;	68	const MediaQueryParser::State MediaQueryParser::ReadMediaNot = &MediaQueryParser::readMediaNot;
		69	const MediaQueryParser::State MediaQueryParser::ReadContainerQuery = &MediaQueryParser::readContainerQuery;
60	const MediaQueryParser::State MediaQueryParser::ReadMediaType = &MediaQueryParser::readMediaType;	70	const MediaQueryParser::State MediaQueryParser::ReadMediaType = &MediaQueryParser::readMediaType;
61	const MediaQueryParser::State MediaQueryParser::ReadAnd = &MediaQueryParser::readAnd;	71	const MediaQueryParser::State MediaQueryParser::ReadAnd = &MediaQueryParser::readAnd;
62	const MediaQueryParser::State MediaQueryParser::ReadFeatureStart = &MediaQueryParser::readFeatureStart;	72	const MediaQueryParser::State MediaQueryParser::ReadFeatureStart = &MediaQueryParser::readFeatureStart;
Lines 74-83 MediaQueryParser::MediaQueryParser(ParserType parserType, MediaQueryParserContex a/Source/WebCore/css/parser/MediaQueryParser.cpp_sec2
74	, m_querySet(MediaQuerySet::create())	84	, m_querySet(MediaQuerySet::create())
75		85
76	{	86	{
77	if (parserType == MediaQuerySetParser)	87	switch (m_parserType) {
		88	case MediaQuerySetParser:
78	m_state = &MediaQueryParser::readRestrictor;	89	m_state = &MediaQueryParser::readRestrictor;
79	else // MediaConditionParser	90	break;
		91	case MediaConditionParser:
80	m_state = &MediaQueryParser::readMediaNot;	92	m_state = &MediaQueryParser::readMediaNot;
		93	break;
		94	case ContainerQueryParser:
		95	m_state = &MediaQueryParser::readContainerQuery;
		96	break;
		97	}
81	}	98	}
82		99
83	MediaQueryParser::~MediaQueryParser() = default;	100	MediaQueryParser::~MediaQueryParser() = default;
Lines 102-107 void MediaQueryParser::readMediaNot(CSSParserTokenType type, const CSSParserToke a/Source/WebCore/css/parser/MediaQueryParser.cpp_sec3
102	readFeatureStart(type, token, range);	119	readFeatureStart(type, token, range);
103	}	120	}
104		121
		122	void MediaQueryParser::readContainerQuery(CSSParserTokenType type, const CSSParserToken&, CSSParserTokenRange&)
		123	{
		124	if (type == FunctionToken \|\| type == LeftParenthesisToken)
		125	m_state = ReadFeature;
		126	}
		127
105	static bool isRestrictorOrLogicalOperator(const CSSParserToken& token)	128	static bool isRestrictorOrLogicalOperator(const CSSParserToken& token)
106	{	129	{
107	// FIXME: it would be more efficient to use lower-case always for tokenValue.	130	// FIXME: it would be more efficient to use lower-case always for tokenValue.
Lines 239-267 void MediaQueryParser::done(CSSParserTokenType /type/, const CSSParserToken& / a/Source/WebCore/css/parser/MediaQueryParser.cpp_sec4
239		262
240	void MediaQueryParser::handleBlocks(const CSSParserToken& token)	263	void MediaQueryParser::handleBlocks(const CSSParserToken& token)
241	{	264	{
242	if (token.getBlockType() == CSSParserToken::BlockStart	265	if (token.getBlockType() != CSSParserToken::BlockStart)
243	&& (token.type() != LeftParenthesisToken \|\| m_blockWatcher.blockLevel()))	266	return;
244	m_state = SkipUntilBlockEnd;	267	auto shouldSkipBlock = [&] {
		268	// FIXME: Nested blocks should be supported.
		269	if (m_blockWatcher.blockLevel())
		270	return true;
		271	if (token.type() == LeftParenthesisToken)
		272	return false;
		273	if (m_parserType == ContainerQueryParser && token.type() == FunctionToken)
		274	return !equalLettersIgnoringASCIICase(token.value(), "size");
		275	return true;
		276	}();
		277	if (shouldSkipBlock)
		278	m_state = SkipUntilBlockEnd;
245	}	279	}
246		280
247	void MediaQueryParser::processToken(const CSSParserToken& token, CSSParserTokenRange& range)	281	void MediaQueryParser::processToken(const CSSParserToken& token, CSSParserTokenRange& range)
248	{	282	{
249	CSSParserTokenType type = token.type();	283	CSSParserTokenType type = token.type();
250		284
251	if (m_state != ReadFeatureValue \|\| type == WhitespaceToken) {	285	if (type == WhitespaceToken) {
		286	range.consume();
		287	return;
		288	}
		289
		290	if (m_state != ReadFeatureValue) {
252	handleBlocks(token);	291	handleBlocks(token);
253	m_blockWatcher.handleToken(token);	292	m_blockWatcher.handleToken(token);
254	range.consume();	293	range.consume();
255	}	294	}
256		295
257	// Call the function that handles current state	296	// Call the function that handles current state
258	if (type != WhitespaceToken)	297	((this)->*(m_state))(type, token, range);
259	((this)->*(m_state))(type, token, range);
260	}	298	}
261		299
262	// The state machine loop	300	// The state machine loop
263	RefPtr<MediaQuerySet> MediaQueryParser::parseInternal(CSSParserTokenRange range)	301	RefPtr<MediaQuerySet> MediaQueryParser::parseInternal(CSSParserTokenRange& range)
264	{	302	{
		303
265	while (!range.atEnd())	304	while (!range.atEnd())
266	processToken(range.peek(), range);	305	processToken(range.peek(), range);
267		306

Lines 48-69 public: a/Source/WebCore/css/parser/MediaQueryParser.h_sec1
- a/Source/WebCore/css/parser/MediaQueryParser.h -1 / +5 lines
48	static RefPtr<MediaQuerySet> parseMediaQuerySet(const String&, MediaQueryParserContext);	48	static RefPtr<MediaQuerySet> parseMediaQuerySet(const String&, MediaQueryParserContext);
49	static RefPtr<MediaQuerySet> parseMediaQuerySet(CSSParserTokenRange, MediaQueryParserContext);	49	static RefPtr<MediaQuerySet> parseMediaQuerySet(CSSParserTokenRange, MediaQueryParserContext);
50	static RefPtr<MediaQuerySet> parseMediaCondition(CSSParserTokenRange, MediaQueryParserContext);	50	static RefPtr<MediaQuerySet> parseMediaCondition(CSSParserTokenRange, MediaQueryParserContext);
		51	static RefPtr<MediaQuerySet> parseContainerQuery(CSSParserTokenRange, MediaQueryParserContext);
51		52
52	private:	53	private:
53	enum ParserType {	54	enum ParserType {
54	MediaQuerySetParser,	55	MediaQuerySetParser,
55	MediaConditionParser,	56	MediaConditionParser,
		57	ContainerQueryParser,
56	};	58	};
57		59
58	MediaQueryParser(ParserType, MediaQueryParserContext);	60	MediaQueryParser(ParserType, MediaQueryParserContext);
59	virtual ~MediaQueryParser();	61	virtual ~MediaQueryParser();
60		62
61	RefPtr<MediaQuerySet> parseInternal(CSSParserTokenRange);	63	RefPtr<MediaQuerySet> parseInternal(CSSParserTokenRange&);
62		64
63	void processToken(const CSSParserToken&, CSSParserTokenRange&);	65	void processToken(const CSSParserToken&, CSSParserTokenRange&);
64		66
65	void readRestrictor(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);	67	void readRestrictor(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
66	void readMediaNot(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);	68	void readMediaNot(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
		69	void readContainerQuery(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
67	void readMediaType(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);	70	void readMediaType(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
68	void readAnd(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);	71	void readAnd(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
69	void readFeatureStart(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);	72	void readFeatureStart(CSSParserTokenType, const CSSParserToken&, CSSParserTokenRange&);
Lines 124-129 private: a/Source/WebCore/css/parser/MediaQueryParser.h_sec2
124		127
125	const static State ReadRestrictor;	128	const static State ReadRestrictor;
126	const static State ReadMediaNot;	129	const static State ReadMediaNot;
		130	const static State ReadContainerQuery;
127	const static State ReadMediaType;	131	const static State ReadMediaType;
128	const static State ReadAnd;	132	const static State ReadAnd;
129	const static State ReadFeatureStart;	133	const static State ReadFeatureStart;

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +31 lines
		1	2022-01-27 Antti Koivisto <antti@apple.com>
		2
		3	[CSS Container Queries] Basic parsing support for query syntax
		4	https://bugs.webkit.org/show_bug.cgi?id=235712
		5
		6	Reviewed by Darin Adler.
		7
		8	https://drafts.csswg.org/css-contain-3/#at-ruledef-container
		9
		10	Use MediaQueryParser to parse the query syntax. Note that because the limitations
		11	of MediaQueryParser only simple non-nested queries can be parsed for now.
		12
		13	* css/StyleRule.h:
		14	* css/parser/CSSParserImpl.cpp:
		15	(WebCore::filterProperties):
		16	(WebCore::CSSParserImpl::consumeAtRule):
		17	(WebCore::CSSParserImpl::consumeContainerRule):
		18	* css/parser/CSSPropertyParser.cpp:
		19	(WebCore::consumeContainerName):
		20	* css/parser/CSSPropertyParserHelpers.cpp:
		21	(WebCore::CSSPropertyParserHelpers::consumeSingleContainerName):
		22	* css/parser/CSSPropertyParserHelpers.h:
		23	* css/parser/MediaQueryParser.cpp:
		24	(WebCore::MediaQueryParser::parseContainerQuery):
		25	(WebCore::MediaQueryParser::MediaQueryParser):
		26	(WebCore::MediaQueryParser::readContainerQuery):
		27	(WebCore::MediaQueryParser::handleBlocks):
		28	(WebCore::MediaQueryParser::processToken):
		29	(WebCore::MediaQueryParser::parseInternal):
		30	* css/parser/MediaQueryParser.h:
		31
1	2022-01-26 Antti Koivisto <antti@apple.com>	32	2022-01-26 Antti Koivisto <antti@apple.com>
2		33
3	ASSERTION FAILED: !hasPendingSheets() under WebCore::Style::Scope::~Scope()	34	ASSERTION FAILED: !hasPendingSheets() under WebCore::Style::Scope::~Scope()

Lines 1-3 a/LayoutTests/imported/w3c/ChangeLog_sec1
- a/LayoutTests/imported/w3c/ChangeLog +9 lines
		1	2022-01-27 Antti Koivisto <antti@apple.com>
		2
		3	[CSS Container Queries] Basic parsing support for query syntax
		4	https://bugs.webkit.org/show_bug.cgi?id=235712
		5
		6	Reviewed by Darin Adler.
		7
		8	* web-platform-tests/css/css-contain/container-queries/at-container-parsing-expected.txt:
		9
1	2022-01-26 Youenn Fablet <youenn@apple.com>	10	2022-01-26 Youenn Fablet <youenn@apple.com>
2		11
3	Rebase WPT streams tests up to 8d1dc42	12	Rebase WPT streams tests up to 8d1dc42

Lines 33-46 PASS size(color-index >= 1) a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/container-queries/at-container-parsing-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/container-queries/at-container-parsing-expected.txt -11 / +11 lines
33	PASS (color-index >= 1)	33	PASS (color-index >= 1)
34	PASS size(grid)	34	PASS size(grid)
35	PASS (grid)	35	PASS (grid)
36	FAIL screen assert_equals: expected 0 but got 1	36	PASS screen
37	FAIL print assert_equals: expected 0 but got 1	37	PASS print
38	FAIL not print assert_equals: expected 0 but got 1	38	PASS not print
39	FAIL only print assert_equals: expected 0 but got 1	39	PASS only print
40	FAIL screen and (width: 100px) assert_equals: expected 0 but got 1	40	PASS screen and (width: 100px)
41	FAIL screen or (width: 100px) assert_equals: expected 0 but got 1	41	PASS screen or (width: 100px)
42	FAIL not screen and (width: 100px) assert_equals: expected 0 but got 1	42	PASS not screen and (width: 100px)
43	FAIL not screen or (width: 100px) assert_equals: expected 0 but got 1	43	PASS not screen or (width: 100px)
44	FAIL (width: 100px), (height: 100px) assert_equals: expected 0 but got 1	44	FAIL (width: 100px), (height: 100px) assert_equals: expected 0 but got 1
45	PASS Container selector: foo	45	PASS Container selector: foo
46	PASS Container selector: foo	46	PASS Container selector: foo
Lines 52-60 PASS Container selector: type(inline-size) a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/container-queries/at-container-parsing-expected.txt_sec2
52	PASS Container selector: type(block-size)	52	PASS Container selector: type(block-size)
53	PASS Container selector: name(bar) type(block-size)	53	PASS Container selector: name(bar) type(block-size)
54	PASS Container selector: type(block-size) name(bar)	54	PASS Container selector: type(block-size) name(bar)
55	FAIL Container selector: foo foo assert_equals: expected 0 but got 1	55	PASS Container selector: foo foo
56	FAIL Container selector: 1px assert_equals: expected 0 but got 1	56	PASS Container selector: 1px
57	FAIL Container selector: 50gil assert_equals: expected 0 but got 1	57	PASS Container selector: 50gil
58	FAIL Container selector: name(1px) assert_equals: expected 0 but got 1	58	FAIL Container selector: name(1px) assert_equals: expected 0 but got 1
59	FAIL Container selector: type(1px) assert_equals: expected 0 but got 1	59	FAIL Container selector: type(1px) assert_equals: expected 0 but got 1
60	FAIL Container selector: type(red) assert_equals: expected 0 but got 1	60	FAIL Container selector: type(red) assert_equals: expected 0 but got 1