1 files changed, 135 insertions, 0 deletions
diff --git a/Source/WebCore/css/parser/CSSParserSelector.h b/Source/WebCore/css/parser/CSSParserSelector.h
new file mode 100644
index 000000000..a3d2e19d1
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserSelector.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010, 2014 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.
+ */
+
+#pragma once
+
+#include "CSSSelector.h"
+#include "CSSValueKeywords.h"
+#include "CSSValueList.h"
+#include <wtf/text/AtomicString.h>
+#include <wtf/text/AtomicStringHash.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSValue;
+class QualifiedName;
+
+enum class CSSParserSelectorCombinator {
+    Child,
+    DescendantSpace,
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+    DescendantDoubleChild,
+#endif
+    DirectAdjacent,
+    IndirectAdjacent
+};
+
+class CSSParserSelector {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    static CSSParserSelector* parsePseudoClassSelectorFromStringView(StringView&);
+    static CSSParserSelector* parsePseudoElementSelectorFromStringView(StringView&);
+    static CSSParserSelector* parsePagePseudoSelector(const AtomicString&);
+    
+    CSSParserSelector();
+    explicit CSSParserSelector(const QualifiedName&);
+    ~CSSParserSelector();
+
+    std::unique_ptr<CSSSelector> releaseSelector() { return WTFMove(m_selector); }
+
+    void setValue(const AtomicString& value, bool matchLowerCase = false) { m_selector->setValue(value, matchLowerCase); }
+    
+    // FIXME-NEWPARSER: These two methods can go away once old parser is gone.
+    void setAttribute(const QualifiedName& value, bool isCaseInsensitive) { m_selector->setAttribute(value, isCaseInsensitive); }
+    void setAttributeValueMatchingIsCaseInsensitive(bool isCaseInsensitive) { m_selector->setAttributeValueMatchingIsCaseInsensitive(isCaseInsensitive); }
+    
+    void setAttribute(const QualifiedName& value, bool convertToLowercase, CSSSelector::AttributeMatchType type) { m_selector->setAttribute(value, convertToLowercase, type); }
+    
+    void setArgument(const AtomicString& value) { m_selector->setArgument(value); }
+    void setNth(int a, int b) { m_selector->setNth(a, b); }
+    void setMatch(CSSSelector::Match value) { m_selector->setMatch(value); }
+    void setRelation(CSSSelector::RelationType value) { m_selector->setRelation(value); }
+    void setForPage() { m_selector->setForPage(); }
+
+    CSSSelector::Match match() const { return m_selector->match(); }
+    CSSSelector::PseudoElementType pseudoElementType() const { return m_selector->pseudoElementType(); }
+    const CSSSelectorList* selectorList() const { return m_selector->selectorList(); }
+    
+    void setPseudoElementType(CSSSelector::PseudoElementType type) { m_selector->setPseudoElementType(type); }
+
+    void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
+    void setLangArgumentList(std::unique_ptr<Vector<AtomicString>>);
+    void setSelectorList(std::unique_ptr<CSSSelectorList>);
+
+    CSSSelector::PseudoClassType pseudoClassType() const { return m_selector->pseudoClassType(); }
+    bool isCustomPseudoElement() const { return m_selector->isCustomPseudoElement(); }
+
+    bool isPseudoElementCueFunction() const
+    {
+#if ENABLE(VIDEO_TRACK)
+        return m_selector->match() == CSSSelector::PseudoElement && m_selector->pseudoElementType() == CSSSelector::PseudoElementCue;
+#else
+        return false;
+#endif
+    }
+
+    bool hasShadowDescendant() const;
+    bool matchesPseudoElement() const;
+
+    bool isHostPseudoSelector() const;
+
+    // FIXME-NEWPARSER: "slotted" was removed here for now, since it leads to a combinator
+    // connection of ShadowDescendant, and the current shadow DOM code doesn't expect this. When
+    // we do fix this issue, make sure to patch the namespace prependTag code to remove the slotted
+    // special case, since it will be covered by this function once again.
+    bool needsImplicitShadowCombinatorForMatching() const;
+
+    CSSParserSelector* tagHistory() const { return m_tagHistory.get(); }
+    void setTagHistory(std::unique_ptr<CSSParserSelector> selector) { m_tagHistory = WTFMove(selector); }
+    void clearTagHistory() { m_tagHistory.reset(); }
+    void insertTagHistory(CSSSelector::RelationType before, std::unique_ptr<CSSParserSelector>, CSSSelector::RelationType after);
+    void appendTagHistory(CSSSelector::RelationType, std::unique_ptr<CSSParserSelector>);
+    void appendTagHistory(CSSParserSelectorCombinator, std::unique_ptr<CSSParserSelector>);
+    void prependTagSelector(const QualifiedName&, bool tagIsForNamespaceRule = false);
+    std::unique_ptr<CSSParserSelector> releaseTagHistory();
+
+private:
+    std::unique_ptr<CSSSelector> m_selector;
+    std::unique_ptr<CSSParserSelector> m_tagHistory;
+};
+
+inline bool CSSParserSelector::hasShadowDescendant() const
+{
+    return m_selector->relation() == CSSSelector::ShadowDescendant;
+}
+
+inline bool CSSParserSelector::needsImplicitShadowCombinatorForMatching() const
+{
+    return match() == CSSSelector::PseudoElement
+        && (pseudoElementType() == CSSSelector::PseudoElementWebKitCustom
+            || pseudoElementType() == CSSSelector::PseudoElementUserAgentCustom
+#if ENABLE(VIDEO_TRACK)
+            || pseudoElementType() == CSSSelector::PseudoElementCue
+#endif
+            || pseudoElementType() == CSSSelector::PseudoElementWebKitCustomLegacyPrefixed);
+}
+
+}