css/ElementRuleCollector.cpp

    css/PageRuleCollector.cpp

	Source/WebCore/css/ElementRuleCollector.cpp \

	Source/WebCore/css/ElementRuleCollector.h \

	Source/WebCore/css/PageRuleCollector.cpp \

	Source/WebCore/css/PageRuleCollector.h \

    css/ElementRuleCollector.cpp \

    css/PageRuleCollector.cpp \

            'css/ElementRuleCollector.cpp',

            'css/ElementRuleCollector.h',

            'css/PageRuleCollector.cpp',

            'css/PageRuleCollector.h',

		FBDB619B16D6032A00BB3394 /* ElementRuleCollector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FBDB619A16D6032A00BB3394 /* ElementRuleCollector.cpp */; };

		FBDB619D16D6034600BB3394 /* PageRuleCollector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FBDB619C16D6034600BB3394 /* PageRuleCollector.cpp */; };

		FBDB619F16D6036500BB3394 /* ElementRuleCollector.h in Headers */ = {isa = PBXBuildFile; fileRef = FBDB619E16D6036500BB3394 /* ElementRuleCollector.h */; };

		FBDB61A116D6037E00BB3394 /* PageRuleCollector.h in Headers */ = {isa = PBXBuildFile; fileRef = FBDB61A016D6037E00BB3394 /* PageRuleCollector.h */; };

		FBDB619A16D6032A00BB3394 /* ElementRuleCollector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ElementRuleCollector.cpp; sourceTree = "<group>"; };

		FBDB619C16D6034600BB3394 /* PageRuleCollector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PageRuleCollector.cpp; sourceTree = "<group>"; };

		FBDB619E16D6036500BB3394 /* ElementRuleCollector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ElementRuleCollector.h; sourceTree = "<group>"; };

		FBDB61A016D6037E00BB3394 /* PageRuleCollector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageRuleCollector.h; sourceTree = "<group>"; };

				FBDB619E16D6036500BB3394 /* ElementRuleCollector.h */,

				FBDB619A16D6032A00BB3394 /* ElementRuleCollector.cpp */,

				FBDB61A016D6037E00BB3394 /* PageRuleCollector.h */,

				FBDB619C16D6034600BB3394 /* PageRuleCollector.cpp */,

				FBDB619F16D6036500BB3394 /* ElementRuleCollector.h in Headers */,

				FBDB61A116D6037E00BB3394 /* PageRuleCollector.h in Headers */,

				FBDB619B16D6032A00BB3394 /* ElementRuleCollector.cpp in Sources */,

				FBDB619D16D6034600BB3394 /* PageRuleCollector.cpp in Sources */,

#include "ElementRuleCollector.cpp"

#include "PageRuleCollector.cpp"

    bool isEmpty() const { return m_shadowDistributedRuleSetMap.isEmpty(); }

/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)

 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.

 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>

 * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.

 * Copyright (C) Research In Motion Limited 2011. All rights reserved.

 * Copyright (C) 2012 Google Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "ElementRuleCollector.h"

#include "CSSDefaultStyleSheets.h"

#include "CSSRule.h"

#include "CSSRuleList.h"

#include "CSSSelector.h"

#include "CSSSelectorList.h"

#include "CSSValueKeywords.h"

#include "HTMLElement.h"

#include "RenderRegion.h"

#include "SVGElement.h"

#include "SelectorCheckerFastPath.h"

#include "SiblingTraversalStrategies.h"

#include "StylePropertySet.h"

#include "StyledElement.h"

#include <wtf/TemporaryChange.h>

