ChangeLog

2016-02-25  Antti Koivisto  <antti@apple.com>

        Implement ::slotted pseudo element

        https://bugs.webkit.org/show_bug.cgi?id=149441

        <rdar://problem/22731987>

        Reviewed by NOBODY (OOPS!).

        Based on latest in https://github.com/w3c/webcomponents/issues/331

        * css/CSSGrammar.y.in:

            Parse ::slotted.

        * css/CSSParser.cpp:

        (WebCore::CSSParser::detectFunctionTypeToken):

        * css/CSSParserValues.cpp:

        (WebCore::CSSParserSelector::parsePseudoElementCueFunctionSelector):

        (WebCore::CSSParserSelector::parsePseudoElementSlottedFunctionSelector):

            Tokenize ::slotted.

        (WebCore::CSSParserSelector::parsePseudoClassAndCompatibilityElementSelector):

        * css/CSSParserValues.h:

        * css/CSSSelector.cpp:

        (WebCore::CSSSelector::pseudoId):

        * css/CSSSelector.h:

        * css/ElementRuleCollector.cpp:

        (WebCore::ElementRuleCollector::matchAuthorRules):

        (WebCore::ElementRuleCollector::matchHostPseudoClassRules):

        (WebCore::ElementRuleCollector::matchSlottedPseudoElementRules):

            Match ::slotted selector.

        (WebCore::ElementRuleCollector::collectSlottedPseudoElementRulesForSlot):

            Collect ::slotted rules that may apply to an element in a slot.

        (WebCore::ElementRuleCollector::matchUserRules):

        (WebCore::ElementRuleCollector::matchUARules):

        (WebCore::findSlottedPseudoElementSelector):

        (WebCore::ElementRuleCollector::ruleMatches):

        * css/ElementRuleCollector.h:

        * css/RuleSet.cpp:

        (WebCore::RuleSet::addRule):

            Collect ::slotted rules.

        (WebCore::RuleSet::shrinkToFit):

        * css/RuleSet.h:

        (WebCore::RuleSet::hostPseudoClassRules):

        (WebCore::RuleSet::slottedPseudoElementRules):

        (WebCore::RuleSet::focusPseudoClassRules):

        (WebCore::RuleSet::universalRules):

        * css/SelectorChecker.cpp:

        (WebCore::SelectorChecker::checkOne):

        * style/StyleSharingResolver.cpp:

        (WebCore::Style::SharingResolver::resolve):

            Disable style sharing for children of shadow host. They may be affected by the shadow tree style

            which is not considered in style sharing checks.

2016-02-25  Said Abou-Hallawa  <sabouhallawa@apple.com>

        REGRESSION (r196268): Many assertion failures and crashes on SVG path animation tests when JS garbage collection happens quickly

197127

Source/WebCore/css/CSSGrammar.y.in

@@static bool selectorListDoesNotMatchAnyP

#endif

#if ENABLE_SHADOW_DOM

%token <string> SLOTTEDFUNCTION

#endif

%%

stylesheet:

@@pseudo:

        $$ = CSSParserSelector::parsePseudoElementCueFunctionSelector($3, $5);

    }

#endif

#if ENABLE_SHADOW_DOM

    | ':' ':' SLOTTEDFUNCTION maybe_space compound_selector maybe_space ')' {

        $$ = CSSParserSelector::parsePseudoElementSlottedFunctionSelector($3, $5);

    }

#endif

    // use by :-webkit-any.

    // FIXME: should we support generic selectors here or just simple_selectors?

    // Use simple_selector_list for now to match -moz-any.

197027

Source/WebCore/css/CSSParser.cpp

@@inline bool CSSParser::detectFunctionTyp

            m_token = MATCHESFUNCTION;

            return true;

        }

#if ENABLE(SHADOW_DOM)

        if (isEqualToCSSIdentifier(name, "slotted")) {

            m_token = SLOTTEDFUNCTION;

            return true;

        }

#endif

        return false;

    case 9:

197027

Source/WebCore/css/CSSParserValues.cpp

@@CSSParserSelector* CSSParserSelector::pa

}

#endif

#if ENABLE(SHADOW_DOM)

CSSParserSelector* CSSParserSelector::parsePseudoElementSlottedFunctionSelector(const CSSParserString& functionIdentifier, CSSParserSelector* parsedSelector)

