ChangeLog

2011-06-07  Roland Steiner  <rolandsteiner@chromium.org>

        Reviewed by NOBODY (OOPS!).

        Bug 49142 - Implement HTML5 style scoped attribute

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

        Add a new map to RuleSet that contains rules from <style scoped> elements.

        Add plumbing to register and unregister <style scoped> elements from their parents.

        Extend rule matching for scoped style rules. 

        No new tests. (OOPS!)

        * WebCore.xcodeproj/project.pbxproj:

        * css/CSSStyleSelector.cpp:

        (WebCore::RuleSet::getIDRules):

        (WebCore::RuleSet::getClassRules):

        (WebCore::RuleSet::getTagRules):

        (WebCore::RuleSet::getPseudoRules):

        (WebCore::RuleSet::getUniversalRules):

        (WebCore::RuleSet::getPageRules):

        (WebCore::RuleSet::scopedRules):

        (WebCore::CSSStyleSelector::pushParentStackFrame):

        (WebCore::CSSStyleSelector::matchRules):

        (WebCore::CSSStyleSelector::fastStyleSheetScopeIsAnAncestor):

        (WebCore::CSSStyleSelector::slowStyleSheetScopeIsAnAncestor):

        (WebCore::matchesInTreeScope):

        (WebCore::CSSStyleSelector::matchRulesForList):

        (WebCore::RuleData::RuleData):

        (WebCore::RuleSet::addToRuleSet):

        (WebCore::RuleSet::addRule):

        (WebCore::RuleSet::determineRulesScope):

        (WebCore::RuleSet::addRulesFromSheet):

        (WebCore::RuleSet::addStyleRule):

        (WebCore::collectFeaturesFromList):

        (WebCore::RuleSet::collectFeatures):

        (WebCore::CSSStyleSelector::matchPageRulesForList):

        * css/CSSStyleSelector.h:

        (WebCore::CSSStyleSelector::ParentStackFrame::ParentStackFrame):

        * css/CSSStyleSheet.cpp:

        (WebCore::CSSStyleSheet::findOwnerNode):

        (WebCore::CSSStyleSheet::document):

        * css/CSSStyleSheet.h:

        * dom/ContainerNode.h:

        (WebCore::ContainerNode::registerScopedHTMLStyleChild):

        (WebCore::ContainerNode::unregisterScopedHTMLStyleChild):

        (WebCore::ContainerNode::hasScopedHTMLStyleChild):

        * dom/Element.cpp:

        (WebCore::Element::registerScopedHTMLStyleChild):

        (WebCore::Element::unregisterScopedHTMLStyleChild):

        (WebCore::Element::hasScopedHTMLStyleChild):

        * dom/Element.h:

        * dom/ElementRareData.h:

        (WebCore::ElementRareData::ElementRareData):

        (WebCore::ElementRareData::registerScopedHTMLStyleChild):

        (WebCore::ElementRareData::unregisterScopedHTMLStyleChild):

        (WebCore::ElementRareData::hasScopedHTMLStyleChild):

        * dom/ShadowRoot.h:

        (WebCore::ShadowRoot::registerScopedHTMLStyleChild):

        (WebCore::ShadowRoot::unregisterScopedHTMLStyleChild):

        (WebCore::ShadowRoot::hasScopedHTMLStyleChild):

        * html/HTMLAttributeNames.in:

        * html/HTMLStyleElement.cpp:

        (WebCore::HTMLStyleElement::insertedIntoDocument):

        (WebCore::HTMLStyleElement::willRemove):

        (WebCore::HTMLStyleElement::scoped):

        * html/HTMLStyleElement.h:

2011-06-07  MORITA Hajime  <morrita@google.com>

        Unreviewed, rolling out r88212 and r88219.

Source/WebCore/css/CSSStyleSelector.cpp

#include "HTMLDocument.h"

#include "HTMLElement.h"

#include "HTMLFrameElementBase.h"

66#include "HTMLHeadElement.h"

6667#include "HTMLInputElement.h"

6768#include "HTMLNames.h"

69#include "HTMLStyleElement.h"

#include "HTMLTextAreaElement.h"

#include "KeyframeList.h"

#include "LinkHash.h"