namespace WebCore {

static StylePropertySet* leftToRightDeclaration()

{

    DEFINE_STATIC_LOCAL(RefPtr<StylePropertySet>, leftToRightDecl, (StylePropertySet::create()));

    if (leftToRightDecl->isEmpty())

        leftToRightDecl->setProperty(CSSPropertyDirection, CSSValueLtr);

    return leftToRightDecl.get();

}

static StylePropertySet* rightToLeftDeclaration()

{

    DEFINE_STATIC_LOCAL(RefPtr<StylePropertySet>, rightToLeftDecl, (StylePropertySet::create()));

    if (rightToLeftDecl->isEmpty())

        rightToLeftDecl->setProperty(CSSPropertyDirection, CSSValueRtl);

    return rightToLeftDecl.get();

}

StyleResolver::MatchResult& ElementRuleCollector::matchedResult()

{

    ASSERT(m_mode == SelectorChecker::ResolvingStyle);

    return m_result;

}

PassRefPtr<CSSRuleList> ElementRuleCollector::matchedRuleList()

{

    ASSERT(m_mode == SelectorChecker::CollectingRules);

    return m_ruleList.release();

}

inline void ElementRuleCollector::addMatchedRule(const RuleData* rule)

{

    if (!m_matchedRules)

        m_matchedRules = adoptPtr(new Vector<const RuleData*, 32>);

    m_matchedRules->append(rule);

}

inline void ElementRuleCollector::clearMatchedRules()

{

    if (!m_matchedRules)

        return;

    m_matchedRules->clear();

}

inline StaticCSSRuleList* ElementRuleCollector::ensureRuleList()

{

    if (!m_ruleList)

        m_ruleList = StaticCSSRuleList::create();

    return m_ruleList.get();

}

inline void ElementRuleCollector::addElementStyleProperties(const StylePropertySet* propertySet, bool isCacheable)

{

    if (!propertySet)

        return;

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

    if (m_result.ranges.firstAuthorRule == -1)

        m_result.ranges.firstAuthorRule = m_result.ranges.lastAuthorRule;

    m_result.addMatchedProperties(propertySet);

    if (!isCacheable)

        m_result.isCacheable = false;

}

void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)

{

    ASSERT(matchRequest.ruleSet);

    ASSERT(m_state.element());

    const StyleResolver::State& state = m_state;

    Element* element = state.element();

    const StyledElement* styledElement = state.styledElement();

    const AtomicString& pseudoId = element->shadowPseudoId();

    if (!pseudoId.isEmpty()) {

        ASSERT(styledElement);

        collectMatchingRulesForList(matchRequest.ruleSet->shadowPseudoElementRules(pseudoId.impl()), matchRequest, ruleRange);

    }

#if ENABLE(VIDEO_TRACK)

    if (element->isWebVTTElement())

        collectMatchingRulesForList(matchRequest.ruleSet->cuePseudoRules(), matchRequest, ruleRange);

#endif

    // Check whether other types of rules are applicable in the current tree scope. Criteria for this:

    // a) it's a UA rule

    // b) the tree scope allows author rules

    // c) the rules comes from a scoped style sheet within the same tree scope

    TreeScope* treeScope = element->treeScope();

    if (!m_matchingUARules

        && !treeScope->applyAuthorStyles()

        && (!matchRequest.scope || matchRequest.scope->treeScope() != treeScope)

        && m_behaviorAtBoundary == SelectorChecker::DoesNotCrossBoundary)

        return;

    // We need to collect the rules for id, class, tag, and everything else into a buffer and

    // then sort the buffer.

    if (element->hasID())

        collectMatchingRulesForList(matchRequest.ruleSet->idRules(element->idForStyleResolution().impl()), matchRequest, ruleRange);

    if (styledElement && styledElement->hasClass()) {

        for (size_t i = 0; i < styledElement->classNames().size(); ++i)

            collectMatchingRulesForList(matchRequest.ruleSet->classRules(styledElement->classNames()[i].impl()), matchRequest, ruleRange);

    }

    if (element->isLink())

        collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest, ruleRange);

    if (SelectorChecker::matchesFocusPseudoClass(element))

        collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest, ruleRange);

    collectMatchingRulesForList(matchRequest.ruleSet->tagRules(element->localName().impl()), matchRequest, ruleRange);

    collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest, ruleRange);

}