{

    ASSERT_UNUSED(functionIdentifier, String(functionIdentifier) == "slotted(");

    if (!parsedSelector)

        return nullptr;

    std::unique_ptr<CSSParserSelector> ownedParsedSelector(parsedSelector);

    for (auto* component = parsedSelector; component; component = component->tagHistory()) {

        if (component->matchesPseudoElement())

            return nullptr;

    }

    auto selectorVector = std::make_unique<Vector<std::unique_ptr<CSSParserSelector>>>();

    selectorVector->append(WTFMove(ownedParsedSelector));

    auto selector = std::make_unique<CSSParserSelector>();

    selector->m_selector->setMatch(CSSSelector::PseudoElement);

    selector->m_selector->setPseudoElementType(CSSSelector::PseudoElementSlotted);

    selector->adoptSelectorVector(*selectorVector);

    return selector.release();

}

#endif

CSSParserSelector* CSSParserSelector::parsePseudoClassAndCompatibilityElementSelector(CSSParserString& pseudoTypeString)

{

    if (pseudoTypeString.length() && pseudoTypeString[pseudoTypeString.length() - 1] == '(')

197027

Source/WebCore/css/CSSParserValues.h

@@class CSSParserSelector {

public:

    static CSSParserSelector* parsePagePseudoSelector(const CSSParserString& pseudoTypeString);

    static CSSParserSelector* parsePseudoElementSelector(CSSParserString& pseudoTypeString);

206 static CSSParserSelector* parsePseudoElementCueFunctionSelector(const CSSParserString& functionIdentifier, Vector<std::unique_ptr<CSSParserSelector>>* selectorVector);

    static CSSParserSelector* parsePseudoElementCueFunctionSelector(const CSSParserString& functionIdentifier, Vector<std::unique_ptr<CSSParserSelector>>*);

#if ENABLE(SHADOW_DOM)

    static CSSParserSelector* parsePseudoElementSlottedFunctionSelector(const CSSParserString& functionIdentifier, CSSParserSelector*);

#endif

    static CSSParserSelector* parsePseudoClassAndCompatibilityElementSelector(CSSParserString& pseudoTypeString);

    CSSParserSelector();

197027

Source/WebCore/css/CSSSelector.cpp

@@PseudoId CSSSelector::pseudoId(PseudoEle

#if ENABLE(VIDEO_TRACK)

    case PseudoElementCue:

#endif

#if ENABLE(SHADOW_DOM)

    case PseudoElementSlotted:

#endif

    case PseudoElementUnknown:

    case PseudoElementUserAgentCustom:

    case PseudoElementWebKitCustom:

@@String CSSSelector::selectorText(const S

                ASSERT_NOT_REACHED();

            }

        } else if (cs->match() == CSSSelector::PseudoElement) {

647 str.appendLiteral("::");

648 str.append(cs->value());

            switch (cs->pseudoElementType()) {

#if ENABLE(SHADOW_DOM)

            case CSSSelector::PseudoElementSlotted:

                str.appendLiteral("::slotted(");

                cs->selectorList()->buildSelectorsText(str);

                str.append(')');

                break;

#endif

            default:

                str.appendLiteral("::");

                str.append(cs->value());

            }

        } else if (cs->isAttributeSelector()) {

            str.append('[');

            const AtomicString& prefix = cs->attribute().prefix();

197027

Source/WebCore/css/CSSSelector.h

@@namespace WebCore {

            PseudoElementScrollbarTrack,

            PseudoElementScrollbarTrackPiece,

            PseudoElementSelection,

#if ENABLE(SHADOW_DOM)

            PseudoElementSlotted,

#endif

            PseudoElementUserAgentCustom,

            PseudoElementWebKitCustom,

        };

197027

Source/WebCore/css/ElementRuleCollector.cpp

#include "CSSSelectorList.h"

#include "CSSValueKeywords.h"

#include "HTMLElement.h"

39#include "HTMLSlotElement.h"

#include "InspectorInstrumentation.h"

#include "NodeRenderStyle.h"

#include "RenderRegion.h"

@@void ElementRuleCollector::matchAuthorRu

#if ENABLE(SHADOW_DOM)

    if (m_element.shadowRoot())

        matchHostPseudoClassRules(includeEmptyRules);

    auto* parent = m_element.parentNode();

    if (parent && parent->shadowRoot())

        matchSlottedPseudoElementRules(includeEmptyRules);

#endif

    clearMatchedRules();

@@void ElementRuleCollector::matchHostPseu

    // FIXME: Match the spec when it is finalized.

    sortAndTransferMatchedRules();

}

void ElementRuleCollector::matchSlottedPseudoElementRules(bool includeEmptyRules)

{

    auto* hostShadowRoot = m_element.parentNode()->shadowRoot();

    ASSERT(hostShadowRoot);

    auto* slot = hostShadowRoot->findAssignedSlot(m_element);

    if (!slot)

        return;

    auto* shadowAuthorStyle = hostShadowRoot->styleResolver().ruleSets().authorStyle();

    if (!shadowAuthorStyle)

        return;

    // Find out if there are any ::slotted rules in the shadow tree matching the current slot.

    // FIXME: This is really part of the slot style and could be cached when resolving it.

    ElementRuleCollector collector(*slot, *shadowAuthorStyle, nullptr);

    auto slottedPseudoElementRules = collector.collectSlottedPseudoElementRulesForSlot(includeEmptyRules);

    if (slottedPseudoElementRules.isEmpty())

        return;

    clearMatchedRules();

    m_result.ranges.lastAuthorRule = m_result.matchedProperties().size() - 1;

    {

        // Match in the current scope.

        TemporaryChange<bool> change(m_isMatchingSlottedPseudoElement, true);

        MatchRequest matchRequest(nullptr, includeEmptyRules);

        auto ruleRange = m_result.ranges.authorRuleRange();

        collectMatchingRulesForList(&slottedPseudoElementRules, matchRequest, ruleRange);

    }

    // FIXME: What is the correct order?

    sortAndTransferMatchedRules();

}

RuleSet::RuleDataVector ElementRuleCollector::collectSlottedPseudoElementRulesForSlot(bool includeEmptyRules)

{

    ASSERT(is<HTMLSlotElement>(m_element));

    clearMatchedRules();

    m_mode = SelectorChecker::Mode::CollectingRules;

    // Match global author rules.

    MatchRequest matchRequest(&m_authorStyle, includeEmptyRules);

    StyleResolver::RuleRange ruleRange = m_result.ranges.authorRuleRange();

    collectMatchingRulesForList(&m_authorStyle.slottedPseudoElementRules(), matchRequest, ruleRange);

    if (m_matchedRules.isEmpty())

        return { };

    RuleSet::RuleDataVector ruleDataVector;

    for (auto& matchedRule : m_matchedRules)

        ruleDataVector.append(*matchedRule.ruleData);

    return ruleDataVector;

}

#endif

void ElementRuleCollector::matchUserRules(bool includeEmptyRules)

@@void ElementRuleCollector::matchUARules(

    sortAndTransferMatchedRules();

}

#if ENABLE(SHADOW_DOM)

static const CSSSelector* findSlottedPseudoElementSelector(const CSSSelector* selector)

{

    for (; selector; selector = selector->tagHistory()) {

        if (selector->match() == CSSSelector::PseudoElement && selector->pseudoElementType() == CSSSelector::PseudoElementSlotted) {

            if (auto* list = selector->selectorList())

                return list->first();

            break;

        }

    };

    return nullptr;

}

#endif

inline bool ElementRuleCollector::ruleMatches(const RuleData& ruleData, unsigned& specificity)

{

    // We know a sufficiently simple single part selector matches simply because we found it from the rule hash when filtering the RuleSet.

@@inline bool ElementRuleCollector::ruleMa

    } else

#endif // ENABLE(CSS_SELECTOR_JIT)

    {

        auto* selector = ruleData.selector();

#if ENABLE(SHADOW_DOM)

        if (m_isMatchingSlottedPseudoElement) {

            selector = findSlottedPseudoElementSelector(ruleData.selector());

            if (!selector)

                return false;

        }

#endif

359443 // Slow path.

360444 SelectorChecker selectorChecker(m_element.document());

361 selectorMatches = selectorChecker.match(*~~ruleData.~~selector(), m_element, context, specificity);

445 selectorMatches = selectorChecker.match(*selector, m_element, context, specificity);

    }

    commitStyleRelations(context.styleRelations);

197027

Source/WebCore/css/ElementRuleCollector.h

@@private:

    void matchUARules(RuleSet*);

#if ENABLE(SHADOW_DOM)

    void matchHostPseudoClassRules(bool includeEmptyRules);

76 void matchSlottedPseudoElementRules(bool includeEmptyRules);

77 RuleSet::RuleDataVector collectSlottedPseudoElementRulesForSlot(bool includeEmptyRules);

#endif

    void collectMatchingRules(const MatchRequest&, StyleResolver::RuleRange&);

@@private:

    PseudoStyleRequest m_pseudoStyleRequest { NOPSEUDO };

    bool m_sameOriginOnly { false };

    SelectorChecker::Mode m_mode { SelectorChecker::Mode::ResolvingStyle };

#if ENABLE(SHADOW_DOM)

    bool m_isMatchingSlottedPseudoElement { false };

#endif

    Vector<MatchedRule, 64> m_matchedRules;

197027

Source/WebCore/css/RuleSet.cpp

@@void RuleSet::addRule(StyleRule* rule, u

            m_hostPseudoClassRules.append(ruleData);

            return;

        }

        if (selector->match() == CSSSelector::PseudoElement && selector->pseudoElementType() == CSSSelector::PseudoElementSlotted) {

            // ::slotted pseudo elements work accross shadow boundary making filtering difficult.

            ruleData.disableSelectorFiltering();

            m_slottedPseudoElementRules.append(ruleData);

            return;

        }

#endif

        if (selector->relation() != CSSSelector::SubSelector)

            break;

@@void RuleSet::shrinkToFit()

#if ENABLE(VIDEO_TRACK)

    m_cuePseudoRules.shrinkToFit();

#endif

#if ENABLE(SHADOW_DOM)

    m_hostPseudoClassRules.shrinkToFit();

    m_slottedPseudoElementRules.shrinkToFit();

#endif

    m_focusPseudoClassRules.shrinkToFit();

    m_universalRules.shrinkToFit();

    m_pageRules.shrinkToFit();

197027

Source/WebCore/css/RuleSet.h

@@public:

#endif

#if ENABLE(SHADOW_DOM)

    const RuleDataVector& hostPseudoClassRules() const { return m_hostPseudoClassRules; }

187 const RuleDataVector& slottedPseudoElementRules() const { return m_slottedPseudoElementRules; }

#endif

    const RuleDataVector* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }

    const RuleDataVector* universalRules() const { return &m_universalRules; }

@@private:

#endif

#if ENABLE(SHADOW_DOM)

    RuleDataVector m_hostPseudoClassRules;

214 RuleDataVector m_slottedPseudoElementRules;

#endif

    RuleDataVector m_focusPseudoClassRules;

    RuleDataVector m_universalRules;

197027

Source/WebCore/css/SelectorChecker.cpp

#include "HTMLOptionElement.h"

#include "HTMLParserIdioms.h"

#include "HTMLProgressElement.h"

47#include "HTMLSlotElement.h"

#include "HTMLStyleElement.h"

#include "InspectorInstrumentation.h"

#include "Page.h"

@@bool SelectorChecker::checkOne(CheckingC

        return false;

    }

#endif

1041 // ### add the rest of the checks...

#if ENABLE(SHADOW_DOM)

    if (selector.match() == CSSSelector::PseudoElement && selector.pseudoElementType() == CSSSelector::PseudoElementSlotted) {

        // We see ::slotted() pseudo elements when collecting slotted rules from the slot shadow tree only.

        ASSERT(checkingContext.resolvingMode == Mode::CollectingRules);

        return is<HTMLSlotElement>(element);

    }

#endif

    return true;

}