@@if (id == propID) { \

    return; \

}

291typedef CSSStyleSelector::StyleSheetScope StyleSheetScope;

292

289293class RuleData {

290294public:

291 RuleData(CSSStyleRule*, CSSSelector*, unsigned position);

295 RuleData(CSSStyleRule*, CSSSelector*, unsigned position, StyleSheetScope);

    unsigned position() const { return m_position; }

    CSSStyleRule* rule() const { return m_rule; }

@@private:

    unsigned m_descendantSelectorIdentifierHashes[maximumIdentifierCount];

};

325typedef Vector<RuleData> RulesVector;

326

class RuleSet {

    WTF_MAKE_NONCOPYABLE(RuleSet);

public:

    RuleSet();

    ~RuleSet();

    
    typedef HashMap<AtomicStringImpl*, Vector<RuleData>*> AtomRuleMap;

    void addRulesFromSheet(CSSStyleSheet*, const MediaQueryEvaluator&, CSSStyleSelector* = 0);

330332

    void addStyleRule(CSSStyleRule* item);

    void addRule(CSSStyleRule* rule, CSSSelector* sel);

    void addPageRule(CSSStyleRule* rule, CSSSelector* sel);

    typedef HashMap<AtomicStringImpl*, RulesVector*> AtomRuleMap;

    typedef HashMap<StyleSheetScope, RulesVector*> ScopedRuleMap;

    StyleSheetScope determineRulesScope(CSSStyleSheet*) const;

    void addRulesFromSheet(CSSStyleSheet*, const MediaQueryEvaluator&, CSSStyleSelector* = 0, StyleSheetScope = 0);

    void addStyleRule(CSSStyleRule*, StyleSheetScope);

    void addRule(CSSStyleRule*, CSSSelector*, StyleSheetScope);

    void addPageRule(CSSStyleRule*, CSSSelector*);

    void addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,

                      CSSStyleRule* rule, CSSSelector* sel);

    void shrinkToFit();

@@public:

    void collectFeatures(CSSStyleSelector::Features&) const;

    

    const Vector<RuleData>* getIDRules(AtomicStringImpl* key) const { return m_idRules.get(key); }

    const Vector<RuleData>* getClassRules(AtomicStringImpl* key) const { return m_classRules.get(key); }

    const Vector<RuleData>* getTagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }

    const Vector<RuleData>* getPseudoRules(AtomicStringImpl* key) const { return m_pseudoRules.get(key); }

    const Vector<RuleData>* getUniversalRules() const { return &m_universalRules; }

    const Vector<RuleData>* getPageRules() const { return &m_pageRules; }

    const RulesVector* getIDRules(AtomicStringImpl* key) const { return m_idRules.get(key); }

    const RulesVector* getClassRules(AtomicStringImpl* key) const { return m_classRules.get(key); }

    const RulesVector* getTagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }

    const RulesVector* getPseudoRules(AtomicStringImpl* key) const { return m_pseudoRules.get(key); }

    const RulesVector* getUniversalRules() const { return &m_universalRules; }

    const RulesVector* getPageRules() const { return &m_pageRules; }

    const ScopedRuleMap& scopedRules() const { return m_scopedRules; }

    
public:

    AtomRuleMap m_idRules;

    AtomRuleMap m_classRules;

    AtomRuleMap m_tagRules;

    AtomRuleMap m_pseudoRules;

353 Vector<RuleData> m_universalRules;

354 Vector<RuleData> m_pageRules;

    RulesVector m_universalRules;

    RulesVector m_pageRules;

    ScopedRuleMap m_scopedRules;

    unsigned m_ruleCount;

    bool m_autoShrinkToFitEnabled;

};

@@void CSSStyleSelector::pushParentStackFrame(Element* parent)

    size_t count = parentFrame.identifierHashes.size();

    for (size_t i = 0; i < count; ++i)

        m_ancestorIdentifierFilter->add(parentFrame.identifierHashes[i]);

    // Point to frame containing the closest style scope (or leave at 0 if none).

    if (parent->hasScopedHTMLStyleChild())

        parentFrame.closestStyleScopeFrame = &parentFrame;

    else if (m_parentStack.size() >= 2)

        parentFrame.closestStyleScopeFrame = m_parentStack[m_parentStack.size() - 2].closestStyleScopeFrame;

}