void ElementRuleCollector::collectMatchingRulesForRegion(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)

{

    if (!m_regionForStyling)

        return;

    unsigned size = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.size();

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

        const CSSSelector* regionSelector = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).selector;

        if (checkRegionSelector(regionSelector, static_cast<Element*>(m_regionForStyling->node()))) {

            RuleSet* regionRules = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).ruleSet.get();

            ASSERT(regionRules);

            collectMatchingRules(MatchRequest(regionRules, matchRequest.includeEmptyRules, matchRequest.scope), ruleRange);

        }

    }

}

void ElementRuleCollector::sortAndTransferMatchedRules()

{

    const StyleResolver::State& state = m_state;

    if (!m_matchedRules || m_matchedRules->isEmpty())

        return;

    sortMatchedRules();

    Vector<const RuleData*, 32>& matchedRules = *m_matchedRules;

    if (m_mode == SelectorChecker::CollectingRules) {

        for (unsigned i = 0; i < matchedRules.size(); ++i)

            ensureRuleList()->rules().append(matchedRules[i]->rule()->createCSSOMWrapper());

        return;

    }

    // Now transfer the set of matched rules over to our list of declarations.

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

        if (state.style() && matchedRules[i]->containsUncommonAttributeSelector())

            state.style()->setUnique();

        m_result.addMatchedProperties(matchedRules[i]->rule()->properties(), matchedRules[i]->rule(), matchedRules[i]->linkMatchType(), matchedRules[i]->propertyWhitelistType());

    }

}

void ElementRuleCollector::matchScopedAuthorRules(bool includeEmptyRules)

{

#if ENABLE(STYLE_SCOPED) || ENABLE(SHADOW_DOM)

    if (!m_scopeResolver)

        return;

    // Match scoped author rules by traversing the scoped element stack (rebuild it if it got inconsistent).

    if (m_scopeResolver->hasScopedStyles() && m_scopeResolver->ensureStackConsistency(m_state.element())) {

        bool applyAuthorStyles = m_state.element()->treeScope()->applyAuthorStyles();

        bool documentScope = true;

        unsigned scopeSize = m_scopeResolver->stackSize();

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

            clearMatchedRules();

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

            const StyleScopeResolver::StackFrame& frame = m_scopeResolver->stackFrameAt(i);

            documentScope = documentScope && !frame.m_scope->isInShadowTree();

            if (documentScope) {

                if (!applyAuthorStyles)

                    continue;

            } else {

                if (!m_scopeResolver->matchesStyleBounds(frame))

                    continue;

            }

            MatchRequest matchRequest(frame.m_ruleSet, includeEmptyRules, frame.m_scope);

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

            collectMatchingRules(matchRequest, ruleRange);

            collectMatchingRulesForRegion(matchRequest, ruleRange);

            sortAndTransferMatchedRules();

        }

    }

    matchHostRules(includeEmptyRules);

#else

    UNUSED_PARAM(includeEmptyRules);

#endif

}

void ElementRuleCollector::matchHostRules(bool includeEmptyRules)

{

#if ENABLE(SHADOW_DOM)

    ASSERT(m_scopeResolver);

    clearMatchedRules();

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

    Vector<RuleSet*> matchedRules;

    m_scopeResolver->matchHostRules(m_state.element(), matchedRules);

    if (matchedRules.isEmpty())

        return;

    for (unsigned i = matchedRules.size(); i > 0; --i) {

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

        collectMatchingRules(MatchRequest(matchedRules.at(i-1), includeEmptyRules, m_state.element()), ruleRange);

    }

    sortAndTransferMatchedRules();

#else

    UNUSED_PARAM(includeEmptyRules);

#endif

}

#if ENABLE(SHADOW_DOM)

inline void ElementRuleCollector::matchShadowDistributedRules(bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)

