2016-09-09  Dave Hyatt  <hyatt@apple.com>

        [CSS Parser] Add the main parser implementation

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

        Reviewed by NOBODY (OOPS!).

        This patch add the main CSSParserImpl that handles stylesheet and rule parsing. All parsing starts with this

        class (it will eventually be invoked from the CSSParser). This patch also adds @supports parsing.

        * WebCore.xcodeproj/project.pbxproj:

        * css/CSSKeyframeRule.cpp:

        (WebCore::StyleKeyframe::StyleKeyframe):

        * css/CSSKeyframeRule.h:

        * css/StyleRule.cpp:

        (WebCore::StyleRuleBase::destroy):

        (WebCore::StyleRuleBase::copy):

        (WebCore::StyleRuleBase::createCSSOMWrapper):

        (WebCore::StyleRuleCharset::StyleRuleCharset):

        (WebCore::StyleRuleCharset::~StyleRuleCharset):

        (WebCore::StyleRuleNamespace::StyleRuleNamespace):

        (WebCore::StyleRuleNamespace::~StyleRuleNamespace):

        * css/StyleRule.h:

        (WebCore::StyleRuleBase::isNamespaceRule):

        (isType):

        (WebCore::StyleRuleBase::isKeyframesRule): Deleted.

        * css/StyleSheetContents.cpp:

        (WebCore::traverseSubresourcesInRules):

        * css/parser/CSSParserImpl.cpp: Added.

        (WebCore::CSSParserImpl::CSSParserImpl):

        (WebCore::CSSParserImpl::parseValue):

        (WebCore::CSSParserImpl::parseVariableValue):

        (WebCore::filterProperties):

        (WebCore::createStyleProperties):

        (WebCore::CSSParserImpl::parseInlineStyleDeclaration):

        (WebCore::CSSParserImpl::parseDeclarationList):

        (WebCore::CSSParserImpl::parseRule):

        (WebCore::CSSParserImpl::parseStyleSheet):

        (WebCore::CSSParserImpl::parsePageSelector):

        (WebCore::CSSParserImpl::parseCustomPropertySet):

        (WebCore::CSSParserImpl::parseKeyframeKeyList):

        (WebCore::CSSParserImpl::supportsDeclaration):

        (WebCore::CSSParserImpl::parseDeclarationListForInspector):

        (WebCore::CSSParserImpl::parseStyleSheetForInspector):

        (WebCore::computeNewAllowedRules):

        (WebCore::CSSParserImpl::consumeRuleList):

        (WebCore::CSSParserImpl::consumeAtRule):

        (WebCore::CSSParserImpl::consumeQualifiedRule):

        (WebCore::consumeStringOrURI):

        (WebCore::CSSParserImpl::consumeCharsetRule):

        (WebCore::CSSParserImpl::consumeImportRule):

        (WebCore::CSSParserImpl::consumeNamespaceRule):

        (WebCore::CSSParserImpl::consumeMediaRule):

        (WebCore::CSSParserImpl::consumeSupportsRule):

        (WebCore::CSSParserImpl::consumeViewportRule):

        (WebCore::CSSParserImpl::consumeFontFaceRule):

        (WebCore::CSSParserImpl::consumeKeyframesRule):

        (WebCore::CSSParserImpl::consumePageRule):

        (WebCore::CSSParserImpl::consumeKeyframeStyleRule):

        (WebCore::observeSelectors):

        (WebCore::CSSParserImpl::consumeStyleRule):

        (WebCore::CSSParserImpl::consumeDeclarationList):

        (WebCore::CSSParserImpl::consumeDeclaration):

        (WebCore::CSSParserImpl::consumeVariableValue):

        (WebCore::CSSParserImpl::consumeDeclarationValue):

        (WebCore::CSSParserImpl::consumeKeyframeKeyList):

        * css/parser/CSSParserImpl.h: Added.

        * css/parser/CSSParserValues.cpp:

        (WebCore::CSSParserSelector::parsePagePseudoSelector):

        * css/parser/CSSParserValues.h:

        * css/parser/CSSPropertyParser.cpp:

        (WebCore::CSSPropertyParser::parseValue):

        * css/parser/CSSSupportsParser.cpp: Added.

        (WebCore::CSSSupportsParser::supportsCondition):

        (WebCore::CSSSupportsParser::consumeCondition):

        (WebCore::CSSSupportsParser::consumeNegation):

        (WebCore::CSSSupportsParser::consumeConditionInParenthesis):

        * css/parser/CSSSupportsParser.h: Added.

        (WebCore::CSSSupportsParser::CSSSupportsParser):

    css/parser/CSSParserImpl.cpp

    css/parser/CSSSupportsParser.cpp

		94DE5C911D83011D00164F2A /* CSSSupportsParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94DE5C8F1D8300CB00164F2A /* CSSSupportsParser.cpp */; };

		94DE5C921D83011D00164F2A /* CSSSupportsParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 94DE5C901D8300CB00164F2A /* CSSSupportsParser.h */; };

		94DE5C951D8301BD00164F2A /* CSSParserImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94DE5C931D8301B000164F2A /* CSSParserImpl.cpp */; };

		94DE5C961D8301BD00164F2A /* CSSParserImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 94DE5C941D8301B000164F2A /* CSSParserImpl.h */; };

		94DE5C8F1D8300CB00164F2A /* CSSSupportsParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CSSSupportsParser.cpp; path = parser/CSSSupportsParser.cpp; sourceTree = "<group>"; };

		94DE5C901D8300CB00164F2A /* CSSSupportsParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CSSSupportsParser.h; path = parser/CSSSupportsParser.h; sourceTree = "<group>"; };

		94DE5C931D8301B000164F2A /* CSSParserImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CSSParserImpl.cpp; path = parser/CSSParserImpl.cpp; sourceTree = "<group>"; };

		94DE5C941D8301B000164F2A /* CSSParserImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CSSParserImpl.h; path = parser/CSSParserImpl.h; sourceTree = "<group>"; };

				94DE5C931D8301B000164F2A /* CSSParserImpl.cpp */,

				94DE5C941D8301B000164F2A /* CSSParserImpl.h */,

				94DE5C8F1D8300CB00164F2A /* CSSSupportsParser.cpp */,

				94DE5C901D8300CB00164F2A /* CSSSupportsParser.h */,

				94DE5C961D8301BD00164F2A /* CSSParserImpl.h in Headers */,

				94DE5C921D83011D00164F2A /* CSSSupportsParser.h in Headers */,

				94DE5C911D83011D00164F2A /* CSSSupportsParser.cpp in Sources */,

				94DE5C951D8301BD00164F2A /* CSSParserImpl.cpp in Sources */,