void CSSStyleSelector::popParentStackFrame()

@@void CSSStyleSelector::matchRules(RuleSet* rules, int& firstRuleIndex, int& last

    }

    matchRulesForList(rules->getTagRules(m_element->localName().impl()), firstRuleIndex, lastRuleIndex, includeEmptyRules);

    matchRulesForList(rules->getUniversalRules(), firstRuleIndex, lastRuleIndex, includeEmptyRules);

721

    // Add applicable scoped rules.

    bool canUseFastScoping = !m_parentStack.isEmpty() && m_parentStack.last().element == m_parentNode;

    if (canUseFastScoping) {

        for (RuleSet::ScopedRuleMap::const_iterator it = rules->scopedRules().begin(), itEnd = rules->scopedRules().end(); it != itEnd; ++it) {

            ASSERT(it->first);

            ASSERT(it->first->hasScopedHTMLStyleChild());

            if (it->first == m_element || fastStyleSheetScopeIsAnAncestor(it->first))

                matchRulesForList(it->second, firstRuleIndex, lastRuleIndex, includeEmptyRules, it->first);

        }

    } else {

        for (RuleSet::ScopedRuleMap::const_iterator it = rules->scopedRules().begin(), itEnd = rules->scopedRules().end(); it != itEnd; ++it) {

            ASSERT(it->first);

            ASSERT(it->first->hasScopedHTMLStyleChild());

            if (slowStyleSheetScopeIsAnAncestor(it->first))

                matchRulesForList(it->second, firstRuleIndex, lastRuleIndex, includeEmptyRules, it->first);

        }

    }

    // If we didn't match any rules, we're done.

    if (m_matchedRules.isEmpty())

        return;

@@void CSSStyleSelector::matchRules(RuleSet* rules, int& firstRuleIndex, int& last

    }

}

bool CSSStyleSelector::fastStyleSheetScopeIsAnAncestor(StyleSheetScope scope) const

{

    ASSERT(!m_parentStack.isEmpty());    

    ParentStackFrame* closestScopeFrame = m_parentStack.last().closestStyleScopeFrame;

    while (closestScopeFrame) {

        if (closestScopeFrame->element == scope)

            return true;

        if (closestScopeFrame == &m_parentStack.first())

            return false;

        --closestScopeFrame;

        closestScopeFrame = closestScopeFrame->closestStyleScopeFrame;

    }

    return false;

}

bool CSSStyleSelector::slowStyleSheetScopeIsAnAncestor(StyleSheetScope scope) const

{

    for (const ContainerNode* node = m_element; node; node = node->parentOrHostNode()) {

        if (scope == node)

            return true;

    }

    return false;

}

inline bool CSSStyleSelector::fastRejectSelector(const RuleData& ruleData) const