{

    if (m_ruleSets.shadowDistributedRules().isEmpty())

        return;

    TemporaryChange<bool> canUseFastReject(m_canUseFastReject, false);

    TemporaryChange<SelectorChecker::BehaviorAtBoundary> behaviorAtBoundary(m_behaviorAtBoundary, SelectorChecker::CrossesBoundary);

    Vector<MatchRequest> matchRequests;

    m_ruleSets.shadowDistributedRules().collectMatchRequests(includeEmptyRules, matchRequests);

    for (size_t i = 0; i < matchRequests.size(); ++i)

        collectMatchingRules(matchRequests[i], ruleRange);

}

#endif

void ElementRuleCollector::matchAuthorRules(bool includeEmptyRules)

{

    clearMatchedRules();

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

    if (!m_state.element())

        return;

    // Match global author rules.

    MatchRequest matchRequest(m_ruleSets.authorStyle(), includeEmptyRules);

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

    collectMatchingRules(matchRequest, ruleRange);

    collectMatchingRulesForRegion(matchRequest, ruleRange);

#if ENABLE(SHADOW_DOM)

    matchShadowDistributedRules(includeEmptyRules, ruleRange);

#endif

    sortAndTransferMatchedRules();

    matchScopedAuthorRules(includeEmptyRules);

}

void ElementRuleCollector::matchUserRules(bool includeEmptyRules)

{

    if (!m_ruleSets.userStyle())

        return;

    clearMatchedRules();

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

    MatchRequest matchRequest(m_ruleSets.userStyle(), includeEmptyRules);

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

    collectMatchingRules(matchRequest, ruleRange);

    collectMatchingRulesForRegion(matchRequest, ruleRange);

    sortAndTransferMatchedRules();

}

void ElementRuleCollector::matchUARules()

{

    TemporaryChange<bool> scope(m_matchingUARules, true);

    // First we match rules from the user agent sheet.

    if (CSSDefaultStyleSheets::simpleDefaultStyleSheet)

        m_result.isCacheable = false;

    RuleSet* userAgentStyleSheet = m_isPrintStyle

        ? CSSDefaultStyleSheets::defaultPrintStyle : CSSDefaultStyleSheets::defaultStyle;

    matchUARules(userAgentStyleSheet);

    // In quirks mode, we match rules from the quirks user agent sheet.

    if (document()->inQuirksMode())

        matchUARules(CSSDefaultStyleSheets::defaultQuirksStyle);

    // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.

    if (document()->isViewSource())

        matchUARules(CSSDefaultStyleSheets::viewSourceStyle());

}

void ElementRuleCollector::matchUARules(RuleSet* rules)

{

    clearMatchedRules();

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

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

    collectMatchingRules(MatchRequest(rules), ruleRange);

    sortAndTransferMatchedRules();

}

inline bool ElementRuleCollector::ruleMatches(const RuleData& ruleData, const ContainerNode* scope, PseudoId& dynamicPseudo)

{

    const StyleResolver::State& state = m_state;

    if (ruleData.hasFastCheckableSelector()) {

        // We know this selector does not include any pseudo elements.

        if (m_pseudoStyleRequest.pseudoId != NOPSEUDO)

            return false;

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

        // This is limited to HTML only so we don't need to check the namespace.

        if (ruleData.hasRightmostSelectorMatchingHTMLBasedOnRuleHash() && state.element()->isHTMLElement()) {

            if (!ruleData.hasMultipartSelector())

                return true;

        }

        if (ruleData.selector()->m_match == CSSSelector::Tag && !SelectorChecker::tagMatches(state.element(), ruleData.selector()->tagQName()))

            return false;

        SelectorCheckerFastPath selectorCheckerFastPath(ruleData.selector(), state.element());

        if (!selectorCheckerFastPath.matchesRightmostAttributeSelector())

            return false;

        return selectorCheckerFastPath.matches();

    }

    // Slow path.

    SelectorChecker selectorChecker(document(), m_mode);

    SelectorChecker::SelectorCheckingContext context(ruleData.selector(), state.element(), SelectorChecker::VisitedMatchEnabled);

    context.elementStyle = state.style();

    context.scope = scope;

    context.pseudoId = m_pseudoStyleRequest.pseudoId;

    context.scrollbar = m_pseudoStyleRequest.scrollbar;

    context.scrollbarPart = m_pseudoStyleRequest.scrollbarPart;

    context.behaviorAtBoundary = m_behaviorAtBoundary;

    SelectorChecker::Match match = selectorChecker.match(context, dynamicPseudo, DOMSiblingTraversalStrategy());

    if (match != SelectorChecker::SelectorMatches)

        return false;

    if (m_pseudoStyleRequest.pseudoId != NOPSEUDO && m_pseudoStyleRequest.pseudoId != dynamicPseudo)

        return false;

    return true;

}