StyleKeyframe::StyleKeyframe(std::unique_ptr<Vector<double>> keys, Ref<StyleProperties>&& properties)

    : StyleRuleBase(Keyframe, 0)

    , m_properties(WTFMove(properties))

    , m_keys(*keys)

{

}

    // FIXME-NEWPARSER: Remove this create function once we get rid of the old parser.

    static Ref<StyleKeyframe> create(std::unique_ptr<Vector<double>> keys, Ref<StyleProperties>&& properties)

    {

        return adoptRef(*new StyleKeyframe(WTFMove(keys), WTFMove(properties)));

    }

    StyleKeyframe(std::unique_ptr<Vector<double>>, Ref<StyleProperties>&&);

    case Namespace:

        delete downcast<StyleRuleNamespace>(this);

        return;

    case Namespace: // FIXME: Add support for CSSNamespaceRule.

StyleRuleCharset::StyleRuleCharset()

    : StyleRuleBase(Charset, 0)

{

}

StyleRuleCharset::StyleRuleCharset(const StyleRuleCharset& o)

: StyleRuleBase(o)

{

}

StyleRuleCharset::~StyleRuleCharset()

{

}

StyleRuleNamespace::StyleRuleNamespace(AtomicString prefix, AtomicString uri)

    : StyleRuleBase(Namespace, 0)

    , m_prefix(prefix)

    , m_uri(uri)

{

}

StyleRuleNamespace::StyleRuleNamespace(const StyleRuleNamespace& o)

    : StyleRuleBase(o)

    , m_prefix(o.m_prefix)

    , m_uri(o.m_uri)

{

}

StyleRuleNamespace::~StyleRuleNamespace()

{

}

        Namespace,

    bool isNamespaceRule() const { return type() == Namespace; }

// This is only used by the CSS parser.

class StyleRuleCharset final : public StyleRuleBase {

public:

    static Ref<StyleRuleCharset> create() { return adoptRef(*new StyleRuleCharset()); }

    ~StyleRuleCharset();

    Ref<StyleRuleCharset> copy() const { return adoptRef(*new StyleRuleCharset(*this)); }

private:

    explicit StyleRuleCharset();

    StyleRuleCharset(const StyleRuleCharset&);

};

class StyleRuleNamespace final : public StyleRuleBase {

public:

    static Ref<StyleRuleNamespace> create(AtomicString prefix, AtomicString uri)

    {

        return adoptRef(*new StyleRuleNamespace(prefix, uri));

    }

    ~StyleRuleNamespace();

    Ref<StyleRuleNamespace> copy() const { return adoptRef(*new StyleRuleNamespace(*this)); }

    AtomicString prefix() const { return m_prefix; }

    AtomicString uri() const { return m_uri; }

private:

    StyleRuleNamespace(AtomicString prefix, AtomicString uri);

    StyleRuleNamespace(const StyleRuleNamespace&);

    AtomicString m_prefix;

    AtomicString m_uri;

};

SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleNamespace)

    static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isNamespaceRule(); }

SPECIALIZE_TYPE_TRAITS_END()

        case StyleRuleBase::Namespace:

// Copyright 2014 The Chromium Authors. All rights reserved.

// Copyright (C) 2016 Apple Inc. All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//    * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//    * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "config.h"

#include "CSSParserImpl.h"

#include "CSSAtRuleID.h"

#include "CSSCustomPropertyValue.h"

#include "CSSKeyframeRule.h"

#include "CSSKeyframesRule.h"

#include "CSSParserObserver.h"

#include "CSSParserObserverWrapper.h"

#include "CSSParserValues.h" // FIXME-NEWPARSER We need to move CSSParserSelector to its own file.

#include "CSSPropertyParser.h"

#include "CSSSelectorParser.h"

#include "CSSStyleSheet.h"

#include "CSSSupportsParser.h"

#include "CSSTokenizer.h"

// FIXME-NEWPARSER: #include "CSSVariableParser.h"

#include "Document.h"

#include "Element.h"

#include "MediaQueryParser.h"

#include "StyleProperties.h"

#include "StyleRuleImport.h"

#include "StyleSheetContents.h"

#include <bitset>

#include <memory>

namespace WebCore {

CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)

    : m_context(context)

    , m_styleSheet(styleSheet)

    , m_observerWrapper(nullptr)

{

}

bool CSSParserImpl::parseValue(MutableStyleProperties* declaration, CSSPropertyID unresolvedProperty, const String& string, bool important, const CSSParserContext& context)

{

    CSSParserImpl parser(context);

    StyleRule::Type ruleType = StyleRule::Style;

#if ENABLE(CSS_DEVICE_ADAPTATION)

    if (declaration->cssParserMode() == CSSViewportRuleMode)

        ruleType = StyleRule::Viewport;

#endif

    CSSTokenizer::Scope scope(string);

    parser.consumeDeclarationValue(scope.tokenRange(), unresolvedProperty, important, ruleType);

    if (parser.m_parsedProperties.isEmpty())

        return false;

    return declaration->addParsedProperties(parser.m_parsedProperties);

}

bool CSSParserImpl::parseVariableValue(MutableStyleProperties* declaration, const AtomicString& propertyName, const String& value, bool important, const CSSParserContext& context)

{

    CSSParserImpl parser(context);

    CSSTokenizer::Scope scope(value);

    parser.consumeVariableValue(scope.tokenRange(), propertyName, important);

    if (parser.m_parsedProperties.isEmpty())

        return false;

    return declaration->addParsedProperties(parser.m_parsedProperties);

}

static inline void filterProperties(bool important, const ParsedPropertyVector& input, ParsedPropertyVector& output, size_t& unusedEntries, std::bitset<numCSSProperties>& seenProperties, HashSet<AtomicString>& seenCustomProperties)