{

    ASSERT(m_ancestorIdentifierFilter);

@@inline bool MatchingUARulesScope::isMatchingUARules()

bool MatchingUARulesScope::m_matchingUARules = false;

782 inline static bool matchesInTreeScope(TreeScope* treeScope, bool ruleReachesIntoShadowDOM)

839inline static bool matchesInTreeScope(TreeScope* treeScope, StyleSheetScope styleScope, bool ruleReachesIntoShadowDOM)

783840{

784 return MatchingUARulesScope::isMatchingUARules() || treeScope->applyAuthorSheets() || ruleReachesIntoShadowDOM;

    return MatchingUARulesScope::isMatchingUARules()

        || treeScope->applyAuthorSheets()

        || (styleScope && styleScope->treeScope() == treeScope)

        || ruleReachesIntoShadowDOM;

785845}

786846

787 void CSSStyleSelector::matchRulesForList(const Vector~~<RuleData>~~* rules, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules)

847void CSSStyleSelector::matchRulesForList(const RulesVector* rules, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules, StyleSheetScope styleScope)

{

    if (!rules)

        return;

@@void CSSStyleSelector::matchRulesForList(const Vector<RuleData>* rules, int& fir

        if (canUseFastReject && fastRejectSelector(ruleData))

            continue;

        if (checkSelector(ruleData)) {

801 if (!matchesInTreeScope(m_element->treeScope(), m_checker.m_hasUnknownPseudoElements))

861 if (!matchesInTreeScope(m_element->treeScope(), styleScope, m_checker.m_hasUnknownPseudoElements))

                continue;

            // If the rule has no properties to apply, then ignore it in the non-debug mode.

            CSSStyleRule* rule = ruleData.rule();

@@static inline bool isSelectorMatchingHTMLBasedOnRuleHash(const CSSSelector* sele

    return selector->tag() == starAtom;

}

3052 RuleData::RuleData(CSSStyleRule* rule, CSSSelector* selector, unsigned position)

3112RuleData::RuleData(CSSStyleRule* rule, CSSSelector* selector, unsigned position, StyleSheetScope scope = 0)

    : m_rule(rule)

    , m_selector(selector)

    , m_specificity(selector->specificity())

    , m_position(position)

    , m_hasFastCheckableSelector(isFastCheckableSelector(selector))

    , m_hasMultipartSelector(selector->tagHistory())

3059 , m_hasTopSelectorMatchingHTMLBasedOnRuleHash(isSelectorMatchingHTMLBasedOnRuleHash(selector))

3119 , m_hasTopSelectorMatchingHTMLBasedOnRuleHash(!scope && isSelectorMatchingHTMLBasedOnRuleHash(selector))

{

    collectDescendantSelectorIdentifierHashes();

}

@@void RuleSet::addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,

                              CSSStyleRule* rule, CSSSelector* sel)

{

    if (!key) return;

3126 Vector~~<RuleData>~~* rules = map.get(key);

3186 RulesVector* rules = map.get(key);

31273187 if (!rules) {

3128 rules = new Vector~~<RuleData>~~;

3188 rules = new RulesVector;

        map.set(key, rules);

    }

    rules->append(RuleData(rule, sel, m_ruleCount++));

}

3134 void RuleSet::addRule(CSSStyleRule* rule, CSSSelector* sel)

3194void RuleSet::addRule(CSSStyleRule* rule, CSSSelector* sel, StyleSheetScope scope)

31353195{

    if (scope) {

        RulesVector* rules = m_scopedRules.get(scope);

        if (!rules) {

            rules = new RulesVector;

            m_scopedRules.set(scope, rules);

        }

        rules->append(RuleData(rule, sel, m_ruleCount++, scope));

        return;

    }

    if (sel->m_match == CSSSelector::Id) {

        addToRuleSet(sel->value().impl(), m_idRules, rule, sel);

        return;

@@void RuleSet::addPageRule(CSSStyleRule* rule, CSSSelector* sel)

    m_pageRules.append(RuleData(rule, sel, m_pageRules.size()));

}

3164 void RuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator& medium, CSSStyleSelector* styleSelector)

StyleSheetScope RuleSet::determineRulesScope(CSSStyleSheet* sheet) const

{

    if (!sheet)

        return 0;

    Node* ownerNode = sheet->findOwnerNode();

    if (!ownerNode || !ownerNode->isHTMLElement() || !ownerNode->hasTagName(HTMLNames::styleTag))

        return 0;

    HTMLStyleElement* styleElement = static_cast<HTMLStyleElement*>(ownerNode);

    if (!styleElement->scoped())

        return 0;

    Document* document = styleElement->document();

    if (!document)

        return 0;

    // Ignore 'scoped' attribute for <style scoped> elements within <head>.

    HTMLHeadElement* head = document->head();

    if (head && head->contains(styleElement))

        return 0;

    StyleSheetScope scope = styleElement->parentNode();

    return scope;

}

void RuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator& medium, CSSStyleSelector* styleSelector, StyleSheetScope scope)

{

    if (!sheet)

        return;

@@void RuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator&

    for (int i = 0; i < len; i++) {

        StyleBase* item = sheet->item(i);

        if (item->isStyleRule())

3179 addStyleRule(static_cast<CSSStyleRule*>(item));

3275 addStyleRule(static_cast<CSSStyleRule*>(item), scope);

        else if (item->isImportRule()) {

            CSSImportRule* import = static_cast<CSSImportRule*>(item);

            if (!import->media() || medium.eval(import->media(), styleSelector))

@@void RuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator&

                    CSSRule *childItem = rules->item(j);

                    if (childItem->isStyleRule()) {

                        // It is a StyleRule, so append it to our list

3195 addStyleRule(static_cast<CSSStyleRule*>(childItem));

3291 addStyleRule(static_cast<CSSStyleRule*>(childItem), scope);

                    } else if (childItem->isFontFaceRule() && styleSelector) {

                        // Add this font face to our set.

                        const CSSFontFaceRule* fontFaceRule = static_cast<CSSFontFaceRule*>(childItem);

@@void RuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator&

        shrinkToFit();

}

3217 void RuleSet::addStyleRule(CSSStyleRule* rule)

3313void RuleSet::addStyleRule(CSSStyleRule* rule, StyleSheetScope scope)

32183314{

32193315 if (rule->isPageRule()) {

        // Ignore @page rules if the style sheet is scoped

        if (scope)

            return;

        CSSPageRule* pageRule = static_cast<CSSPageRule*>(rule);

        addPageRule(pageRule, pageRule->selectorList().first());

    } else {

        for (CSSSelector* s = rule->selectorList().first(); s; s = CSSSelectorList::next(s))

3224 addRule(rule, s);

3323 addRule(rule, s, scope);

    }

}

@@static inline void collectFeaturesFromSelector(CSSStyleSelector::Features& featu

    }

}

3264 static void collectFeaturesFromList(CSSStyleSelector::Features& features, const Vector~~<RuleData>~~& rules)

3363static void collectFeaturesFromList(CSSStyleSelector::Features& features, const RulesVector& rules, StyleSheetScope scope = 0)

{

    unsigned size = rules.size();

    for (unsigned i = 0; i < size; ++i) {

@@static void collectFeaturesFromList(CSSStyleSelector::Features& features, const

        if (foundSiblingSelector) {

            if (!features.siblingRules)

                features.siblingRules = adoptPtr(new RuleSet);

3285 features.siblingRules->addRule(ruleData.rule(), ruleData.selector());

3384 features.siblingRules->addRule(ruleData.rule(), ruleData.selector(), scope);

        }

    }

}

void RuleSet::collectFeatures(CSSStyleSelector::Features& features) const

{

3391 for (ScopedRuleMap::const_iterator it = m_scopedRules.begin(), itEnd = m_scopedRules.end(); it != itEnd; ++it)

3392 collectFeaturesFromList(features, *it->second, it->first);

    AtomRuleMap::const_iterator end = m_idRules.end();

    for (AtomRuleMap::const_iterator it = m_idRules.begin(); it != end; ++it)

        collectFeaturesFromList(features, *it->second);

@@void CSSStyleSelector::matchPageRules(RuleSet* rules, bool isLeftPage, bool isFi

        addMatchedDeclaration(m_matchedRules[i]->rule()->declaration());

}

3425 void CSSStyleSelector::matchPageRulesForList(const Vector~~<RuleData>~~* rules, bool isLeftPage, bool isFirstPage, const String& pageName)

3526void CSSStyleSelector::matchPageRulesForList(const RulesVector* rules, bool isLeftPage, bool isFirstPage, const String& pageName)

{

    if (!rules)

        return;

Source/WebCore/css/CSSStyleSelector.h

@@public:

        friend class CSSStyleApplyProperty;

        WTF_MAKE_NONCOPYABLE(CSSStyleSelector); WTF_MAKE_FAST_ALLOCATED;

    public:

90 typedef const ContainerNode* StyleSheetScope;

        CSSStyleSelector(Document*, StyleSheetList* authorSheets, CSSStyleSheet* mappedElementSheet,

                         CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,

                         bool strictParsing, bool matchAuthorAndUserStyles);

@@public:

        void addMatchedDeclaration(CSSMutableStyleDeclaration* decl);

        void matchRules(RuleSet*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);

218 void matchRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);

220 void matchRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules, StyleSheetScope styleScope = 0);

219221 bool fastRejectSelector(const RuleData&) const;

222 bool fastStyleSheetScopeIsAnAncestor(StyleSheetScope) const;

223 bool slowStyleSheetScopeIsAnAncestor(StyleSheetScope) const;

        void sortMatchedRules();

        bool checkSelector(const RuleData&);

@@public:

        struct ParentStackFrame {

            ParentStackFrame() {}

241 ParentStackFrame(Element* element) : element(element) {}

245 ParentStackFrame(Element* element) : element(element), closestStyleScopeFrame(0) { }

242246 Element* element;

243247 Vector<unsigned, 4> identifierHashes;

248 ParentStackFrame* closestStyleScopeFrame;

249

        };

        Vector<ParentStackFrame> m_parentStack;

Source/WebCore/css/CSSStyleSheet.cpp

@@void CSSStyleSheet::startLoadingDynamicSheet()

        owner->startLoadingDynamicSheet();

}

239 D~~ocument~~* CSSStyleSheet::d~~ocument~~()

239Node* CSSStyleSheet::findOwnerNode() const

240240{

241 StyleBase* styleObject = this;

242 while (styleObject) {

241 for (const StyleBase* styleObject = this; styleObject; styleObject = styleObject->parent()) {

243242 if (styleObject->isCSSStyleSheet()) {

244 Node* ownerNode = static_cast<CSSStyleSheet*>(styleObject)->ownerNode();

243 Node* ownerNode = static_cast<const CSSStyleSheet*>(styleObject)->ownerNode();

245244 if (ownerNode)

246 return ownerNode~~->document()~~;

245 return ownerNode;

247246 }

        if (styleObject->isRule())

            styleObject = static_cast<CSSRule*>(styleObject)->parentStyleSheet();

        else

            styleObject = styleObject->parent();

252247 }

253

    return 0;

}

Document* CSSStyleSheet::document()

{

    Node* ownerNode = findOwnerNode();

    return ownerNode ? ownerNode->document() : 0;

}

void CSSStyleSheet::styleSheetChanged()

{

    StyleBase* root = this;

Source/WebCore/css/CSSStyleSheet.h

@@public:

    virtual void checkLoaded();

    void startLoadingDynamicSheet();

91 Node* findOwnerNode() const;

    Document* document();

    const String& charset() const { return m_charset; }

Source/WebCore/dom/ContainerNode.h

@@public:

    void takeAllChildrenFrom(ContainerNode*);

    void cloneChildNodes(ContainerNode* clone);

    // This is virtual on ContainerNode with a default no-op implementation for convenience.

    // If we should convert ShadowRoot to become a regular element, we can move these methods

    // to Element and make them non-virtual.

    virtual void registerScopedHTMLStyleChild() { }

    virtual void unregisterScopedHTMLStyleChild() { }

    virtual bool hasScopedHTMLStyleChild() const { return false; }

    bool dispatchBeforeLoadEvent(const String& sourceURL);

    static void queuePostAttachCallback(NodeCallback, Node*);

Source/WebCore/dom/Element.cpp

@@void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* af

        checkForSiblingStyleChanges(this, renderStyle(), false, beforeChange, afterChange, childCountDelta);

}

void Element::registerScopedHTMLStyleChild()

{

    ensureRareData()->registerScopedHTMLStyleChild();

}

void Element::unregisterScopedHTMLStyleChild()

{

    ASSERT(hasRareData());

    if (hasRareData())

        rareData()->unregisterScopedHTMLStyleChild();

}

bool Element::hasScopedHTMLStyleChild() const

{

    return hasRareData() && rareData()->hasScopedHTMLStyleChild();

}

void Element::beginParsingChildren()

{

    clearIsParsingChildrenFinished();

Source/WebCore/dom/Element.h

@@public:

    virtual const AtomicString& shadowPseudoId() const;

    virtual void registerScopedHTMLStyleChild();

    virtual void unregisterScopedHTMLStyleChild();

    virtual bool hasScopedHTMLStyleChild() const;

    RenderStyle* computedStyle(PseudoId = NOPSEUDO);

    AtomicString computeInheritedLanguage() const;

Source/WebCore/dom/ElementRareData.h

@@public:

    void resetComputedStyle();

    void registerScopedHTMLStyleChild();

    void unregisterScopedHTMLStyleChild();

    bool hasScopedHTMLStyleChild() const;

    using NodeRareData::needsFocusAppearanceUpdateSoonAfterAttach;

    using NodeRareData::setNeedsFocusAppearanceUpdateSoonAfterAttach;

@@public:

    OwnPtr<DatasetDOMStringMap> m_datasetDOMStringMap;

    OwnPtr<ClassList> m_classList;

56 unsigned m_numberOfScopedHTMLStyleChildren;

#if ENABLE(FULLSCREEN_API)

    bool m_containsFullScreenElement;

#endif

@@inline IntSize defaultMinimumSizeForResizing()

inline ElementRareData::ElementRareData()

    : m_minimumSizeForResizing(defaultMinimumSizeForResizing())

    , m_shadowRoot(0)

71 , m_numberOfScopedHTMLStyleChildren(0)

#if ENABLE(FULLSCREEN_API)

    , m_containsFullScreenElement(false)

#endif

@@inline void ElementRareData::resetComputedStyle()

    m_computedStyle.clear();

}

inline void ElementRareData::registerScopedHTMLStyleChild()

{

    ++m_numberOfScopedHTMLStyleChildren;

}

inline void ElementRareData::unregisterScopedHTMLStyleChild()

{

    ASSERT(m_numberOfScopedHTMLStyleChildren > 0);

    --m_numberOfScopedHTMLStyleChildren;

}

inline bool ElementRareData::hasScopedHTMLStyleChild() const

{

    return m_numberOfScopedHTMLStyleChildren;

}

81104}

82105#endif // ElementRareData_h

Source/WebCore/dom/ShadowRoot.h

@@public:

    ContainerNode* activeContentContainer();

    void hostChildrenChanged();

    virtual void registerScopedHTMLStyleChild();

    virtual void unregisterScopedHTMLStyleChild();

    virtual bool hasScopedHTMLStyleChild() const;

private:

    ShadowRoot(Document*);

    virtual ~ShadowRoot();

@@private:

    virtual void attach();

    bool hasContentElement() const;

64 unsigned m_numberOfScopedHTMLStyleChildren;

};

inline PassRefPtr<ShadowRoot> ShadowRoot::create(Document* document)

@@inline PassRefPtr<ShadowRoot> ShadowRoot::create(Document* document)

    return adoptRef(new ShadowRoot(document));

}

inline void ShadowRoot::registerScopedHTMLStyleChild()

{

    ++m_numberOfScopedHTMLStyleChildren;

}

inline void ShadowRoot::unregisterScopedHTMLStyleChild()

{

    ASSERT(m_numberOfScopedHTMLStyleChildren > 0);

    --m_numberOfScopedHTMLStyleChildren;

}

inline bool ShadowRoot::hasScopedHTMLStyleChild() const

{

    return m_numberOfScopedHTMLStyleChildren;

}

} // namespace

#endif

Source/WebCore/html/HTMLAttributeNames.in

@@rules

sandbox

scheme

scope

268scoped

scrollamount

scrolldelay

scrolling

Source/WebCore/html/HTMLStyleElement.cpp

@@void HTMLStyleElement::insertedIntoDocument()

{

    HTMLElement::insertedIntoDocument();

    StyleElement::insertedIntoDocument(document(), this);

    if (scoped()) {

        ContainerNode* parent = parentNode();

        if (parent)

            parent->registerScopedHTMLStyleChild();

    }

}

void HTMLStyleElement::willRemove()

{

    if (scoped()) {

        ContainerNode* parent = parentNode();

        if (parent)

            parent->unregisterScopedHTMLStyleChild();

    }

}

void HTMLStyleElement::removedFromDocument()

@@void HTMLStyleElement::setDisabled(bool setDisabled)

        styleSheet->setDisabled(setDisabled);

}

bool HTMLStyleElement::scoped() const

{

    return fastHasAttribute(scopedAttr);

}

123142}

Source/WebCore/html/HTMLStyleElement.h

@@public:

    bool disabled() const;

    void setDisabled(bool);

45 bool scoped() const;

private:

    HTMLStyleElement(const QualifiedName&, Document*, bool createdByParser);

    // overload from HTMLElement

    virtual void parseMappedAttribute(Attribute*);

    virtual void insertedIntoDocument();

53 virtual void willRemove();

    virtual void removedFromDocument();

    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);