void ElementRuleCollector::collectMatchingRulesForList(const Vector<RuleData>* rules, const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)

{

    if (!rules)

        return;

    const StyleResolver::State& state = m_state;

    unsigned size = rules->size();

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

        const RuleData& ruleData = rules->at(i);

        if (m_canUseFastReject && m_selectorFilter.fastRejectSelector<RuleData::maximumIdentifierCount>(ruleData.descendantSelectorIdentifierHashes()))

            continue;

        StyleRule* rule = ruleData.rule();

        InspectorInstrumentationCookie cookie = InspectorInstrumentation::willMatchRule(document(), rule, m_inspectorCSSOMWrappers, document()->styleSheetCollection());

        PseudoId dynamicPseudo = NOPSEUDO;

        if (ruleMatches(ruleData, matchRequest.scope, dynamicPseudo)) {

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

            const StylePropertySet* properties = rule->properties();

            if (!properties || (properties->isEmpty() && !matchRequest.includeEmptyRules)) {

                InspectorInstrumentation::didMatchRule(cookie, false);

                continue;

            }

            // FIXME: Exposing the non-standard getMatchedCSSRules API to web is the only reason this is needed.

            if (m_sameOriginOnly && !ruleData.hasDocumentSecurityOrigin()) {

                InspectorInstrumentation::didMatchRule(cookie, false);

                continue;

            }

            // If we're matching normal rules, set a pseudo bit if

            // we really just matched a pseudo-element.

            if (dynamicPseudo != NOPSEUDO && m_pseudoStyleRequest.pseudoId == NOPSEUDO) {

                if (m_mode == SelectorChecker::CollectingRules) {

                    InspectorInstrumentation::didMatchRule(cookie, false);

                    continue;

                }

                if (dynamicPseudo < FIRST_INTERNAL_PSEUDOID)

                    state.style()->setHasPseudoStyle(dynamicPseudo);

            } else {

                // Update our first/last rule indices in the matched rules array.

                ++ruleRange.lastRuleIndex;

                if (ruleRange.firstRuleIndex == -1)

                    ruleRange.firstRuleIndex = ruleRange.lastRuleIndex;

                // Add this rule to our list of matched rules.

                addMatchedRule(&ruleData);

                InspectorInstrumentation::didMatchRule(cookie, true);

                continue;

            }

        }

        InspectorInstrumentation::didMatchRule(cookie, false);

    }

}

static inline bool compareRules(const RuleData* r1, const RuleData* r2)

{

    unsigned specificity1 = r1->specificity();

    unsigned specificity2 = r2->specificity();

    return (specificity1 == specificity2) ? r1->position() < r2->position() : specificity1 < specificity2;

}

void ElementRuleCollector::sortMatchedRules()

{

    ASSERT(m_matchedRules);

    std::sort(m_matchedRules->begin(), m_matchedRules->end(), compareRules);

}

void ElementRuleCollector::matchAllRules(bool matchAuthorAndUserStyles, bool includeSMILProperties)