{

    // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found.

    for (size_t i = input.size(); i--; ) {

        const CSSProperty& property = input[i];

        if (property.isImportant() != important)

            continue;

        const unsigned propertyIDIndex = property.id() - firstCSSProperty;

        if (property.id() == CSSPropertyCustom) {

            if (property.value()) {

                auto& name = downcast<CSSCustomPropertyValue>(*property.value()).name();

                if (!seenCustomProperties.add(name).isNewEntry)

                    continue;

                output[--unusedEntries] = property;

            }

            continue;

        } else {

            if (seenProperties.test(propertyIDIndex))

                continue;

            seenProperties.set(propertyIDIndex);

        }

        // FIXME-NEWPARSER: We won't support @apply yet.

        /*else if (property.id() == CSSPropertyApplyAtRule) {

         // FIXME: Do we need to do anything here?

         } */

        output[--unusedEntries] = property;

    }

}

static Ref<ImmutableStyleProperties> createStyleProperties(ParsedPropertyVector& parsedProperties, CSSParserMode mode)

{

    std::bitset<numCSSProperties> seenProperties;

    size_t unusedEntries = parsedProperties.size();

    ParsedPropertyVector results(unusedEntries);

    HashSet<AtomicString> seenCustomProperties;

    filterProperties(true, parsedProperties, results, unusedEntries, seenProperties, seenCustomProperties);

    filterProperties(false, parsedProperties, results, unusedEntries, seenProperties, seenCustomProperties);

    Ref<ImmutableStyleProperties> result = ImmutableStyleProperties::create(results.data() + unusedEntries, results.size() - unusedEntries, mode);

    parsedProperties.clear();

    return result;

}

Ref<ImmutableStyleProperties> CSSParserImpl::parseInlineStyleDeclaration(const String& string, Element* element)

{

    Document& document = element->document();

    CSSParserContext context = CSSParserContext(document.elementSheet().contents().parserContext());

    CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode() ? HTMLStandardMode : HTMLQuirksMode;

    context.mode = mode;

    CSSParserImpl parser(context, &document.elementSheet().contents());

    CSSTokenizer::Scope scope(string);

    parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);

    return createStyleProperties(parser.m_parsedProperties, mode);

}

bool CSSParserImpl::parseDeclarationList(MutableStyleProperties* declaration, const String& string, const CSSParserContext& context)

{

    CSSParserImpl parser(context);

    StyleRule::Type ruleType = StyleRule::Style;

#if ENABLE(CSS_DEVICE_ADAPTATION)

    if (declaration->cssParserMode() == CSSViewportRuleMode)

        ruleType = StyleRule::Viewport;

#endif

    CSSTokenizer::Scope scope(string);

    parser.consumeDeclarationList(scope.tokenRange(), ruleType);

    if (parser.m_parsedProperties.isEmpty())

        return false;

    std::bitset<numCSSProperties> seenProperties;

    size_t unusedEntries = parser.m_parsedProperties.size();

    ParsedPropertyVector results(unusedEntries);

    HashSet<AtomicString> seenCustomProperties;

    filterProperties(true, parser.m_parsedProperties, results, unusedEntries, seenProperties, seenCustomProperties);

    filterProperties(false, parser.m_parsedProperties, results, unusedEntries, seenProperties, seenCustomProperties);

    if (unusedEntries)

        results.remove(0, unusedEntries);

    return declaration->addParsedProperties(results);

}

RefPtr<StyleRuleBase> CSSParserImpl::parseRule(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet, AllowedRulesType allowedRules)

{

    CSSParserImpl parser(context, styleSheet);

    CSSTokenizer::Scope scope(string);

    CSSParserTokenRange range = scope.tokenRange();

    range.consumeWhitespace();

    if (range.atEnd())

        return nullptr; // Parse error, empty rule

    RefPtr<StyleRuleBase> rule;

    if (range.peek().type() == AtKeywordToken)

        rule = parser.consumeAtRule(range, allowedRules);

    else

        rule = parser.consumeQualifiedRule(range, allowedRules);

    if (!rule)

        return nullptr; // Parse error, failed to consume rule

    range.consumeWhitespace();

    if (!rule || !range.atEnd())

        return nullptr; // Parse error, trailing garbage

    return rule;

}

void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet)

{

    CSSTokenizer::Scope scope(string);

    CSSParserImpl parser(context, styleSheet);

    bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](RefPtr<StyleRuleBase> rule) {

        if (rule->isCharsetRule())

            return;

        styleSheet->parserAppendRule(rule.releaseNonNull());

    });

    styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);

}

CSSSelectorList CSSParserImpl::parsePageSelector(CSSParserTokenRange range, StyleSheetContents* styleSheet)

{

    // We only support a small subset of the css-page spec.

    range.consumeWhitespace();

    AtomicString typeSelector;

    if (range.peek().type() == IdentToken)

        typeSelector = range.consume().value().toAtomicString();

    AtomicString pseudo;

    if (range.peek().type() == ColonToken) {

        range.consume();

        if (range.peek().type() != IdentToken)

            return CSSSelectorList();

        pseudo = range.consume().value().toAtomicString();

    }

    range.consumeWhitespace();

    if (!range.atEnd())

        return CSSSelectorList(); // Parse error; extra tokens in @page selector

    std::unique_ptr<CSSParserSelector> selector;

    if (!typeSelector.isNull() && pseudo.isNull())

        selector = std::unique_ptr<CSSParserSelector>(new CSSParserSelector(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace())));

    else {

        selector = std::unique_ptr<CSSParserSelector>(new CSSParserSelector);

        if (!pseudo.isNull()) {

            selector = std::unique_ptr<CSSParserSelector>(CSSParserSelector::parsePagePseudoSelector(pseudo));

            if (!selector || selector->pseudoElementType() == CSSSelector::PseudoElementUnknown)

                return CSSSelectorList();

        }

        if (!typeSelector.isNull())

            selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace()));

    }

    selector->setForPage();

    Vector<std::unique_ptr<CSSParserSelector>> selectorVector;

    selectorVector.append(WTFMove(selector));

    CSSSelectorList selectorList;

    selectorList.adoptSelectorVector(selectorVector);

    return selectorList;

}

RefPtr<ImmutableStyleProperties> CSSParserImpl::parseCustomPropertySet(CSSParserTokenRange range)