197027

Source/WebCore/style/StyleSharingResolver.cpp

@@const Element* SharingResolver::resolve(

    if (!element.parentElement())

        return nullptr;

    auto& parentElement = *element.parentElement();

79 if (parentElement.shadowRoot())

80 return nullptr;

    if (!parentElement.renderStyle())

        return nullptr;

    // If the element has inline style it is probably unique.

197027

LayoutTests/ChangeLog

2016-02-26  Antti Koivisto  <antti@apple.com>

        Implement ::slotted pseudo element

        https://bugs.webkit.org/show_bug.cgi?id=149441

        <rdar://problem/22731987>

        Reviewed by NOBODY (OOPS!).

        * fast/shadow-dom/css-scoping-shadow-slotted-rule.html:

            Enable the test, fix it and update it to the current spec.

        * fast/shadow-dom/slotted-pseudo-element-css-text-expected.txt: Added.

        * fast/shadow-dom/slotted-pseudo-element-css-text.html: Added.

            Add parsing/cssText test based on a Blink test.

            There are a few failures due to * not rountripping and the parser being slightly too lenient.

        * platform/mac/TestExpectations:

2016-02-25  Myles C. Maxfield  <mmaxfield@apple.com>

        Font size computed style is innaccurate

197161

LayoutTests/fast/shadow-dom/css-scoping-shadow-slotted-rule.html

<!DOCTYPE html>

<html>

<head>

4 <title>CSS Scoping - :slotted pesudo element must allow selecting elements assigned to a slot element</title>

4 <title>CSS Scoping - :slotted pseudo element must allow selecting elements assigned to a slot element</title>

    <link rel="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org"/>

    <link rel="help" href="http://www.w3.org/TR/css-scoping-1/#selectors-data-model">

    <link rel="match" href="reference/green-box.html"/>

            display: block;

            width: 100px;

            height: 100px;

15 background: red;

15 color: red;

16 background: green;

        }

        my-host > div, nested-host {

            display: block;

    <p>Test passes if you see a single 100px by 100px green box below.</p> 

    <my-host>

        <div class="green">FAIL1</div>

26 <~~div~~><span>FAIL2</span></~~div~~>

27 <myelem><span>FAIL2</span></myelem>

        <nested-host>

            <span>FAIL3</span>

        </nested-host>

        try {

            var shadowHost = document.querySelector('my-host');

            shadowRoot = shadowHost.attachShadow({mode: 'open'});

39 shadowRoot.innerHTML = '<slot></slot><style> ::slotted > .green, ::slotted ~~span~~ { color:green; } </style>';

40 shadowRoot.innerHTML = '<slot></slot><style> ::slotted(.green), ::slotted(myelem) { color:green; } </style>';

            shadowHost = document.querySelector('nested-host');

            shadowRoot = shadowHost.attachShadow({mode: 'open'});

43 shadowRoot.innerHTML = '<slot></slot>';

44 shadowRoot.innerHTML = '<style> .mydiv ::slotted(*) { color:green; } </style><div class=mydiv><slot></slot></div>';

            shadowHost = document.querySelector('another-host');

            shadowRoot = shadowHost.attachShadow({mode: 'open'});

47 shadowRoot.innerHTML = '<style> ::slotted { color:green; } </style><slot></slot>';

48 shadowRoot.innerHTML = '<style> ::slotted(*) { color:green; } </style><slot></slot>';

        } catch (exception) {

            document.body.appendChild(document.createTextNode(exception));

        }

197027

LayoutTests/fast/shadow-dom/slotted-pseudo-element-css-text-expected.txt

Test for cssText of '::slotted' rule.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Rule ::slotted { display: block; }

PASS cssText is ""

Rule ::slotted() { display: block; }

PASS cssText is ""

Rule ::slotted(*) { display: block; }

PASS cssText is "::slotted(*) { display: block; }"

Rule *::slotted(*) { display: block; }

FAIL cssText should be *::slotted(*) { display: block; }. Was ::slotted(*) { display: block; }.

Rule ::slotted(div) { display: block; }

PASS cssText is "::slotted(div) { display: block; }"

Rule ::slotted( div) { display: block; }

PASS cssText is "::slotted(div) { display: block; }"

Rule ::slotted(div ) { display: block; }

PASS cssText is "::slotted(div) { display: block; }"

Rule ::slotted(div::before) { display: block; }

PASS cssText is ""

Rule .foo::slotted(div) { color: blue; }

PASS cssText is ".foo::slotted(div) { color: blue; }"

Rule #id::slotted(*) { color: blue; }

PASS cssText is "#id::slotted(*) { color: blue; }"

Rule [attr=foo]::slotted(*) { color: blue; }

PASS cssText is "[attr=\"foo\"]::slotted(*) { color: blue; }"

Rule .foo .bar::slotted(div) { color: blue; }

PASS cssText is ".foo .bar::slotted(div) { color: blue; }"

Rule .foo::before .bar::slotted(div) { color: blue; }

FAIL cssText should be . Was .foo::before .bar::slotted(div) { color: blue; }.

Rule .foo::slotted(div) .bar { color: blue; }

FAIL cssText should be . Was .foo::slotted(div) .bar { color: blue; }.

Rule ::slotted(div, div) { color: blue; }

PASS cssText is ""

Rule ::slotted(div div) { color: blue; }

PASS cssText is ""

Rule slot::slotted(.green) { color: green; }

PASS cssText is "slot::slotted(.green) { color: green; }"

Rule slot::slotted(#green) { color: green; }

PASS cssText is "slot::slotted(#green) { color: green; }"

Rule slot::slotted([green=green]) { color: green; }

PASS cssText is "slot::slotted([green=\"green\"]) { color: green; }"

Rule slot::slotted(div.green) { color: green; }

PASS cssText is "slot::slotted(div.green) { color: green; }"

Rule div ::slotted(div) { color: red; }

PASS cssText is "div ::slotted(div) { color: red; }"

Rule div + slot::slotted(div) { color: red; }

PASS cssText is "div + slot::slotted(div) { color: red; }"

Rule span::slotted(*) { color: red; }

PASS cssText is "span::slotted(*) { color: red; }"

Rule ::slotted(span)::slotted(span) { color: red; }

FAIL cssText should be . Was ::slotted(span)::slotted(span) { color: red; }.

Rule ::slotted(::slotted(div)) { color: red; }

PASS cssText is ""

PASS successfullyParsed is true

TEST COMPLETE

0

LayoutTests/fast/shadow-dom/slotted-pseudo-element-css-text.html

<!DOCTYPE html>

<script src='../../resources/js-test-pre.js'></script>

<script>

description("Test for cssText of '::slotted' rule.");

var rules = [

"::slotted { display: block; }", /* invalid - no parameter */

"::slotted() { display: block; }", /* invalid - empty parameter */

"::slotted(*) { display: block; }",

"*::slotted(*) { display: block; }",

"::slotted(div) { display: block; }", /* expects universal selector (*) on the left in cssText */

"::slotted( div) { display: block; }", /* allow a space on left */

"::slotted(div ) { display: block; }", /* allow a space on right */

"::slotted(div::before) { display: block; }", /* having a pseudo element in () is invalid */

".foo::slotted(div) { color: blue; }",

"#id::slotted(*) { color: blue; }",

"[attr=foo]::slotted(*) { color: blue; }",

".foo .bar::slotted(div) { color: blue; }",

".foo::before .bar::slotted(div) { color: blue; }", /* invalid, only one pseudo element is allowed at the rightmost compound */

".foo::slotted(div) .bar { color: blue; }", /* invalid, same as above */

"::slotted(div, div) { color: blue; }", /* invalid - selector list */

"::slotted(div div) { color: blue; }", /* invalid - complex selector (combinator is used) */

"slot::slotted(.green) { color: green; }",

"slot::slotted(#green) { color: green; }",

"slot::slotted([green=green]) { color: green; }",

"slot::slotted(div.green) { color: green; }",

"div ::slotted(div) { color: red; }",

"div + slot::slotted(div) { color: red; }",

"span::slotted(*) { color: red; }", /* never matches, but valid as a selector */

"::slotted(span)::slotted(span) { color: red; }", /* invalid */

"::slotted(::slotted(div)) { color: red; }" /* invalid */

];

var expectedCSSTexts = [

"", 

"",

"::slotted(*) { display: block; }",

"*::slotted(*) { display: block; }",

"::slotted(div) { display: block; }",

"::slotted(div) { display: block; }", 

"::slotted(div) { display: block; }",

"",

".foo::slotted(div) { color: blue; }",

"#id::slotted(*) { color: blue; }",

"[attr=\"foo\"]::slotted(*) { color: blue; }",

".foo .bar::slotted(div) { color: blue; }",

"",

"",

"",

"",

"slot::slotted(.green) { color: green; }",

"slot::slotted(#green) { color: green; }",

"slot::slotted([green=\"green\"]) { color: green; }",

"slot::slotted(div.green) { color: green; }",

"div ::slotted(div) { color: red; }",

"div + slot::slotted(div) { color: red; }",

"span::slotted(*) { color: red; }",

"",

"",

];

function ruleCSSText(rule)

{

    var style = document.createElement("style");

    style.innerText = rule;

    document.head.appendChild(style);

    if (style.sheet.cssRules.length == 0)

        return "";

    return style.sheet.cssRules.item(0).cssText;

}

for (var i = 0; i < rules.length; ++i) {

    debug("Rule " + rules[i]);

    cssText = ruleCSSText(rules[i]);

    expectedCSSText = expectedCSSTexts[i]

    shouldBeEqualToString("cssText", expectedCSSText);

}

</script>

<script src='../../resources/js-test-post.js'></script>

0

LayoutTests/platform/mac/TestExpectations

@@webkit.org/b/149128 fast/text/control-ch

webkit.org/b/148695 fast/shadow-dom [ Pass ]

webkit.org/b/149440 fast/shadow-dom/css-scoping-shadow-host-functional-rule.html [ ImageOnlyFailure ]

1253 webkit.org/b/149441 fast/shadow-dom/css-scoping-shadow-slotted-rule.html [ ImageOnlyFailure ]

webkit.org/b/149441 fast/shadow-dom/css-scoping-shadow-slot-display-override.html [ ImageOnlyFailure ]

# Touch events is not enabled on Mac

197027