{

    matchUARules();

    // Now we check user sheet rules.

    if (matchAuthorAndUserStyles)

        matchUserRules(false);

    // Now check author rules, beginning first with presentational attributes mapped from HTML.

    if (m_state.styledElement()) {

        addElementStyleProperties(m_state.styledElement()->presentationAttributeStyle());

        // Now we check additional mapped declarations.

        // Tables and table cells share an additional mapped rule that must be applied

        // after all attributes, since their mapped style depends on the values of multiple attributes.

        addElementStyleProperties(m_state.styledElement()->additionalPresentationAttributeStyle());

        if (m_state.styledElement()->isHTMLElement()) {

            bool isAuto;

            TextDirection textDirection = toHTMLElement(m_state.styledElement())->directionalityIfhasDirAutoAttribute(isAuto);

            if (isAuto)

                m_result.addMatchedProperties(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());

        }

    }

    // Check the rules in author sheets next.

    if (matchAuthorAndUserStyles)

        matchAuthorRules(false);

    // Now check our inline style attribute.

    if (matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->inlineStyle()) {

        // Inline style is immutable as long as there is no CSSOM wrapper.

        // FIXME: Media control shadow trees seem to have problems with caching.

        bool isInlineStyleCacheable = !m_state.styledElement()->inlineStyle()->isMutable() && !m_state.styledElement()->isInShadowTree();

        // FIXME: Constify.

        addElementStyleProperties(m_state.styledElement()->inlineStyle(), isInlineStyleCacheable);

    }

#if ENABLE(SVG)

    // Now check SMIL animation override style.

    if (includeSMILProperties && matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->isSVGElement())

        addElementStyleProperties(static_cast<SVGElement*>(m_state.styledElement())->animatedSMILStyleProperties(), false /* isCacheable */);

#else

    UNUSED_PARAM(includeSMILProperties);

#endif

}

bool ElementRuleCollector::hasAnyMatchingRules(RuleSet* ruleSet)

{

    clearMatchedRules();

    m_mode = SelectorChecker::SharingRules;

    int firstRuleIndex = -1, lastRuleIndex = -1;

    StyleResolver::RuleRange ruleRange(firstRuleIndex, lastRuleIndex);

    collectMatchingRules(MatchRequest(ruleSet), ruleRange);

    return m_matchedRules && !m_matchedRules->isEmpty();

}

} // namespace WebCore

/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#ifndef ElementRuleCollector_h

#define ElementRuleCollector_h

#include "MediaQueryEvaluator.h"

#include "SelectorChecker.h"

#include "StyleResolver.h"

#include <wtf/RefPtr.h>

#include <wtf/Vector.h>

namespace WebCore {

class CSSRuleList;

class DocumentRuleSets;

class RenderRegion;

class RuleData;

class RuleSet;

class SelectorFilter;

class StyleScopeResolver;

class StaticCSSRuleList;

class ElementRuleCollector {

public:

    ElementRuleCollector(StyleResolver* styleResolver, const StyleResolver::State& state)

        : m_state(state)

        , m_ruleSets(styleResolver->ruleSets())

        , m_selectorFilter(styleResolver->selectorFilter())

        , m_inspectorCSSOMWrappers(styleResolver->inspectorCSSOMWrappers())

        , m_scopeResolver(styleResolver->scopeResolver())

        , m_isPrintStyle(false)

        , m_regionForStyling(0)

        , m_pseudoStyleRequest(NOPSEUDO)

        , m_sameOriginOnly(false)

        , m_mode(SelectorChecker::ResolvingStyle)

        , m_canUseFastReject(m_selectorFilter.parentStackIsConsistent(state.parentNode()))

        , m_behaviorAtBoundary(SelectorChecker::DoesNotCrossBoundary)

        , m_matchingUARules(false) { }

    void matchAllRules(bool matchAuthorAndUserStyles, bool includeSMILProperties);

    void matchUARules();

    void matchAuthorRules(bool includeEmptyRules);

    void matchUserRules(bool includeEmptyRules);

    void setMode(SelectorChecker::Mode mode) { m_mode = mode; }

    void setPseudoStyleRequest(const PseudoStyleRequest& request) { m_pseudoStyleRequest = request; }