{

    range.consumeWhitespace();

    if (range.peek().type() != LeftBraceToken)

        return nullptr;

    CSSParserTokenRange block = range.consumeBlock();

    range.consumeWhitespace();

    if (!range.atEnd())

        return nullptr;

    CSSParserImpl parser(strictCSSParserContext());

    parser.consumeDeclarationList(block, StyleRule::Style);

    // FIXME-NEWPARSER: We dont support @apply yet.

    // Drop nested @apply rules. Seems nicer to do this here instead of making

    // a different StyleRule type

    /*for (size_t i = parser.m_parsedProperties.size(); i--; ) {

        if (parser.m_parsedProperties[i].id() == CSSPropertyApplyAtRule)

            parser.m_parsedProperties.remove(i);

    }*/

    return createStyleProperties(parser.m_parsedProperties, HTMLStandardMode);

}

std::unique_ptr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)

{

    return consumeKeyframeKeyList(CSSTokenizer::Scope(keyList).tokenRange());

}

bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range)

{

    ASSERT(m_parsedProperties.isEmpty());

    consumeDeclaration(range, StyleRule::Style);

    bool result = !m_parsedProperties.isEmpty();

    m_parsedProperties.clear();

    return result;

}

void CSSParserImpl::parseDeclarationListForInspector(const String& declaration, const CSSParserContext& context, CSSParserObserver& observer)

{

    CSSParserImpl parser(context);

    CSSParserObserverWrapper wrapper(observer);

    parser.m_observerWrapper = &wrapper;

    CSSTokenizer::Scope scope(declaration, wrapper);

    observer.startRuleHeader(StyleRule::Style, 0);

    observer.endRuleHeader(1);

    parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style);

}

void CSSParserImpl::parseStyleSheetForInspector(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet, CSSParserObserver& observer)

{

    CSSParserImpl parser(context, styleSheet);

    CSSParserObserverWrapper wrapper(observer);

    parser.m_observerWrapper = &wrapper;

    CSSTokenizer::Scope scope(string, wrapper);

    bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](RefPtr<StyleRuleBase> rule) {

        if (rule->isCharsetRule())

            return;

        styleSheet->parserAppendRule(rule.releaseNonNull());

    });

    styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);

}

static CSSParserImpl::AllowedRulesType computeNewAllowedRules(CSSParserImpl::AllowedRulesType allowedRules, StyleRuleBase* rule)

{

    if (!rule || allowedRules == CSSParserImpl::KeyframeRules || allowedRules == CSSParserImpl::NoRules)

        return allowedRules;

    ASSERT(allowedRules <= CSSParserImpl::RegularRules);

    if (rule->isCharsetRule() || rule->isImportRule())

        return CSSParserImpl::AllowImportRules;

    if (rule->isNamespaceRule())

        return CSSParserImpl::AllowNamespaceRules;

    return CSSParserImpl::RegularRules;

}

template<typename T>

bool CSSParserImpl::consumeRuleList(CSSParserTokenRange range, RuleListType ruleListType, const T callback)

{

    AllowedRulesType allowedRules = RegularRules;

    switch (ruleListType) {

    case TopLevelRuleList:

        allowedRules = AllowCharsetRules;

        break;

    case RegularRuleList:

        allowedRules = RegularRules;

        break;

    case KeyframesRuleList:

        allowedRules = KeyframeRules;

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    bool seenRule = false;

    bool firstRuleValid = false;

    while (!range.atEnd()) {

        RefPtr<StyleRuleBase> rule;

        switch (range.peek().type()) {

        case WhitespaceToken:

            range.consumeWhitespace();

            continue;

        case AtKeywordToken:

            rule = consumeAtRule(range, allowedRules);

            break;

        case CDOToken:

        case CDCToken:

            if (ruleListType == TopLevelRuleList) {

                range.consume();

                continue;

            }

            FALLTHROUGH;

        default:

            rule = consumeQualifiedRule(range, allowedRules);

            break;

        }

        if (!seenRule) {

            seenRule = true;

            firstRuleValid = rule;

        }

        if (rule) {

            allowedRules = computeNewAllowedRules(allowedRules, rule.get());

            callback(rule);

        }

    }

    return firstRuleValid;

}

RefPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, AllowedRulesType allowedRules)

{

    ASSERT(range.peek().type() == AtKeywordToken);

    const StringView name = range.consumeIncludingWhitespace().value();

    const CSSParserToken* preludeStart = &range.peek();

    while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek().type() != SemicolonToken)

        range.consumeComponentValue();

    CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());

    CSSAtRuleID id = cssAtRuleID(name);

    if (range.atEnd() || range.peek().type() == SemicolonToken) {

        range.consume();

        if (allowedRules == AllowCharsetRules && id == CSSAtRuleCharset)

            return consumeCharsetRule(prelude);

        if (allowedRules <= AllowImportRules && id == CSSAtRuleImport)

            return consumeImportRule(prelude);

        if (allowedRules <= AllowNamespaceRules && id == CSSAtRuleNamespace)

            return consumeNamespaceRule(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

    }

    CSSParserTokenRange block = range.consumeBlock();

    if (allowedRules == KeyframeRules)

        return nullptr; // Parse error, no at-rules supported inside @keyframes

    if (allowedRules == NoRules || allowedRules == ApplyRules)

        return nullptr; // Parse error, no at-rules with blocks supported inside declaration lists

    ASSERT(allowedRules <= RegularRules);

    switch (id) {

    case CSSAtRuleMedia:

        return consumeMediaRule(prelude, block);

    case CSSAtRuleSupports:

        return consumeSupportsRule(prelude, block);

#if ENABLE(CSS_DEVICE_ADAPTATION)

    case CSSAtRuleViewport:

        return consumeViewportRule(prelude, block);

#endif

    case CSSAtRuleFontFace:

        return consumeFontFaceRule(prelude, block);

    case CSSAtRuleWebkitKeyframes:

        return consumeKeyframesRule(true, prelude, block);

    case CSSAtRuleKeyframes:

        return consumeKeyframesRule(false, prelude, block);

    case CSSAtRulePage:

        return consumePageRule(prelude, block);

    default:

        return nullptr; // Parse error, unrecognised at-rule with block

    }

}

RefPtr<StyleRuleBase> CSSParserImpl::consumeQualifiedRule(CSSParserTokenRange& range, AllowedRulesType allowedRules)