    void setSameOriginOnly(bool f) { m_sameOriginOnly = f; } 

    void setRegionForStyling(RenderRegion* regionForStyling) { m_regionForStyling = regionForStyling; }

    void setMedium(const MediaQueryEvaluator* medium) { m_isPrintStyle = medium->mediaTypeMatchSpecific("print"); }

    bool hasAnyMatchingRules(RuleSet*);

    StyleResolver::MatchResult& matchedResult();

    PassRefPtr<CSSRuleList> matchedRuleList();

private:

    Document* document() { return m_state.document(); }

    void addElementStyleProperties(const StylePropertySet*, bool isCacheable = true);

#if ENABLE(SHADOW_DOM)

    void matchUARules(RuleSet*);

    void matchShadowDistributedRules(bool includeEmptyRules, StyleResolver::RuleRange&);

    void matchScopedAuthorRules(bool includeEmptyRules);

    void matchHostRules(bool includeEmptyRules);

#endif

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

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

    void collectMatchingRulesForList(const Vector<RuleData>*, const MatchRequest&, StyleResolver::RuleRange&);

    bool ruleMatches(const RuleData&, const ContainerNode* scope, PseudoId&);

    void sortMatchedRules();

    void sortAndTransferMatchedRules();

    void addMatchedRule(const RuleData*);

    void clearMatchedRules();

    StaticCSSRuleList* ensureRuleList();

private:

    const StyleResolver::State& m_state;

    DocumentRuleSets& m_ruleSets;

    SelectorFilter& m_selectorFilter;

    InspectorCSSOMWrappers& m_inspectorCSSOMWrappers;

    StyleScopeResolver* m_scopeResolver;

    bool m_isPrintStyle;

    RenderRegion* m_regionForStyling;

    PseudoStyleRequest m_pseudoStyleRequest;

    bool m_sameOriginOnly;

    SelectorChecker::Mode m_mode;

    bool m_canUseFastReject;

    SelectorChecker::BehaviorAtBoundary m_behaviorAtBoundary;

    bool m_matchingUARules;

    OwnPtr<Vector<const RuleData*, 32> > m_matchedRules;

    // Output.

    RefPtr<StaticCSSRuleList> m_ruleList;

    StyleResolver::MatchResult m_result;

};

} // namespace WebCore

#endif // ElementRuleCollector_h

/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)

 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.

 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>

 * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.

 * Copyright (C) Research In Motion Limited 2011. All rights reserved.

 * Copyright (C) 2012 Google Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "PageRuleCollector.h"

#include "CSSDefaultStyleSheets.h"

#include "StylePropertySet.h"

#include "StyleRule.h"

namespace WebCore {

static inline bool comparePageRules(const StyleRulePage* r1, const StyleRulePage* r2)

{

    return r1->selector()->specificity() < r2->selector()->specificity();

}

bool PageRuleCollector::isLeftPage(int pageIndex) const

{

    bool isFirstPageLeft = false;

    if (!m_state.rootElementStyle()->isLeftToRightDirection())

        isFirstPageLeft = true;

    return (pageIndex + (isFirstPageLeft ? 1 : 0)) % 2;

}

bool PageRuleCollector::isFirstPage(int pageIndex) const

{

    // FIXME: In case of forced left/right page, page at index 1 (not 0) can be the first page.

    return (!pageIndex);

}

String PageRuleCollector::pageName(int /* pageIndex */) const

{

    // FIXME: Implement page index to page name mapping.

    return "";

}

void PageRuleCollector::matchAllPageRules(int pageIndex)

{

    const bool isLeft = isLeftPage(pageIndex);

    const bool isFirst = isFirstPage(pageIndex);

    const String page = pageName(pageIndex);

    matchPageRules(CSSDefaultStyleSheets::defaultPrintStyle, isLeft, isFirst, page);

    matchPageRules(m_ruleSets.userStyle(), isLeft, isFirst, page);

    // Only consider the global author RuleSet for @page rules, as per the HTML5 spec.

    matchPageRules(m_ruleSets.authorStyle(), isLeft, isFirst, page);

}

void PageRuleCollector::matchPageRules(RuleSet* rules, bool isLeftPage, bool isFirstPage, const String& pageName)

{

    if (!rules)

        return;

    Vector<StyleRulePage*> matchedPageRules;

    matchPageRulesForList(matchedPageRules, rules->pageRules(), isLeftPage, isFirstPage, pageName);

    if (matchedPageRules.isEmpty())

        return;

    std::stable_sort(matchedPageRules.begin(), matchedPageRules.end(), comparePageRules);

    for (unsigned i = 0; i < matchedPageRules.size(); i++)

        m_result.addMatchedProperties(matchedPageRules[i]->properties());

}

static bool checkPageSelectorComponents(const CSSSelector* selector, bool isLeftPage, bool isFirstPage, const String& pageName)

{

    for (const CSSSelector* component = selector; component; component = component->tagHistory()) {

        if (component->m_match == CSSSelector::Tag) {

            const AtomicString& localName = component->tagQName().localName();

            if (localName != starAtom && localName != pageName)

                return false;

        }

        CSSSelector::PseudoType pseudoType = component->pseudoType();

        if ((pseudoType == CSSSelector::PseudoLeftPage && !isLeftPage)

            || (pseudoType == CSSSelector::PseudoRightPage && isLeftPage)

            || (pseudoType == CSSSelector::PseudoFirstPage && !isFirstPage))

        {

            return false;

        }

    }

    return true;

}

void PageRuleCollector::matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>& rules, bool isLeftPage, bool isFirstPage, const String& pageName)

{

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

        StyleRulePage* rule = rules[i];

        if (!checkPageSelectorComponents(rule->selector(), isLeftPage, isFirstPage, pageName))

            continue;

        // If the rule has no properties to apply, then ignore it.

        const StylePropertySet* properties = rule->properties();

        if (!properties || properties->isEmpty())

            continue;

        // Add this rule to our list of matched rules.

        matchedRules.append(rule);

    }

}

} // namespace WebCore

/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#ifndef PageRuleCollector_h

#define PageRuleCollector_h

#include "DocumentRuleSets.h"

#include "StyleResolver.h"

#include <wtf/RefPtr.h>

#include <wtf/Vector.h>

namespace WebCore {

class StyleRulePage;

class PageRuleCollector {

public:

    PageRuleCollector(StyleResolver::State& state, DocumentRuleSets& ruleSets)

        : m_state(state)

        , m_ruleSets(ruleSets) { }

    void matchAllPageRules(int pageIndex);

    StyleResolver::MatchResult& matchedResult() { return m_result; }

private:

    bool isLeftPage(int pageIndex) const;

    bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }

    bool isFirstPage(int pageIndex) const;

    String pageName(int pageIndex) const;

    void matchPageRules(RuleSet* rules, bool isLeftPage, bool isFirstPage, const String& pageName);

    void matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>& rules, bool isLeftPage, bool isFirstPage, const String& pageName);

    const StyleResolver::State& m_state;

    DocumentRuleSets& m_ruleSets;

    StyleResolver::MatchResult m_result;

};

} // namespace WebCore

#endif // PageRuleCollector_h

#include "ElementRuleCollector.h"

#include "PageRuleCollector.h"

void StyleResolver::MatchResult::addMatchedProperties(const StylePropertySet* properties, StyleRule* rule, unsigned linkMatchType, PropertyWhitelistType propertyWhitelistType)

{

    matchedProperties.grow(matchedProperties.size() + 1);

    StyleResolver::MatchedProperties& newProperties = matchedProperties.last();

    newProperties.properties = const_cast<StylePropertySet*>(properties);

    newProperties.linkMatchType = linkMatchType;

    newProperties.whitelistType = propertyWhitelistType;

    matchedRules.append(rule);

}

    MatchResult& result = collector.matchedResult();