{

    const CSSParserToken* preludeStart = &range.peek();

    while (!range.atEnd() && range.peek().type() != LeftBraceToken)

        range.consumeComponentValue();

    if (range.atEnd())

        return nullptr; // Parse error, EOF instead of qualified rule block

    CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());

    CSSParserTokenRange block = range.consumeBlock();

    if (allowedRules <= RegularRules)

        return consumeStyleRule(prelude, block);

    if (allowedRules == KeyframeRules)

        return consumeKeyframeStyleRule(prelude, block);

    ASSERT_NOT_REACHED();

    return nullptr;

}

// This may still consume tokens if it fails

static AtomicString consumeStringOrURI(CSSParserTokenRange& range)

{

    const CSSParserToken& token = range.peek();

    if (token.type() == StringToken || token.type() == UrlToken)

        return range.consumeIncludingWhitespace().value().toAtomicString();

    if (token.type() != FunctionToken || !equalIgnoringASCIICase(token.value(), "url"))

        return AtomicString();

    CSSParserTokenRange contents = range.consumeBlock();

    const CSSParserToken& uri = contents.consumeIncludingWhitespace();

    if (uri.type() == BadStringToken || !contents.atEnd())

        return AtomicString();

    return uri.value().toAtomicString();

}

RefPtr<StyleRuleCharset> CSSParserImpl::consumeCharsetRule(CSSParserTokenRange prelude)

{

    const CSSParserToken& string = prelude.consumeIncludingWhitespace();

    if (string.type() != StringToken || !prelude.atEnd())

        return nullptr; // Parse error, expected a single string

    return StyleRuleCharset::create();

}

RefPtr<StyleRuleImport> CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude)

{

    AtomicString uri(consumeStringOrURI(prelude));

    if (uri.isNull())

        return nullptr; // Parse error, expected string or URI

    if (m_observerWrapper) {

        unsigned endOffset = m_observerWrapper->endOffset(prelude);

        m_observerWrapper->observer().startRuleHeader(StyleRule::Import, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(endOffset);

        m_observerWrapper->observer().startRuleBody(endOffset);

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

    }

    return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(prelude).releaseNonNull());

}

RefPtr<StyleRuleNamespace> CSSParserImpl::consumeNamespaceRule(CSSParserTokenRange prelude)

{

    AtomicString namespacePrefix;

    if (prelude.peek().type() == IdentToken)

        namespacePrefix = prelude.consumeIncludingWhitespace().value().toAtomicString();

    AtomicString uri(consumeStringOrURI(prelude));

    if (uri.isNull() || !prelude.atEnd())

        return nullptr; // Parse error, expected string or URI

    return StyleRuleNamespace::create(namespacePrefix, uri);

}

RefPtr<StyleRuleMedia> CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    Vector<RefPtr<StyleRuleBase>> rules;

    if (m_observerWrapper) {

        m_observerWrapper->observer().startRuleHeader(StyleRule::Media, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));

        m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));

    }

    consumeRuleList(block, RegularRuleList, [&rules](RefPtr<StyleRuleBase> rule) {

        rules.append(rule);

    });

    if (m_observerWrapper)

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

    return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude).releaseNonNull(), rules);

}

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

{

    CSSSupportsParser::SupportsResult supported = CSSSupportsParser::supportsCondition(prelude, *this);

    if (supported == CSSSupportsParser::Invalid)

        return nullptr; // Parse error, invalid @supports condition

    if (m_observerWrapper) {

        m_observerWrapper->observer().startRuleHeader(StyleRule::Supports, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));

        m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));

    }

    Vector<RefPtr<StyleRuleBase>> rules;

    consumeRuleList(block, RegularRuleList, [&rules](RefPtr<StyleRuleBase> rule) {

        rules.append(rule);

    });

    if (m_observerWrapper)

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

    return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(), supported, rules);

}

#if ENABLE(CSS_DEVICE_ADAPTATION)

RefPtr<StyleRuleViewport> CSSParserImpl::consumeViewportRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    if (!prelude.atEnd())

        return nullptr; // Parser error; @viewport prelude should be empty

    if (m_observerWrapper) {

        unsigned endOffset = m_observerWrapper->endOffset(prelude);

        m_observerWrapper->observer().startRuleHeader(StyleRule::Viewport, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(endOffset);

        m_observerWrapper->observer().startRuleBody(endOffset);

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

    }

    consumeDeclarationList(block, StyleRule::Viewport);

    return StyleRuleViewport::create(createStyleProperties(m_parsedProperties, CSSViewportRuleMode));

}

#endif

RefPtr<StyleRuleFontFace> CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    if (!prelude.atEnd())

        return nullptr; // Parse error; @font-face prelude should be empty

    if (m_observerWrapper) {

        unsigned endOffset = m_observerWrapper->endOffset(prelude);

        m_observerWrapper->observer().startRuleHeader(StyleRule::FontFace, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(endOffset);

        m_observerWrapper->observer().startRuleBody(endOffset);

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

    }

    consumeDeclarationList(block, StyleRule::FontFace);

    return StyleRuleFontFace::create(createStyleProperties(m_parsedProperties, m_context.mode));

}

RefPtr<StyleRuleKeyframes> CSSParserImpl::consumeKeyframesRule(bool webkitPrefixed, CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    CSSParserTokenRange rangeCopy = prelude; // For inspector callbacks

    const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();

    if (!prelude.atEnd())

        return nullptr; // Parse error; expected single non-whitespace token in @keyframes header

    String name;

    if (nameToken.type() == IdentToken) {

        name = nameToken.value().toString();

    } else if (nameToken.type() == StringToken && webkitPrefixed)

        name = nameToken.value().toString();

    else

        return nullptr; // Parse error; expected ident token in @keyframes header

    if (m_observerWrapper) {

        m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframes, m_observerWrapper->startOffset(rangeCopy));

        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));

        m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));

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

    }

    RefPtr<StyleRuleKeyframes> keyframeRule = StyleRuleKeyframes::create();

    consumeRuleList(block, KeyframesRuleList, [keyframeRule](RefPtr<StyleRuleBase> keyframe) {

        RefPtr<StyleKeyframe> key = static_cast<StyleKeyframe*>(keyframe.get());

        keyframeRule->parserAppendKeyframe(key.releaseNonNull());

    });

    keyframeRule->setName(name);

    // FIXME-NEWPARSER: Find out why this is done. Behavior difference when prefixed?

    // keyframeRule->setVendorPrefixed(webkitPrefixed);

    return keyframeRule;

}

RefPtr<StyleRulePage> CSSParserImpl::consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    CSSSelectorList selectorList = parsePageSelector(prelude, m_styleSheet.get());

    if (!selectorList.isValid())

        return nullptr; // Parse error, invalid @page selector

    if (m_observerWrapper) {

        unsigned endOffset = m_observerWrapper->endOffset(prelude);

        m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(endOffset);

    }

    consumeDeclarationList(block, StyleRule::Style);

    RefPtr<StyleRulePage> page = StyleRulePage::create(createStyleProperties(m_parsedProperties, m_context.mode));

    page->wrapperAdoptSelectorList(selectorList);

    return page;

}

// FIXME-NEWPARSER: Support "apply"

/*void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude)

{

    const CSSParserToken& ident = prelude.consumeIncludingWhitespace();

    if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))

        return; // Parse error, expected a single custom property name

    m_parsedProperties.append(CSSProperty(

        CSSPropertyApplyAtRule,

        *CSSCustomIdentValue::create(ident.value().toString())));

}

*/

RefPtr<StyleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    std::unique_ptr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);

    if (!keyList)

        return nullptr;

    if (m_observerWrapper) {

        m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframe, m_observerWrapper->startOffset(prelude));

        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));

    }

    consumeDeclarationList(block, StyleRule::Keyframe);

    return StyleKeyframe::create(WTFMove(keyList), createStyleProperties(m_parsedProperties, m_context.mode));

}

static void observeSelectors(CSSParserObserverWrapper& wrapper, CSSParserTokenRange selectors)

{

    // This is easier than hooking into the CSSSelectorParser

    selectors.consumeWhitespace();

    CSSParserTokenRange originalRange = selectors;

    wrapper.observer().startRuleHeader(StyleRule::Style, wrapper.startOffset(originalRange));

    while (!selectors.atEnd()) {

        const CSSParserToken* selectorStart = &selectors.peek();

        while (!selectors.atEnd() && selectors.peek().type() != CommaToken)

            selectors.consumeComponentValue();

        CSSParserTokenRange selector = selectors.makeSubRange(selectorStart, &selectors.peek());

        selectors.consumeIncludingWhitespace();

        wrapper.observer().observeSelector(wrapper.startOffset(selector), wrapper.endOffset(selector));

    }

    wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange));

}

RefPtr<StyleRule> CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)

{

    CSSSelectorList selectorList = CSSSelectorParser::parseSelector(prelude, m_context, m_styleSheet.get());

    if (!selectorList.isValid())

        return nullptr; // Parse error, invalid selector list

    if (m_observerWrapper)

        observeSelectors(*m_observerWrapper, prelude);

    consumeDeclarationList(block, StyleRule::Style);

    // FIXME-NEWPARSER: Line number is in the StyleRule constructor (gross), need to figure this out.

    RefPtr<StyleRule> rule = StyleRule::create(0, createStyleProperties(m_parsedProperties, m_context.mode));

    rule->wrapperAdoptSelectorList(selectorList);

    return rule;

}

void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range, StyleRule::Type ruleType)

{

    ASSERT(m_parsedProperties.isEmpty());

    bool useObserver = m_observerWrapper && (ruleType == StyleRule::Style || ruleType == StyleRule::Keyframe);

    if (useObserver) {

        m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(range));

        m_observerWrapper->skipCommentsBefore(range, true);

    }

    while (!range.atEnd()) {

        switch (range.peek().type()) {

        case WhitespaceToken:

        case SemicolonToken:

            range.consume();

            break;

        case IdentToken: {

            const CSSParserToken* declarationStart = &range.peek();

            if (useObserver)

                m_observerWrapper->yieldCommentsBefore(range);

            while (!range.atEnd() && range.peek().type() != SemicolonToken)

                range.consumeComponentValue();

            consumeDeclaration(range.makeSubRange(declarationStart, &range.peek()), ruleType);

            if (useObserver)

                m_observerWrapper->skipCommentsBefore(range, false);

            break;

        }

        case AtKeywordToken: {

            // FIXME-NEWPARSER: Support apply

            AllowedRulesType allowedRules = /* ruleType == StyleRule::Style && RuntimeEnabledFeatures::cssApplyAtRulesEnabled() ? ApplyRules :*/ NoRules;

            RefPtr<StyleRuleBase> rule = consumeAtRule(range, allowedRules);

            ASSERT_UNUSED(rule, !rule);

            break;

        }

        default: // Parse error, unexpected token in declaration list

            while (!range.atEnd() && range.peek().type() != SemicolonToken)

                range.consumeComponentValue();

            break;

        }

    }

    // Yield remaining comments

    if (useObserver) {

        m_observerWrapper->yieldCommentsBefore(range);

        m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(range));

    }

}

void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range, StyleRule::Type ruleType)

{

    CSSParserTokenRange rangeCopy = range; // For inspector callbacks

    ASSERT(range.peek().type() == IdentToken);

    const CSSParserToken& token = range.consumeIncludingWhitespace();

    CSSPropertyID unresolvedProperty = token.parseAsUnresolvedCSSPropertyID();

    if (range.consume().type() != ColonToken)

        return; // Parse error

    bool important = false;

    const CSSParserToken* declarationValueEnd = range.end();

    const CSSParserToken* last = range.end() - 1;

    while (last->type() == WhitespaceToken)

        --last;

    if (last->type() == IdentToken && equalIgnoringASCIICase(last->value(), "important")) {

        --last;

        while (last->type() == WhitespaceToken)

            --last;

        if (last->type() == DelimiterToken && last->delimiter() == '!') {

            important = true;

            declarationValueEnd = last;

        }

    }

    size_t propertiesCount = m_parsedProperties.size();

    // FIXME-NEWPARSER: Support variables

    /*if (unresolvedProperty == CSSPropertyInvalid && CSSVariableParser::isValidVariableName(token)) {

        AtomicString variableName = token.value().toAtomicString();

        consumeVariableValue(range.makeSubRange(&range.peek(), declarationValueEnd), variableName, important);

    }*/

    if (important && (ruleType == StyleRule::FontFace || ruleType == StyleRule::Keyframe))

        return;

    if (unresolvedProperty != CSSPropertyInvalid)

        consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), unresolvedProperty, important, ruleType);

    if (m_observerWrapper && (ruleType == StyleRule::Style || ruleType == StyleRule::Keyframe)) {

        m_observerWrapper->observer().observeProperty(

            m_observerWrapper->startOffset(rangeCopy), m_observerWrapper->endOffset(rangeCopy),

            important, m_parsedProperties.size() != propertiesCount);

    }

}

void CSSParserImpl::consumeVariableValue(CSSParserTokenRange /* range */, const AtomicString& /*variableName */, bool /* important */)

{

    // FIXME-NEWPARSER: Support variables

    // if (CSSCustomPropertyDeclaration* value = CSSVariableParser::parseDeclarationValue(variableName, range))

    //     m_parsedProperties.append(CSSProperty(CSSPropertyVariable, *value, important));

}

void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID unresolvedProperty, bool important, StyleRule::Type ruleType)

{

    CSSPropertyParser::parseValue(unresolvedProperty, important, range, m_context, m_parsedProperties, ruleType);

}

std::unique_ptr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenRange range)

{

    std::unique_ptr<Vector<double>> result = std::unique_ptr<Vector<double>>(new Vector<double>);

    while (true) {

        range.consumeWhitespace();

        const CSSParserToken& token = range.consumeIncludingWhitespace();

        if (token.type() == PercentageToken && token.numericValue() >= 0 && token.numericValue() <= 100)

            result->append(token.numericValue() / 100);

        else if (token.type() == IdentToken && equalIgnoringASCIICase(token.value(), "from"))

            result->append(0);

        else if (token.type() == IdentToken && equalIgnoringASCIICase(token.value(), "to"))

            result->append(1);

        else

            return nullptr; // Parser error, invalid value in keyframe selector

        if (range.atEnd())

            return result;

        if (range.consume().type() != CommaToken)

            return nullptr; // Parser error

    }

}

} // namespace WebCore

// Copyright 2014 The Chromium Authors. All rights reserved.

// Copyright (C) 2016 Apple Inc. All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//    * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//    * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#pragma once

#include "CSSParserMode.h"

#include "CSSParserTokenRange.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "CSSPropertySourceData.h"

#include "StyleRule.h"

#include <memory>

#include <wtf/Vector.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

class CSSParserObserver;

class CSSParserObserverWrapper;

class CSSSelectorList;

class StyleKeyframe;

class StyleRule;

class StyleRuleBase;

class StyleRuleCharset;

class StyleRuleFontFace;

class StyleRuleImport;

class StyleRuleKeyframes;

class StyleRuleMedia;

class StyleRuleNamespace;

class StyleRulePage;

class StyleRuleSupports;

class StyleRuleViewport;

class StyleSheetContents;

class ImmutableStyleProperties;

class Element;

class MutableStyleProperties;

class CSSParserImpl {

    WTF_MAKE_NONCOPYABLE(CSSParserImpl);

public:

    CSSParserImpl(const CSSParserContext&, StyleSheetContents* = nullptr);

    enum AllowedRulesType {

        // As per css-syntax, css-cascade and css-namespaces, @charset rules

        // must come first, followed by @import then @namespace.

        // AllowImportRules actually means we allow @import and any rules thay

        // may follow it, i.e. @namespace rules and regular rules.

        // AllowCharsetRules and AllowNamespaceRules behave similarly.

        AllowCharsetRules,

        AllowImportRules,

        AllowNamespaceRules,

        RegularRules,

        KeyframeRules,

        ApplyRules, // For @apply inside style rules

        NoRules, // For parsing at-rules inside declaration lists

    };

    static bool parseValue(MutableStyleProperties*, CSSPropertyID, const String&, bool important, const CSSParserContext&);

    static bool parseVariableValue(MutableStyleProperties*, const AtomicString& propertyName, const String&, bool important, const CSSParserContext&);

    static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, Element*);

    static bool parseDeclarationList(MutableStyleProperties*, const String&, const CSSParserContext&);

    static RefPtr<StyleRuleBase> parseRule(const String&, const CSSParserContext&, StyleSheetContents*, AllowedRulesType);

    static void parseStyleSheet(const String&, const CSSParserContext&, StyleSheetContents*);

    static CSSSelectorList parsePageSelector(CSSParserTokenRange, StyleSheetContents*);

    static RefPtr<ImmutableStyleProperties> parseCustomPropertySet(CSSParserTokenRange);

    static std::unique_ptr<Vector<double>> parseKeyframeKeyList(const String&);

    bool supportsDeclaration(CSSParserTokenRange&);

    static void parseDeclarationListForInspector(const String&, const CSSParserContext&, CSSParserObserver&);

    static void parseStyleSheetForInspector(const String&, const CSSParserContext&, StyleSheetContents*, CSSParserObserver&);

private:

    enum RuleListType {

        TopLevelRuleList,

        RegularRuleList,

        KeyframesRuleList

    };

    // Returns whether the first encountered rule was valid

    template<typename T>

    bool consumeRuleList(CSSParserTokenRange, RuleListType, T callback);

    // These two functions update the range they're given

    RefPtr<StyleRuleBase> consumeAtRule(CSSParserTokenRange&, AllowedRulesType);

    RefPtr<StyleRuleBase> consumeQualifiedRule(CSSParserTokenRange&, AllowedRulesType);

    static RefPtr<StyleRuleCharset> consumeCharsetRule(CSSParserTokenRange prelude);

    RefPtr<StyleRuleImport> consumeImportRule(CSSParserTokenRange prelude);

    RefPtr<StyleRuleNamespace> consumeNamespaceRule(CSSParserTokenRange prelude);

    RefPtr<StyleRuleMedia> consumeMediaRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

    RefPtr<StyleRuleSupports> consumeSupportsRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

    RefPtr<StyleRuleViewport> consumeViewportRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

    RefPtr<StyleRuleFontFace> consumeFontFaceRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

    RefPtr<StyleRuleKeyframes> consumeKeyframesRule(bool webkitPrefixed, CSSParserTokenRange prelude, CSSParserTokenRange block);

    RefPtr<StyleRulePage> consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

    // Updates m_parsedProperties

    // FIXME-NEWPARSER: Support "apply"

    // void consumeApplyRule(CSSParserTokenRange prelude);

    RefPtr<StyleKeyframe> consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block);

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

    void consumeDeclarationList(CSSParserTokenRange, StyleRule::Type);

    void consumeDeclaration(CSSParserTokenRange, StyleRule::Type);

    void consumeDeclarationValue(CSSParserTokenRange, CSSPropertyID, bool important, StyleRule::Type);

    void consumeVariableValue(CSSParserTokenRange, const AtomicString& propertyName, bool important);

    static std::unique_ptr<Vector<double>> consumeKeyframeKeyList(CSSParserTokenRange);

    // FIXME: Can we build StylePropertySets directly?

    // FIXME: Investigate using a smaller inline buffer

    ParsedPropertyVector m_parsedProperties;

    const CSSParserContext& m_context;

    RefPtr<StyleSheetContents> m_styleSheet;

    // For the inspector

    CSSParserObserverWrapper* m_observerWrapper;

};

} // namespace WebCore

CSSParserSelector* CSSParserSelector::parsePagePseudoSelector(const AtomicString& pseudoTypeString)

{

    CSSSelector::PagePseudoClassType pseudoType;

    if (equalLettersIgnoringASCIICase(pseudoTypeString, "first"))

        pseudoType = CSSSelector::PagePseudoClassFirst;

    else if (equalLettersIgnoringASCIICase(pseudoTypeString, "left"))

        pseudoType = CSSSelector::PagePseudoClassLeft;

    else if (equalLettersIgnoringASCIICase(pseudoTypeString, "right"))

        pseudoType = CSSSelector::PagePseudoClassRight;

    else

        return nullptr;

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

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

    selector->m_selector->setPagePseudoType(pseudoType);

    return selector.release();

}

    // FIXME-NEWPARSER: Remove the CSSParserString-based parsing functions once the old parser is gone.

    static CSSParserSelector* parsePagePseudoSelector(const AtomicString&);

    return false;

    /*

     */

// Copyright 2015 The Chromium Authors. All rights reserved.

// Copyright (C) 2016 Apple Inc. All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//    * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//    * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "config.h"

#include "CSSSupportsParser.h"

#include "CSSParserImpl.h"

namespace WebCore {

CSSSupportsParser::SupportsResult CSSSupportsParser::supportsCondition(CSSParserTokenRange range, CSSParserImpl& parser)

{

    // FIXME: The spec allows leading whitespace in @supports but not CSS.supports,

    // but major browser vendors allow it in CSS.supports also.

    range.consumeWhitespace();

    return CSSSupportsParser(parser).consumeCondition(range);

}

enum ClauseType { Unresolved, Conjunction, Disjunction };

CSSSupportsParser::SupportsResult CSSSupportsParser::consumeCondition(CSSParserTokenRange range)

{

    if (range.peek().type() == IdentToken)

        return consumeNegation(range);

    bool result;

    ClauseType clauseType = Unresolved;

    while (true) {

        SupportsResult nextResult = consumeConditionInParenthesis(range);

        if (nextResult == Invalid)

            return Invalid;

        bool nextSupported = nextResult;

        if (clauseType == Unresolved)

            result = nextSupported;

        else if (clauseType == Conjunction)

            result &= nextSupported;

        else

            result |= nextSupported;

        if (range.atEnd())

            break;

        if (range.consumeIncludingWhitespace().type() != WhitespaceToken)

            return Invalid;

        if (range.atEnd())

            break;

        const CSSParserToken& token = range.consume();

        if (token.type() != IdentToken)

            return Invalid;

        if (clauseType == Unresolved)

            clauseType = token.value().length() == 3 ? Conjunction : Disjunction;

        if ((clauseType == Conjunction && !equalIgnoringASCIICase(token.value(), "and"))

            || (clauseType == Disjunction && !equalIgnoringASCIICase(token.value(), "or")))

            return Invalid;

        if (range.consumeIncludingWhitespace().type() != WhitespaceToken)

            return Invalid;

    }

    return result ? Supported : Unsupported;

}

CSSSupportsParser::SupportsResult CSSSupportsParser::consumeNegation(CSSParserTokenRange range)

{

    ASSERT(range.peek().type() == IdentToken);

    if (!equalIgnoringASCIICase(range.consume().value(), "not"))

        return Invalid;

    if (range.consumeIncludingWhitespace().type() != WhitespaceToken)

        return Invalid;

    SupportsResult result = consumeConditionInParenthesis(range);

    range.consumeWhitespace();

    if (!range.atEnd() || result == Invalid)

        return Invalid;

    return result ? Unsupported : Supported;

}

CSSSupportsParser::SupportsResult CSSSupportsParser::consumeConditionInParenthesis(CSSParserTokenRange& range)

{

    if (range.peek().type() == FunctionToken) {

        range.consumeComponentValue();

        return Unsupported;

    }

    if (range.peek().type() != LeftParenthesisToken)

        return Invalid;

    CSSParserTokenRange innerRange = range.consumeBlock();

    innerRange.consumeWhitespace();

    SupportsResult result = consumeCondition(innerRange);

    if (result != Invalid)

        return result;

    return innerRange.peek().type() == IdentToken && m_parser.supportsDeclaration(innerRange) ? Supported : Unsupported;

}

} // namespace blink

// Copyright 2015 The Chromium Authors. All rights reserved.

// Copyright (C) 2016 Apple Inc. All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//    * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//    * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//    * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#pragma once

namespace WebCore {

class CSSParserImpl;

class CSSParserTokenRange;

class CSSSupportsParser {

public:

    enum SupportsResult {

        Unsupported = false,

        Supported = true,

        Invalid

    };

    static SupportsResult supportsCondition(CSSParserTokenRange, CSSParserImpl&);

private:

    CSSSupportsParser(CSSParserImpl& parser)

        : m_parser(parser) { }

    SupportsResult consumeCondition(CSSParserTokenRange);

    SupportsResult consumeNegation(CSSParserTokenRange);

    SupportsResult consumeConditionInParenthesis(CSSParserTokenRange&);

    CSSParserImpl& m_parser;

};

} // namespace WebCore