webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

44 files changed, 15519 insertions, 0 deletions

diff --git a/Source/WebCore/css/parser/CSSAtRuleID.cpp b/Source/WebCore/css/parser/CSSAtRuleID.cpp
new file mode 100644
index 000000000..c0c3144c9
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSAtRuleID.cpp
@@ -0,0 +1,67 @@
+// 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 "CSSAtRuleID.h"
+
+namespace WebCore {
+
+CSSAtRuleID cssAtRuleID(StringView name)
+{
+    if (equalIgnoringASCIICase(name, "charset"))
+        return CSSAtRuleCharset;
+    if (equalIgnoringASCIICase(name, "font-face"))
+        return CSSAtRuleFontFace;
+    if (equalIgnoringASCIICase(name, "import"))
+        return CSSAtRuleImport;
+    if (equalIgnoringASCIICase(name, "keyframes"))
+        return CSSAtRuleKeyframes;
+    if (equalIgnoringASCIICase(name, "media"))
+        return CSSAtRuleMedia;
+    if (equalIgnoringASCIICase(name, "namespace"))
+        return CSSAtRuleNamespace;
+    if (equalIgnoringASCIICase(name, "page"))
+        return CSSAtRulePage;
+    if (equalIgnoringASCIICase(name, "supports"))
+        return CSSAtRuleSupports;
+    if (equalIgnoringASCIICase(name, "viewport"))
+        return CSSAtRuleViewport;
+    if (equalIgnoringASCIICase(name, "-webkit-keyframes"))
+        return CSSAtRuleWebkitKeyframes;
+    if (equalIgnoringASCIICase(name, "apply"))
+        return CSSAtRuleApply;
+#if ENABLE(CSS_REGIONS)
+    if (equalIgnoringASCIICase(name, "-webkit-region"))
+        return CSSAtRuleWebkitRegion;
+#endif
+    return CSSAtRuleInvalid;
+}
+
+} // namespace WebCore
+
diff --git a/Source/WebCore/css/parser/CSSAtRuleID.h b/Source/WebCore/css/parser/CSSAtRuleID.h
new file mode 100644
index 000000000..e360a7fd2
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSAtRuleID.h
@@ -0,0 +1,55 @@
+// 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
+#include <wtf/text/StringView.h>
+
+namespace WebCore {
+
+enum CSSAtRuleID {
+    CSSAtRuleInvalid = 0,
+
+    CSSAtRuleCharset = 1,
+    CSSAtRuleFontFace = 2,
+    CSSAtRuleImport = 3,
+    CSSAtRuleKeyframes = 4,
+    CSSAtRuleMedia = 5,
+    CSSAtRuleNamespace = 6,
+    CSSAtRulePage = 7,
+    CSSAtRuleSupports = 8,
+    CSSAtRuleViewport = 9,
+
+    CSSAtRuleWebkitKeyframes = 10,
+    CSSAtRuleApply = 11,
+    CSSAtRuleWebkitRegion = 12
+};
+
+CSSAtRuleID cssAtRuleID(StringView name);
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSDeferredParser.cpp b/Source/WebCore/css/parser/CSSDeferredParser.cpp
new file mode 100644
index 000000000..06469ea9f
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSDeferredParser.cpp
@@ -0,0 +1,57 @@
+/*
+ * 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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 "CSSDeferredParser.h"
+
+#include "CSSParserImpl.h"
+#include "StyleSheetContents.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+CSSDeferredParser::CSSDeferredParser(const CSSParserContext& context, const String& sheetText, StyleSheetContents& styleSheet)
+    : m_context(context)
+    , m_sheetText(sheetText)
+    , m_styleSheet(styleSheet.createWeakPtr())
+{
+}
+
+Ref<ImmutableStyleProperties> CSSDeferredParser::parseDeclaration(const CSSParserTokenRange& range)
+{
+    return CSSParserImpl::parseDeferredDeclaration(range, m_context, m_styleSheet.get());
+}
+
+void CSSDeferredParser::parseRuleList(const CSSParserTokenRange& range, Vector<RefPtr<StyleRuleBase>>& childRules)
+{
+    CSSParserImpl::parseDeferredRuleList(range, *this, childRules);
+}
+
+void CSSDeferredParser::parseKeyframeList(const CSSParserTokenRange& range, StyleRuleKeyframes&keyframesRule)
+{
+    CSSParserImpl::parseDeferredKeyframeList(range, *this, keyframesRule);
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSDeferredParser.h b/Source/WebCore/css/parser/CSSDeferredParser.h
new file mode 100644
index 000000000..9b09d767a
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSDeferredParser.h
@@ -0,0 +1,68 @@
+/*
+ * 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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 "CSSTokenizer.h"
+#include <wtf/RefCounted.h>
+#include <wtf/WeakPtr.h>
+
+namespace WebCore {
+
+class ImmutableStyleProperties;
+class StyleRuleKeyframes;
+class StyleRuleBase;
+
+class CSSDeferredParser : public RefCounted<CSSDeferredParser> {
+public:
+    static Ref<CSSDeferredParser> create(const CSSParserContext& parserContext, const String& sheetText, StyleSheetContents& styleSheet)
+    {
+        return adoptRef(*new CSSDeferredParser(parserContext, sheetText, styleSheet));
+    }
+
+    CSSParserMode mode() const { return m_context.mode; }
+
+    const CSSParserContext& context() const { return m_context; }
+    StyleSheetContents* styleSheet() const { return m_styleSheet.get(); }
+
+    Ref<ImmutableStyleProperties> parseDeclaration(const CSSParserTokenRange&);
+    void parseRuleList(const CSSParserTokenRange&, Vector<RefPtr<StyleRuleBase>>&);
+    void parseKeyframeList(const CSSParserTokenRange&, StyleRuleKeyframes&);
+
+    void adoptTokenizerEscapedStrings(Vector<String>&& strings) { m_escapedStrings = WTFMove(strings); }
+
+private:
+    CSSDeferredParser(const CSSParserContext&, const String&, StyleSheetContents&);
+    
+    Vector<String> m_escapedStrings;
+    CSSParserContext m_context;
+    
+    String m_sheetText;
+
+    WeakPtr<StyleSheetContents> m_styleSheet;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParser.cpp b/Source/WebCore/css/parser/CSSParser.cpp
new file mode 100644
index 000000000..4af6ecfc8
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParser.cpp
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
+ * Copyright (C) 2004-2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
+ * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
+ * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2012, 2013 Adobe Systems Incorporated. All rights reserved.
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2014 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 "CSSParser.h"
+
+#include "CSSKeyframeRule.h"
+#include "CSSParserFastPaths.h"
+#include "CSSParserImpl.h"
+#include "CSSPendingSubstitutionValue.h"
+#include "CSSPropertyParser.h"
+#include "CSSSelectorParser.h"
+#include "CSSSupportsParser.h"
+#include "CSSTokenizer.h"
+#include "CSSVariableData.h"
+#include "CSSVariableReferenceValue.h"
+#include "Document.h"
+#include "Element.h"
+#include "Page.h"
+#include "RenderTheme.h"
+#include "RuntimeEnabledFeatures.h"
+#include "Settings.h"
+#include "StyleColor.h"
+#include "StyleRule.h"
+#include "StyleSheetContents.h"
+#include <wtf/NeverDestroyed.h>
+#include <wtf/text/StringBuilder.h>
+
+using namespace WTF;
+
+namespace WebCore {
+
+const CSSParserContext& strictCSSParserContext()
+{
+    static NeverDestroyed<CSSParserContext> strictContext(HTMLStandardMode);
+    return strictContext;
+}
+
+CSSParserContext::CSSParserContext(CSSParserMode mode, const URL& baseURL)
+    : baseURL(baseURL)
+    , mode(mode)
+    , cssGridLayoutEnabled(RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled())
+{
+#if PLATFORM(IOS)
+    // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
+    // to see if we can enable the preference all together is to be handled by:
+    // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
+    needsSiteSpecificQuirks = true;
+#endif
+}
+
+CSSParserContext::CSSParserContext(Document& document, const URL& baseURL, const String& charset)
+    : baseURL(baseURL.isNull() ? document.baseURL() : baseURL)
+    , charset(charset)
+    , mode(document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode)
+    , isHTMLDocument(document.isHTMLDocument())
+    , cssGridLayoutEnabled(document.isCSSGridLayoutEnabled())
+{
+    needsSiteSpecificQuirks = document.settings().needsSiteSpecificQuirks();
+    enforcesCSSMIMETypeInNoQuirksMode = document.settings().enforceCSSMIMETypeInNoQuirksMode();
+    useLegacyBackgroundSizeShorthandBehavior = document.settings().useLegacyBackgroundSizeShorthandBehavior();
+#if ENABLE(TEXT_AUTOSIZING)
+    textAutosizingEnabled = document.settings().textAutosizingEnabled();
+#endif
+    springTimingFunctionEnabled = document.settings().springTimingFunctionEnabled();
+    deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
+
+#if PLATFORM(IOS)
+    // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
+    // to see if we can enable the preference all together is to be handled by:
+    // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
+    needsSiteSpecificQuirks = true;
+#endif
+}
+
+bool operator==(const CSSParserContext& a, const CSSParserContext& b)
+{
+    return a.baseURL == b.baseURL
+        && a.charset == b.charset
+        && a.mode == b.mode
+        && a.isHTMLDocument == b.isHTMLDocument
+        && a.cssGridLayoutEnabled == b.cssGridLayoutEnabled
+        && a.needsSiteSpecificQuirks == b.needsSiteSpecificQuirks
+        && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
+        && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior
+        && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled
+        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled;
+}
+
+CSSParser::CSSParser(const CSSParserContext& context)
+    : m_context(context)
+{
+}
+
+CSSParser::~CSSParser()
+{
+}
+
+void CSSParser::parseSheet(StyleSheetContents* sheet, const String& string, RuleParsing ruleParsing)
+{
+    return CSSParserImpl::parseStyleSheet(string, m_context, sheet, ruleParsing);
+}
+
+void CSSParser::parseSheetForInspector(const CSSParserContext& context, StyleSheetContents* sheet, const String& string, CSSParserObserver& observer)
+{
+    return CSSParserImpl::parseStyleSheetForInspector(string, context, sheet, observer);
+}
+
+RefPtr<StyleRuleBase> CSSParser::parseRule(const CSSParserContext& context, StyleSheetContents* sheet, const String& string)
+{
+    return CSSParserImpl::parseRule(string, context, sheet, CSSParserImpl::AllowImportRules);
+}
+
+RefPtr<StyleRuleKeyframe> CSSParser::parseKeyframeRule(const String& string)
+{
+    RefPtr<StyleRuleBase> keyframe = CSSParserImpl::parseRule(string, m_context, nullptr, CSSParserImpl::KeyframeRules);
+    return downcast<StyleRuleKeyframe>(keyframe.get());
+}
+
+bool CSSParser::parseSupportsCondition(const String& condition)
+{
+    CSSParserImpl parser(m_context, condition);
+    return CSSSupportsParser::supportsCondition(parser.tokenizer()->tokenRange(), parser) == CSSSupportsParser::Supported;
+}
+
+Color CSSParser::parseColor(const String& string, bool strict)
+{
+    if (string.isEmpty())
+        return Color();
+    
+    // Try named colors first.
+    Color namedColor { string };
+    if (namedColor.isValid())
+        return namedColor;
+    
+    // Try the fast path to parse hex and rgb.
+    RefPtr<CSSValue> value = CSSParserFastPaths::parseColor(string, strict ? HTMLStandardMode : HTMLQuirksMode);
+    
+    // If that fails, try the full parser.
+    if (!value)
+        value = parseSingleValue(CSSPropertyColor, string, strictCSSParserContext());
+    if (!value || !value->isPrimitiveValue())
+        return Color();
+    const auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
+    if (!primitiveValue.isRGBColor())
+        return Color();
+    return primitiveValue.color();
+}
+
+Color CSSParser::parseSystemColor(const String& string, Document* document)
+{
+    if (!document || !document->page())
+        return Color();
+    
+    CSSValueID id = cssValueKeywordID(string);
+    if (!StyleColor::isSystemColor(id))
+        return Color();
+    
+    return document->page()->theme().systemColor(id);
+}
+
+RefPtr<CSSValue> CSSParser::parseSingleValue(CSSPropertyID propertyID, const String& string, const CSSParserContext& context)
+{
+    if (string.isEmpty())
+        return nullptr;
+    if (RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode))
+        return value;
+    CSSTokenizer tokenizer(string);
+    return CSSPropertyParser::parseSingleValue(propertyID, tokenizer.tokenRange(), context, nullptr);
+}
+
+CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
+{
+    ASSERT(!string.isEmpty());
+    RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode);
+    if (value)
+        return declaration.addParsedProperty(CSSProperty(propertyID, WTFMove(value), important)) ? CSSParser::ParseResult::Changed : CSSParser::ParseResult::Unchanged;
+
+    CSSParser parser(context);
+    return parser.parseValue(declaration, propertyID, string, important);
+}
+
+CSSParser::ParseResult CSSParser::parseCustomPropertyValue(MutableStyleProperties& declaration, const AtomicString& propertyName, const String& string, bool important, const CSSParserContext& context)
+{
+    return CSSParserImpl::parseCustomPropertyValue(&declaration, propertyName, string, important, context);
+}
+
+CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important)
+{
+    return CSSParserImpl::parseValue(&declaration, propertyID, string, important, m_context);
+}
+
+void CSSParser::parseSelector(const String& string, CSSSelectorList& selectorList)
+{
+    CSSTokenizer tokenizer(string);
+    selectorList = CSSSelectorParser::parseSelector(tokenizer.tokenRange(), m_context, nullptr);
+}
+
+Ref<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const String& string, Element* element)
+{
+    CSSParserContext context(element->document());
+    context.mode = strictToCSSParserMode(element->isHTMLElement() && !element->document().inQuirksMode());
+    return CSSParserImpl::parseInlineStyleDeclaration(string, element);
+}
+
+bool CSSParser::parseDeclaration(MutableStyleProperties& declaration, const String& string)
+{
+    return CSSParserImpl::parseDeclarationList(&declaration, string, m_context);
+}
+
+void CSSParser::parseDeclarationForInspector(const CSSParserContext& context, const String& string, CSSParserObserver& observer)
+{
+    CSSParserImpl::parseDeclarationListForInspector(string, context, observer);
+}
+
+RefPtr<CSSValue> CSSParser::parseValueWithVariableReferences(CSSPropertyID propID, const CSSValue& value, const CustomPropertyValueMap& customProperties, TextDirection direction, WritingMode writingMode)
+{
+    if (value.isPendingSubstitutionValue()) {
+        // FIXME: Should have a resolvedShorthands cache to stop this from being done
+        // over and over for each longhand value.
+        const CSSPendingSubstitutionValue& pendingSubstitution = downcast<CSSPendingSubstitutionValue>(value);
+        CSSPropertyID shorthandID = pendingSubstitution.shorthandPropertyId();
+        if (CSSProperty::isDirectionAwareProperty(shorthandID))
+            shorthandID = CSSProperty::resolveDirectionAwareProperty(shorthandID, direction, writingMode);
+        CSSVariableReferenceValue* shorthandValue = pendingSubstitution.shorthandValue();
+        const CSSVariableData* variableData = shorthandValue->variableDataValue();
+        ASSERT(variableData);
+        
+        Vector<CSSParserToken> resolvedTokens;
+        if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
+            return nullptr;
+        
+        ParsedPropertyVector parsedProperties;
+        if (!CSSPropertyParser::parseValue(shorthandID, false, resolvedTokens, m_context, nullptr, parsedProperties, StyleRule::Style))
+            return nullptr;
+        
+        for (auto& property : parsedProperties) {
+            if (property.id() == propID)
+                return property.value();
+        }
+        
+        return nullptr;
+    }
+
+    if (value.isVariableReferenceValue()) {
+        const CSSVariableReferenceValue& valueWithReferences = downcast<CSSVariableReferenceValue>(value);
+        const CSSVariableData* variableData = valueWithReferences.variableDataValue();
+        ASSERT(variableData);
+        
+        Vector<CSSParserToken> resolvedTokens;
+        if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
+            return nullptr;
+        
+        return CSSPropertyParser::parseSingleValue(propID, resolvedTokens, m_context, nullptr);
+    }
+    
+    return nullptr;
+}
+
+std::unique_ptr<Vector<double>> CSSParser::parseKeyframeKeyList(const String& selector)
+{
+    return CSSParserImpl::parseKeyframeKeyList(selector);
+}
+
+RefPtr<CSSValue> CSSParser::parseFontFaceDescriptor(CSSPropertyID propertyID, const String& propertyValue, const CSSParserContext& context)
+{
+    StringBuilder builder;
+    builder.append("@font-face { ");
+    builder.append(getPropertyNameString(propertyID));
+    builder.append(" : ");
+    builder.append(propertyValue);
+    builder.append("; }");
+    RefPtr<StyleRuleBase> rule = parseRule(context, nullptr, builder.toString());
+    if (!rule || !rule->isFontFaceRule())
+        return nullptr;
+    return downcast<StyleRuleFontFace>(*rule.get()).properties().getPropertyCSSValue(propertyID);
+}
+
+}
diff --git a/Source/WebCore/css/parser/CSSParser.h b/Source/WebCore/css/parser/CSSParser.h
new file mode 100644
index 000000000..0991dff40
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParser.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004-2010, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
+ * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. 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 "CSSParserMode.h"
+#include "CSSValue.h"
+#include "WritingMode.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSParserObserver;
+class CSSSelectorList;
+class Color;
+class Element;
+class ImmutableStyleProperties;
+class MutableStyleProperties;
+class StyleRuleBase;
+class StyleRuleKeyframe;
+class StyleSheetContents;
+
+class CSSParser {
+public:
+    enum class ParseResult {
+        Changed,
+        Unchanged,
+        Error
+    };
+
+    WEBCORE_EXPORT explicit CSSParser(const CSSParserContext&);
+    WEBCORE_EXPORT ~CSSParser();
+
+    enum class RuleParsing { Normal, Deferred };
+    void parseSheet(StyleSheetContents*, const String&, RuleParsing = RuleParsing::Normal);
+    
+    static RefPtr<StyleRuleBase> parseRule(const CSSParserContext&, StyleSheetContents*, const String&);
+    
+    RefPtr<StyleRuleKeyframe> parseKeyframeRule(const String&);
+    static std::unique_ptr<Vector<double>> parseKeyframeKeyList(const String&);
+    
+    bool parseSupportsCondition(const String&);
+
+    static void parseSheetForInspector(const CSSParserContext&, StyleSheetContents*, const String&, CSSParserObserver&);
+    static void parseDeclarationForInspector(const CSSParserContext&, const String&, CSSParserObserver&);
+
+    static ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important, const CSSParserContext&);
+    static ParseResult parseCustomPropertyValue(MutableStyleProperties&, const AtomicString& propertyName, const String&, bool important, const CSSParserContext&);
+    
+    static RefPtr<CSSValue> parseFontFaceDescriptor(CSSPropertyID, const String&, const CSSParserContext&);
+
+    static RefPtr<CSSValue> parseSingleValue(CSSPropertyID, const String&, const CSSParserContext& = strictCSSParserContext());
+
+    WEBCORE_EXPORT bool parseDeclaration(MutableStyleProperties&, const String&);
+    static Ref<ImmutableStyleProperties> parseInlineStyleDeclaration(const String&, Element*);
+
+    void parseSelector(const String&, CSSSelectorList&);
+
+    RefPtr<CSSValue> parseValueWithVariableReferences(CSSPropertyID, const CSSValue&, const CustomPropertyValueMap& customProperties, TextDirection, WritingMode);
+
+    static Color parseColor(const String&, bool strict = false);
+    static Color parseSystemColor(const String&, Document*);
+
+private:
+    ParseResult parseValue(MutableStyleProperties&, CSSPropertyID, const String&, bool important);
+
+    CSSParserContext m_context;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserFastPaths.cpp b/Source/WebCore/css/parser/CSSParserFastPaths.cpp
new file mode 100644
index 000000000..f563a9a6d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserFastPaths.cpp
@@ -0,0 +1,1258 @@
+// 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 "CSSParserFastPaths.h"
+
+#include "CSSFunctionValue.h"
+#include "CSSInheritedValue.h"
+#include "CSSInitialValue.h"
+#include "CSSParserIdioms.h"
+#include "CSSPrimitiveValue.h"
+#include "CSSPropertyParser.h"
+#include "CSSValueList.h"
+#include "CSSValuePool.h"
+#include "HTMLParserIdioms.h"
+#include "RuntimeEnabledFeatures.h"
+#include "StyleColor.h"
+#include "StylePropertyShorthand.h"
+#include "StyleSheetContents.h"
+
+namespace WebCore {
+
+static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers)
+{
+    switch (propertyId) {
+    case CSSPropertyFontSize:
+    case CSSPropertyGridColumnGap:
+    case CSSPropertyGridRowGap:
+    case CSSPropertyHeight:
+    case CSSPropertyWidth:
+    case CSSPropertyMinHeight:
+    case CSSPropertyMinWidth:
+    case CSSPropertyPaddingBottom:
+    case CSSPropertyPaddingLeft:
+    case CSSPropertyPaddingRight:
+    case CSSPropertyPaddingTop:
+    case CSSPropertyWebkitLogicalWidth:
+    case CSSPropertyWebkitLogicalHeight:
+    case CSSPropertyWebkitMinLogicalWidth:
+    case CSSPropertyWebkitMinLogicalHeight:
+    case CSSPropertyWebkitPaddingAfter:
+    case CSSPropertyWebkitPaddingBefore:
+    case CSSPropertyWebkitPaddingEnd:
+    case CSSPropertyWebkitPaddingStart:
+    case CSSPropertyShapeMargin:
+        acceptsNegativeNumbers = false;
+        return true;
+    case CSSPropertyBottom:
+    case CSSPropertyCx:
+    case CSSPropertyCy:
+    case CSSPropertyLeft:
+    case CSSPropertyMarginBottom:
+    case CSSPropertyMarginLeft:
+    case CSSPropertyMarginRight:
+    case CSSPropertyMarginTop:
+    case CSSPropertyRight:
+    case CSSPropertyTop:
+    case CSSPropertyWebkitMarginAfter:
+    case CSSPropertyWebkitMarginBefore:
+    case CSSPropertyWebkitMarginEnd:
+    case CSSPropertyWebkitMarginStart:
+    case CSSPropertyX:
+    case CSSPropertyY:
+    case CSSPropertyR:
+    case CSSPropertyRx:
+    case CSSPropertyRy:
+        acceptsNegativeNumbers = true;
+        return true;
+    default:
+        return false;
+    }
+}
+
+template <typename CharacterType>
+static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number)
+{
+    if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') {
+        length -= 2;
+        unit = CSSPrimitiveValue::UnitType::CSS_PX;
+    } else if (length > 1 && characters[length - 1] == '%') {
+        length -= 1;
+        unit = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
+    }
+
+    // We rely on charactersToDouble for validation as well. The function
+    // will set "ok" to "false" if the entire passed-in character range does
+    // not represent a double.
+    bool ok;
+    number = charactersToDouble(characters, length, &ok);
+    if (!ok)
+        return false;
+    return true;
+}
+
+static RefPtr<CSSValue> parseSimpleLengthValue(CSSPropertyID propertyId, const String& string, CSSParserMode cssParserMode)
+{
+    ASSERT(!string.isEmpty());
+    bool acceptsNegativeNumbers = false;
+
+    // In @viewport, width and height are shorthands, not simple length values.
+    if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
+        return nullptr;
+
+    unsigned length = string.length();
+    double number;
+    CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
+
+    if (string.is8Bit()) {
+        if (!parseSimpleLength(string.characters8(), length, unit, number))
+            return nullptr;
+    } else {
+        if (!parseSimpleLength(string.characters16(), length, unit, number))
+            return nullptr;
+    }
+
+    if (unit == CSSPrimitiveValue::UnitType::CSS_NUMBER) {
+        if (number && cssParserMode != SVGAttributeMode)
+            return nullptr;
+        unit = CSSPrimitiveValue::UnitType::CSS_PX;
+    }
+
+    if (number < 0 && !acceptsNegativeNumbers)
+        return nullptr;
+    if (std::isinf(number))
+        return nullptr;
+
+    return CSSPrimitiveValue::create(number, unit);
+}
+
+static inline bool isColorPropertyID(CSSPropertyID propertyId)
+{
+    switch (propertyId) {
+    case CSSPropertyColor:
+    case CSSPropertyBackgroundColor:
+    case CSSPropertyBorderBottomColor:
+    case CSSPropertyBorderLeftColor:
+    case CSSPropertyBorderRightColor:
+    case CSSPropertyBorderTopColor:
+    case CSSPropertyFill:
+    case CSSPropertyFloodColor:
+    case CSSPropertyLightingColor:
+    case CSSPropertyOutlineColor:
+    case CSSPropertyStopColor:
+    case CSSPropertyStroke:
+    case CSSPropertyWebkitBorderAfterColor:
+    case CSSPropertyWebkitBorderBeforeColor:
+    case CSSPropertyWebkitBorderEndColor:
+    case CSSPropertyWebkitBorderStartColor:
+    case CSSPropertyColumnRuleColor:
+    case CSSPropertyWebkitTextEmphasisColor:
+    case CSSPropertyWebkitTextFillColor:
+    case CSSPropertyWebkitTextStrokeColor:
+    case CSSPropertyWebkitTextDecorationColor:
+        return true;
+    default:
+        return false;
+    }
+}
+
+// Returns the number of characters which form a valid double
+// and are terminated by the given terminator character
+template <typename CharacterType>
+static int checkForValidDouble(const CharacterType* string, const CharacterType* end, const char terminator)
+{
+    int length = end - string;
+    if (length < 1)
+        return 0;
+
+    bool decimalMarkSeen = false;
+    int processedLength = 0;
+
+    for (int i = 0; i < length; ++i) {
+        if (string[i] == terminator) {
+            processedLength = i;
+            break;
+        }
+        if (!isASCIIDigit(string[i])) {
+            if (!decimalMarkSeen && string[i] == '.')
+                decimalMarkSeen = true;
+            else
+                return 0;
+        }
+    }
+
+    if (decimalMarkSeen && processedLength == 1)
+        return 0;
+
+    return processedLength;
+}
+
+// Returns the number of characters consumed for parsing a valid double
+// terminated by the given terminator character
+template <typename CharacterType>
+static int parseDouble(const CharacterType* string, const CharacterType* end, const char terminator, double& value)
+{
+    int length = checkForValidDouble(string, end, terminator);
+    if (!length)
+        return 0;
+
+    int position = 0;
+    double localValue = 0;
+
+    // The consumed characters here are guaranteed to be
+    // ASCII digits with or without a decimal mark
+    for (; position < length; ++position) {
+        if (string[position] == '.')
+            break;
+        localValue = localValue * 10 + string[position] - '0';
+    }
+
+    if (++position == length) {
+        value = localValue;
+        return length;
+    }
+
+    double fraction = 0;
+    double scale = 1;
+
+    const double maxScale = 1000000;
+    while (position < length && scale < maxScale) {
+        fraction = fraction * 10 + string[position++] - '0';
+        scale *= 10;
+    }
+
+    value = localValue + fraction / scale;
+    return length;
+}
+
+template <typename CharacterType>
+static bool parseColorIntOrPercentage(const CharacterType*& string, const CharacterType* end, const char terminator, CSSPrimitiveValue::UnitType& expect, int& value)
+{
+    const CharacterType* current = string;
+    double localValue = 0;
+    bool negative = false;
+    while (current != end && isHTMLSpace<CharacterType>(*current))
+        current++;
+    if (current != end && *current == '-') {
+        negative = true;
+        current++;
+    }
+    if (current == end || !isASCIIDigit(*current))
+        return false;
+    while (current != end && isASCIIDigit(*current)) {
+        double newValue = localValue * 10 + *current++ - '0';
+        if (newValue >= 255) {
+            // Clamp values at 255.
+            localValue = 255;
+            while (current != end && isASCIIDigit(*current))
+                ++current;
+            break;
+        }
+        localValue = newValue;
+    }
+
+    if (current == end)
+        return false;
+
+    if (expect == CSSPrimitiveValue::UnitType::CSS_NUMBER && (*current == '.' || *current == '%'))
+        return false;
+
+    if (*current == '.') {
+        // We already parsed the integral part, try to parse
+        // the fraction part of the percentage value.
+        double percentage = 0;
+        int numCharactersParsed = parseDouble(current, end, '%', percentage);
+        if (!numCharactersParsed)
+            return false;
+        current += numCharactersParsed;
+        if (*current != '%')
+            return false;
+        localValue += percentage;
+    }
+
+    if (expect == CSSPrimitiveValue::UnitType::CSS_PERCENTAGE && *current != '%')
+        return false;
+
+    if (*current == '%') {
+        expect = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
+        localValue = localValue / 100.0 * 256.0;
+        // Clamp values at 255 for percentages over 100%
+        if (localValue > 255)
+            localValue = 255;
+        current++;
+    } else {
+        expect = CSSPrimitiveValue::UnitType::CSS_NUMBER;
+    }
+
+    while (current != end && isHTMLSpace<CharacterType>(*current))
+        current++;
+    if (current == end || *current++ != terminator)
+        return false;
+    // Clamp negative values at zero.
+    value = negative ? 0 : static_cast<int>(localValue);
+    string = current;
+    return true;
+}
+
+template <typename CharacterType>
+static inline bool isTenthAlpha(const CharacterType* string, const int length)
+{
+    // "0.X"
+    if (length == 3 && string[0] == '0' && string[1] == '.' && isASCIIDigit(string[2]))
+        return true;
+
+    // ".X"
+    if (length == 2 && string[0] == '.' && isASCIIDigit(string[1]))
+        return true;
+
+    return false;
+}
+
+template <typename CharacterType>
+static inline bool parseAlphaValue(const CharacterType*& string, const CharacterType* end, const char terminator, int& value)
+{
+    while (string != end && isHTMLSpace<CharacterType>(*string))
+        string++;
+
+    bool negative = false;
+
+    if (string != end && *string == '-') {
+        negative = true;
+        string++;
+    }
+
+    value = 0;
+
+    int length = end - string;
+    if (length < 2)
+        return false;
+
+    if (string[length - 1] != terminator || !isASCIIDigit(string[length - 2]))
+        return false;
+
+    if (string[0] != '0' && string[0] != '1' && string[0] != '.') {
+        if (checkForValidDouble(string, end, terminator)) {
+            value = negative ? 0 : 255;
+            string = end;
+            return true;
+        }
+        return false;
+    }
+
+    if (length == 2 && string[0] != '.') {
+        value = !negative && string[0] == '1' ? 255 : 0;
+        string = end;
+        return true;
+    }
+
+    if (isTenthAlpha(string, length - 1)) {
+        static const int tenthAlphaValues[] = { 0, 25, 51, 76, 102, 127, 153, 179, 204, 230 };
+        value = negative ? 0 : tenthAlphaValues[string[length - 2] - '0'];
+        string = end;
+        return true;
+    }
+
+    double alpha = 0;
+    if (!parseDouble(string, end, terminator, alpha))
+        return false;
+    value = negative ? 0 : static_cast<int>(alpha * nextafter(256.0, 0.0));
+    string = end;
+    return true;
+}
+
+template <typename CharacterType>
+static inline bool mightBeRGBA(const CharacterType* characters, unsigned length)
+{
+    if (length < 5)
+        return false;
+    return characters[4] == '('
+        && isASCIIAlphaCaselessEqual(characters[0], 'r')
+        && isASCIIAlphaCaselessEqual(characters[1], 'g')
+        && isASCIIAlphaCaselessEqual(characters[2], 'b')
+        && isASCIIAlphaCaselessEqual(characters[3], 'a');
+}
+
+template <typename CharacterType>
+static inline bool mightBeRGB(const CharacterType* characters, unsigned length)
+{
+    if (length < 4)
+        return false;
+    return characters[3] == '('
+        && isASCIIAlphaCaselessEqual(characters[0], 'r')
+        && isASCIIAlphaCaselessEqual(characters[1], 'g')
+        && isASCIIAlphaCaselessEqual(characters[2], 'b');
+}
+
+template <typename CharacterType>
+static Color fastParseColorInternal(const CharacterType* characters, unsigned length, bool quirksMode)
+{
+    CSSPrimitiveValue::UnitType expect = CSSPrimitiveValue::UnitType::CSS_UNKNOWN;
+
+    if (length >= 4 && characters[0] == '#') {
+        RGBA32 rgb;
+        if (Color::parseHexColor(characters + 1, length - 1, rgb))
+            return Color(rgb);
+    }
+
+    if (quirksMode && (length == 3 || length == 6)) {
+        RGBA32 rgb;
+        if (Color::parseHexColor(characters, length, rgb))
+            return Color(rgb);
+    }
+
+    // Try rgba() syntax.
+    if (mightBeRGBA(characters, length)) {
+        const CharacterType* current = characters + 5;
+        const CharacterType* end = characters + length;
+        int red;
+        int green;
+        int blue;
+        int alpha;
+
+        if (!parseColorIntOrPercentage(current, end, ',', expect, red))
+            return Color();
+        if (!parseColorIntOrPercentage(current, end, ',', expect, green))
+            return Color();
+        if (!parseColorIntOrPercentage(current, end, ',', expect, blue))
+            return Color();
+        if (!parseAlphaValue(current, end, ')', alpha))
+            return Color();
+        if (current != end)
+            return Color();
+        return Color(makeRGBA(red, green, blue, alpha));
+    }
+
+    // Try rgb() syntax.
+    if (mightBeRGB(characters, length)) {
+        const CharacterType* current = characters + 4;
+        const CharacterType* end = characters + length;
+        int red;
+        int green;
+        int blue;
+        if (!parseColorIntOrPercentage(current, end, ',', expect, red))
+            return Color();
+        if (!parseColorIntOrPercentage(current, end, ',', expect, green))
+            return Color();
+        if (!parseColorIntOrPercentage(current, end, ')', expect, blue))
+            return Color();
+        if (current != end)
+            return Color();
+        return Color(makeRGB(red, green, blue));
+    }
+
+    return Color();
+}
+
+RefPtr<CSSValue> CSSParserFastPaths::parseColor(const String& string, CSSParserMode parserMode)
+{
+    ASSERT(!string.isEmpty());
+    CSSValueID valueID = cssValueKeywordID(string);
+    if (StyleColor::isColorKeyword(valueID)) {
+        if (!isValueAllowedInMode(valueID, parserMode))
+            return nullptr;
+        return CSSValuePool::singleton().createIdentifierValue(valueID);
+    }
+
+    bool quirksMode = isQuirksModeBehavior(parserMode);
+
+    // Fast path for hex colors and rgb()/rgba() colors
+    Color color;
+    if (string.is8Bit())
+        color = fastParseColorInternal(string.characters8(), string.length(), quirksMode);
+    else
+        color = fastParseColorInternal(string.characters16(), string.length(), quirksMode);
+    if (!color.isValid())
+        return nullptr;
+    return CSSValuePool::singleton().createColorValue(color);
+}
+
+bool CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyID propertyId, CSSValueID valueID, CSSParserMode parserMode)
+{
+    if (valueID == CSSValueInvalid || !isValueAllowedInMode(valueID, parserMode))
+        return false;
+
+    switch (propertyId) {
+    case CSSPropertyAlignmentBaseline:
+        // auto | baseline | before-edge | text-before-edge | middle |
+        // central | after-edge | text-after-edge | ideographic | alphabetic |
+        // hanging | mathematical
+        return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueBaseline
+            || valueID == CSSValueMiddle || (valueID >= CSSValueBeforeEdge && valueID <= CSSValueMathematical);
+    case CSSPropertyAll:
+        return false; // Only accepts css-wide keywords
+    case CSSPropertyBackgroundRepeatX: // repeat | no-repeat
+    case CSSPropertyBackgroundRepeatY: // repeat | no-repeat
+        return valueID == CSSValueRepeat || valueID == CSSValueNoRepeat;
+    case CSSPropertyBorderCollapse: // collapse | separate
+        return valueID == CSSValueCollapse || valueID == CSSValueSeparate;
+    case CSSPropertyBorderTopStyle: // <border-style>
+    case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed |
+    case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset
+    case CSSPropertyBorderLeftStyle:
+    case CSSPropertyWebkitBorderAfterStyle:
+    case CSSPropertyWebkitBorderBeforeStyle:
+    case CSSPropertyWebkitBorderEndStyle:
+    case CSSPropertyWebkitBorderStartStyle:
+    case CSSPropertyColumnRuleStyle:
+        return valueID >= CSSValueNone && valueID <= CSSValueDouble;
+    case CSSPropertyBoxSizing:
+        return valueID == CSSValueBorderBox || valueID == CSSValueContentBox;
+    case CSSPropertyBufferedRendering:
+        return valueID == CSSValueAuto || valueID == CSSValueDynamic || valueID == CSSValueStatic;
+    case CSSPropertyCaptionSide: // top | bottom | left | right
+        return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom;
+    case CSSPropertyClear: // none | left | right | both
+        return valueID == CSSValueNone || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth;
+    case CSSPropertyClipRule:
+    case CSSPropertyFillRule:
+        return valueID == CSSValueNonzero || valueID == CSSValueEvenodd;
+    case CSSPropertyColorInterpolation:
+    case CSSPropertyColorInterpolationFilters:
+        return valueID == CSSValueAuto || valueID == CSSValueSRGB || valueID == CSSValueLinearRGB;
+    case CSSPropertyColorRendering:
+        return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeQuality;
+    case CSSPropertyDirection: // ltr | rtl
+        return valueID == CSSValueLtr || valueID == CSSValueRtl;
+    case CSSPropertyDisplay:
+        // inline | block | list-item | inline-block | table |
+        // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
+        // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none
+        // flex | inline-flex | -webkit-flex | -webkit-inline-flex | grid | inline-grid
+        return (valueID >= CSSValueInline && valueID <= CSSValueContents) || valueID == CSSValueNone
+            || (RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled() && (valueID == CSSValueGrid || valueID == CSSValueInlineGrid))
+        ;
+    case CSSPropertyDominantBaseline:
+        // auto | use-script | no-change | reset-size | ideographic |
+        // alphabetic | hanging | mathematical | central | middle |
+        // text-after-edge | text-before-edge
+        return valueID == CSSValueAuto || valueID == CSSValueAlphabetic || valueID == CSSValueMiddle
+            || (valueID >= CSSValueUseScript && valueID <= CSSValueResetSize)
+            || (valueID >= CSSValueCentral && valueID <= CSSValueMathematical);
+    case CSSPropertyEmptyCells: // show | hide
+        return valueID == CSSValueShow || valueID == CSSValueHide;
+    case CSSPropertyFloat: // left | right | none
+        return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone;
+    case CSSPropertyFontStyle: // normal | italic | oblique
+        return valueID == CSSValueNormal || valueID == CSSValueItalic || valueID == CSSValueOblique;
+    case CSSPropertyFontStretch: // normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded
+        return valueID == CSSValueNormal || (valueID >= CSSValueUltraCondensed && valueID <= CSSValueUltraExpanded);
+    case CSSPropertyImageRendering: // auto | optimizeContrast | pixelated | optimizeSpeed | crispEdges | optimizeQuality | webkit-crispEdges
+        return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeQuality || valueID == CSSValueWebkitCrispEdges || valueID == CSSValueWebkitOptimizeContrast || valueID == CSSValueCrispEdges || valueID == CSSValuePixelated;
+#if ENABLE(CSS_COMPOSITING)
+    case CSSPropertyIsolation: // auto | isolate
+        return valueID == CSSValueAuto || valueID == CSSValueIsolate;
+#endif
+    case CSSPropertyListStylePosition: // inside | outside
+        return valueID == CSSValueInside || valueID == CSSValueOutside;
+    case CSSPropertyListStyleType:
+        // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in
+        // for the list of supported list-style-types.
+        return (valueID >= CSSValueDisc && valueID <= CSSValueKatakanaIroha) || valueID == CSSValueNone;
+    case CSSPropertyMaskType:
+        return valueID == CSSValueLuminance || valueID == CSSValueAlpha;
+    case CSSPropertyObjectFit:
+        return valueID == CSSValueFill || valueID == CSSValueContain || valueID == CSSValueCover || valueID == CSSValueNone || valueID == CSSValueScaleDown;
+    case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto
+        return valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble);
+    // FIXME-NEWPARSER: Support?
+    // case CSSPropertyOverflowAnchor:
+    //    return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAuto;
+    case CSSPropertyOverflowWrap: // normal | break-word
+    case CSSPropertyWordWrap:
+        return valueID == CSSValueNormal || valueID == CSSValueBreakWord;
+    case CSSPropertyOverflowX: // visible | hidden | scroll | auto | overlay
+        return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay;
+    case CSSPropertyOverflowY: // visible | hidden | scroll | auto | overlay | -webkit-paged-x | -webkit-paged-y
+        return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitPagedX || valueID == CSSValueWebkitPagedY;
+    case CSSPropertyBreakAfter:
+    case CSSPropertyBreakBefore:
+        return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValuePage || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueRecto || valueID == CSSValueVerso || valueID == CSSValueAvoidColumn || valueID == CSSValueColumn
+#if ENABLE(CSS_REGIONS)
+            || valueID == CSSValueRegion || valueID == CSSValueAvoidRegion
+#endif
+        ;
+    case CSSPropertyBreakInside:
+        return valueID == CSSValueAuto || valueID == CSSValueAvoid || valueID == CSSValueAvoidPage || valueID == CSSValueAvoidColumn
+#if ENABLE(CSS_REGIONS)
+            || valueID == CSSValueAvoidRegion
+#endif
+        ;
+    case CSSPropertyPointerEvents:
+        // none | visiblePainted | visibleFill | visibleStroke | visible |
+        // painted | fill | stroke | auto | all | bounding-box
+        return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || (valueID >= CSSValueVisiblePainted && valueID <= CSSValueStroke);
+    case CSSPropertyPosition: // static | relative | absolute | fixed | sticky
+        return valueID == CSSValueStatic || valueID == CSSValueRelative || valueID == CSSValueAbsolute || valueID == CSSValueFixed || valueID == CSSValueWebkitSticky;
+    case CSSPropertyResize: // none | both | horizontal | vertical | auto
+        return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
+    // FIXME-NEWPARSER: Investigate this property.
+    // case CSSPropertyScrollBehavior: // auto | smooth
+    //     ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
+    //   return valueID == CSSValueAuto || valueID == CSSValueSmooth;
+    case CSSPropertyShapeRendering:
+        return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueCrispedges || valueID == CSSValueGeometricPrecision;
+    case CSSPropertySpeak: // none | normal | spell-out | digits | literal-punctuation | no-punctuation
+        return valueID == CSSValueNone || valueID == CSSValueNormal || valueID == CSSValueSpellOut || valueID == CSSValueDigits || valueID == CSSValueLiteralPunctuation || valueID == CSSValueNoPunctuation;
+    case CSSPropertyStrokeLinejoin:
+        return valueID == CSSValueMiter || valueID == CSSValueRound || valueID == CSSValueBevel;
+    case CSSPropertyStrokeLinecap:
+        return valueID == CSSValueButt || valueID == CSSValueRound || valueID == CSSValueSquare;
+    case CSSPropertyTableLayout: // auto | fixed
+        return valueID == CSSValueAuto || valueID == CSSValueFixed;
+    case CSSPropertyTextAlign:
+        return (valueID >= CSSValueWebkitAuto && valueID <= CSSValueWebkitMatchParent) || valueID == CSSValueStart || valueID == CSSValueEnd;
+#if ENABLE(CSS3_TEXT)
+    case CSSPropertyWebkitTextAlignLast:
+        // auto | start | end | left | right | center | justify
+        return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueAuto;
+#endif
+    case CSSPropertyTextAnchor:
+        return valueID == CSSValueStart || valueID == CSSValueMiddle || valueID == CSSValueEnd;
+// FIXME-NEWPARSER: Support
+//    case CSSPropertyTextCombineUpright:
+//        return valueID == CSSValueNone || valueID == CSSValueAll;
+    case CSSPropertyWebkitTextDecorationStyle:
+        // solid | double | dotted | dashed | wavy
+        return valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDotted || valueID == CSSValueDashed || valueID == CSSValueWavy;
+#if ENABLE(CSS3_TEXT)
+    case CSSPropertyWebkitTextJustify:
+        // auto | none | inter-word | distribute
+        return valueID == CSSValueInterWord || valueID == CSSValueDistribute || valueID == CSSValueAuto || valueID == CSSValueNone;
+#endif
+    case CSSPropertyWebkitTextOrientation: // mixed | upright | sideways | sideways-right
+        return valueID == CSSValueMixed || valueID == CSSValueUpright || valueID == CSSValueSideways || valueID == CSSValueSidewaysRight;
+    case CSSPropertyTextOverflow: // clip | ellipsis
+        return valueID == CSSValueClip || valueID == CSSValueEllipsis;
+    case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision
+        return valueID == CSSValueAuto || valueID == CSSValueOptimizeSpeed || valueID == CSSValueOptimizeLegibility || valueID == CSSValueGeometricPrecision;
+    case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none
+        return (valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone;
+    case CSSPropertyUnicodeBidi:
+        return valueID == CSSValueNormal || valueID == CSSValueEmbed
+            || valueID == CSSValueBidiOverride || valueID == CSSValueWebkitIsolate
+            || valueID == CSSValueWebkitIsolateOverride || valueID == CSSValueWebkitPlaintext;
+    case CSSPropertyVectorEffect:
+        return valueID == CSSValueNone || valueID == CSSValueNonScalingStroke;
+    case CSSPropertyVisibility: // visible | hidden | collapse
+        return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse;
+    case CSSPropertyWebkitAppearance:
+        return (valueID >= CSSValueCheckbox && valueID <= CSSValueCapsLockIndicator) || valueID == CSSValueNone;
+    case CSSPropertyWebkitBackfaceVisibility:
+        return valueID == CSSValueVisible || valueID == CSSValueHidden;
+#if ENABLE(CSS_COMPOSITING)
+    case CSSPropertyMixBlendMode:
+        return valueID == CSSValueNormal || valueID == CSSValueMultiply || valueID == CSSValueScreen || valueID == CSSValueOverlay
+            || valueID == CSSValueDarken || valueID == CSSValueLighten || valueID == CSSValueColorDodge || valueID == CSSValueColorBurn
+            || valueID == CSSValueHardLight || valueID == CSSValueSoftLight || valueID == CSSValueDifference || valueID == CSSValueExclusion
+            || valueID == CSSValueHue || valueID == CSSValueSaturation || valueID == CSSValueColor || valueID == CSSValueLuminosity || valueID == CSSValuePlusDarker || valueID == CSSValuePlusLighter;
+#endif
+    case CSSPropertyWebkitBoxAlign:
+        return valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline;
+#if ENABLE(CSS_BOX_DECORATION_BREAK)
+    case CSSPropertyWebkitBoxDecorationBreak:
+        return valueID == CSSValueClone || valueID == CSSValueSlice;
+    case CSSPropertyWebkitBoxDirection:
+        return valueID == CSSValueNormal || valueID == CSSValueReverse;
+#endif
+    case CSSPropertyWebkitBoxLines:
+        return valueID == CSSValueSingle || valueID == CSSValueMultiple;
+    case CSSPropertyWebkitBoxOrient:
+        return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis;
+    case CSSPropertyWebkitBoxPack:
+        return valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify;
+#if ENABLE(CURSOR_VISIBILITY)
+    case CSSPropertyWebkitCursorVisibility:
+        return valueID == CSSValueAuto || valueID == CSSValueAutoHide;
+#endif
+    case CSSPropertyColumnFill:
+        return valueID == CSSValueAuto || valueID == CSSValueBalance;
+    case CSSPropertyWebkitColumnAxis:
+        return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
+    case CSSPropertyWebkitColumnProgression:
+        return valueID == CSSValueNormal || valueID == CSSValueReverse;
+    case CSSPropertyAlignContent:
+        // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'.
+        return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround || valueID == CSSValueStretch;
+    case CSSPropertyAlignItems:
+        // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
+        return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch;
+    case CSSPropertyAlignSelf:
+        // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
+        return valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch;
+    case CSSPropertyFlexDirection:
+        return valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse;
+    case CSSPropertyFlexWrap:
+        return valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse;
+    case CSSPropertyWebkitHyphens:
+        return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueManual;
+    case CSSPropertyJustifyContent:
+        // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'.
+        return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround;
+    case CSSPropertyWebkitFontKerning:
+        return valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone;
+    case CSSPropertyWebkitFontSmoothing:
+        return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased;
+    case CSSPropertyWebkitLineAlign:
+        return valueID == CSSValueNone || valueID == CSSValueEdges;
+    case CSSPropertyWebkitLineBreak: // auto | loose | normal | strict | after-white-space
+        return valueID == CSSValueAuto || valueID == CSSValueLoose || valueID == CSSValueNormal || valueID == CSSValueStrict || valueID == CSSValueAfterWhiteSpace;
+    case CSSPropertyWebkitLineSnap:
+        return valueID == CSSValueNone || valueID == CSSValueBaseline || valueID == CSSValueContain;
+    case CSSPropertyWebkitMarginAfterCollapse:
+    case CSSPropertyWebkitMarginBeforeCollapse:
+    case CSSPropertyWebkitMarginBottomCollapse:
+    case CSSPropertyWebkitMarginTopCollapse:
+        return valueID == CSSValueCollapse || valueID == CSSValueSeparate || valueID == CSSValueDiscard;
+    case CSSPropertyWebkitPrintColorAdjust:
+        return valueID == CSSValueExact || valueID == CSSValueEconomy;
+    case CSSPropertyWebkitRtlOrdering:
+        return valueID == CSSValueLogical || valueID == CSSValueVisual;
+    case CSSPropertyWebkitRubyPosition:
+        return valueID == CSSValueBefore || valueID == CSSValueAfter || valueID == CSSValueInterCharacter;
+    case CSSPropertyWebkitTextCombine:
+        return valueID == CSSValueNone || valueID == CSSValueHorizontal;
+    case CSSPropertyWebkitTextSecurity: // disc | circle | square | none
+        return valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone;
+    case CSSPropertyTransformStyle:
+    case CSSPropertyWebkitTransformStyle:
+        return valueID == CSSValueFlat || valueID == CSSValuePreserve3d;
+    case CSSPropertyWebkitUserDrag: // auto | none | element
+        return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement;
+    case CSSPropertyWebkitUserModify: // read-only | read-write
+        return valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly;
+    case CSSPropertyWebkitUserSelect: // auto | none | text | all
+        return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText || valueID == CSSValueAll;
+    case CSSPropertyWritingMode:
+        // Note that horizontal-bt is not supported by the unprefixed version of
+        // the property, only by the -webkit- version.
+        return (valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt)
+            || valueID == CSSValueLrTb || valueID == CSSValueRlTb || valueID == CSSValueTbRl
+            || valueID == CSSValueLr || valueID == CSSValueRl || valueID == CSSValueTb;
+    case CSSPropertyWhiteSpace: // normal | pre | nowrap
+        return valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap;
+    case CSSPropertyWordBreak: // normal | break-all | keep-all | break-word (this is a custom extension)
+        return valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueKeepAll || valueID == CSSValueBreakWord;
+    case CSSPropertyWebkitBorderFit:
+        return valueID == CSSValueBorder || valueID == CSSValueLines;
+#if ENABLE(CSS_REGIONS)
+    case CSSPropertyWebkitRegionFragment:
+        return valueID == CSSValueAuto || valueID == CSSValueBreak;
+#endif
+#if ENABLE(TOUCH_EVENTS)
+    case CSSPropertyTouchAction: // auto | manipulation
+        return valueID == CSSValueAuto || valueID == CSSValueManipulation;
+#endif
+#if ENABLE(CSS_TRAILING_WORD)
+    case CSSPropertyAppleTrailingWord: // auto | -apple-partially-balanced
+        return valueID == CSSValueAuto || valueID == CSSValueWebkitPartiallyBalanced;
+#endif
+#if ENABLE(APPLE_PAY)
+    case CSSPropertyApplePayButtonStyle: // white | white-outline | black
+        return valueID == CSSValueWhite || valueID == CSSValueWhiteOutline || valueID == CSSValueBlack;
+    case CSSPropertyApplePayButtonType: // plain | buy | set-up | donate
+        return valueID == CSSValuePlain || valueID == CSSValueBuy || valueID == CSSValueSetUp || valueID == CSSValueDonate;
+#endif
+    case CSSPropertyWebkitNbspMode: // normal | space
+        return valueID == CSSValueNormal || valueID == CSSValueSpace;
+    case CSSPropertyWebkitTextZoom:
+        return valueID == CSSValueNormal || valueID == CSSValueReset;
+#if PLATFORM(IOS)
+    // Apple specific property. These will never be standardized and is purely to
+    // support custom WebKit-based Apple applications.
+    case CSSPropertyWebkitTouchCallout:
+        return valueID == CSSValueDefault || valueID == CSSValueNone;
+#endif
+    case CSSPropertyWebkitMarqueeDirection:
+        return valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown
+            || valueID == CSSValueUp || valueID == CSSValueAuto;
+    case CSSPropertyWebkitMarqueeStyle:
+        return valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate;
+    case CSSPropertyFontVariantPosition: // normal | sub | super
+        return valueID == CSSValueNormal || valueID == CSSValueSub || valueID == CSSValueSuper;
+    case CSSPropertyFontVariantCaps: // normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps
+        return valueID == CSSValueNormal || valueID == CSSValueSmallCaps || valueID == CSSValueAllSmallCaps || valueID == CSSValuePetiteCaps || valueID == CSSValueAllPetiteCaps || valueID == CSSValueUnicase || valueID == CSSValueTitlingCaps;
+    case CSSPropertyFontVariantAlternates: // We only support the normal and historical-forms values.
+        return valueID == CSSValueNormal || valueID == CSSValueHistoricalForms;
+#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
+    case CSSPropertyWebkitOverflowScrolling:
+        return valueID == CSSValueAuto || valueID == CSSValueTouch;
+#endif
+    default:
+        ASSERT_NOT_REACHED();
+        return false;
+    }
+}
+
+bool CSSParserFastPaths::isKeywordPropertyID(CSSPropertyID propertyId)
+{
+    switch (propertyId) {
+    case CSSPropertyBorderBottomStyle:
+    case CSSPropertyBorderCollapse:
+    case CSSPropertyBorderLeftStyle:
+    case CSSPropertyBorderRightStyle:
+    case CSSPropertyBorderTopStyle:
+    case CSSPropertyBoxSizing:
+    case CSSPropertyBreakAfter:
+    case CSSPropertyBreakBefore:
+    case CSSPropertyBreakInside:
+    case CSSPropertyCaptionSide:
+    case CSSPropertyClear:
+    case CSSPropertyColumnFill:
+    case CSSPropertyWebkitColumnProgression:
+    case CSSPropertyColumnRuleStyle:
+    case CSSPropertyDirection:
+    case CSSPropertyDisplay:
+    case CSSPropertyEmptyCells:
+    case CSSPropertyFlexDirection:
+    case CSSPropertyFlexWrap:
+    case CSSPropertyFloat:
+    case CSSPropertyFontStretch:
+    case CSSPropertyFontStyle:
+    case CSSPropertyFontVariantAlternates:
+    case CSSPropertyFontVariantCaps:
+    case CSSPropertyFontVariantPosition:
+    case CSSPropertyImageRendering:
+    case CSSPropertyListStylePosition:
+    case CSSPropertyListStyleType:
+    case CSSPropertyObjectFit:
+    case CSSPropertyOutlineStyle:
+    case CSSPropertyOverflowWrap:
+    case CSSPropertyOverflowX:
+    case CSSPropertyOverflowY:
+    case CSSPropertyPointerEvents:
+    case CSSPropertyPosition:
+    case CSSPropertyResize:
+    case CSSPropertySpeak:
+    case CSSPropertyTableLayout:
+    case CSSPropertyTextAlign:
+    case CSSPropertyTextLineThroughMode:
+    case CSSPropertyTextLineThroughStyle:
+    case CSSPropertyTextOverflow:
+    case CSSPropertyTextOverlineMode:
+    case CSSPropertyTextOverlineStyle:
+    case CSSPropertyTextRendering:
+    case CSSPropertyTextTransform:
+    case CSSPropertyTextUnderlineMode:
+    case CSSPropertyTextUnderlineStyle:
+    case CSSPropertyTransformStyle:
+    case CSSPropertyUnicodeBidi:
+    case CSSPropertyVisibility:
+    case CSSPropertyWebkitAppearance:
+    case CSSPropertyWebkitBackfaceVisibility:
+    case CSSPropertyWebkitBorderAfterStyle:
+    case CSSPropertyWebkitBorderBeforeStyle:
+    case CSSPropertyWebkitBorderEndStyle:
+    case CSSPropertyWebkitBorderFit:
+    case CSSPropertyWebkitBorderStartStyle:
+    case CSSPropertyWebkitBoxAlign:
+    case CSSPropertyWebkitBoxDirection:
+    case CSSPropertyWebkitBoxLines:
+    case CSSPropertyWebkitBoxOrient:
+    case CSSPropertyWebkitBoxPack:
+    case CSSPropertyWebkitColumnAxis:
+    case CSSPropertyWebkitFontKerning:
+    case CSSPropertyWebkitFontSmoothing:
+    case CSSPropertyWebkitHyphens:
+    case CSSPropertyWebkitLineAlign:
+    case CSSPropertyWebkitLineBreak:
+    case CSSPropertyWebkitLineSnap:
+    case CSSPropertyWebkitMarginAfterCollapse:
+    case CSSPropertyWebkitMarginBeforeCollapse:
+    case CSSPropertyWebkitMarginBottomCollapse:
+    case CSSPropertyWebkitMarginTopCollapse:
+    case CSSPropertyWebkitMarqueeDirection:
+    case CSSPropertyWebkitMarqueeStyle:
+    case CSSPropertyWebkitNbspMode:
+    case CSSPropertyWebkitPrintColorAdjust:
+    case CSSPropertyWebkitRtlOrdering:
+    case CSSPropertyWebkitRubyPosition:
+    case CSSPropertyWebkitTextCombine:
+    case CSSPropertyWebkitTextDecorationStyle:
+    case CSSPropertyWebkitTextOrientation:
+    case CSSPropertyWebkitTextSecurity:
+    case CSSPropertyWebkitTextZoom:
+    case CSSPropertyWebkitTransformStyle:
+    case CSSPropertyWebkitUserDrag:
+    case CSSPropertyWebkitUserModify:
+    case CSSPropertyWebkitUserSelect:
+    case CSSPropertyWhiteSpace:
+    case CSSPropertyWordBreak:
+    case CSSPropertyWordWrap:
+
+    // SVG CSS properties from SVG 1.1, Appendix N: Property Index.
+    case CSSPropertyAlignmentBaseline:
+    case CSSPropertyBufferedRendering:
+    case CSSPropertyClipRule:
+    case CSSPropertyColorInterpolation:
+    case CSSPropertyColorInterpolationFilters:
+    case CSSPropertyColorRendering:
+    case CSSPropertyDominantBaseline:
+    case CSSPropertyFillRule:
+    case CSSPropertyMaskType:
+    case CSSPropertyShapeRendering:
+    case CSSPropertyStrokeLinecap:
+    case CSSPropertyStrokeLinejoin:
+    case CSSPropertyTextAnchor:
+    case CSSPropertyVectorEffect:
+    case CSSPropertyWritingMode:
+
+    // FIXME-NEWPARSER: Treat all as a keyword property.
+    // case CSSPropertyAll:
+
+    // FIXME-NEWPARSER: Add the following unprefixed properties:
+    // case CSSPropertyBackfaceVisibility:
+    // case CSSPropertyFontKerning:
+    // case CSSPropertyHyphens:
+    // case CSSPropertyOverflowAnchor:
+    // case CSSPropertyScrollBehavior:
+    // case CSSPropertyScrollSnapType:
+    // case CSSPropertyTextAlignLast:
+    // case CSSPropertyTextCombineUpright:
+    // case CSSPropertyTextDecorationStyle:
+    // case CSSPropertyTextJustify:
+    // case CSSPropertyTextOrientation:
+    // case CSSPropertyUserSelect:
+#if ENABLE(CSS_TRAILING_WORD)
+    case CSSPropertyAppleTrailingWord:
+#endif
+#if ENABLE(CSS_COMPOSITING)
+    case CSSPropertyIsolation:
+    case CSSPropertyMixBlendMode:
+#endif
+#if ENABLE(TOUCH_EVENTS)
+    case CSSPropertyTouchAction:
+#endif
+#if ENABLE(CSS_BOX_DECORATION_BREAK)
+    case CSSPropertyWebkitBoxDecorationBreak:
+#endif
+#if ENABLE(CURSOR_VISIBILITY)
+    case CSSPropertyWebkitCursorVisibility:
+#endif
+#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
+    case CSSPropertyWebkitOverflowScrolling:
+#endif
+#if ENABLE(CSS_REGIONS)
+    case CSSPropertyWebkitRegionFragment:
+#endif
+#if ENABLE(CSS3_TEXT)
+    case CSSPropertyWebkitTextAlignLast:
+    case CSSPropertyWebkitTextJustify:
+#endif
+#if PLATFORM(IOS)
+    // Apple specific property. This will never be standardized and is purely to
+    // support custom WebKit-based Apple applications.
+    case CSSPropertyWebkitTouchCallout:
+#endif
+#if ENABLE(APPLE_PAY)
+    case CSSPropertyApplePayButtonStyle:
+    case CSSPropertyApplePayButtonType:
+#endif
+        return true;
+    case CSSPropertyJustifyContent:
+    case CSSPropertyAlignContent:
+    case CSSPropertyAlignItems:
+    case CSSPropertyAlignSelf:
+        return !RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled();
+    default:
+        return false;
+    }
+}
+
+static bool isUniversalKeyword(const String& string)
+{
+    // These keywords can be used for all properties.
+    return equalLettersIgnoringASCIICase(string, "initial")
+    || equalLettersIgnoringASCIICase(string, "inherit")
+    || equalLettersIgnoringASCIICase(string, "unset")
+    || equalLettersIgnoringASCIICase(string, "revert");
+}
+
+static RefPtr<CSSValue> parseKeywordValue(CSSPropertyID propertyId, const String& string, CSSParserMode parserMode)
+{
+    ASSERT(!string.isEmpty());
+
+    if (!CSSParserFastPaths::isKeywordPropertyID(propertyId)) {
+        // All properties accept the values of "initial" and "inherit".
+        if (!isUniversalKeyword(string))
+            return nullptr;
+
+        // Parse initial/inherit shorthands using the CSSPropertyParser.
+        if (shorthandForProperty(propertyId).length())
+            return nullptr;
+
+        // Descriptors do not support css wide keywords.
+        if (CSSProperty::isDescriptorOnly(propertyId))
+            return nullptr;
+    }
+
+    CSSValueID valueID = cssValueKeywordID(string);
+
+    if (!valueID)
+        return nullptr;
+
+    if (valueID == CSSValueInherit)
+        return CSSValuePool::singleton().createInheritedValue();
+    if (valueID == CSSValueInitial)
+        return CSSValuePool::singleton().createExplicitInitialValue();
+    if (valueID == CSSValueUnset)
+        return CSSValuePool::singleton().createUnsetValue();
+    if (valueID == CSSValueRevert)
+        return CSSValuePool::singleton().createRevertValue();
+    
+    if (CSSParserFastPaths::isValidKeywordPropertyAndValue(propertyId, valueID, parserMode))
+        return CSSPrimitiveValue::createIdentifier(valueID);
+    return nullptr;
+}
+
+template <typename CharType>
+static bool parseTransformTranslateArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSFunctionValue* transformValue)
+{
+    while (expectedCount) {
+        size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
+        if (delimiter == notFound)
+            return false;
+        unsigned argumentLength = static_cast<unsigned>(delimiter);
+        CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
+        double number;
+        if (!parseSimpleLength(pos, argumentLength, unit, number))
+            return false;
+        if (!number && unit == CSSPrimitiveValue::CSS_NUMBER)
+            unit = CSSPrimitiveValue::UnitType::CSS_PX;
+        if (unit == CSSPrimitiveValue::UnitType::CSS_NUMBER || (unit == CSSPrimitiveValue::UnitType::CSS_PERCENTAGE && (transformValue->name() == CSSValueTranslateZ || (transformValue->name() == CSSValueTranslate3d && expectedCount == 1))))
+            return false;
+        transformValue->append(CSSPrimitiveValue::create(number, unit));
+        pos += argumentLength + 1;
+        --expectedCount;
+    }
+    return true;
+}
+
+template <typename CharType>
+static bool parseTransformNumberArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSFunctionValue* transformValue)
+{
+    while (expectedCount) {
+        size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
+        if (delimiter == notFound)
+            return false;
+        unsigned argumentLength = static_cast<unsigned>(delimiter);
+        bool ok;
+        double number = charactersToDouble(pos, argumentLength, &ok);
+        if (!ok)
+            return false;
+        transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitType::CSS_NUMBER));
+        pos += argumentLength + 1;
+        --expectedCount;
+    }
+    return true;
+}
+
+static const int kShortestValidTransformStringLength = 12;
+
+template <typename CharType>
+static RefPtr<CSSFunctionValue> parseSimpleTransformValue(CharType*& pos, CharType* end)
+{
+    if (end - pos < kShortestValidTransformStringLength)
+        return nullptr;
+
+    const bool isTranslate = toASCIILower(pos[0]) == 't'
+        && toASCIILower(pos[1]) == 'r'
+        && toASCIILower(pos[2]) == 'a'
+        && toASCIILower(pos[3]) == 'n'
+        && toASCIILower(pos[4]) == 's'
+        && toASCIILower(pos[5]) == 'l'
+        && toASCIILower(pos[6]) == 'a'
+        && toASCIILower(pos[7]) == 't'
+        && toASCIILower(pos[8]) == 'e';
+
+    if (isTranslate) {
+        CSSValueID transformType;
+        unsigned expectedArgumentCount = 1;
+        unsigned argumentStart = 11;
+        CharType c9 = toASCIILower(pos[9]);
+        if (c9 == 'x' && pos[10] == '(') {
+            transformType = CSSValueTranslateX;
+        } else if (c9 == 'y' && pos[10] == '(') {
+            transformType = CSSValueTranslateY;
+        } else if (c9 == 'z' && pos[10] == '(') {
+            transformType = CSSValueTranslateZ;
+        } else if (c9 == '(') {
+            transformType = CSSValueTranslate;
+            expectedArgumentCount = 2;
+            argumentStart = 10;
+        } else if (c9 == '3' && toASCIILower(pos[10]) == 'd' && pos[11] == '(') {
+            transformType = CSSValueTranslate3d;
+            expectedArgumentCount = 3;
+            argumentStart = 12;
+        } else {
+            return nullptr;
+        }
+        pos += argumentStart;
+        RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(transformType);
+        if (!parseTransformTranslateArguments(pos, end, expectedArgumentCount, transformValue.get()))
+            return nullptr;
+        return transformValue;
+    }
+
+    const bool isMatrix3d = toASCIILower(pos[0]) == 'm'
+        && toASCIILower(pos[1]) == 'a'
+        && toASCIILower(pos[2]) == 't'
+        && toASCIILower(pos[3]) == 'r'
+        && toASCIILower(pos[4]) == 'i'
+        && toASCIILower(pos[5]) == 'x'
+        && pos[6] == '3'
+        && toASCIILower(pos[7]) == 'd'
+        && pos[8] == '(';
+
+    if (isMatrix3d) {
+        pos += 9;
+        RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(CSSValueMatrix3d);
+        if (!parseTransformNumberArguments(pos, end, 16, transformValue.get()))
+            return nullptr;
+        return transformValue;
+    }
+
+    const bool isScale3d = toASCIILower(pos[0]) == 's'
+        && toASCIILower(pos[1]) == 'c'
+        && toASCIILower(pos[2]) == 'a'
+        && toASCIILower(pos[3]) == 'l'
+        && toASCIILower(pos[4]) == 'e'
+        && pos[5] == '3'
+        && toASCIILower(pos[6]) == 'd'
+        && pos[7] == '(';
+
+    if (isScale3d) {
+        pos += 8;
+        RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(CSSValueScale3d);
+        if (!parseTransformNumberArguments(pos, end, 3, transformValue.get()))
+            return nullptr;
+        return transformValue;
+    }
+
+    return nullptr;
+}
+
+template <typename CharType>
+static bool transformCanLikelyUseFastPath(const CharType* chars, unsigned length)
+{
+    // Very fast scan that attempts to reject most transforms that couldn't
+    // take the fast path. This avoids doing the malloc and string->double
+    // conversions in parseSimpleTransformValue only to discard them when we
+    // run into a transform component we don't understand.
+    unsigned i = 0;
+    while (i < length) {
+        if (isCSSSpace(chars[i])) {
+            ++i;
+            continue;
+        }
+        if (length - i < kShortestValidTransformStringLength)
+            return false;
+        switch (toASCIILower(chars[i])) {
+        case 't':
+            // translate, translateX, translateY, translateZ, translate3d.
+            if (toASCIILower(chars[i + 8]) != 'e')
+                return false;
+            i += 9;
+            break;
+        case 'm':
+            // matrix3d.
+            if (toASCIILower(chars[i + 7]) != 'd')
+                return false;
+            i += 8;
+            break;
+        case 's':
+            // scale3d.
+            if (toASCIILower(chars[i + 6]) != 'd')
+                return false;
+            i += 7;
+            break;
+        default:
+            // All other things, ex. rotate.
+            return false;
+        }
+        size_t argumentsEnd = WTF::find(chars, length, ')', i);
+        if (argumentsEnd == notFound)
+            return false;
+        // Advance to the end of the arguments.
+        i = argumentsEnd + 1;
+    }
+    return i == length;
+}
+
+template <typename CharType>
+static RefPtr<CSSValueList> parseSimpleTransformList(const CharType* chars, unsigned length)
+{
+    if (!transformCanLikelyUseFastPath(chars, length))
+        return nullptr;
+    const CharType*& pos = chars;
+    const CharType* end = chars + length;
+    RefPtr<CSSValueList> transformList;
+    while (pos < end) {
+        while (pos < end && isCSSSpace(*pos))
+            ++pos;
+        if (pos >= end)
+            break;
+        RefPtr<CSSFunctionValue> transformValue = parseSimpleTransformValue(pos, end);
+        if (!transformValue)
+            return nullptr;
+        if (!transformList)
+            transformList = CSSValueList::createSpaceSeparated();
+        transformList->append(*transformValue);
+    }
+    return transformList;
+}
+
+static RefPtr<CSSValue> parseSimpleTransform(CSSPropertyID propertyID, const String& string)
+{
+    ASSERT(!string.isEmpty());
+
+    if (propertyID != CSSPropertyTransform)
+        return nullptr;
+    if (string.is8Bit())
+        return parseSimpleTransformList(string.characters8(), string.length());
+    return parseSimpleTransformList(string.characters16(), string.length());
+}
+
+RefPtr<CSSValue> CSSParserFastPaths::maybeParseValue(CSSPropertyID propertyID, const String& string, CSSParserMode parserMode)
+{
+    RefPtr<CSSValue> result = parseSimpleLengthValue(propertyID, string, parserMode);
+    if (result)
+        return result;
+    if (isColorPropertyID(propertyID))
+        return parseColor(string, parserMode);
+    result = parseKeywordValue(propertyID, string, parserMode);
+    if (result)
+        return result;
+    result = parseSimpleTransform(propertyID, string);
+    if (result)
+        return result;
+    return nullptr;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserFastPaths.h b/Source/WebCore/css/parser/CSSParserFastPaths.h
new file mode 100644
index 000000000..35fbf6a34
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserFastPaths.h
@@ -0,0 +1,55 @@
+// 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 "CSSPropertyNames.h"
+#include "CSSValueKeywords.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSValue;
+class StyleSheetContents;
+
+class CSSParserFastPaths {
+public:
+    // Parses simple values like '10px' or 'green', but makes no guarantees
+    // about handling any property completely.
+    static RefPtr<CSSValue> maybeParseValue(CSSPropertyID, const String&, CSSParserMode);
+
+    // Properties handled here shouldn't be explicitly handled in CSSPropertyParser
+    static bool isKeywordPropertyID(CSSPropertyID);
+    static bool isValidKeywordPropertyAndValue(CSSPropertyID, CSSValueID, CSSParserMode);
+
+    static RefPtr<CSSValue> parseColor(const String&, CSSParserMode);
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserIdioms.cpp b/Source/WebCore/css/parser/CSSParserIdioms.cpp
new file mode 100644
index 000000000..a7ae2084d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserIdioms.cpp
@@ -0,0 +1,58 @@
+// 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 "CSSParserIdioms.h"
+#include "CSSValueKeywords.h"
+#include "TextEncoding.h"
+
+namespace WebCore {
+
+bool isValueAllowedInMode(unsigned short id, CSSParserMode mode)
+{
+    switch (id) {
+    case CSSValueInternalVariableValue:
+        return isUASheetBehavior(mode);
+    case CSSValueWebkitFocusRingColor:
+        return isUASheetBehavior(mode) || isQuirksModeBehavior(mode);
+    default:
+        return true;
+    }
+}
+
+URL completeURL(const CSSParserContext& context, const String& url)
+{
+    if (url.isNull())
+        return URL();
+    if (context.charset.isEmpty())
+        return URL(context.baseURL, url);
+    return URL(context.baseURL, url, context.charset);
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserIdioms.h b/Source/WebCore/css/parser/CSSParserIdioms.h
new file mode 100644
index 000000000..fe8b54f5b
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserIdioms.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Google Inc. 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 <wtf/ASCIICType.h>
+#include <wtf/text/StringView.h>
+
+namespace WebCore {
+
+class URL;
+    
+// Space characters as defined by the CSS specification.
+// http://www.w3.org/TR/css3-syntax/#whitespace
+inline bool isCSSSpace(UChar c)
+{
+    return c == ' ' || c == '\t' || c == '\n';
+}
+
+// http://dev.w3.org/csswg/css-syntax/#name-start-code-point
+template <typename CharacterType>
+bool isNameStartCodePoint(CharacterType c)
+{
+    return isASCIIAlpha(c) || c == '_' || !isASCII(c);
+}
+
+// http://dev.w3.org/csswg/css-syntax/#name-code-point
+template <typename CharacterType>
+bool isNameCodePoint(CharacterType c)
+{
+    return isNameStartCodePoint(c) || isASCIIDigit(c) || c == '-';
+}
+
+bool isValueAllowedInMode(unsigned short, CSSParserMode);
+
+URL completeURL(const CSSParserContext&, const String& url);
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserImpl.cpp b/Source/WebCore/css/parser/CSSParserImpl.cpp
new file mode 100644
index 000000000..2da1144d9
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserImpl.cpp
@@ -0,0 +1,910 @@
+// 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 "CSSDeferredParser.h"
+#include "CSSKeyframeRule.h"
+#include "CSSKeyframesRule.h"
+#include "CSSParserObserver.h"
+#include "CSSParserObserverWrapper.h"
+#include "CSSParserSelector.h"
+#include "CSSPropertyParser.h"
+#include "CSSSelectorParser.h"
+#include "CSSStyleSheet.h"
+#include "CSSSupportsParser.h"
+#include "CSSTokenizer.h"
+#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)
+{
+    
+}
+
+CSSParserImpl::CSSParserImpl(CSSDeferredParser& deferredParser)
+    : m_context(deferredParser.context())
+    , m_styleSheet(deferredParser.styleSheet())
+    , m_deferredParser(&deferredParser)
+{
+}
+
+CSSParserImpl::CSSParserImpl(const CSSParserContext& context, const String& string, StyleSheetContents* styleSheet, CSSParserObserverWrapper* wrapper, CSSParser::RuleParsing ruleParsing)
+    : m_context(context)
+    , m_styleSheet(styleSheet)
+    , m_observerWrapper(wrapper)
+{
+    m_tokenizer = wrapper ? std::make_unique<CSSTokenizer>(string, *wrapper) : std::make_unique<CSSTokenizer>(string);
+    if (context.deferredCSSParserEnabled && !wrapper && styleSheet && ruleParsing == CSSParser::RuleParsing::Deferred)
+        m_deferredParser = CSSDeferredParser::create(context, string, *styleSheet);
+}
+
+CSSParser::ParseResult CSSParserImpl::parseValue(MutableStyleProperties* declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
+{
+    CSSParserImpl parser(context, string);
+    StyleRule::Type ruleType = StyleRule::Style;
+#if ENABLE(CSS_DEVICE_ADAPTATION)
+    if (declaration->cssParserMode() == CSSViewportRuleMode)
+        ruleType = StyleRule::Viewport;
+#endif
+    parser.consumeDeclarationValue(parser.tokenizer()->tokenRange(), propertyID, important, ruleType);
+    if (parser.m_parsedProperties.isEmpty())
+        return CSSParser::ParseResult::Error;
+    return declaration->addParsedProperties(parser.m_parsedProperties) ? CSSParser::ParseResult::Changed : CSSParser::ParseResult::Unchanged;
+}
+
+CSSParser::ParseResult CSSParserImpl::parseCustomPropertyValue(MutableStyleProperties* declaration, const AtomicString& propertyName, const String& string, bool important, const CSSParserContext& context)
+{
+    CSSParserImpl parser(context, string);
+    parser.consumeCustomPropertyValue(parser.tokenizer()->tokenRange(), propertyName, important);
+    if (parser.m_parsedProperties.isEmpty())
+        return CSSParser::ParseResult::Error;
+    return declaration->addParsedProperties(parser.m_parsedProperties) ? CSSParser::ParseResult::Changed : CSSParser::ParseResult::Unchanged;
+}
+
+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) {
+            auto& name = downcast<CSSCustomPropertyValue>(*property.value()).name();
+            if (!seenCustomProperties.add(name).isNewEntry)
+                continue;
+            output[--unusedEntries] = property;
+            continue;
+        }
+        
+        // FIXME-NEWPARSER: We won't support @apply yet.
+        /*else if (property.id() == CSSPropertyApplyAtRule) {
+         // FIXME: Do we need to do anything here?
+         } */
+        
+        if (seenProperties.test(propertyIDIndex))
+            continue;
+        seenProperties.set(propertyIDIndex);
+
+        output[--unusedEntries] = property;
+    }
+}
+
+Ref<DeferredStyleProperties> CSSParserImpl::createDeferredStyleProperties(const CSSParserTokenRange& propertyRange)
+{
+    ASSERT(m_deferredParser);
+    return DeferredStyleProperties::create(propertyRange, *m_deferredParser);
+}
+
+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)
+{
+    CSSParserContext context(element->document());
+    context.mode = strictToCSSParserMode(element->isHTMLElement() && !element->document().inQuirksMode());
+
+    CSSParserImpl parser(context, string);
+    parser.consumeDeclarationList(parser.tokenizer()->tokenRange(), StyleRule::Style);
+    return createStyleProperties(parser.m_parsedProperties, context.mode);
+}
+
+Ref<ImmutableStyleProperties> CSSParserImpl::parseDeferredDeclaration(CSSParserTokenRange tokenRange, const CSSParserContext& context, StyleSheetContents* styleSheet)
+{
+    if (!styleSheet) {
+        ParsedPropertyVector properties;
+        return createStyleProperties(properties, context.mode);
+    }
+    CSSParserImpl parser(context, styleSheet);
+    parser.consumeDeclarationList(tokenRange, StyleRule::Style);
+    return createStyleProperties(parser.m_parsedProperties, context.mode);
+}
+    
+void CSSParserImpl::parseDeferredRuleList(CSSParserTokenRange tokenRange, CSSDeferredParser& deferredParser, Vector<RefPtr<StyleRuleBase>>& childRules)
+{
+    if (!deferredParser.styleSheet())
+        return;
+    CSSParserImpl parser(deferredParser);
+    parser.consumeRuleList(tokenRange, RegularRuleList, [&childRules](const RefPtr<StyleRuleBase>& rule) {
+        childRules.append(rule);
+    });
+}
+
+void CSSParserImpl::parseDeferredKeyframeList(CSSParserTokenRange tokenRange, CSSDeferredParser& deferredParser, StyleRuleKeyframes& keyframeRule)
+{
+    if (!deferredParser.styleSheet())
+        return;
+    CSSParserImpl parser(deferredParser);
+    parser.consumeRuleList(tokenRange, KeyframesRuleList, [&keyframeRule](const RefPtr<StyleRuleBase>& keyframe) {
+        keyframeRule.parserAppendKeyframe(downcast<const StyleRuleKeyframe>(keyframe.get()));
+    });
+}
+
+bool CSSParserImpl::parseDeclarationList(MutableStyleProperties* declaration, const String& string, const CSSParserContext& context)
+{
+    CSSParserImpl parser(context, string);
+    StyleRule::Type ruleType = StyleRule::Style;
+#if ENABLE(CSS_DEVICE_ADAPTATION)
+    if (declaration->cssParserMode() == CSSViewportRuleMode)
+        ruleType = StyleRule::Viewport;
+#endif
+    parser.consumeDeclarationList(parser.tokenizer()->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, string, styleSheet);
+    CSSParserTokenRange range = parser.tokenizer()->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, CSSParser::RuleParsing ruleParsing)
+{
+    CSSParserImpl parser(context, string, styleSheet, nullptr, ruleParsing);
+    bool firstRuleValid = parser.consumeRuleList(parser.tokenizer()->tokenRange(), TopLevelRuleList, [&styleSheet](RefPtr<StyleRuleBase> rule) {
+        if (rule->isCharsetRule())
+            return;
+        styleSheet->parserAppendRule(rule.releaseNonNull());
+    });
+    styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
+    parser.adoptTokenizerEscapedStrings();
+}
+
+void CSSParserImpl::adoptTokenizerEscapedStrings()
+{
+    if (!m_deferredParser || !m_tokenizer)
+        return;
+    m_deferredParser->adoptTokenizerEscapedStrings(m_tokenizer->escapedStringsForAdoption());
+}
+
+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->match() != CSSSelector::PagePseudoClass)
+                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;
+}
+
+std::unique_ptr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
+{
+    return consumeKeyframeKeyList(CSSTokenizer(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)
+{
+    CSSParserObserverWrapper wrapper(observer);
+    CSSParserImpl parser(context, declaration, nullptr, &wrapper);
+    observer.startRuleHeader(StyleRule::Style, 0);
+    observer.endRuleHeader(1);
+    parser.consumeDeclarationList(parser.tokenizer()->tokenRange(), StyleRule::Style);
+}
+
+void CSSParserImpl::parseStyleSheetForInspector(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet, CSSParserObserver& observer)
+{
+    CSSParserObserverWrapper wrapper(observer);
+    CSSParserImpl parser(context, string, styleSheet, &wrapper);
+    bool firstRuleValid = parser.consumeRuleList(parser.tokenizer()->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);
+#if ENABLE(CSS_REGIONS)
+    case CSSAtRuleWebkitRegion:
+        return consumeRegionRule(prelude, block);
+#endif
+    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.consumeBlockCheckingForEditability(m_styleSheet.get());
+
+    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)
+{
+    if (m_deferredParser)
+        return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude).releaseNonNull(),  std::make_unique<DeferredStyleGroupRuleList>(block, *m_deferredParser));
+
+    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_deferredParser)
+        return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(), supported, std::make_unique<DeferredStyleGroupRuleList>(block, *m_deferredParser));
+
+    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_deferredParser)
+        return StyleRuleKeyframes::create(name, std::make_unique<DeferredStyleGroupRuleList>(block, *m_deferredParser));
+
+    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(name);
+    consumeRuleList(block, KeyframesRuleList, [keyframeRule](const RefPtr<StyleRuleBase>& keyframe) {
+        keyframeRule->parserAppendKeyframe(downcast<const StyleRuleKeyframe>(keyframe.get()));
+    });
+
+    // 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;
+}
+
+#if ENABLE(CSS_REGIONS)
+RefPtr<StyleRuleRegion> CSSParserImpl::consumeRegionRule(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) {
+        m_observerWrapper->observer().startRuleHeader(StyleRule::Region, 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 StyleRuleRegion::create(selectorList, rules);
+
+}
+#endif
+
+// 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<StyleRuleKeyframe> 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 StyleRuleKeyframe::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
+
+    RefPtr<StyleRule> rule;
+    if (m_observerWrapper)
+        observeSelectors(*m_observerWrapper, prelude);
+    
+    if (m_deferredParser) {
+        // If a rule is empty (i.e., only whitespace), don't bother using
+        // deferred parsing. This allows the empty rule optimization in ElementRuleCollector
+        // to continue to work. Note we don't have to consider CommentTokens, since those
+        // are stripped out.
+        CSSParserTokenRange blockCopy = block;
+        blockCopy.consumeWhitespace();
+        if (!blockCopy.atEnd()) {
+            rule = StyleRule::create(createDeferredStyleProperties(block));
+            rule->wrapperAdoptSelectorList(selectorList);
+            return rule;
+        }
+    }
+
+    consumeDeclarationList(block, StyleRule::Style);
+    rule = StyleRule::create(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 propertyID = token.parseAsCSSPropertyID();
+    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();
+    if (propertyID == CSSPropertyInvalid && CSSVariableParser::isValidVariableName(token)) {
+        AtomicString variableName = token.value().toAtomicString();
+        consumeCustomPropertyValue(range.makeSubRange(&range.peek(), declarationValueEnd), variableName, important);
+    }
+
+    if (important && (ruleType == StyleRule::FontFace || ruleType == StyleRule::Keyframe))
+        return;
+
+    if (propertyID != CSSPropertyInvalid)
+        consumeDeclarationValue(range.makeSubRange(&range.peek(), declarationValueEnd), propertyID, 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::consumeCustomPropertyValue(CSSParserTokenRange range, const AtomicString& variableName, bool important)
+{
+    if (RefPtr<CSSCustomPropertyValue> value = CSSVariableParser::parseDeclarationValue(variableName, range))
+        m_parsedProperties.append(CSSProperty(CSSPropertyCustom, WTFMove(value), important));
+}
+
+void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID propertyID, bool important, StyleRule::Type ruleType)
+{
+    CSSPropertyParser::parseValue(propertyID, important, range, m_context, m_styleSheet.get(), 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
diff --git a/Source/WebCore/css/parser/CSSParserImpl.h b/Source/WebCore/css/parser/CSSParserImpl.h
new file mode 100644
index 000000000..302c22b1e
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserImpl.h
@@ -0,0 +1,176 @@
+// 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 "CSSDeferredParser.h"
+#include "CSSParser.h"
+#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 CSSTokenizer;
+class StyleRuleKeyframe;
+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&, const String&, StyleSheetContents* = nullptr, CSSParserObserverWrapper* = nullptr, CSSParser::RuleParsing = CSSParser::RuleParsing::Normal);
+
+    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 CSSParser::ParseResult parseValue(MutableStyleProperties*, CSSPropertyID, const String&, bool important, const CSSParserContext&);
+    static CSSParser::ParseResult parseCustomPropertyValue(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*, CSSParser::RuleParsing);
+    static CSSSelectorList parsePageSelector(CSSParserTokenRange, StyleSheetContents*);
+
+    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&);
+
+    static Ref<ImmutableStyleProperties> parseDeferredDeclaration(CSSParserTokenRange, const CSSParserContext&, StyleSheetContents*);
+    static void parseDeferredRuleList(CSSParserTokenRange, CSSDeferredParser&, Vector<RefPtr<StyleRuleBase>>&);
+    static void parseDeferredKeyframeList(CSSParserTokenRange, CSSDeferredParser&, StyleRuleKeyframes&);
+
+    CSSTokenizer* tokenizer() const { return m_tokenizer.get(); };
+    CSSDeferredParser* deferredParser() const { return m_deferredParser.get(); }
+
+private:
+    CSSParserImpl(const CSSParserContext&, StyleSheetContents*);
+    CSSParserImpl(CSSDeferredParser&);
+
+    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);
+#if ENABLE(CSS_REGIONS)
+    RefPtr<StyleRuleRegion> consumeRegionRule(CSSParserTokenRange prelude, CSSParserTokenRange block);
+#endif
+    // Updates m_parsedProperties
+    
+    // FIXME-NEWPARSER: Support "apply"
+    // void consumeApplyRule(CSSParserTokenRange prelude);
+
+    RefPtr<StyleRuleKeyframe> 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 consumeCustomPropertyValue(CSSParserTokenRange, const AtomicString& propertyName, bool important);
+
+    static std::unique_ptr<Vector<double>> consumeKeyframeKeyList(CSSParserTokenRange);
+
+    Ref<DeferredStyleProperties> createDeferredStyleProperties(const CSSParserTokenRange& propertyRange);
+    
+    void adoptTokenizerEscapedStrings();
+
+    // 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 deferred property parsing.
+    RefPtr<CSSDeferredParser> m_deferredParser;
+    
+    // For normal parsing.
+    std::unique_ptr<CSSTokenizer> m_tokenizer;
+
+    // For the inspector
+    CSSParserObserverWrapper* m_observerWrapper { nullptr };
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserMode.h b/Source/WebCore/css/parser/CSSParserMode.h
new file mode 100644
index 000000000..2f926a44d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserMode.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
+ * Copyright (C) 2012 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:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “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 HOLDER 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 "TextEncoding.h"
+#include "URL.h"
+#include "URLHash.h"
+#include <wtf/HashFunctions.h>
+#include <wtf/text/StringHash.h>
+
+namespace WebCore {
+
+class Document;
+
+// Must not grow beyond 3 bits, due to packing in StyleProperties.
+enum CSSParserMode {
+    HTMLStandardMode,
+    HTMLQuirksMode,
+    // HTML attributes are parsed in quirks mode but also allows internal properties and values.
+    HTMLAttributeMode,
+    // SVG attributes are parsed in quirks mode but rules differ slightly.
+    SVGAttributeMode,
+    // @viewport rules are parsed in standards mode but CSSOM modifications (via StylePropertySet)
+    // must call parseViewportProperties so needs a special mode.
+    CSSViewportRuleMode,
+    // User agent stylesheets are parsed in standards mode but also allows internal properties and values.
+    UASheetMode
+};
+
+inline bool isQuirksModeBehavior(CSSParserMode mode)
+{
+    return mode == HTMLQuirksMode || mode == HTMLAttributeMode;
+}
+
+inline bool isUASheetBehavior(CSSParserMode mode)
+{
+    return mode == UASheetMode;
+}
+
+inline bool isUnitLessValueParsingEnabledForMode(CSSParserMode mode)
+{
+    return mode == HTMLAttributeMode || mode == SVGAttributeMode;
+}
+
+inline bool isCSSViewportParsingEnabledForMode(CSSParserMode mode)
+{
+    return mode == CSSViewportRuleMode;
+}
+
+// FIXME-NEWPARSER: Next two functions should be removed eventually.
+inline CSSParserMode strictToCSSParserMode(bool inStrictMode)
+{
+    return inStrictMode ? HTMLStandardMode : HTMLQuirksMode;
+}
+
+inline bool isStrictParserMode(CSSParserMode cssParserMode)
+{
+    return cssParserMode == UASheetMode || cssParserMode == HTMLStandardMode || cssParserMode == SVGAttributeMode;
+}
+
+struct CSSParserContext {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    CSSParserContext(CSSParserMode, const URL& baseURL = URL());
+    WEBCORE_EXPORT CSSParserContext(Document&, const URL& baseURL = URL(), const String& charset = emptyString());
+
+    URL baseURL;
+    String charset;
+    CSSParserMode mode { HTMLStandardMode };
+    bool isHTMLDocument { false };
+    bool cssGridLayoutEnabled { false };
+#if ENABLE(TEXT_AUTOSIZING)
+    bool textAutosizingEnabled { false };
+#endif
+    bool needsSiteSpecificQuirks { false };
+    bool enforcesCSSMIMETypeInNoQuirksMode { true };
+    bool useLegacyBackgroundSizeShorthandBehavior { false };
+    bool springTimingFunctionEnabled { false };
+    
+    bool deferredCSSParserEnabled { false };
+
+    URL completeURL(const String& url) const
+    {
+        if (url.isNull())
+            return URL();
+        if (charset.isEmpty())
+            return URL(baseURL, url);
+        return URL(baseURL, url, TextEncoding(charset));
+    }
+};
+
+bool operator==(const CSSParserContext&, const CSSParserContext&);
+inline bool operator!=(const CSSParserContext& a, const CSSParserContext& b) { return !(a == b); }
+
+WEBCORE_EXPORT const CSSParserContext& strictCSSParserContext();
+
+struct CSSParserContextHash {
+    static unsigned hash(const CSSParserContext& key)
+    {
+        auto hash = URLHash::hash(key.baseURL);
+        if (!key.charset.isEmpty())
+            hash ^= StringHash::hash(key.charset);
+        unsigned bits = key.isHTMLDocument                  << 0
+            & key.isHTMLDocument                            << 1
+            & key.cssGridLayoutEnabled                      << 2
+#if ENABLE(TEXT_AUTOSIZING)
+            & key.textAutosizingEnabled                     << 3
+#endif
+            & key.needsSiteSpecificQuirks                   << 4
+            & key.enforcesCSSMIMETypeInNoQuirksMode         << 5
+            & key.useLegacyBackgroundSizeShorthandBehavior  << 6
+            & key.springTimingFunctionEnabled               << 7
+            & key.deferredCSSParserEnabled                  << 8
+            & key.mode                                      << 9;
+        hash ^= WTF::intHash(bits);
+        return hash;
+    }
+    static bool equal(const CSSParserContext& a, const CSSParserContext& b)
+    {
+        return a == b;
+    }
+    static const bool safeToCompareToEmptyOrDeleted = false;
+};
+
+} // namespace WebCore
+
+namespace WTF {
+template<> struct HashTraits<WebCore::CSSParserContext> : GenericHashTraits<WebCore::CSSParserContext> {
+    static void constructDeletedValue(WebCore::CSSParserContext& slot) { new (NotNull, &slot.baseURL) WebCore::URL(WTF::HashTableDeletedValue); }
+    static bool isDeletedValue(const WebCore::CSSParserContext& value) { return value.baseURL.isHashTableDeletedValue(); }
+    static WebCore::CSSParserContext emptyValue() { return WebCore::CSSParserContext(WebCore::HTMLStandardMode); }
+};
+
+template<> struct DefaultHash<WebCore::CSSParserContext> {
+    typedef WebCore::CSSParserContextHash Hash;
+};
+} // namespace WTF
diff --git a/Source/WebCore/css/parser/CSSParserObserver.h b/Source/WebCore/css/parser/CSSParserObserver.h
new file mode 100644
index 000000000..5c4539caa
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserObserver.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010, 2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
+ * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. 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 "CSSPropertySourceData.h"
+#include "StyleRule.h"
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+class CSSParserToken;
+class CSSParserTokenRange;
+
+// This is only for the inspector and shouldn't be used elsewhere.
+class CSSParserObserver {
+public:
+    virtual ~CSSParserObserver() { };
+    virtual void startRuleHeader(StyleRule::Type, unsigned offset) = 0;
+    virtual void endRuleHeader(unsigned offset) = 0;
+    virtual void observeSelector(unsigned startOffset, unsigned endOffset) = 0;
+    virtual void startRuleBody(unsigned offset) = 0;
+    virtual void endRuleBody(unsigned offset) = 0;
+    virtual void observeProperty(unsigned startOffset, unsigned endOffset, bool isImportant, bool isParsed) = 0;
+    virtual void observeComment(unsigned startOffset, unsigned endOffset) = 0;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserObserverWrapper.cpp b/Source/WebCore/css/parser/CSSParserObserverWrapper.cpp
new file mode 100644
index 000000000..65b224853
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserObserverWrapper.cpp
@@ -0,0 +1,72 @@
+// 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 "CSSParserObserverWrapper.h"
+
+#include "CSSParserTokenRange.h"
+
+namespace WebCore {
+
+unsigned CSSParserObserverWrapper::startOffset(const CSSParserTokenRange& range)
+{
+    return m_tokenOffsets[range.begin() - m_firstParserToken];
+}
+
+unsigned CSSParserObserverWrapper::previousTokenStartOffset(const CSSParserTokenRange& range)
+{
+    if (range.begin() == m_firstParserToken)
+        return 0;
+    return m_tokenOffsets[range.begin() - m_firstParserToken - 1];
+}
+
+unsigned CSSParserObserverWrapper::endOffset(const CSSParserTokenRange& range)
+{
+    return m_tokenOffsets[range.end() - m_firstParserToken];
+}
+
+void CSSParserObserverWrapper::skipCommentsBefore(const CSSParserTokenRange& range, bool leaveDirectlyBefore)
+{
+    unsigned startIndex = range.begin() - m_firstParserToken;
+    if (!leaveDirectlyBefore)
+        startIndex++;
+    while (m_commentIterator < m_commentOffsets.end() && m_commentIterator->tokensBefore < startIndex)
+        m_commentIterator++;
+}
+
+void CSSParserObserverWrapper::yieldCommentsBefore(const CSSParserTokenRange& range)
+{
+    unsigned startIndex = range.begin() - m_firstParserToken;
+    while (m_commentIterator < m_commentOffsets.end() && m_commentIterator->tokensBefore <= startIndex) {
+        m_observer.observeComment(m_commentIterator->startOffset, m_commentIterator->endOffset);
+        m_commentIterator++;
+    }
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserObserverWrapper.h b/Source/WebCore/css/parser/CSSParserObserverWrapper.h
new file mode 100644
index 000000000..456c0cd43
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserObserverWrapper.h
@@ -0,0 +1,77 @@
+// 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
+
+#include "CSSParserObserver.h"
+
+namespace WebCore {
+
+class CSSParserObserverWrapper {
+public:
+    explicit CSSParserObserverWrapper(CSSParserObserver& observer)
+        : m_observer(observer)
+    { }
+
+    unsigned startOffset(const CSSParserTokenRange&);
+    unsigned previousTokenStartOffset(const CSSParserTokenRange&);
+    unsigned endOffset(const CSSParserTokenRange&); // Includes trailing comments
+
+    void skipCommentsBefore(const CSSParserTokenRange&, bool leaveDirectlyBefore);
+    void yieldCommentsBefore(const CSSParserTokenRange&);
+
+    CSSParserObserver& observer() { return m_observer; }
+    void addComment(unsigned startOffset, unsigned endOffset, unsigned tokensBefore)
+    {
+        CommentPosition position = {startOffset, endOffset, tokensBefore};
+        m_commentOffsets.append(position);
+    }
+    void addToken(unsigned startOffset) { m_tokenOffsets.append(startOffset); }
+    void finalizeConstruction(CSSParserToken* firstParserToken)
+    {
+        m_firstParserToken = firstParserToken;
+        m_commentIterator = m_commentOffsets.begin();
+    }
+
+private:
+    CSSParserObserver& m_observer;
+    Vector<unsigned> m_tokenOffsets;
+    CSSParserToken* m_firstParserToken;
+
+    struct CommentPosition {
+        unsigned startOffset;
+        unsigned endOffset;
+        unsigned tokensBefore;
+    };
+
+    Vector<CommentPosition> m_commentOffsets;
+    Vector<CommentPosition>::iterator m_commentIterator;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserSelector.cpp b/Source/WebCore/css/parser/CSSParserSelector.cpp
new file mode 100644
index 000000000..808026d92
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserSelector.cpp
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2008, 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.
+ */
+
+#include "config.h"
+#include "CSSParserSelector.h"
+
+#include "CSSCustomPropertyValue.h"
+#include "CSSParserIdioms.h"
+#include "CSSPrimitiveValue.h"
+#include "CSSFunctionValue.h"
+#include "CSSSelector.h"
+#include "CSSSelectorList.h"
+#include "SelectorPseudoTypeMap.h"
+
+#if COMPILER(MSVC)
+// See https://msdn.microsoft.com/en-us/library/1wea5zwe.aspx
+#pragma warning(disable: 4701)
+#endif
+
+namespace WebCore {
+
+using namespace WTF;
+
+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();
+}
+
+CSSParserSelector* CSSParserSelector::parsePseudoElementSelectorFromStringView(StringView& pseudoTypeString)
+{
+    AtomicString name = pseudoTypeString.toAtomicString();
+    
+    CSSSelector::PseudoElementType pseudoType = CSSSelector::parsePseudoElementType(name);
+    if (pseudoType == CSSSelector::PseudoElementUnknown) {
+        // FIXME-NEWPARSER: We can't add "slotted" to the map without breaking the old
+        // parser, so this hack ensures the new parser still recognizes it. When the new
+        // parser turns on, we can add "slotted" to the map and remove this code.
+        if (pseudoTypeString.startsWithIgnoringASCIICase("slotted"))
+            pseudoType = CSSSelector::PseudoElementSlotted;
+        else
+            return nullptr;
+    }
+
+    auto selector = std::make_unique<CSSParserSelector>();
+    selector->m_selector->setMatch(CSSSelector::PseudoElement);
+    selector->m_selector->setPseudoElementType(pseudoType);
+    if (pseudoType == CSSSelector::PseudoElementWebKitCustomLegacyPrefixed) {
+        ASSERT_WITH_MESSAGE(name == "-webkit-input-placeholder", "-webkit-input-placeholder is the only LegacyPrefix pseudo type.");
+        if (name == "-webkit-input-placeholder")
+            name = AtomicString("placeholder", AtomicString::ConstructFromLiteral);
+    }
+    selector->m_selector->setValue(name);
+    return selector.release();
+}
+
+CSSParserSelector* CSSParserSelector::parsePseudoClassSelectorFromStringView(StringView& pseudoTypeString)
+{
+    PseudoClassOrCompatibilityPseudoElement pseudoType = parsePseudoClassAndCompatibilityElementString(pseudoTypeString);
+    if (pseudoType.pseudoClass != CSSSelector::PseudoClassUnknown) {
+        auto selector = std::make_unique<CSSParserSelector>();
+        selector->m_selector->setMatch(CSSSelector::PseudoClass);
+        selector->m_selector->setPseudoClassType(pseudoType.pseudoClass);
+        return selector.release();
+    }
+    if (pseudoType.compatibilityPseudoElement != CSSSelector::PseudoElementUnknown) {
+        auto selector = std::make_unique<CSSParserSelector>();
+        selector->m_selector->setMatch(CSSSelector::PseudoElement);
+        selector->m_selector->setPseudoElementType(pseudoType.compatibilityPseudoElement);
+        AtomicString name = pseudoTypeString.toAtomicString();
+        selector->m_selector->setValue(name);
+        return selector.release();
+    }
+    return nullptr;
+}
+
+CSSParserSelector::CSSParserSelector()
+    : m_selector(std::make_unique<CSSSelector>())
+{
+}
+
+CSSParserSelector::CSSParserSelector(const QualifiedName& tagQName)
+    : m_selector(std::make_unique<CSSSelector>(tagQName))
+{
+}
+
+CSSParserSelector::~CSSParserSelector()
+{
+    if (!m_tagHistory)
+        return;
+    Vector<std::unique_ptr<CSSParserSelector>, 16> toDelete;
+    std::unique_ptr<CSSParserSelector> selector = WTFMove(m_tagHistory);
+    while (true) {
+        std::unique_ptr<CSSParserSelector> next = WTFMove(selector->m_tagHistory);
+        toDelete.append(WTFMove(selector));
+        if (!next)
+            break;
+        selector = WTFMove(next);
+    }
+}
+
+void CSSParserSelector::adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector)
+{
+    auto selectorList = std::make_unique<CSSSelectorList>();
+    selectorList->adoptSelectorVector(selectorVector);
+    m_selector->setSelectorList(WTFMove(selectorList));
+}
+
+void CSSParserSelector::setLangArgumentList(std::unique_ptr<Vector<AtomicString>> argumentList)
+{
+    ASSERT_WITH_MESSAGE(!argumentList->isEmpty(), "No CSS Selector takes an empty argument list.");
+    m_selector->setLangArgumentList(WTFMove(argumentList));
+}
+
+void CSSParserSelector::setSelectorList(std::unique_ptr<CSSSelectorList> selectorList)
+{
+    m_selector->setSelectorList(WTFMove(selectorList));
+}
+
+static bool selectorListMatchesPseudoElement(const CSSSelectorList* selectorList)
+{
+    if (!selectorList)
+        return false;
+
+    for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
+        for (const CSSSelector* selector = subSelector; selector; selector = selector->tagHistory()) {
+            if (selector->matchesPseudoElement())
+                return true;
+            if (const CSSSelectorList* subselectorList = selector->selectorList()) {
+                if (selectorListMatchesPseudoElement(subselectorList))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool CSSParserSelector::matchesPseudoElement() const
+{
+    return m_selector->matchesPseudoElement() || selectorListMatchesPseudoElement(m_selector->selectorList());
+}
+
+void CSSParserSelector::insertTagHistory(CSSSelector::RelationType before, std::unique_ptr<CSSParserSelector> selector, CSSSelector::RelationType after)
+{
+    if (m_tagHistory)
+        selector->setTagHistory(WTFMove(m_tagHistory));
+    setRelation(before);
+    selector->setRelation(after);
+    m_tagHistory = WTFMove(selector);
+}
+
+void CSSParserSelector::appendTagHistory(CSSSelector::RelationType relation, std::unique_ptr<CSSParserSelector> selector)
+{
+    CSSParserSelector* end = this;
+    while (end->tagHistory())
+        end = end->tagHistory();
+
+    end->setRelation(relation);
+    end->setTagHistory(WTFMove(selector));
+}
+
+void CSSParserSelector::appendTagHistory(CSSParserSelectorCombinator relation, std::unique_ptr<CSSParserSelector> selector)
+{
+    CSSParserSelector* end = this;
+    while (end->tagHistory())
+        end = end->tagHistory();
+
+    CSSSelector::RelationType selectorRelation;
+    switch (relation) {
+    case CSSParserSelectorCombinator::Child:
+        selectorRelation = CSSSelector::Child;
+        break;
+    case CSSParserSelectorCombinator::DescendantSpace:
+        selectorRelation = CSSSelector::DescendantSpace;
+        break;
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+    case CSSParserSelectorCombinator::DescendantDoubleChild:
+        selectorRelation = CSSSelector::DescendantDoubleChild;
+        break;
+#endif
+    case CSSParserSelectorCombinator::DirectAdjacent:
+        selectorRelation = CSSSelector::DirectAdjacent;
+        break;
+    case CSSParserSelectorCombinator::IndirectAdjacent:
+        selectorRelation = CSSSelector::IndirectAdjacent;
+        break;
+    }
+    end->setRelation(selectorRelation);
+    end->setTagHistory(WTFMove(selector));
+}
+
+void CSSParserSelector::prependTagSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
+{
+    auto second = std::make_unique<CSSParserSelector>();
+    second->m_selector = WTFMove(m_selector);
+    second->m_tagHistory = WTFMove(m_tagHistory);
+    m_tagHistory = WTFMove(second);
+
+    m_selector = std::make_unique<CSSSelector>(tagQName, tagIsForNamespaceRule);
+    m_selector->setRelation(CSSSelector::Subselector);
+}
+
+std::unique_ptr<CSSParserSelector> CSSParserSelector::releaseTagHistory()
+{
+    setRelation(CSSSelector::Subselector);
+    return WTFMove(m_tagHistory);
+}
+
+// FIXME-NEWPARSER: Add support for :host-context
+bool CSSParserSelector::isHostPseudoSelector() const
+{
+    return match() == CSSSelector::PseudoClass && pseudoClassType() == CSSSelector::PseudoClassHost;
+}
+
+}
+
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);
+}
+
+}
diff --git a/Source/WebCore/css/parser/CSSParserToken.cpp b/Source/WebCore/css/parser/CSSParserToken.cpp
new file mode 100644
index 000000000..3e95b5a49
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserToken.cpp
@@ -0,0 +1,479 @@
+// 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 "CSSParserToken.h"
+
+#include "CSSMarkup.h"
+#include "CSSPrimitiveValue.h"
+#include "CSSPropertyParser.h"
+#include <limits.h>
+#include <wtf/HashMap.h>
+#include <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+template<typename CharacterType>
+CSSPrimitiveValue::UnitType cssPrimitiveValueUnitFromTrie(const CharacterType* data, unsigned length)
+{
+    ASSERT(data);
+    ASSERT(length);
+    switch (length) {
+    case 1:
+        switch (toASCIILower(data[0])) {
+        case 's':
+            return CSSPrimitiveValue::UnitType::CSS_S;
+        }
+        break;
+    case 2:
+        switch (toASCIILower(data[0])) {
+        case 'c':
+            switch (toASCIILower(data[1])) {
+            case 'h':
+                return CSSPrimitiveValue::UnitType::CSS_CHS;
+            case 'm':
+                return CSSPrimitiveValue::UnitType::CSS_CM;
+            }
+            break;
+        case 'e':
+            switch (toASCIILower(data[1])) {
+            case 'm':
+                return CSSPrimitiveValue::UnitType::CSS_EMS;
+            case 'x':
+                return CSSPrimitiveValue::UnitType::CSS_EXS;
+            }
+            break;
+        case 'f':
+            if (toASCIILower(data[1]) == 'r')
+                return CSSPrimitiveValue::UnitType::CSS_FR;
+            break;
+        case 'h':
+            if (toASCIILower(data[1]) == 'z')
+                return CSSPrimitiveValue::UnitType::CSS_HZ;
+            break;
+        case 'i':
+            if (toASCIILower(data[1]) == 'n')
+                return CSSPrimitiveValue::UnitType::CSS_IN;
+            break;
+        case 'm':
+            switch (toASCIILower(data[1])) {
+            case 'm':
+                return CSSPrimitiveValue::UnitType::CSS_MM;
+            case 's':
+                return CSSPrimitiveValue::UnitType::CSS_MS;
+            }
+            break;
+        case 'p':
+            switch (toASCIILower(data[1])) {
+            case 'c':
+                return CSSPrimitiveValue::UnitType::CSS_PC;
+            case 't':
+                return CSSPrimitiveValue::UnitType::CSS_PT;
+            case 'x':
+                return CSSPrimitiveValue::UnitType::CSS_PX;
+            }
+            break;
+        case 'v':
+            switch (toASCIILower(data[1])) {
+            case 'h':
+                return CSSPrimitiveValue::UnitType::CSS_VH;
+            case 'w':
+                return CSSPrimitiveValue::UnitType::CSS_VW;
+            }
+            break;
+        }
+        break;
+    case 3:
+        switch (toASCIILower(data[0])) {
+        case 'd':
+            switch (toASCIILower(data[1])) {
+            case 'e':
+                if (toASCIILower(data[2]) == 'g')
+                    return CSSPrimitiveValue::UnitType::CSS_DEG;
+                break;
+            case 'p':
+                if (toASCIILower(data[2]) == 'i')
+                    return CSSPrimitiveValue::UnitType::CSS_DPI;
+                break;
+            }
+        break;
+        case 'k':
+            if (toASCIILower(data[1]) == 'h' && toASCIILower(data[2]) == 'z')
+                return CSSPrimitiveValue::UnitType::CSS_KHZ;
+            break;
+        case 'r':
+            switch (toASCIILower(data[1])) {
+            case 'a':
+                if (toASCIILower(data[2]) == 'd')
+                    return CSSPrimitiveValue::UnitType::CSS_RAD;
+                break;
+            case 'e':
+                if (toASCIILower(data[2]) == 'm')
+                    return CSSPrimitiveValue::UnitType::CSS_REMS;
+                break;
+            }
+        break;
+    }
+    break;
+    case 4:
+        switch (toASCIILower(data[0])) {
+        case 'd':
+            switch (toASCIILower(data[1])) {
+            case 'p':
+                switch (toASCIILower(data[2])) {
+                case 'c':
+                    if (toASCIILower(data[3]) == 'm')
+                        return CSSPrimitiveValue::UnitType::CSS_DPCM;
+                    break;
+                case 'p':
+                    if (toASCIILower(data[3]) == 'x')
+                        return CSSPrimitiveValue::UnitType::CSS_DPPX;
+                    break;
+                }
+            break;
+        }
+        break;
+        case 'g':
+            if (toASCIILower(data[1]) == 'r' && toASCIILower(data[2]) == 'a' && toASCIILower(data[3]) == 'd')
+                return CSSPrimitiveValue::UnitType::CSS_GRAD;
+            break;
+        case 't':
+            if (toASCIILower(data[1]) == 'u' && toASCIILower(data[2]) == 'r' && toASCIILower(data[3]) == 'n')
+                return CSSPrimitiveValue::UnitType::CSS_TURN;
+            break;
+        case 'v':
+            switch (toASCIILower(data[1])) {
+            case 'm':
+                switch (toASCIILower(data[2])) {
+                case 'a':
+                    if (toASCIILower(data[3]) == 'x')
+                        return CSSPrimitiveValue::UnitType::CSS_VMAX;
+                    break;
+                case 'i':
+                    if (toASCIILower(data[3]) == 'n')
+                        return CSSPrimitiveValue::UnitType::CSS_VMIN;
+                    break;
+                }
+                break;
+            }
+            break;
+        }
+        break;
+    case 5:
+        switch (toASCIILower(data[0])) {
+        case '_':
+            if (toASCIILower(data[1]) == '_' && toASCIILower(data[2]) == 'q' && toASCIILower(data[3]) == 'e' && toASCIILower(data[4]) == 'm')
+                return CSSPrimitiveValue::UnitType::CSS_QUIRKY_EMS;
+            break;
+        }
+        break;
+    }
+    return CSSPrimitiveValue::UnitType::CSS_UNKNOWN;
+}
+
+static CSSPrimitiveValue::UnitType stringToUnitType(StringView stringView)
+{
+    if (stringView.is8Bit())
+        return cssPrimitiveValueUnitFromTrie(stringView.characters8(), stringView.length());
+    return cssPrimitiveValueUnitFromTrie(stringView.characters16(), stringView.length());
+}
+
+CSSParserToken::CSSParserToken(CSSParserTokenType type, BlockType blockType)
+    : m_type(type)
+    , m_blockType(blockType)
+{
+}
+
+// Just a helper used for Delimiter tokens.
+CSSParserToken::CSSParserToken(CSSParserTokenType type, UChar c)
+    : m_type(type)
+    , m_blockType(NotBlock)
+    , m_delimiter(c)
+{
+    ASSERT(m_type == DelimiterToken);
+}
+
+CSSParserToken::CSSParserToken(CSSParserTokenType type, StringView value, BlockType blockType)
+    : m_type(type)
+    , m_blockType(blockType)
+{
+    initValueFromStringView(value);
+    m_id = -1;
+}
+
+CSSParserToken::CSSParserToken(CSSParserTokenType type, double numericValue, NumericValueType numericValueType, NumericSign sign)
+    : m_type(type)
+    , m_blockType(NotBlock)
+    , m_numericValueType(numericValueType)
+    , m_numericSign(sign)
+    , m_unit(static_cast<unsigned>(CSSPrimitiveValue::UnitType::CSS_NUMBER))
+{
+    ASSERT(type == NumberToken);
+    m_numericValue = numericValue;
+}
+
+CSSParserToken::CSSParserToken(CSSParserTokenType type, UChar32 start, UChar32 end)
+    : m_type(UnicodeRangeToken)
+    , m_blockType(NotBlock)
+{
+    ASSERT_UNUSED(type, type == UnicodeRangeToken);
+    m_unicodeRange.start = start;
+    m_unicodeRange.end = end;
+}
+
+CSSParserToken::CSSParserToken(HashTokenType type, StringView value)
+    : m_type(HashToken)
+    , m_blockType(NotBlock)
+    , m_hashTokenType(type)
+{
+    initValueFromStringView(value);
+}
+
+void CSSParserToken::convertToDimensionWithUnit(StringView unit)
+{
+    ASSERT(m_type == NumberToken);
+    m_type = DimensionToken;
+    initValueFromStringView(unit);
+    m_unit = static_cast<unsigned>(stringToUnitType(unit));
+}
+
+void CSSParserToken::convertToPercentage()
+{
+    ASSERT(m_type == NumberToken);
+    m_type = PercentageToken;
+    m_unit = static_cast<unsigned>(CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+}
+
+UChar CSSParserToken::delimiter() const
+{
+    ASSERT(m_type == DelimiterToken);
+    return m_delimiter;
+}
+
+NumericSign CSSParserToken::numericSign() const
+{
+    // This is valid for DimensionToken and PercentageToken, but only used
+    // in <an+b> parsing on NumberTokens.
+    ASSERT(m_type == NumberToken);
+    return static_cast<NumericSign>(m_numericSign);
+}
+
+NumericValueType CSSParserToken::numericValueType() const
+{
+    ASSERT(m_type == NumberToken || m_type == PercentageToken || m_type == DimensionToken);
+    return static_cast<NumericValueType>(m_numericValueType);
+}
+
+double CSSParserToken::numericValue() const
+{
+    ASSERT(m_type == NumberToken || m_type == PercentageToken || m_type == DimensionToken);
+    return m_numericValue;
+}
+
+CSSPropertyID CSSParserToken::parseAsCSSPropertyID() const
+{
+    ASSERT(m_type == IdentToken);
+    return cssPropertyID(value());
+}
+
+CSSValueID CSSParserToken::id() const
+{
+    if (m_type != IdentToken)
+        return CSSValueInvalid;
+    if (m_id < 0)
+        m_id = cssValueKeywordID(value());
+    return static_cast<CSSValueID>(m_id);
+}
+
+CSSValueID CSSParserToken::functionId() const
+{
+    if (m_type != FunctionToken)
+        return CSSValueInvalid;
+    if (m_id < 0)
+        m_id = cssValueKeywordID(value());
+    return static_cast<CSSValueID>(m_id);
+}
+
+bool CSSParserToken::hasStringBacking() const
+{
+    CSSParserTokenType tokenType = type();
+    return tokenType == IdentToken
+        || tokenType == FunctionToken
+        || tokenType == AtKeywordToken
+        || tokenType == HashToken
+        || tokenType == UrlToken
+        || tokenType == DimensionToken
+        || tokenType == StringToken;
+}
+
+CSSParserToken CSSParserToken::copyWithUpdatedString(const StringView& string) const
+{
+    CSSParserToken copy(*this);
+    copy.initValueFromStringView(string);
+    return copy;
+}
+
+bool CSSParserToken::valueDataCharRawEqual(const CSSParserToken& other) const
+{
+    if (m_valueLength != other.m_valueLength)
+        return false;
+
+    if (m_valueDataCharRaw == other.m_valueDataCharRaw && m_valueIs8Bit == other.m_valueIs8Bit)
+        return true;
+
+    if (m_valueIs8Bit)
+        return other.m_valueIs8Bit ? equal(static_cast<const LChar*>(m_valueDataCharRaw), static_cast<const LChar*>(other.m_valueDataCharRaw), m_valueLength) : equal(static_cast<const LChar*>(m_valueDataCharRaw), static_cast<const UChar*>(other.m_valueDataCharRaw), m_valueLength);
+    
+    return other.m_valueIs8Bit ? equal(static_cast<const UChar*>(m_valueDataCharRaw), static_cast<const LChar*>(other.m_valueDataCharRaw), m_valueLength) : equal(static_cast<const UChar*>(m_valueDataCharRaw), static_cast<const UChar*>(other.m_valueDataCharRaw), m_valueLength);
+}
+
+bool CSSParserToken::operator==(const CSSParserToken& other) const
+{
+    if (m_type != other.m_type)
+        return false;
+    switch (m_type) {
+    case DelimiterToken:
+        return delimiter() == other.delimiter();
+    case HashToken:
+        if (m_hashTokenType != other.m_hashTokenType)
+            return false;
+        FALLTHROUGH;
+    case IdentToken:
+    case FunctionToken:
+    case StringToken:
+    case UrlToken:
+        return valueDataCharRawEqual(other);
+    case DimensionToken:
+        if (!valueDataCharRawEqual(other))
+            return false;
+        FALLTHROUGH;
+    case NumberToken:
+    case PercentageToken:
+        return m_numericSign == other.m_numericSign && m_numericValue == other.m_numericValue && m_numericValueType == other.m_numericValueType;
+    case UnicodeRangeToken:
+        return m_unicodeRange.start == other.m_unicodeRange.start && m_unicodeRange.end == other.m_unicodeRange.end;
+    default:
+        return true;
+    }
+}
+
+void CSSParserToken::serialize(StringBuilder& builder) const
+{
+    // This is currently only used for @supports CSSOM. To keep our implementation
+    // simple we handle some of the edge cases incorrectly (see comments below).
+    switch (type()) {
+    case IdentToken:
+        serializeIdentifier(value().toString(), builder);
+        break;
+    case FunctionToken:
+        serializeIdentifier(value().toString(), builder);
+        return builder.append('(');
+    case AtKeywordToken:
+        builder.append('@');
+        serializeIdentifier(value().toString(), builder);
+        break;
+    case HashToken:
+        builder.append('#');
+        serializeIdentifier(value().toString(), builder, (getHashTokenType() == HashTokenUnrestricted));
+        break;
+    case UrlToken:
+        builder.append("url(");
+        serializeIdentifier(value().toString(), builder);
+        return builder.append(')');
+    case DelimiterToken:
+        if (delimiter() == '\\')
+            return builder.append("\\\n");
+        return builder.append(delimiter());
+    case NumberToken:
+        // These won't properly preserve the NumericValueType flag
+        if (m_numericSign == PlusSign)
+            builder.append('+');
+        return builder.appendNumber(numericValue());
+    case PercentageToken:
+        builder.appendNumber(numericValue());
+        return builder.append('%');
+    case DimensionToken:
+        // This will incorrectly serialize e.g. 4e3e2 as 4000e2
+        builder.appendNumber(numericValue());
+        serializeIdentifier(value().toString(), builder);
+        break;
+    case UnicodeRangeToken:
+        return builder.append(String::format("U+%X-%X", unicodeRangeStart(), unicodeRangeEnd()));
+    case StringToken:
+        return serializeString(value().toString(), builder);
+
+    case IncludeMatchToken:
+        return builder.append("~=");
+    case DashMatchToken:
+        return builder.append("|=");
+    case PrefixMatchToken:
+        return builder.append("^=");
+    case SuffixMatchToken:
+        return builder.append("$=");
+    case SubstringMatchToken:
+        return builder.append("*=");
+    case ColumnToken:
+        return builder.append("||");
+    case CDOToken:
+        return builder.append("<!--");
+    case CDCToken:
+        return builder.append("-->");
+    case BadStringToken:
+        return builder.append("'\n");
+    case BadUrlToken:
+        return builder.append("url(()");
+    case WhitespaceToken:
+        return builder.append(' ');
+    case ColonToken:
+        return builder.append(':');
+    case SemicolonToken:
+        return builder.append(';');
+    case CommaToken:
+        return builder.append(',');
+    case LeftParenthesisToken:
+        return builder.append('(');
+    case RightParenthesisToken:
+        return builder.append(')');
+    case LeftBracketToken:
+        return builder.append('[');
+    case RightBracketToken:
+        return builder.append(']');
+    case LeftBraceToken:
+        return builder.append('{');
+    case RightBraceToken:
+        return builder.append('}');
+
+    case EOFToken:
+    case CommentToken:
+        ASSERT_NOT_REACHED();
+        return;
+    }
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserToken.h b/Source/WebCore/css/parser/CSSParserToken.h
new file mode 100644
index 000000000..7870c00f3
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserToken.h
@@ -0,0 +1,178 @@
+// 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 "CSSPrimitiveValue.h"
+#include <wtf/text/StringView.h>
+
+namespace WebCore {
+
+enum CSSParserTokenType {
+    IdentToken = 0,
+    FunctionToken,
+    AtKeywordToken,
+    HashToken,
+    UrlToken,
+    BadUrlToken,
+    DelimiterToken,
+    NumberToken,
+    PercentageToken,
+    DimensionToken,
+    IncludeMatchToken,
+    DashMatchToken,
+    PrefixMatchToken,
+    SuffixMatchToken,
+    SubstringMatchToken,
+    ColumnToken,
+    UnicodeRangeToken,
+    WhitespaceToken,
+    CDOToken,
+    CDCToken,
+    ColonToken,
+    SemicolonToken,
+    CommaToken,
+    LeftParenthesisToken,
+    RightParenthesisToken,
+    LeftBracketToken,
+    RightBracketToken,
+    LeftBraceToken,
+    RightBraceToken,
+    StringToken,
+    BadStringToken,
+    EOFToken,
+    CommentToken,
+};
+
+enum NumericSign {
+    NoSign,
+    PlusSign,
+    MinusSign,
+};
+
+enum NumericValueType {
+    IntegerValueType,
+    NumberValueType,
+};
+
+enum HashTokenType {
+    HashTokenId,
+    HashTokenUnrestricted,
+};
+
+class CSSParserToken {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    enum BlockType {
+        NotBlock,
+        BlockStart,
+        BlockEnd,
+    };
+
+    CSSParserToken(CSSParserTokenType, BlockType = NotBlock);
+    CSSParserToken(CSSParserTokenType, StringView, BlockType = NotBlock);
+
+    CSSParserToken(CSSParserTokenType, UChar); // for DelimiterToken
+    CSSParserToken(CSSParserTokenType, double, NumericValueType, NumericSign); // for NumberToken
+    CSSParserToken(CSSParserTokenType, UChar32, UChar32); // for UnicodeRangeToken
+
+    CSSParserToken(HashTokenType, StringView);
+
+    bool operator==(const CSSParserToken& other) const;
+    bool operator!=(const CSSParserToken& other) const { return !(*this == other); }
+
+    // Converts NumberToken to DimensionToken.
+    void convertToDimensionWithUnit(StringView);
+
+    // Converts NumberToken to PercentageToken.
+    void convertToPercentage();
+
+    CSSParserTokenType type() const { return static_cast<CSSParserTokenType>(m_type); }
+    StringView value() const
+    {
+        if (m_valueIs8Bit)
+            return StringView(static_cast<const LChar*>(m_valueDataCharRaw), m_valueLength);
+        return StringView(static_cast<const UChar*>(m_valueDataCharRaw), m_valueLength);
+    }
+
+    UChar delimiter() const;
+    NumericSign numericSign() const;
+    NumericValueType numericValueType() const;
+    double numericValue() const;
+    HashTokenType getHashTokenType() const { ASSERT(m_type == HashToken); return m_hashTokenType; }
+    BlockType getBlockType() const { return static_cast<BlockType>(m_blockType); }
+    CSSPrimitiveValue::UnitType unitType() const { return static_cast<CSSPrimitiveValue::UnitType>(m_unit); }
+    UChar32 unicodeRangeStart() const { ASSERT(m_type == UnicodeRangeToken); return m_unicodeRange.start; }
+    UChar32 unicodeRangeEnd() const { ASSERT(m_type == UnicodeRangeToken); return m_unicodeRange.end; }
+    CSSValueID id() const;
+    CSSValueID functionId() const;
+
+    bool hasStringBacking() const;
+
+    CSSPropertyID parseAsCSSPropertyID() const;
+
+    void serialize(StringBuilder&) const;
+
+    CSSParserToken copyWithUpdatedString(const StringView&) const;
+
+private:
+    void initValueFromStringView(StringView string)
+    {
+        m_valueLength = string.length();
+        m_valueIs8Bit = string.is8Bit();
+        m_valueDataCharRaw = m_valueIs8Bit ? const_cast<void*>(static_cast<const void*>(string.characters8())) : const_cast<void*>(static_cast<const void*>(string.characters16()));
+    }
+    unsigned m_type : 6; // CSSParserTokenType
+    unsigned m_blockType : 2; // BlockType
+    unsigned m_numericValueType : 1; // NumericValueType
+    unsigned m_numericSign : 2; // NumericSign
+    unsigned m_unit : 7; // CSSPrimitiveValue::UnitType
+
+    bool valueDataCharRawEqual(const CSSParserToken& other) const;
+
+    // m_value... is an unpacked StringView so that we can pack it
+    // tightly with the rest of this object for a smaller object size.
+    bool m_valueIs8Bit : 1;
+    unsigned m_valueLength;
+    void* m_valueDataCharRaw; // Either LChar* or UChar*.
+
+    union {
+        UChar m_delimiter;
+        HashTokenType m_hashTokenType;
+        double m_numericValue;
+        mutable int m_id;
+
+        struct {
+            UChar32 start;
+            UChar32 end;
+        } m_unicodeRange;
+    };
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserTokenRange.cpp b/Source/WebCore/css/parser/CSSParserTokenRange.cpp
new file mode 100644
index 000000000..cb9c5807d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserTokenRange.cpp
@@ -0,0 +1,119 @@
+// 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 "CSSParserTokenRange.h"
+
+#include "StyleSheetContents.h"
+#include <wtf/NeverDestroyed.h>
+#include <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+CSSParserToken& CSSParserTokenRange::eofToken()
+{
+    static NeverDestroyed<CSSParserToken> eofToken(EOFToken);
+    return eofToken.get();
+}
+
+CSSParserTokenRange CSSParserTokenRange::makeSubRange(const CSSParserToken* first, const CSSParserToken* last) const
+{
+    if (first == &eofToken())
+        first = m_last;
+    if (last == &eofToken())
+        last = m_last;
+    ASSERT(first <= last);
+    return CSSParserTokenRange(first, last);
+}
+
+CSSParserTokenRange CSSParserTokenRange::consumeBlock()
+{
+    ASSERT(peek().getBlockType() == CSSParserToken::BlockStart);
+    const CSSParserToken* start = &peek() + 1;
+    unsigned nestingLevel = 0;
+    do {
+        const CSSParserToken& token = consume();
+        if (token.getBlockType() == CSSParserToken::BlockStart)
+            nestingLevel++;
+        else if (token.getBlockType() == CSSParserToken::BlockEnd)
+            nestingLevel--;
+    } while (nestingLevel && m_first < m_last);
+
+    if (nestingLevel)
+        return makeSubRange(start, m_first); // Ended at EOF
+    return makeSubRange(start, m_first - 1);
+}
+
+CSSParserTokenRange CSSParserTokenRange::consumeBlockCheckingForEditability(StyleSheetContents* styleSheet)
+{
+    ASSERT(peek().getBlockType() == CSSParserToken::BlockStart);
+    const auto* start = &peek() + 1;
+    unsigned nestingLevel = 0;
+    do {
+        const auto& token = consume();
+        if (token.getBlockType() == CSSParserToken::BlockStart)
+            nestingLevel++;
+        else if (token.getBlockType() == CSSParserToken::BlockEnd)
+            nestingLevel--;
+
+        if (styleSheet && !styleSheet->usesStyleBasedEditability() && token.type() == IdentToken && equalLettersIgnoringASCIICase(token.value(), "-webkit-user-modify"))
+            styleSheet->parserSetUsesStyleBasedEditability();
+    } while (nestingLevel && m_first < m_last);
+    
+    if (nestingLevel)
+        return makeSubRange(start, m_first); // Ended at EOF
+    return makeSubRange(start, m_first - 1);
+}
+
+void CSSParserTokenRange::consumeComponentValue()
+{
+    // FIXME: This is going to do multiple passes over large sections of a stylesheet.
+    // We should consider optimising this by precomputing where each block ends.
+    unsigned nestingLevel = 0;
+    do {
+        const CSSParserToken& token = consume();
+        if (token.getBlockType() == CSSParserToken::BlockStart)
+            nestingLevel++;
+        else if (token.getBlockType() == CSSParserToken::BlockEnd)
+            nestingLevel--;
+    } while (nestingLevel && m_first < m_last);
+}
+
+String CSSParserTokenRange::serialize() const
+{
+    // We're supposed to insert comments between certain pairs of token types
+    // as per spec, but since this is currently only used for @supports CSSOM
+    // we just get these cases wrong and avoid the additional complexity.
+    StringBuilder builder;
+    for (const CSSParserToken* it = m_first; it < m_last; ++it)
+        it->serialize(builder);
+    return builder.toString();
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSParserTokenRange.h b/Source/WebCore/css/parser/CSSParserTokenRange.h
new file mode 100644
index 000000000..8a9dd439d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSParserTokenRange.h
@@ -0,0 +1,104 @@
+// 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 "CSSParserToken.h"
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+// A CSSParserTokenRange is an iterator over a subrange of a vector of CSSParserTokens.
+// Accessing outside of the range will return an endless stream of EOF tokens.
+// This class refers to half-open intervals [first, last).
+class CSSParserTokenRange {
+public:
+    template<size_t inlineBuffer>
+    CSSParserTokenRange(const Vector<CSSParserToken, inlineBuffer>& vector)
+        : m_first(vector.begin())
+        , m_last(vector.end())
+    {
+    }
+
+    // This should be called on a range with tokens returned by that range.
+    CSSParserTokenRange makeSubRange(const CSSParserToken* first, const CSSParserToken* last) const;
+
+    bool atEnd() const { return m_first == m_last; }
+    const CSSParserToken* end() const { return m_last; }
+
+    const CSSParserToken& peek(unsigned offset = 0) const
+    {
+        if (m_first + offset >= m_last)
+            return eofToken();
+        return *(m_first + offset);
+    }
+
+    const CSSParserToken& consume()
+    {
+        if (m_first == m_last)
+            return eofToken();
+        return *m_first++;
+    }
+
+    const CSSParserToken& consumeIncludingWhitespace()
+    {
+        const CSSParserToken& result = consume();
+        consumeWhitespace();
+        return result;
+    }
+
+    // The returned range doesn't include the brackets
+    CSSParserTokenRange consumeBlock();
+    CSSParserTokenRange consumeBlockCheckingForEditability(StyleSheetContents*);
+
+    void consumeComponentValue();
+
+    void consumeWhitespace()
+    {
+        while (peek().type() == WhitespaceToken)
+            ++m_first;
+    }
+
+    String serialize() const;
+
+    const CSSParserToken* begin() const { return m_first; }
+
+    static CSSParserToken& eofToken();
+
+private:
+    CSSParserTokenRange(const CSSParserToken* first, const CSSParserToken* last)
+        : m_first(first)
+        , m_last(last)
+    { }
+
+    const CSSParserToken* m_first;
+    const CSSParserToken* m_last;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSPropertyParser.cpp b/Source/WebCore/css/parser/CSSPropertyParser.cpp
new file mode 100644
index 000000000..129c2996a
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSPropertyParser.cpp
@@ -0,0 +1,5445 @@
+// 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 "CSSPropertyParser.h"
+
+#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
+#include "CSSAnimationTriggerScrollValue.h"
+#endif
+#include "CSSAspectRatioValue.h"
+#include "CSSBasicShapes.h"
+#include "CSSBorderImage.h"
+#include "CSSBorderImageSliceValue.h"
+#include "CSSContentDistributionValue.h"
+#include "CSSCursorImageValue.h"
+#include "CSSCustomIdentValue.h"
+#include "CSSFontFaceSrcValue.h"
+#include "CSSFontFeatureValue.h"
+#if ENABLE(VARIATION_FONTS)
+#include "CSSFontVariationValue.h"
+#endif
+#include "CSSFunctionValue.h"
+#include "CSSGridAutoRepeatValue.h"
+#include "CSSGridLineNamesValue.h"
+#include "CSSGridTemplateAreasValue.h"
+#include "CSSInheritedValue.h"
+#include "CSSInitialValue.h"
+#include "CSSLineBoxContainValue.h"
+#include "CSSParserFastPaths.h"
+#include "CSSParserIdioms.h"
+#include "CSSPendingSubstitutionValue.h"
+#include "CSSPrimitiveValueMappings.h"
+#include "CSSPropertyParserHelpers.h"
+#include "CSSReflectValue.h"
+#include "CSSRevertValue.h"
+#include "CSSShadowValue.h"
+#include "CSSTimingFunctionValue.h"
+#include "CSSUnicodeRangeValue.h"
+#include "CSSUnsetValue.h"
+#include "CSSVariableParser.h"
+#include "CSSVariableReferenceValue.h"
+#include "Counter.h"
+#if ENABLE(DASHBOARD_SUPPORT)
+#include "DashboardRegion.h"
+#endif
+#include "FontFace.h"
+#include "HashTools.h"
+// FIXME-NEWPARSER: Replace Pair and Rect with actual CSSValue subclasses (CSSValuePair and CSSQuadValue).
+#include "Pair.h"
+#include "Rect.h"
+#include "RenderTheme.h"
+#include "RuntimeEnabledFeatures.h"
+#include "SVGPathByteStream.h"
+#include "SVGPathUtilities.h"
+#include "StylePropertyShorthand.h"
+#include "StylePropertyShorthandFunctions.h"
+#include <bitset>
+#include <memory>
+#include <wtf/text/StringBuilder.h>
+
+using namespace WTF;
+
+namespace WebCore {
+
+    
+bool isCustomPropertyName(const String& propertyName)
+{
+    return propertyName.length() > 2 && propertyName.characterAt(0) == '-' && propertyName.characterAt(1) == '-';
+}
+
+static bool hasPrefix(const char* string, unsigned length, const char* prefix)
+{
+    for (unsigned i = 0; i < length; ++i) {
+        if (!prefix[i])
+            return true;
+        if (string[i] != prefix[i])
+            return false;
+    }
+    return false;
+}
+
+#if PLATFORM(IOS)
+void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength)
+{
+    if (!strcmp(propertyName, "-webkit-hyphenate-locale")) {
+        // Worked in iOS 4.2.
+        static const char webkitLocale[] = "-webkit-locale";
+        propertyNameAlias = webkitLocale;
+        newLength = strlen(webkitLocale);
+    }
+}
+#endif
+
+template <typename CharacterType>
+static CSSPropertyID cssPropertyID(const CharacterType* propertyName, unsigned length)
+{
+    char buffer[maxCSSPropertyNameLength + 1 + 1]; // 1 to turn "apple"/"khtml" into "webkit", 1 for null character
+    
+    for (unsigned i = 0; i != length; ++i) {
+        CharacterType c = propertyName[i];
+        if (!c || c >= 0x7F)
+            return CSSPropertyInvalid; // illegal character
+        buffer[i] = toASCIILower(c);
+    }
+    buffer[length] = '\0';
+    
+    const char* name = buffer;
+    if (buffer[0] == '-') {
+#if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
+        // If the prefix is -apple- or -khtml-, change it to -webkit-.
+        // This makes the string one character longer.
+        if (RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled()
+            && (hasPrefix(buffer, length, "-apple-") || hasPrefix(buffer, length, "-khtml-"))) {
+            memmove(buffer + 7, buffer + 6, length + 1 - 6);
+            memcpy(buffer, "-webkit", 7);
+            ++length;
+        }
+#endif
+#if PLATFORM(IOS)
+        cssPropertyNameIOSAliasing(buffer, name, length);
+#endif
+    }
+    
+    const Property* hashTableEntry = findProperty(name, length);
+    return hashTableEntry ? static_cast<CSSPropertyID>(hashTableEntry->id) : CSSPropertyInvalid;
+}
+
+static bool isAppleLegacyCssValueKeyword(const char* valueKeyword, unsigned length)
+{
+    static const char applePrefix[] = "-apple-";
+    static const char appleSystemPrefix[] = "-apple-system";
+    static const char applePayPrefix[] = "-apple-pay";
+    static const char* appleWirelessPlaybackTargetActive = getValueName(CSSValueAppleWirelessPlaybackTargetActive);
+    
+    return hasPrefix(valueKeyword, length, applePrefix)
+    && !hasPrefix(valueKeyword, length, appleSystemPrefix)
+    && !hasPrefix(valueKeyword, length, applePayPrefix)
+    && !WTF::equal(reinterpret_cast<const LChar*>(valueKeyword), reinterpret_cast<const LChar*>(appleWirelessPlaybackTargetActive), length);
+}
+
+template <typename CharacterType>
+static CSSValueID cssValueKeywordID(const CharacterType* valueKeyword, unsigned length)
+{
+    char buffer[maxCSSValueKeywordLength + 1 + 1]; // 1 to turn "apple"/"khtml" into "webkit", 1 for null character
+    
+    for (unsigned i = 0; i != length; ++i) {
+        CharacterType c = valueKeyword[i];
+        if (!c || c >= 0x7F)
+            return CSSValueInvalid; // illegal keyword.
+        buffer[i] = WTF::toASCIILower(c);
+    }
+    buffer[length] = '\0';
+    
+    if (buffer[0] == '-') {
+        // If the prefix is -apple- or -khtml-, change it to -webkit-.
+        // This makes the string one character longer.
+        // On iOS we don't want to change values starting with -apple-system to -webkit-system.
+        // FIXME: Remove this mangling without breaking the web.
+        if (isAppleLegacyCssValueKeyword(buffer, length) || hasPrefix(buffer, length, "-khtml-")) {
+            memmove(buffer + 7, buffer + 6, length + 1 - 6);
+            memcpy(buffer, "-webkit", 7);
+            ++length;
+        }
+    }
+    
+    const Value* hashTableEntry = findValue(buffer, length);
+    return hashTableEntry ? static_cast<CSSValueID>(hashTableEntry->id) : CSSValueInvalid;
+}
+
+CSSValueID cssValueKeywordID(StringView string)
+{
+    unsigned length = string.length();
+    if (!length)
+        return CSSValueInvalid;
+    if (length > maxCSSValueKeywordLength)
+        return CSSValueInvalid;
+    
+    return string.is8Bit() ? cssValueKeywordID(string.characters8(), length) : cssValueKeywordID(string.characters16(), length);
+}
+
+CSSPropertyID cssPropertyID(StringView string)
+{
+    unsigned length = string.length();
+    
+    if (!length)
+        return CSSPropertyInvalid;
+    if (length > maxCSSPropertyNameLength)
+        return CSSPropertyInvalid;
+    
+    return string.is8Bit() ? cssPropertyID(string.characters8(), length) : cssPropertyID(string.characters16(), length);
+}
+    
+using namespace CSSPropertyParserHelpers;
+
+CSSPropertyParser::CSSPropertyParser(const CSSParserTokenRange& range, const CSSParserContext& context, StyleSheetContents* styleSheetContents, Vector<CSSProperty, 256>* parsedProperties)
+    : m_range(range)
+    , m_context(context)
+    , m_styleSheetContents(styleSheetContents)
+    , m_parsedProperties(parsedProperties)
+{
+    m_range.consumeWhitespace();
+}
+
+void CSSPropertyParser::addProperty(CSSPropertyID property, CSSPropertyID currentShorthand, Ref<CSSValue>&& value, bool important, bool implicit)
+{
+    int shorthandIndex = 0;
+    bool setFromShorthand = false;
+
+    if (currentShorthand) {
+        auto shorthands = matchingShorthandsForLonghand(property);
+        setFromShorthand = true;
+        if (shorthands.size() > 1)
+            shorthandIndex = indexOfShorthandForLonghand(currentShorthand, shorthands);
+    }
+
+    m_parsedProperties->append(CSSProperty(property, WTFMove(value), important, setFromShorthand, shorthandIndex, implicit));
+}
+
+void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID property, Ref<CSSValue>&& value, bool important)
+{
+    const StylePropertyShorthand& shorthand = shorthandForProperty(property);
+    unsigned shorthandLength = shorthand.length();
+    ASSERT(shorthandLength);
+    const CSSPropertyID* longhands = shorthand.properties();
+    for (unsigned i = 0; i < shorthandLength; ++i)
+        addProperty(longhands[i], property, value.copyRef(), important);
+}
+
+bool CSSPropertyParser::parseValue(CSSPropertyID propertyID, bool important, const CSSParserTokenRange& range, const CSSParserContext& context, StyleSheetContents* styleSheetContents, ParsedPropertyVector& parsedProperties, StyleRule::Type ruleType)
+{
+    int parsedPropertiesSize = parsedProperties.size();
+
+    CSSPropertyParser parser(range, context, styleSheetContents, &parsedProperties);
+    bool parseSuccess;
+
+#if ENABLE(CSS_DEVICE_ADAPTATION)
+    if (ruleType == StyleRule::Viewport)
+        parseSuccess = parser.parseViewportDescriptor(propertyID, important);
+    else
+#endif
+    if (ruleType == StyleRule::FontFace)
+        parseSuccess = parser.parseFontFaceDescriptor(propertyID);
+    else
+        parseSuccess = parser.parseValueStart(propertyID, important);
+
+    if (!parseSuccess)
+        parsedProperties.shrink(parsedPropertiesSize);
+
+    return parseSuccess;
+}
+
+RefPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID property, const CSSParserTokenRange& range, const CSSParserContext& context, StyleSheetContents* styleSheetContents)
+{
+    CSSPropertyParser parser(range, context, styleSheetContents, nullptr);
+    RefPtr<CSSValue> value = parser.parseSingleValue(property);
+    if (!value || !parser.m_range.atEnd())
+        return nullptr;
+    return value;
+}
+
+static bool isLegacyBreakProperty(CSSPropertyID propertyID)
+{
+    switch (propertyID) {
+    case CSSPropertyPageBreakAfter:
+    case CSSPropertyPageBreakBefore:
+    case CSSPropertyPageBreakInside:
+    case CSSPropertyWebkitColumnBreakAfter:
+    case CSSPropertyWebkitColumnBreakBefore:
+    case CSSPropertyWebkitColumnBreakInside:
+#if ENABLE(CSS_REGIONS)
+    case CSSPropertyWebkitRegionBreakAfter:
+    case CSSPropertyWebkitRegionBreakBefore:
+    case CSSPropertyWebkitRegionBreakInside:
+#endif
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+bool CSSPropertyParser::parseValueStart(CSSPropertyID propertyID, bool important)
+{
+    if (consumeCSSWideKeyword(propertyID, important))
+        return true;
+
+    CSSParserTokenRange originalRange = m_range;
+    bool isShorthand = isShorthandCSSProperty(propertyID);
+
+    if (isShorthand) {
+        // Variable references will fail to parse here and will fall out to the variable ref parser below.
+        if (parseShorthand(propertyID, important))
+            return true;
+    } else if (isLegacyBreakProperty(propertyID)) {
+        // FIXME-NEWPARSER: Can turn this into a shorthand once old parser is gone, and then
+        // we don't need the special case.
+        if (consumeLegacyBreakProperty(propertyID, important))
+            return true;
+    } else {
+        RefPtr<CSSValue> parsedValue = parseSingleValue(propertyID);
+        if (parsedValue && m_range.atEnd()) {
+            addProperty(propertyID, CSSPropertyInvalid, *parsedValue, important);
+            return true;
+        }
+    }
+
+    if (CSSVariableParser::containsValidVariableReferences(originalRange)) {
+        RefPtr<CSSVariableReferenceValue> variable = CSSVariableReferenceValue::create(CSSVariableData::create(originalRange));
+
+        if (isShorthand) {
+            RefPtr<CSSPendingSubstitutionValue> pendingValue = CSSPendingSubstitutionValue::create(propertyID, variable.releaseNonNull());
+            addExpandedPropertyForValue(propertyID, pendingValue.releaseNonNull(), important);
+        } else
+            addProperty(propertyID, CSSPropertyInvalid, variable.releaseNonNull(), important);
+        return true;
+    }
+
+    return false;
+}
+ 
+bool CSSPropertyParser::consumeCSSWideKeyword(CSSPropertyID propertyID, bool important)
+{
+    CSSParserTokenRange rangeCopy = m_range;
+    CSSValueID valueID = rangeCopy.consumeIncludingWhitespace().id();
+    if (!rangeCopy.atEnd())
+        return false;
+
+    RefPtr<CSSValue> value;
+    if (valueID == CSSValueInherit)
+        value = CSSValuePool::singleton().createInheritedValue();
+    else if (valueID == CSSValueInitial)
+        value = CSSValuePool::singleton().createExplicitInitialValue();
+    else if (valueID == CSSValueUnset)
+        value = CSSValuePool::singleton().createUnsetValue();
+    else if (valueID == CSSValueRevert)
+        value = CSSValuePool::singleton().createRevertValue();
+    else
+        return false;
+    
+    const StylePropertyShorthand& shorthand = shorthandForProperty(propertyID);
+    if (!shorthand.length()) {
+        if (CSSProperty::isDescriptorOnly(propertyID))
+            return false;
+        addProperty(propertyID, CSSPropertyInvalid, value.releaseNonNull(), important);
+    } else
+        addExpandedPropertyForValue(propertyID, value.releaseNonNull(), important);
+    m_range = rangeCopy;
+    return true;
+}
+
+bool CSSPropertyParser::consumeTransformOrigin(bool important)
+{
+    RefPtr<CSSPrimitiveValue> resultX;
+    RefPtr<CSSPrimitiveValue> resultY;
+    if (consumeOneOrTwoValuedPosition(m_range, m_context.mode, UnitlessQuirk::Forbid, resultX, resultY)) {
+        m_range.consumeWhitespace();
+        bool atEnd = m_range.atEnd();
+        RefPtr<CSSPrimitiveValue> resultZ = consumeLength(m_range, m_context.mode, ValueRangeAll);
+        bool hasZ = resultZ;
+        if (!hasZ && !atEnd)
+            return false;
+        addProperty(CSSPropertyTransformOriginX, CSSPropertyTransformOrigin, resultX.releaseNonNull(), important);
+        addProperty(CSSPropertyTransformOriginY, CSSPropertyTransformOrigin, resultY.releaseNonNull(), important);
+        addProperty(CSSPropertyTransformOriginZ, CSSPropertyTransformOrigin, resultZ ? resultZ.releaseNonNull() : CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitType::CSS_PX), important, !hasZ);
+        
+        return true;
+    }
+    return false;
+}
+
+bool CSSPropertyParser::consumePerspectiveOrigin(bool important)
+{
+    RefPtr<CSSPrimitiveValue> resultX;
+    RefPtr<CSSPrimitiveValue> resultY;
+    if (consumePosition(m_range, m_context.mode, UnitlessQuirk::Forbid, resultX, resultY)) {
+        addProperty(CSSPropertyPerspectiveOriginX, CSSPropertyPerspectiveOrigin, resultX.releaseNonNull(), important);
+        addProperty(CSSPropertyPerspectiveOriginY, CSSPropertyPerspectiveOrigin, resultY.releaseNonNull(), important);
+        return true;
+    }
+    return false;
+}
+
+// Methods for consuming non-shorthand properties starts here.
+static RefPtr<CSSValue> consumeWillChange(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+    // Every comma-separated list of identifiers is a valid will-change value,
+    // unless the list includes an explicitly disallowed identifier.
+    while (true) {
+        if (range.peek().type() != IdentToken)
+            return nullptr;
+        CSSPropertyID propertyID = cssPropertyID(range.peek().value());
+        if (propertyID != CSSPropertyInvalid) {
+            // Now "all" is used by both CSSValue and CSSPropertyValue.
+            // Need to return nullptr when currentValue is CSSPropertyAll.
+            if (propertyID == CSSPropertyWillChange || propertyID == CSSPropertyAll)
+                return nullptr;
+            // FIXME-NEWPARSER: Use CSSCustomIdentValue someday.
+            values->append(CSSValuePool::singleton().createIdentifierValue(propertyID));
+            range.consumeIncludingWhitespace();
+        } else {
+            switch (range.peek().id()) {
+            case CSSValueNone:
+            case CSSValueAll:
+            case CSSValueAuto:
+            case CSSValueDefault:
+            case CSSValueInitial:
+            case CSSValueInherit:
+                return nullptr;
+            case CSSValueContents:
+            case CSSValueScrollPosition:
+                values->append(consumeIdent(range).releaseNonNull());
+                break;
+            default:
+                // Append properties we don't recognize, but that are legal, as strings.
+                values->append(consumeCustomIdent(range).releaseNonNull());
+                break;
+            }
+        }
+
+        if (range.atEnd())
+            break;
+        if (!consumeCommaIncludingWhitespace(range))
+            return nullptr;
+    }
+
+    return values;
+}
+
+static RefPtr<CSSFontFeatureValue> consumeFontFeatureTag(CSSParserTokenRange& range)
+{
+    // Feature tag name consists of 4-letter characters.
+    static const unsigned tagNameLength = 4;
+
+    const CSSParserToken& token = range.consumeIncludingWhitespace();
+    // Feature tag name comes first
+    if (token.type() != StringToken)
+        return nullptr;
+    if (token.value().length() != tagNameLength)
+        return nullptr;
+    
+    FontTag tag;
+    for (unsigned i = 0; i < tag.size(); ++i) {
+        // Limits the range of characters to 0x20-0x7E, following the tag name rules defiend in the OpenType specification.
+        UChar character = token.value()[i];
+        if (character < 0x20 || character > 0x7E)
+            return nullptr;
+        tag[i] = toASCIILower(character);
+    }
+
+    int tagValue = 1;
+    // Feature tag values could follow: <integer> | on | off
+    if (range.peek().type() == NumberToken && range.peek().numericValueType() == IntegerValueType && range.peek().numericValue() >= 0) {
+        tagValue = clampTo<int>(range.consumeIncludingWhitespace().numericValue());
+        if (tagValue < 0)
+            return nullptr;
+    } else if (range.peek().id() == CSSValueOn || range.peek().id() == CSSValueOff) {
+        tagValue = range.consumeIncludingWhitespace().id() == CSSValueOn;
+    }
+    return CSSFontFeatureValue::create(WTFMove(tag), tagValue);
+}
+
+static RefPtr<CSSValue> consumeFontFeatureSettings(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    RefPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
+    do {
+        RefPtr<CSSFontFeatureValue> fontFeatureValue = consumeFontFeatureTag(range);
+        if (!fontFeatureValue)
+            return nullptr;
+        settings->append(fontFeatureValue.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    return settings;
+}
+
+#if ENABLE(VARIATION_FONTS)
+static RefPtr<CSSValue> consumeFontVariationTag(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != StringToken)
+        return nullptr;
+    
+    auto string = range.consumeIncludingWhitespace().value().toString();
+    
+    FontTag tag;
+    if (string.length() != tag.size())
+        return nullptr;
+    for (unsigned i = 0; i < tag.size(); ++i) {
+        // Limits the range of characters to 0x20-0x7E, following the tag name rules defiend in the OpenType specification.
+        UChar character = string[i];
+        if (character < 0x20 || character > 0x7E)
+            return nullptr;
+        tag[i] = character;
+    }
+    
+    if (range.atEnd() || range.peek().type() != NumberToken)
+        return nullptr;
+
+    float tagValue = range.consumeIncludingWhitespace().numericValue();
+    
+    return CSSFontVariationValue::create(tag, tagValue);
+}
+    
+static RefPtr<CSSValue> consumeFontVariationSettings(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    
+    auto settings = CSSValueList::createCommaSeparated();
+    do {
+        RefPtr<CSSValue> variationValue = consumeFontVariationTag(range);
+        if (!variationValue)
+            return nullptr;
+        settings->append(variationValue.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    
+    if (!settings->length())
+        return nullptr;
+
+    return WTFMove(settings);
+}
+#endif // ENABLE(VARIATION_FONTS)
+
+static RefPtr<CSSValue> consumePage(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeCustomIdent(range);
+}
+
+static RefPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    while (!range.atEnd()) {
+        RefPtr<CSSPrimitiveValue> parsedValue = consumeString(range);
+        if (!parsedValue)
+            return nullptr;
+        values->append(parsedValue.releaseNonNull());
+    }
+    if (values->length() && values->length() % 2 == 0)
+        return values;
+    return nullptr;
+}
+
+class FontVariantLigaturesParser {
+public:
+    FontVariantLigaturesParser()
+        : m_sawCommonLigaturesValue(false)
+        , m_sawDiscretionaryLigaturesValue(false)
+        , m_sawHistoricalLigaturesValue(false)
+        , m_sawContextualLigaturesValue(false)
+        , m_result(CSSValueList::createSpaceSeparated())
+    {
+    }
+
+    enum class ParseResult {
+        ConsumedValue,
+        DisallowedValue,
+        UnknownValue
+    };
+
+    ParseResult consumeLigature(CSSParserTokenRange& range)
+    {
+        CSSValueID valueID = range.peek().id();
+        switch (valueID) {
+        case CSSValueNoCommonLigatures:
+        case CSSValueCommonLigatures:
+            if (m_sawCommonLigaturesValue)
+                return ParseResult::DisallowedValue;
+            m_sawCommonLigaturesValue = true;
+            break;
+        case CSSValueNoDiscretionaryLigatures:
+        case CSSValueDiscretionaryLigatures:
+            if (m_sawDiscretionaryLigaturesValue)
+                return ParseResult::DisallowedValue;
+            m_sawDiscretionaryLigaturesValue = true;
+            break;
+        case CSSValueNoHistoricalLigatures:
+        case CSSValueHistoricalLigatures:
+            if (m_sawHistoricalLigaturesValue)
+                return ParseResult::DisallowedValue;
+            m_sawHistoricalLigaturesValue = true;
+            break;
+        case CSSValueNoContextual:
+        case CSSValueContextual:
+            if (m_sawContextualLigaturesValue)
+                return ParseResult::DisallowedValue;
+            m_sawContextualLigaturesValue = true;
+            break;
+        default:
+            return ParseResult::UnknownValue;
+        }
+        m_result->append(consumeIdent(range).releaseNonNull());
+        return ParseResult::ConsumedValue;
+    }
+
+    RefPtr<CSSValue> finalizeValue()
+    {
+        if (!m_result->length())
+            return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
+        return m_result.release();
+    }
+
+private:
+    bool m_sawCommonLigaturesValue;
+    bool m_sawDiscretionaryLigaturesValue;
+    bool m_sawHistoricalLigaturesValue;
+    bool m_sawContextualLigaturesValue;
+    RefPtr<CSSValueList> m_result;
+};
+
+static RefPtr<CSSValue> consumeFontVariantLigatures(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal || range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    FontVariantLigaturesParser ligaturesParser;
+    do {
+        if (ligaturesParser.consumeLigature(range) !=
+            FontVariantLigaturesParser::ParseResult::ConsumedValue)
+            return nullptr;
+    } while (!range.atEnd());
+
+    return ligaturesParser.finalizeValue();
+}
+
+static RefPtr<CSSValue> consumeFontVariantEastAsian(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    FontVariantEastAsianVariant variant = FontVariantEastAsianVariant::Normal;
+    FontVariantEastAsianWidth width = FontVariantEastAsianWidth::Normal;
+    FontVariantEastAsianRuby ruby = FontVariantEastAsianRuby::Normal;
+    
+    while (!range.atEnd()) {
+        if (range.peek().type() != IdentToken)
+            return nullptr;
+        
+        auto id = range.peek().id();
+        
+        switch (id) {
+        case CSSValueJis78:
+            variant = FontVariantEastAsianVariant::Jis78;
+            break;
+        case CSSValueJis83:
+            variant = FontVariantEastAsianVariant::Jis83;
+            break;
+        case CSSValueJis90:
+            variant = FontVariantEastAsianVariant::Jis90;
+            break;
+        case CSSValueJis04:
+            variant = FontVariantEastAsianVariant::Jis04;
+            break;
+        case CSSValueSimplified:
+            variant = FontVariantEastAsianVariant::Simplified;
+            break;
+        case CSSValueTraditional:
+            variant = FontVariantEastAsianVariant::Traditional;
+            break;
+        case CSSValueFullWidth:
+            width = FontVariantEastAsianWidth::Full;
+            break;
+        case CSSValueProportionalWidth:
+            width = FontVariantEastAsianWidth::Proportional;
+            break;
+        case CSSValueRuby:
+            ruby = FontVariantEastAsianRuby::Yes;
+            break;
+        default:
+            return nullptr;
+        }
+        
+        range.consumeIncludingWhitespace();
+    }
+        
+    switch (variant) {
+    case FontVariantEastAsianVariant::Normal:
+        break;
+    case FontVariantEastAsianVariant::Jis78:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis78));
+        break;
+    case FontVariantEastAsianVariant::Jis83:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis83));
+        break;
+    case FontVariantEastAsianVariant::Jis90:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis90));
+        break;
+    case FontVariantEastAsianVariant::Jis04:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis04));
+        break;
+    case FontVariantEastAsianVariant::Simplified:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueSimplified));
+        break;
+    case FontVariantEastAsianVariant::Traditional:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueTraditional));
+        break;
+    }
+        
+    switch (width) {
+    case FontVariantEastAsianWidth::Normal:
+        break;
+    case FontVariantEastAsianWidth::Full:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueFullWidth));
+        break;
+    case FontVariantEastAsianWidth::Proportional:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalWidth));
+        break;
+    }
+        
+    switch (ruby) {
+    case FontVariantEastAsianRuby::Normal:
+        break;
+    case FontVariantEastAsianRuby::Yes:
+        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueRuby));
+    }
+
+    if (!values->length())
+        return nullptr;
+
+    return values;
+}
+    
+static RefPtr<CSSPrimitiveValue> consumeFontVariantCaps(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueNormal, CSSValueSmallCaps, CSSValueAllSmallCaps,
+        CSSValuePetiteCaps, CSSValueAllPetiteCaps,
+        CSSValueUnicase, CSSValueTitlingCaps>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeFontVariantAlternates(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueNormal, CSSValueHistoricalForms>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeFontVariantPosition(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueNormal, CSSValueSub, CSSValueSuper>(range);
+}
+
+class FontVariantNumericParser {
+public:
+    FontVariantNumericParser()
+        : m_sawNumericFigureValue(false)
+        , m_sawNumericSpacingValue(false)
+        , m_sawNumericFractionValue(false)
+        , m_sawOrdinalValue(false)
+        , m_sawSlashedZeroValue(false)
+        , m_result(CSSValueList::createSpaceSeparated())
+    {
+    }
+
+    enum class ParseResult {
+        ConsumedValue,
+        DisallowedValue,
+        UnknownValue
+    };
+
+    ParseResult consumeNumeric(CSSParserTokenRange& range)
+    {
+        CSSValueID valueID = range.peek().id();
+        switch (valueID) {
+        case CSSValueLiningNums:
+        case CSSValueOldstyleNums:
+            if (m_sawNumericFigureValue)
+                return ParseResult::DisallowedValue;
+            m_sawNumericFigureValue = true;
+            break;
+        case CSSValueProportionalNums:
+        case CSSValueTabularNums:
+            if (m_sawNumericSpacingValue)
+                return ParseResult::DisallowedValue;
+            m_sawNumericSpacingValue = true;
+            break;
+        case CSSValueDiagonalFractions:
+        case CSSValueStackedFractions:
+            if (m_sawNumericFractionValue)
+                return ParseResult::DisallowedValue;
+            m_sawNumericFractionValue = true;
+            break;
+        case CSSValueOrdinal:
+            if (m_sawOrdinalValue)
+                return ParseResult::DisallowedValue;
+            m_sawOrdinalValue = true;
+            break;
+        case CSSValueSlashedZero:
+            if (m_sawSlashedZeroValue)
+                return ParseResult::DisallowedValue;
+            m_sawSlashedZeroValue = true;
+            break;
+        default:
+            return ParseResult::UnknownValue;
+        }
+        m_result->append(consumeIdent(range).releaseNonNull());
+        return ParseResult::ConsumedValue;
+    }
+
+    RefPtr<CSSValue> finalizeValue()
+    {
+        if (!m_result->length())
+            return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
+        return m_result.release();
+    }
+
+
+private:
+    bool m_sawNumericFigureValue;
+    bool m_sawNumericSpacingValue;
+    bool m_sawNumericFractionValue;
+    bool m_sawOrdinalValue;
+    bool m_sawSlashedZeroValue;
+    RefPtr<CSSValueList> m_result;
+};
+
+static RefPtr<CSSValue> consumeFontVariantNumeric(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+
+    FontVariantNumericParser numericParser;
+    do {
+        if (numericParser.consumeNumeric(range) !=
+            FontVariantNumericParser::ParseResult::ConsumedValue)
+            return nullptr;
+    } while (!range.atEnd());
+
+    return numericParser.finalizeValue();
+}
+
+static RefPtr<CSSPrimitiveValue> consumeFontVariantCSS21(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueNormal, CSSValueSmallCaps>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeFontWeight(CSSParserTokenRange& range)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter)
+        return consumeIdent(range);
+    int weight;
+    if (!consumePositiveIntegerRaw(range, weight))
+        return nullptr;
+    if ((weight % 100) || weight < 100 || weight > 900)
+        return nullptr;
+    return CSSValuePool::singleton().createIdentifierValue(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1));
+}
+
+static String concatenateFamilyName(CSSParserTokenRange& range)
+{
+    StringBuilder builder;
+    bool addedSpace = false;
+    const CSSParserToken& firstToken = range.peek();
+    while (range.peek().type() == IdentToken) {
+        if (!builder.isEmpty()) {
+            builder.append(' ');
+            addedSpace = true;
+        }
+        builder.append(range.consumeIncludingWhitespace().value());
+    }
+    if (!addedSpace && isCSSWideKeyword(firstToken.id()))
+        return String();
+    return builder.toString();
+}
+
+static RefPtr<CSSValue> consumeFamilyName(CSSParserTokenRange& range)
+{
+    if (range.peek().type() == StringToken)
+        return CSSValuePool::singleton().createFontFamilyValue(range.consumeIncludingWhitespace().value().toString());
+    if (range.peek().type() != IdentToken)
+        return nullptr;
+    String familyName = concatenateFamilyName(range);
+    if (familyName.isNull())
+        return nullptr;
+    return CSSValuePool::singleton().createFontFamilyValue(familyName);
+}
+
+static RefPtr<CSSValue> consumeGenericFamily(CSSParserTokenRange& range)
+{
+    return consumeIdentRange(range, CSSValueSerif, CSSValueWebkitBody);
+}
+
+static RefPtr<CSSValueList> consumeFontFamily(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    do {
+        RefPtr<CSSValue> parsedValue = consumeGenericFamily(range);
+        if (parsedValue) {
+            list->append(parsedValue.releaseNonNull());
+        } else {
+            parsedValue = consumeFamilyName(range);
+            if (parsedValue) {
+                list->append(parsedValue.releaseNonNull());
+            } else {
+                return nullptr;
+            }
+        }
+    } while (consumeCommaIncludingWhitespace(range));
+    return list;
+}
+
+static RefPtr<CSSValueList> consumeFontFamilyDescriptor(CSSParserTokenRange& range)
+{
+    // FIXME-NEWPARSER: For compatibility with the old parser, we have to make
+    // a list here, even though the list always contains only a single family name.
+    // Once the old parser is gone, we can delete this function, make the caller
+    // use consumeFamilyName instead, and then patch the @font-face code to
+    // not expect a list with a single name in it.
+    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValue> parsedValue = consumeFamilyName(range);
+    if (parsedValue)
+        list->append(parsedValue.releaseNonNull());
+    
+    if (!range.atEnd() || !list->length())
+        return nullptr;
+
+    return list;
+}
+
+static RefPtr<CSSValue> consumeFontSynthesis(CSSParserTokenRange& range)
+{
+    // none | [ weight || style || small-caps ]
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+    
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    while (true) {
+        auto ident = consumeIdent<CSSValueWeight, CSSValueStyle, CSSValueSmallCaps>(range);
+        if (!ident)
+            break;
+        if (list->hasValue(ident.get()))
+            return nullptr;
+        list->append(ident.releaseNonNull());
+    }
+    
+    if (!list->length())
+        return nullptr;
+    return list;
+}
+
+static RefPtr<CSSValue> consumeLetterSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    
+    return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeWordSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+}
+    
+static RefPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtr<CSSPrimitiveValue> parsedValue = consumeInteger(range, 0);
+    if (parsedValue)
+        return parsedValue;
+    return consumeLength(range, cssParserMode, ValueRangeNonNegative);
+}
+
+#if ENABLE(TEXT_AUTOSIZING)
+static RefPtr<CSSValue> consumeTextSizeAdjust(CSSParserTokenRange& range, CSSParserMode /* cssParserMode */)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    return consumePercent(range, ValueRangeNonNegative);
+}
+#endif
+
+static RefPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
+{
+    if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, unitless);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+
+    RefPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRangeNonNegative);
+    if (lineHeight)
+        return lineHeight;
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+}
+
+template<typename... Args>
+static Ref<CSSPrimitiveValue> createPrimitiveValuePair(Args&&... args)
+{
+    return CSSValuePool::singleton().createValue(Pair::create(std::forward<Args>(args)...));
+}
+
+static RefPtr<CSSValue> consumeCounter(CSSParserTokenRange& range, int defaultValue)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    do {
+        RefPtr<CSSPrimitiveValue> counterName = consumeCustomIdent(range);
+        if (!counterName)
+            return nullptr;
+        int i = defaultValue;
+        if (RefPtr<CSSPrimitiveValue> counterValue = consumeInteger(range))
+            i = counterValue->intValue();
+        list->append(createPrimitiveValuePair(counterName.releaseNonNull(), CSSPrimitiveValue::create(i, CSSPrimitiveValue::UnitType::CSS_NUMBER), Pair::IdenticalValueEncoding::Coalesce));
+    } while (!range.atEnd());
+    return list;
+}
+
+static RefPtr<CSSValue> consumePageSize(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueA3, CSSValueA4, CSSValueA5, CSSValueB4, CSSValueB5, CSSValueLedger, CSSValueLegal, CSSValueLetter>(range);
+}
+
+static RefPtr<CSSValueList> consumeSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
+
+    if (range.peek().id() == CSSValueAuto) {
+        result->append(consumeIdent(range).releaseNonNull());
+        return result;
+    }
+
+    if (RefPtr<CSSValue> width = consumeLength(range, cssParserMode, ValueRangeNonNegative)) {
+        RefPtr<CSSValue> height = consumeLength(range, cssParserMode, ValueRangeNonNegative);
+        result->append(width.releaseNonNull());
+        if (height)
+            result->append(height.releaseNonNull());
+        return result;
+    }
+
+    RefPtr<CSSValue> pageSize = consumePageSize(range);
+    RefPtr<CSSValue> orientation = consumeIdent<CSSValuePortrait, CSSValueLandscape>(range);
+    if (!pageSize)
+        pageSize = consumePageSize(range);
+
+    if (!orientation && !pageSize)
+        return nullptr;
+    if (pageSize)
+        result->append(pageSize.releaseNonNull());
+    if (orientation)
+        result->append(orientation.releaseNonNull());
+    return result;
+}
+
+static RefPtr<CSSValue> consumeTextIndent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    // [ <length> | <percentage> ] && hanging? && each-line?
+    // Keywords only allowed when css3Text is enabled.
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+
+    bool hasLengthOrPercentage = false;
+//    bool hasEachLine = false;
+    bool hasHanging = false;
+
+    do {
+        if (!hasLengthOrPercentage) {
+            if (RefPtr<CSSValue> textIndent = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow)) {
+                list->append(*textIndent);
+                hasLengthOrPercentage = true;
+                continue;
+            }
+        }
+
+        CSSValueID id = range.peek().id();
+ /* FIXME-NEWPARSER: We don't support this yet.
+        if (!hasEachLine && id == CSSValueEachLine) {
+            list->append(*consumeIdent(range));
+            hasEachLine = true;
+            continue;
+        }
+*/
+        
+        if (!hasHanging && id == CSSValueHanging) {
+            list->append(consumeIdent(range).releaseNonNull());
+            hasHanging = true;
+            continue;
+        }
+        
+        return nullptr;
+    } while (!range.atEnd());
+
+    if (!hasLengthOrPercentage)
+        return nullptr;
+
+    return list;
+}
+
+// FIXME-NEWPARSER: Drop the prefix on min-content, max-content and fit-content.
+static bool validWidthOrHeightKeyword(CSSValueID id, const CSSParserContext& /*context*/)
+{
+    if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic || id == CSSValueWebkitMinContent || id == CSSValueWebkitMaxContent || id == CSSValueWebkitFillAvailable || id == CSSValueWebkitFitContent) {
+        return true;
+    }
+    return false;
+}
+
+static RefPtr<CSSValue> consumeMaxWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
+{
+    if (range.peek().id() == CSSValueNone || validWidthOrHeightKeyword(range.peek().id(), context))
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, context.mode, ValueRangeNonNegative, unitless);
+}
+
+static RefPtr<CSSValue> consumeWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
+{
+    if (range.peek().id() == CSSValueAuto || validWidthOrHeightKeyword(range.peek().id(), context))
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, context.mode, ValueRangeNonNegative, unitless);
+}
+
+static RefPtr<CSSValue> consumeMarginOrOffset(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeClip(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+
+    if (range.peek().functionId() != CSSValueRect)
+        return nullptr;
+
+    CSSParserTokenRange args = consumeFunction(range);
+    // rect(t, r, b, l) || rect(t r b l)
+    RefPtr<CSSPrimitiveValue> top = consumeClipComponent(args, cssParserMode);
+    if (!top)
+        return nullptr;
+    bool needsComma = consumeCommaIncludingWhitespace(args);
+    RefPtr<CSSPrimitiveValue> right = consumeClipComponent(args, cssParserMode);
+    if (!right || (needsComma && !consumeCommaIncludingWhitespace(args)))
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> bottom = consumeClipComponent(args, cssParserMode);
+    if (!bottom || (needsComma && !consumeCommaIncludingWhitespace(args)))
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> left = consumeClipComponent(args, cssParserMode);
+    if (!left || !args.atEnd())
+        return nullptr;
+    
+    auto rect = Rect::create();
+    rect->setLeft(left.releaseNonNull());
+    rect->setTop(top.releaseNonNull());
+    rect->setRight(right.releaseNonNull());
+    rect->setBottom(bottom.releaseNonNull());
+    return CSSValuePool::singleton().createValue(WTFMove(rect));
+}
+
+#if ENABLE(TOUCH_EVENTS)
+static RefPtr<CSSValue> consumeTouchAction(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueManipulation) {
+        list->append(consumeIdent(range).releaseNonNull());
+        return list;
+    }
+    // FIXME-NEWPARSER: Support pan.
+    return nullptr;
+}
+#endif
+
+static RefPtr<CSSPrimitiveValue> consumeLineClamp(CSSParserTokenRange& range)
+{
+    RefPtr<CSSPrimitiveValue> clampValue = consumePercent(range, ValueRangeNonNegative);
+    if (clampValue)
+        return clampValue;
+    // When specifying number of lines, don't allow 0 as a valid value.
+    return consumePositiveInteger(range);
+}
+
+static RefPtr<CSSValue> consumeLocale(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeString(range);
+}
+
+static RefPtr<CSSValue> consumeHyphenateLimit(CSSParserTokenRange& range, CSSValueID valueID)
+{
+    if (range.peek().id() == valueID)
+        return consumeIdent(range);
+    return consumeNumber(range, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSValue> consumeColumnWidth(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
+    // the 'columns' shorthand property.
+    RefPtr<CSSPrimitiveValue> columnWidth = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
+    if (!columnWidth || (!columnWidth->isCalculated() && !columnWidth->doubleValue()) || (columnWidth->cssCalcValue() && !columnWidth->cssCalcValue()->doubleValue()))
+        return nullptr;
+    return columnWidth;
+}
+
+static RefPtr<CSSValue> consumeColumnCount(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumePositiveInteger(range);
+}
+
+static RefPtr<CSSValue> consumeColumnGap(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+    return consumeLength(range, cssParserMode, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSValue> consumeColumnSpan(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueAll, CSSValueNone>(range);
+}
+
+static RefPtr<CSSValue> consumeZoom(CSSParserTokenRange& range, const CSSParserContext& /*context*/)
+{
+    const CSSParserToken& token = range.peek();
+    RefPtr<CSSPrimitiveValue> zoom;
+    if (token.type() == IdentToken)
+        zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
+    else {
+        zoom = consumePercent(range, ValueRangeNonNegative);
+        if (!zoom)
+            zoom = consumeNumber(range, ValueRangeNonNegative);
+    }
+    return zoom;
+}
+
+static RefPtr<CSSValue> consumeAnimationIterationCount(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueInfinite)
+        return consumeIdent(range);
+    return consumeNumber(range, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSValue> consumeAnimationName(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    if (range.peek().type() == StringToken) {
+        const CSSParserToken& token = range.consumeIncludingWhitespace();
+        if (equalIgnoringASCIICase(token.value(), "none"))
+            return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);
+        // FIXME-NEWPARSER: Want to use a CSSCustomIdentValue here eventually.
+        return CSSValuePool::singleton().createValue(token.value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
+    }
+
+    return consumeCustomIdent(range);
+}
+
+static RefPtr<CSSValue> consumeTransitionProperty(CSSParserTokenRange& range)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() != IdentToken)
+        return nullptr;
+    if (token.id() == CSSValueNone)
+        return consumeIdent(range);
+
+    if (CSSPropertyID property = token.parseAsCSSPropertyID()) {
+        range.consumeIncludingWhitespace();
+        
+        // FIXME-NEWPARSER: No reason why we can't use the "all" property now that it exists.
+        // The old parser used a value keyword for "all", though, since it predated support for
+        // the property.
+        if (property == CSSPropertyAll)
+            return CSSValuePool::singleton().createIdentifierValue(CSSValueAll);
+
+        // FIXME-NEWPARSER: Want to use a CSSCustomIdentValue here eventually.
+        return CSSValuePool::singleton().createIdentifierValue(property);
+    }
+    return consumeCustomIdent(range);
+}
+
+    
+static RefPtr<CSSValue> consumeSteps(CSSParserTokenRange& range) {
+    ASSERT(range.peek().functionId() == CSSValueSteps);
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+    
+    RefPtr<CSSPrimitiveValue> steps = consumePositiveInteger(args);
+    if (!steps)
+        return nullptr;
+    
+    // FIXME-NEWPARSER: Support the middle value and change from a boolean to an enum.
+    bool stepAtStart = false;
+    if (consumeCommaIncludingWhitespace(args)) {
+        switch (args.consumeIncludingWhitespace().id()) {
+            case CSSValueStart:
+                stepAtStart = true;
+            break;
+            case CSSValueEnd:
+                stepAtStart = false;
+                break;
+            default:
+                return nullptr;
+        }
+    }
+    
+    if (!args.atEnd())
+        return nullptr;
+    
+    range = rangeCopy;
+    return CSSStepsTimingFunctionValue::create(steps->intValue(), stepAtStart);
+}
+
+static RefPtr<CSSValue> consumeCubicBezier(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().functionId() == CSSValueCubicBezier);
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+
+    double x1, y1, x2, y2;
+    if (consumeNumberRaw(args, x1)
+        && x1 >= 0 && x1 <= 1
+        && consumeCommaIncludingWhitespace(args)
+        && consumeNumberRaw(args, y1)
+        && consumeCommaIncludingWhitespace(args)
+        && consumeNumberRaw(args, x2)
+        && x2 >= 0 && x2 <= 1
+        && consumeCommaIncludingWhitespace(args)
+        && consumeNumberRaw(args, y2)
+        && args.atEnd()) {
+        range = rangeCopy;
+        return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
+    }
+
+    return nullptr;
+}
+
+static RefPtr<CSSValue> consumeSpringFunction(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().functionId() == CSSValueSpring);
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+
+    // Mass must be greater than 0.
+    double mass;
+    if (!consumeNumberRaw(args, mass) || mass <= 0)
+        return nullptr;
+    
+    // Stiffness must be greater than 0.
+    double stiffness;
+    if (!consumeNumberRaw(args, stiffness) || stiffness <= 0)
+        return nullptr;
+    
+    // Damping coefficient must be greater than or equal to 0.
+    double damping;
+    if (!consumeNumberRaw(args, damping) || damping < 0)
+        return nullptr;
+    
+    // Initial velocity may have any value.
+    double initialVelocity;
+    if (!consumeNumberRaw(args, initialVelocity))
+        return nullptr;
+
+    if (!args.atEnd())
+        return nullptr;
+
+    range = rangeCopy;
+
+    return CSSSpringTimingFunctionValue::create(mass, stiffness, damping, initialVelocity);
+}
+
+static RefPtr<CSSValue> consumeAnimationTimingFunction(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueEase || id == CSSValueLinear || id == CSSValueEaseIn
+        || id == CSSValueEaseOut || id == CSSValueEaseInOut || id == CSSValueStepStart || id == CSSValueStepEnd)
+        return consumeIdent(range);
+
+    CSSValueID function = range.peek().functionId();
+    if (function == CSSValueCubicBezier)
+        return consumeCubicBezier(range);
+    if (function == CSSValueSteps)
+        return consumeSteps(range);
+    if (context.springTimingFunctionEnabled && function == CSSValueSpring)
+        return consumeSpringFunction(range);
+    return nullptr;
+}
+
+#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
+static RefPtr<CSSValue> consumeWebkitAnimationTrigger(CSSParserTokenRange& range, CSSParserMode mode)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    
+    if (range.peek().functionId() != CSSValueContainerScroll)
+        return nullptr;
+    
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+
+    RefPtr<CSSPrimitiveValue> startValue = consumeLength(args, mode, ValueRangeAll, UnitlessQuirk::Forbid);
+    if (!startValue)
+        return nullptr;
+    
+    if (args.atEnd()) {
+        range = rangeCopy;
+        return CSSAnimationTriggerScrollValue::create(startValue.releaseNonNull());
+    }
+
+    if (!consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    RefPtr<CSSPrimitiveValue> endValue = consumeLength(args, mode, ValueRangeAll, UnitlessQuirk::Forbid);
+    if (!endValue || !args.atEnd())
+        return nullptr;
+
+    range = rangeCopy;
+
+    return CSSAnimationTriggerScrollValue::create(startValue.releaseNonNull(), endValue.releaseNonNull());
+}
+#endif
+    
+static RefPtr<CSSValue> consumeAnimationValue(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    switch (property) {
+    case CSSPropertyAnimationDelay:
+    case CSSPropertyTransitionDelay:
+        return consumeTime(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid);
+    case CSSPropertyAnimationDirection:
+        return consumeIdent<CSSValueNormal, CSSValueAlternate, CSSValueReverse, CSSValueAlternateReverse>(range);
+    case CSSPropertyAnimationDuration:
+    case CSSPropertyTransitionDuration:
+        return consumeTime(range, context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    case CSSPropertyAnimationFillMode:
+        return consumeIdent<CSSValueNone, CSSValueForwards, CSSValueBackwards, CSSValueBoth>(range);
+    case CSSPropertyAnimationIterationCount:
+        return consumeAnimationIterationCount(range);
+    case CSSPropertyAnimationName:
+        return consumeAnimationName(range);
+    case CSSPropertyAnimationPlayState:
+        return consumeIdent<CSSValueRunning, CSSValuePaused>(range);
+    case CSSPropertyTransitionProperty:
+        return consumeTransitionProperty(range);
+    case CSSPropertyAnimationTimingFunction:
+    case CSSPropertyTransitionTimingFunction:
+        return consumeAnimationTimingFunction(range, context);
+#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
+    case CSSPropertyWebkitAnimationTrigger:
+        return consumeWebkitAnimationTrigger(range, context.mode);
+#endif
+    default:
+        ASSERT_NOT_REACHED();
+        return nullptr;
+    }
+}
+
+static bool isValidAnimationPropertyList(CSSPropertyID property, const CSSValueList& valueList)
+{
+    if (property != CSSPropertyTransitionProperty || valueList.length() < 2)
+        return true;
+    for (auto& value : valueList) {
+        if (value->isPrimitiveValue() && downcast<CSSPrimitiveValue>(value.get()).isValueID()
+            && downcast<CSSPrimitiveValue>(value.get()).valueID() == CSSValueNone)
+            return false;
+    }
+    return true;
+}
+
+static RefPtr<CSSValue> consumeAnimationPropertyList(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValueList> list;
+    RefPtr<CSSValue> singleton;
+    do {
+        RefPtr<CSSValue> currentValue = consumeAnimationValue(property, range, context);
+        if (!currentValue)
+            return nullptr;
+        
+        if (singleton && !list) {
+            list = CSSValueList::createCommaSeparated();
+            list->append(singleton.releaseNonNull());
+        }
+        
+        if (list)
+            list->append(currentValue.releaseNonNull());
+        else
+            singleton = WTFMove(currentValue);
+        
+    } while (consumeCommaIncludingWhitespace(range));
+
+    if (list) {
+        if (!isValidAnimationPropertyList(property, *list))
+            return nullptr;
+    
+        ASSERT(list->length());
+        return list;
+    }
+    
+    return singleton;
+}
+
+bool CSSPropertyParser::consumeAnimationShorthand(const StylePropertyShorthand& shorthand, bool important)
+{
+    const unsigned longhandCount = shorthand.length();
+    RefPtr<CSSValueList> longhands[8];
+    ASSERT(longhandCount <= 8);
+    for (size_t i = 0; i < longhandCount; ++i)
+        longhands[i] = CSSValueList::createCommaSeparated();
+
+    do {
+        bool parsedLonghand[8] = { false };
+        do {
+            bool foundProperty = false;
+            for (size_t i = 0; i < longhandCount; ++i) {
+                if (parsedLonghand[i])
+                    continue;
+
+                if (RefPtr<CSSValue> value = consumeAnimationValue(shorthand.properties()[i], m_range, m_context)) {
+                    parsedLonghand[i] = true;
+                    foundProperty = true;
+                    longhands[i]->append(*value);
+                    break;
+                }
+            }
+            if (!foundProperty)
+                return false;
+        } while (!m_range.atEnd() && m_range.peek().type() != CommaToken);
+
+        // FIXME: This will make invalid longhands, see crbug.com/386459
+        for (size_t i = 0; i < longhandCount; ++i) {
+            if (!parsedLonghand[i])
+                longhands[i]->append(CSSValuePool::singleton().createImplicitInitialValue());
+            parsedLonghand[i] = false;
+        }
+    } while (consumeCommaIncludingWhitespace(m_range));
+
+    for (size_t i = 0; i < longhandCount; ++i) {
+        if (!isValidAnimationPropertyList(shorthand.properties()[i], *longhands[i]))
+            return false;
+    }
+
+    for (size_t i = 0; i < longhandCount; ++i)
+        addProperty(shorthand.properties()[i], shorthand.id(), *longhands[i], important);
+
+    return m_range.atEnd();
+}
+
+static RefPtr<CSSValue> consumeZIndex(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeInteger(range);
+}
+
+static RefPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool isBoxShadowProperty)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> shadowValueList = CSSValueList::createCommaSeparated();
+    do {
+        if (RefPtr<CSSShadowValue> shadowValue = consumeSingleShadow(range, cssParserMode, isBoxShadowProperty, isBoxShadowProperty))
+            shadowValueList->append(*shadowValue);
+        else
+            return nullptr;
+    } while (consumeCommaIncludingWhitespace(range));
+    return shadowValueList;
+}
+
+static RefPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    while (true) {
+#if ENABLE(LETTERPRESS)
+        RefPtr<CSSPrimitiveValue> ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough, CSSValueWebkitLetterpress>(range);
+#else
+        RefPtr<CSSPrimitiveValue> ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough>(range);
+#endif
+        if (!ident)
+            break;
+        if (list->hasValue(ident.get()))
+            return nullptr;
+        list->append(ident.releaseNonNull());
+    }
+
+    if (!list->length())
+        return nullptr;
+    return list;
+}
+
+static RefPtr<CSSValue> consumeTextDecorationSkip(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    while (true) {
+        auto ident = consumeIdent<CSSValueAuto, CSSValueInk, CSSValueObjects>(range);
+        if (!ident)
+            break;
+        if (list->hasValue(ident.get()))
+            return nullptr;
+        list->append(ident.releaseNonNull());
+    }
+
+    if (!list->length())
+        return nullptr;
+    return list;
+}
+
+static RefPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    if (RefPtr<CSSValue> textEmphasisStyle = consumeString(range))
+        return textEmphasisStyle;
+
+    RefPtr<CSSPrimitiveValue> fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
+    RefPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle, CSSValueSesame>(range);
+    if (!fill)
+        fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
+    if (fill && shape) {
+        RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+        parsedValues->append(fill.releaseNonNull());
+        parsedValues->append(shape.releaseNonNull());
+        return parsedValues;
+    }
+    if (fill)
+        return fill;
+    if (shape)
+        return shape;
+    return nullptr;
+}
+
+static RefPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    // Allow the special focus color even in HTML Standard parsing mode.
+    if (range.peek().id() == CSSValueWebkitFocusRingColor)
+        return consumeIdent(range);
+    return consumeColor(range, cssParserMode);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
+        return consumeIdent(range);
+    return consumeLength(range, cssParserMode, ValueRangeNonNegative, unitless);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBorderWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    return consumeLineWidth(range, cssParserMode, unitless);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
+}
+
+static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
+{
+    unsigned numberOfArguments = 2;
+    RefPtr<CSSValue> parsedValue;
+    do {
+        parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+        if (!parsedValue)
+            return false;
+        transformValue->append(*parsedValue);
+        if (!consumeCommaIncludingWhitespace(args))
+            return false;
+    } while (--numberOfArguments);
+    parsedValue = consumeLength(args, cssParserMode, ValueRangeAll);
+    if (!parsedValue)
+        return false;
+    transformValue->append(*parsedValue);
+    return true;
+}
+
+static bool consumeNumbers(CSSParserTokenRange& args, RefPtr<CSSFunctionValue>& transformValue, unsigned numberOfArguments)
+{
+    do {
+        RefPtr<CSSPrimitiveValue> parsedValue = consumeNumber(args, ValueRangeAll);
+        if (!parsedValue)
+            return false;
+        transformValue->append(parsedValue.releaseNonNull());
+        if (--numberOfArguments && !consumeCommaIncludingWhitespace(args))
+            return false;
+    } while (numberOfArguments);
+    return true;
+}
+
+static bool consumePerspective(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
+{
+    RefPtr<CSSPrimitiveValue> parsedValue = consumeLength(args, cssParserMode, ValueRangeNonNegative);
+    if (!parsedValue) {
+        double perspective;
+        if (!consumeNumberRaw(args, perspective) || perspective < 0)
+            return false;
+        parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitType::CSS_PX);
+    }
+    if (!parsedValue)
+        return false;
+    transformValue->append(parsedValue.releaseNonNull());
+    return true;
+}
+
+static RefPtr<CSSValue> consumeTransformValue(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    CSSValueID functionId = range.peek().functionId();
+    if (functionId == CSSValueInvalid)
+        return nullptr;
+    CSSParserTokenRange args = consumeFunction(range);
+    if (args.atEnd())
+        return nullptr;
+    
+    RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(functionId);
+    RefPtr<CSSValue> parsedValue;
+    switch (functionId) {
+    case CSSValueRotate:
+    case CSSValueRotateX:
+    case CSSValueRotateY:
+    case CSSValueRotateZ:
+    case CSSValueSkewX:
+    case CSSValueSkewY:
+    case CSSValueSkew:
+        parsedValue = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid);
+        if (!parsedValue)
+            return nullptr;
+        if (functionId == CSSValueSkew && consumeCommaIncludingWhitespace(args)) {
+            transformValue->append(*parsedValue);
+            parsedValue = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid);
+            if (!parsedValue)
+                return nullptr;
+        }
+        break;
+    case CSSValueScaleX:
+    case CSSValueScaleY:
+    case CSSValueScaleZ:
+    case CSSValueScale:
+        parsedValue = consumeNumber(args, ValueRangeAll);
+        if (!parsedValue)
+            return nullptr;
+        if (functionId == CSSValueScale && consumeCommaIncludingWhitespace(args)) {
+            transformValue->append(*parsedValue);
+            parsedValue = consumeNumber(args, ValueRangeAll);
+            if (!parsedValue)
+                return nullptr;
+        }
+        break;
+    case CSSValuePerspective:
+        if (!consumePerspective(args, cssParserMode, transformValue))
+            return nullptr;
+        break;
+    case CSSValueTranslateX:
+    case CSSValueTranslateY:
+    case CSSValueTranslate:
+        parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+        if (!parsedValue)
+            return nullptr;
+        if (functionId == CSSValueTranslate && consumeCommaIncludingWhitespace(args)) {
+            transformValue->append(*parsedValue);
+            parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+            if (!parsedValue)
+                return nullptr;
+        }
+        break;
+    case CSSValueTranslateZ:
+        parsedValue = consumeLength(args, cssParserMode, ValueRangeAll);
+        break;
+    case CSSValueMatrix:
+    case CSSValueMatrix3d:
+        if (!consumeNumbers(args, transformValue, (functionId == CSSValueMatrix3d) ? 16 : 6))
+            return nullptr;
+        break;
+    case CSSValueScale3d:
+        if (!consumeNumbers(args, transformValue, 3))
+            return nullptr;
+        break;
+    case CSSValueRotate3d:
+        if (!consumeNumbers(args, transformValue, 3) || !consumeCommaIncludingWhitespace(args))
+            return nullptr;
+        parsedValue = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid);
+        if (!parsedValue)
+            return nullptr;
+        break;
+    case CSSValueTranslate3d:
+        if (!consumeTranslate3d(args, cssParserMode, transformValue))
+            return nullptr;
+        break;
+    default:
+        return nullptr;
+    }
+    if (parsedValue)
+        transformValue->append(*parsedValue);
+    if (!args.atEnd())
+        return nullptr;
+    return transformValue;
+}
+
+static RefPtr<CSSValue> consumeTransform(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    do {
+        RefPtr<CSSValue> parsedTransformValue = consumeTransformValue(range, cssParserMode);
+        if (!parsedTransformValue)
+            return nullptr;
+        list->append(parsedTransformValue.releaseNonNull());
+    } while (!range.atEnd());
+
+    return list;
+}
+
+template <CSSValueID start, CSSValueID end>
+static RefPtr<CSSPrimitiveValue> consumePositionLonghand(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().type() == IdentToken) {
+        CSSValueID id = range.peek().id();
+        int percent;
+        if (id == start)
+            percent = 0;
+        else if (id == CSSValueCenter)
+            percent = 50;
+        else if (id == end)
+            percent = 100;
+        else
+            return nullptr;
+        range.consumeIncludingWhitespace();
+        return CSSPrimitiveValue::create(percent, CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+    }
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
+}
+
+static RefPtr<CSSPrimitiveValue> consumePositionX(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    return consumePositionLonghand<CSSValueLeft, CSSValueRight>(range, cssParserMode);
+}
+
+static RefPtr<CSSPrimitiveValue> consumePositionY(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    return consumePositionLonghand<CSSValueTop, CSSValueBottom>(range, cssParserMode);
+}
+
+static RefPtr<CSSValue> consumePaintStroke(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    RefPtr<CSSPrimitiveValue> url = consumeUrl(range);
+    if (url) {
+        RefPtr<CSSValue> parsedValue;
+        if (range.peek().id() == CSSValueNone)
+            parsedValue = consumeIdent(range);
+        else
+            parsedValue = consumeColor(range, cssParserMode);
+        if (parsedValue) {
+            RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+            values->append(url.releaseNonNull());
+            values->append(parsedValue.releaseNonNull());
+            return values;
+        }
+        return url;
+    }
+    return consumeColor(range, cssParserMode);
+}
+
+static RefPtr<CSSValue> consumeGlyphOrientation(CSSParserTokenRange& range, CSSParserMode mode, CSSPropertyID property)
+{
+    if (range.peek().id() == CSSValueAuto) {
+        if (property == CSSPropertyGlyphOrientationVertical)
+            return consumeIdent(range);
+        return nullptr;
+    }
+    
+    return consumeAngle(range, mode, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNormal)
+        return consumeIdent(range);
+
+    Vector<CSSValueID, 3> paintTypeList;
+    RefPtr<CSSPrimitiveValue> fill;
+    RefPtr<CSSPrimitiveValue> stroke;
+    RefPtr<CSSPrimitiveValue> markers;
+    do {
+        CSSValueID id = range.peek().id();
+        if (id == CSSValueFill && !fill)
+            fill = consumeIdent(range);
+        else if (id == CSSValueStroke && !stroke)
+            stroke = consumeIdent(range);
+        else if (id == CSSValueMarkers && !markers)
+            markers = consumeIdent(range);
+        else
+            return nullptr;
+        paintTypeList.append(id);
+    } while (!range.atEnd());
+
+    // After parsing we serialize the paint-order list. Since it is not possible to
+    // pop a last list items from CSSValueList without bigger cost, we create the
+    // list after parsing.
+    CSSValueID firstPaintOrderType = paintTypeList.at(0);
+    RefPtr<CSSValueList> paintOrderList = CSSValueList::createSpaceSeparated();
+    switch (firstPaintOrderType) {
+    case CSSValueFill:
+    case CSSValueStroke:
+        paintOrderList->append(firstPaintOrderType == CSSValueFill ? fill.releaseNonNull() : stroke.releaseNonNull());
+        if (paintTypeList.size() > 1) {
+            if (paintTypeList.at(1) == CSSValueMarkers)
+                paintOrderList->append(markers.releaseNonNull());
+        }
+        break;
+    case CSSValueMarkers:
+        paintOrderList->append(markers.releaseNonNull());
+        if (paintTypeList.size() > 1) {
+            if (paintTypeList.at(1) == CSSValueStroke)
+                paintOrderList->append(stroke.releaseNonNull());
+        }
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+
+    return paintOrderList;
+}
+
+static RefPtr<CSSValue> consumeNoneOrURI(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    return consumeUrl(range);
+}
+
+static RefPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    // FIXME: Support intrinsic dimensions too.
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSValue> consumeKerning(CSSParserTokenRange& range, CSSParserMode mode)
+{
+    RefPtr<CSSValue> result = consumeIdent<CSSValueAuto, CSSValueNormal>(range);
+    if (result)
+        return result;
+    return consumeLength(range, mode, ValueRangeAll, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNone)
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> dashes = CSSValueList::createCommaSeparated();
+    do {
+        RefPtr<CSSPrimitiveValue> dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative);
+        if (!dash || (consumeCommaIncludingWhitespace(range) && range.atEnd()))
+            return nullptr;
+        dashes->append(dash.releaseNonNull());
+    } while (!range.atEnd());
+    return dashes;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBaselineShift(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
+        return consumeIdent(range);
+    return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeRxOrRy(CSSParserTokenRange& range)
+{
+    // FIXME-NEWPARSER: We don't support auto values when mapping, so for now turn this
+    // off until we can figure out if we're even supposed to support it.
+    // if (range.peek().id() == CSSValueAuto)
+    //     return consumeIdent(range);
+    return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
+}
+
+static RefPtr<CSSValue> consumeCursor(CSSParserTokenRange& range, const CSSParserContext& context, bool inQuirksMode)
+{
+    RefPtr<CSSValueList> list;
+    while (RefPtr<CSSValue> image = consumeImage(range, context, ConsumeGeneratedImage::Forbid)) {
+        double num;
+        IntPoint hotSpot(-1, -1);
+        bool hotSpotSpecified = false;
+        if (consumeNumberRaw(range, num)) {
+            hotSpot.setX(int(num));
+            if (!consumeNumberRaw(range, num))
+                return nullptr;
+            hotSpot.setY(int(num));
+            hotSpotSpecified = true;
+        }
+
+        if (!list)
+            list = CSSValueList::createCommaSeparated();
+
+        list->append(CSSCursorImageValue::create(image.releaseNonNull(), hotSpotSpecified, hotSpot));
+        if (!consumeCommaIncludingWhitespace(range))
+            return nullptr;
+    }
+
+    CSSValueID id = range.peek().id();
+    RefPtr<CSSValue> cursorType;
+    if (id == CSSValueHand) {
+        if (!inQuirksMode) // Non-standard behavior
+            return nullptr;
+        cursorType = CSSValuePool::singleton().createIdentifierValue(CSSValuePointer);
+        range.consumeIncludingWhitespace();
+    } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) || id == CSSValueCopy || id == CSSValueNone) {
+        cursorType = consumeIdent(range);
+    } else {
+        return nullptr;
+    }
+
+    if (!list)
+        return cursorType;
+    list->append(cursorType.releaseNonNull());
+    return list;
+}
+
+static RefPtr<CSSValue> consumeAttr(CSSParserTokenRange args, CSSParserContext context)
+{
+    if (args.peek().type() != IdentToken)
+        return nullptr;
+    
+    CSSParserToken token = args.consumeIncludingWhitespace();
+    auto attrName = token.value().toAtomicString();
+    if (context.isHTMLDocument)
+        attrName = attrName.convertToASCIILowercase();
+
+    if (!args.atEnd())
+        return nullptr;
+
+    // FIXME-NEWPARSER: We want to use a CSSCustomIdentValue here eventually for the attrName.
+    // FIXME-NEWPARSER: We want to use a CSSFunctionValue rather than relying on a custom
+    // attr() primitive value.
+    return CSSValuePool::singleton().createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
+}
+
+static RefPtr<CSSValue> consumeCounterContent(CSSParserTokenRange args, bool counters)
+{
+    RefPtr<CSSPrimitiveValue> identifier = consumeCustomIdent(args);
+    if (!identifier)
+        return nullptr;
+
+    RefPtr<CSSPrimitiveValue> separator;
+    if (!counters)
+        separator = CSSPrimitiveValue::create(String(), CSSPrimitiveValue::UnitType::CSS_STRING);
+    else {
+        if (!consumeCommaIncludingWhitespace(args) || args.peek().type() != StringToken)
+            return nullptr;
+        separator = CSSPrimitiveValue::create(args.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
+    }
+
+    RefPtr<CSSPrimitiveValue> listStyle;
+    if (consumeCommaIncludingWhitespace(args)) {
+        CSSValueID id = args.peek().id();
+        if ((id != CSSValueNone && (id < CSSValueDisc || id > CSSValueKatakanaIroha)))
+            return nullptr;
+        listStyle = consumeIdent(args);
+    } else
+        listStyle = CSSValuePool::singleton().createIdentifierValue(CSSValueDecimal);
+
+    if (!args.atEnd())
+        return nullptr;
+    
+    // FIXME-NEWPARSER: Should just have a CSSCounterValue.
+    return CSSValuePool::singleton().createValue(Counter::create(identifier.releaseNonNull(), listStyle.releaseNonNull(), separator.releaseNonNull()));
+}
+
+static RefPtr<CSSValue> consumeContent(CSSParserTokenRange& range, CSSParserContext context)
+{
+    if (identMatches<CSSValueNone, CSSValueNormal>(range.peek().id()))
+        return consumeIdent(range);
+
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+
+    do {
+        RefPtr<CSSValue> parsedValue = consumeImage(range, context);
+        if (!parsedValue)
+            parsedValue = consumeIdent<CSSValueOpenQuote, CSSValueCloseQuote, CSSValueNoOpenQuote, CSSValueNoCloseQuote>(range);
+        if (!parsedValue)
+            parsedValue = consumeString(range);
+        if (!parsedValue) {
+            if (range.peek().functionId() == CSSValueAttr)
+                parsedValue = consumeAttr(consumeFunction(range), context);
+            else if (range.peek().functionId() == CSSValueCounter)
+                parsedValue = consumeCounterContent(consumeFunction(range), false);
+            else if (range.peek().functionId() == CSSValueCounters)
+                parsedValue = consumeCounterContent(consumeFunction(range), true);
+            if (!parsedValue)
+                return nullptr;
+        }
+        values->append(parsedValue.releaseNonNull());
+    } while (!range.atEnd());
+
+    return values;
+}
+
+static RefPtr<CSSPrimitiveValue> consumePerspective(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    RefPtr<CSSPrimitiveValue> parsedValue = consumeLength(range, cssParserMode, ValueRangeAll);
+    if (!parsedValue) {
+        // FIXME: Make this quirk only apply to the webkit prefixed version of the property.
+        double perspective;
+        if (!consumeNumberRaw(range, perspective))
+            return nullptr;
+        parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitType::CSS_PX);
+    }
+    if (parsedValue && (parsedValue->isCalculated() || parsedValue->doubleValue() > 0))
+        return parsedValue;
+    return nullptr;
+}
+
+#if ENABLE(CSS_SCROLL_SNAP)
+
+static RefPtr<CSSValueList> consumeScrollSnapAlign(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValueList> alignmentValue = CSSValueList::createSpaceSeparated();
+    if (RefPtr<CSSPrimitiveValue> firstValue = consumeIdent<CSSValueNone, CSSValueStart, CSSValueCenter, CSSValueEnd>(range)) {
+        alignmentValue->append(firstValue.releaseNonNull());
+        if (auto secondValue = consumeIdent<CSSValueNone, CSSValueStart, CSSValueCenter, CSSValueEnd>(range))
+            alignmentValue->append(secondValue.releaseNonNull());
+    }
+    return alignmentValue->length() ? alignmentValue : nullptr;
+}
+
+static RefPtr<CSSValueList> consumeScrollSnapType(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValueList> typeValue = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSPrimitiveValue> secondValue;
+
+    auto firstValue = consumeIdent<CSSValueX, CSSValueY, CSSValueBlock, CSSValueInline, CSSValueBoth>(range);
+    if (firstValue)
+        secondValue = consumeIdent<CSSValueProximity, CSSValueMandatory>(range);
+    else
+        firstValue = consumeIdent<CSSValueNone, CSSValueProximity, CSSValueMandatory>(range);
+
+    if (!firstValue)
+        return nullptr;
+
+    typeValue->append(firstValue.releaseNonNull());
+    if (secondValue)
+        typeValue->append(secondValue.releaseNonNull());
+
+    return typeValue;
+}
+
+#endif
+
+static RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+    if (!parsedValue1)
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+    if (!parsedValue2)
+        parsedValue2 = parsedValue1;
+    return createPrimitiveValuePair(parsedValue1.releaseNonNull(), parsedValue2.releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    RefPtr<CSSPrimitiveValue> parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
+    if (!parsedValue)
+        parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+    return parsedValue;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+{
+    if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id()))
+        return consumeIdent(args);
+    return consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSBasicShapeCircle> consumeBasicShapeCircle(CSSParserTokenRange& args, const CSSParserContext& context)
+{
+    // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
+    // circle( [<shape-radius>]? [at <position>]? )
+    RefPtr<CSSBasicShapeCircle> shape = CSSBasicShapeCircle::create();
+    if (RefPtr<CSSPrimitiveValue> radius = consumeShapeRadius(args, context.mode))
+        shape->setRadius(radius.releaseNonNull());
+    if (consumeIdent<CSSValueAt>(args)) {
+        RefPtr<CSSPrimitiveValue> centerX;
+        RefPtr<CSSPrimitiveValue> centerY;
+        if (!consumePosition(args, context.mode, UnitlessQuirk::Forbid, centerX, centerY))
+            return nullptr;
+        shape->setCenterX(centerX.releaseNonNull());
+        shape->setCenterY(centerY.releaseNonNull());
+    }
+    return shape;
+}
+
+static RefPtr<CSSBasicShapeEllipse> consumeBasicShapeEllipse(CSSParserTokenRange& args, const CSSParserContext& context)
+{
+    // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
+    // ellipse( [<shape-radius>{2}]? [at <position>]? )
+    RefPtr<CSSBasicShapeEllipse> shape = CSSBasicShapeEllipse::create();
+    if (RefPtr<CSSPrimitiveValue> radiusX = consumeShapeRadius(args, context.mode)) {
+        shape->setRadiusX(radiusX.releaseNonNull());
+        if (RefPtr<CSSPrimitiveValue> radiusY = consumeShapeRadius(args, context.mode))
+            shape->setRadiusY(radiusY.releaseNonNull());
+    }
+    if (consumeIdent<CSSValueAt>(args)) {
+        RefPtr<CSSPrimitiveValue> centerX;
+        RefPtr<CSSPrimitiveValue> centerY;
+        if (!consumePosition(args, context.mode, UnitlessQuirk::Forbid, centerX, centerY))
+            return nullptr;
+        shape->setCenterX(centerX.releaseNonNull());
+        shape->setCenterY(centerY.releaseNonNull());
+    }
+    return shape;
+}
+
+static RefPtr<CSSBasicShapePolygon> consumeBasicShapePolygon(CSSParserTokenRange& args, const CSSParserContext& context)
+{
+    RefPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::create();
+    if (identMatches<CSSValueEvenodd, CSSValueNonzero>(args.peek().id())) {
+        shape->setWindRule(args.consumeIncludingWhitespace().id() == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO);
+        if (!consumeCommaIncludingWhitespace(args))
+            return nullptr;
+    }
+
+    do {
+        RefPtr<CSSPrimitiveValue> xLength = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+        if (!xLength)
+            return nullptr;
+        RefPtr<CSSPrimitiveValue> yLength = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+        if (!yLength)
+            return nullptr;
+        shape->appendPoint(xLength.releaseNonNull(), yLength.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(args));
+    return shape;
+}
+
+static RefPtr<CSSBasicShapePath> consumeBasicShapePath(CSSParserTokenRange& args)
+{
+    WindRule windRule = RULE_NONZERO;
+    if (identMatches<CSSValueEvenodd, CSSValueNonzero>(args.peek().id())) {
+        windRule = args.consumeIncludingWhitespace().id() == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO;
+        if (!consumeCommaIncludingWhitespace(args))
+            return nullptr;
+    }
+
+    if (args.peek().type() != StringToken)
+        return nullptr;
+    
+    auto byteStream = std::make_unique<SVGPathByteStream>();
+    if (!buildSVGPathByteStreamFromString(args.consumeIncludingWhitespace().value().toString(), *byteStream, UnalteredParsing))
+        return nullptr;
+    
+    auto shape = CSSBasicShapePath::create(WTFMove(byteStream));
+    shape->setWindRule(windRule);
+    
+    return WTFMove(shape);
+}
+
+static void complete4Sides(RefPtr<CSSPrimitiveValue> side[4])
+{
+    if (side[3])
+        return;
+    if (!side[2]) {
+        if (!side[1])
+            side[1] = side[0];
+        side[2] = side[0];
+    }
+    side[3] = side[1];
+}
+
+static bool consumeRadii(RefPtr<CSSPrimitiveValue> horizontalRadii[4], RefPtr<CSSPrimitiveValue> verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
+{
+    unsigned i = 0;
+    for (; i < 4 && !range.atEnd() && range.peek().type() != DelimiterToken; ++i) {
+        horizontalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+        if (!horizontalRadii[i])
+            return false;
+    }
+    if (!horizontalRadii[0])
+        return false;
+    if (range.atEnd()) {
+        // Legacy syntax: -webkit-border-radius: l1 l2; is equivalent to border-radius: l1 / l2;
+        if (useLegacyParsing && i == 2) {
+            verticalRadii[0] = horizontalRadii[1];
+            horizontalRadii[1] = nullptr;
+        } else {
+            complete4Sides(horizontalRadii);
+            for (unsigned i = 0; i < 4; ++i)
+                verticalRadii[i] = horizontalRadii[i];
+            return true;
+        }
+    } else {
+        if (!consumeSlashIncludingWhitespace(range))
+            return false;
+        for (i = 0; i < 4 && !range.atEnd(); ++i) {
+            verticalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+            if (!verticalRadii[i])
+                return false;
+        }
+        if (!verticalRadii[0] || !range.atEnd())
+            return false;
+    }
+    complete4Sides(horizontalRadii);
+    complete4Sides(verticalRadii);
+    return true;
+}
+
+static RefPtr<CSSBasicShapeInset> consumeBasicShapeInset(CSSParserTokenRange& args, const CSSParserContext& context)
+{
+    RefPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
+    RefPtr<CSSPrimitiveValue> top = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+    if (!top)
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> right = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+    RefPtr<CSSPrimitiveValue> bottom;
+    RefPtr<CSSPrimitiveValue> left;
+    if (right) {
+        bottom = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+        if (bottom)
+            left = consumeLengthOrPercent(args, context.mode, ValueRangeAll);
+    }
+    if (left)
+        shape->updateShapeSize4Values(top.releaseNonNull(), right.releaseNonNull(), bottom.releaseNonNull(), left.releaseNonNull());
+    else if (bottom)
+        shape->updateShapeSize3Values(top.releaseNonNull(), right.releaseNonNull(), bottom.releaseNonNull());
+    else if (right)
+        shape->updateShapeSize2Values(top.releaseNonNull(), right.releaseNonNull());
+    else
+        shape->updateShapeSize1Value(top.releaseNonNull());
+
+    if (consumeIdent<CSSValueRound>(args)) {
+        RefPtr<CSSPrimitiveValue> horizontalRadii[4] = { 0 };
+        RefPtr<CSSPrimitiveValue> verticalRadii[4] = { 0 };
+        if (!consumeRadii(horizontalRadii, verticalRadii, args, context.mode, false))
+            return nullptr;
+        shape->setTopLeftRadius(createPrimitiveValuePair(horizontalRadii[0].releaseNonNull(), verticalRadii[0].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce));
+        shape->setTopRightRadius(createPrimitiveValuePair(horizontalRadii[1].releaseNonNull(), verticalRadii[1].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce));
+        shape->setBottomRightRadius(createPrimitiveValuePair(horizontalRadii[2].releaseNonNull(), verticalRadii[2].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce));
+        shape->setBottomLeftRadius(createPrimitiveValuePair(horizontalRadii[3].releaseNonNull(), verticalRadii[3].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce));
+    }
+    return shape;
+}
+
+static RefPtr<CSSValue> consumeBasicShape(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValue> result;
+    if (range.peek().type() != FunctionToken)
+        return nullptr;
+    CSSValueID id = range.peek().functionId();
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+    
+    // FIXME-NEWPARSER: CSSBasicShape should be a CSSValue, and shapes should not be primitive values.
+    RefPtr<CSSBasicShape> shape;
+    if (id == CSSValueCircle)
+        shape = consumeBasicShapeCircle(args, context);
+    else if (id == CSSValueEllipse)
+        shape = consumeBasicShapeEllipse(args, context);
+    else if (id == CSSValuePolygon)
+        shape = consumeBasicShapePolygon(args, context);
+    else if (id == CSSValueInset)
+        shape = consumeBasicShapeInset(args, context);
+    else if (id == CSSValuePath)
+        shape = consumeBasicShapePath(args);
+    if (!shape)
+        return nullptr;
+    range = rangeCopy;
+    
+    if (!args.atEnd())
+        return nullptr;
+
+    return CSSValuePool::singleton().createValue(shape.releaseNonNull());
+}
+
+static RefPtr<CSSValue> consumeBasicShapeOrBox(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    bool shapeFound = false;
+    bool boxFound = false;
+    while (!range.atEnd() && !(shapeFound && boxFound)) {
+        RefPtr<CSSValue> componentValue;
+        if (range.peek().type() == FunctionToken && !shapeFound) {
+            componentValue = consumeBasicShape(range, context);
+            shapeFound = true;
+        } else if (range.peek().type() == IdentToken && !boxFound) {
+            componentValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox, CSSValueFill, CSSValueStroke, CSSValueViewBox>(range);
+            boxFound = true;
+        }
+        if (!componentValue)
+            return nullptr;
+        list->append(componentValue.releaseNonNull());
+    }
+    
+    if (!range.atEnd() || !list->length())
+        return nullptr;
+    
+    return list;
+}
+    
+static RefPtr<CSSValue> consumeWebkitClipPath(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    if (RefPtr<CSSPrimitiveValue> url = consumeUrl(range))
+        return url;
+    return consumeBasicShapeOrBox(range, context);
+}
+
+static RefPtr<CSSValue> consumeShapeOutside(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (RefPtr<CSSValue> imageValue = consumeImageOrNone(range, context))
+        return imageValue;
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    if (RefPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
+        list->append(boxValue.releaseNonNull());
+    if (RefPtr<CSSValue> shapeValue = consumeBasicShape(range, context)) {
+        list->append(shapeValue.releaseNonNull());
+        if (list->length() < 2) {
+            if (RefPtr<CSSValue> boxValue = consumeIdent<CSSValueContentBox, CSSValuePaddingBox, CSSValueBorderBox, CSSValueMarginBox>(range))
+                list->append(boxValue.releaseNonNull());
+        }
+    }
+    if (!list->length())
+        return nullptr;
+    return list;
+}
+
+static RefPtr<CSSValue> consumeContentDistributionOverflowPosition(CSSParserTokenRange& range)
+{
+    if (identMatches<CSSValueNormal, CSSValueBaseline, CSSValueLastBaseline>(range.peek().id()))
+        return CSSContentDistributionValue::create(CSSValueInvalid, range.consumeIncludingWhitespace().id(), CSSValueInvalid);
+
+    CSSValueID distribution = CSSValueInvalid;
+    CSSValueID position = CSSValueInvalid;
+    CSSValueID overflow = CSSValueInvalid;
+    do {
+        CSSValueID id = range.peek().id();
+        if (identMatches<CSSValueSpaceBetween, CSSValueSpaceAround, CSSValueSpaceEvenly, CSSValueStretch>(id)) {
+            if (distribution != CSSValueInvalid)
+                return nullptr;
+            distribution = id;
+        } else if (identMatches<CSSValueStart, CSSValueEnd, CSSValueCenter, CSSValueFlexStart, CSSValueFlexEnd, CSSValueLeft, CSSValueRight>(id)) {
+            if (position != CSSValueInvalid)
+                return nullptr;
+            position = id;
+        } else if (identMatches<CSSValueUnsafe, CSSValueSafe>(id)) {
+            if (overflow != CSSValueInvalid)
+                return nullptr;
+            overflow = id;
+        } else {
+            return nullptr;
+        }
+        range.consumeIncludingWhitespace();
+    } while (!range.atEnd());
+
+    // The grammar states that we should have at least <content-distribution> or <content-position>.
+    if (position == CSSValueInvalid && distribution == CSSValueInvalid)
+        return nullptr;
+
+    // The grammar states that <overflow-position> must be associated to <content-position>.
+    if (overflow != CSSValueInvalid && position == CSSValueInvalid)
+        return nullptr;
+
+    return CSSContentDistributionValue::create(distribution, position, overflow);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBorderImageRepeatKeyword(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueStretch, CSSValueRepeat, CSSValueSpace, CSSValueRound>(range);
+}
+
+static RefPtr<CSSValue> consumeBorderImageRepeat(CSSParserTokenRange& range)
+{
+    RefPtr<CSSPrimitiveValue> horizontal = consumeBorderImageRepeatKeyword(range);
+    if (!horizontal)
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> vertical = consumeBorderImageRepeatKeyword(range);
+    if (!vertical)
+        vertical = horizontal;
+    return createPrimitiveValuePair(horizontal.releaseNonNull(), vertical.releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce);
+}
+
+static RefPtr<CSSValue> consumeBorderImageSlice(CSSPropertyID property, CSSParserTokenRange& range)
+{
+    bool fill = consumeIdent<CSSValueFill>(range);
+    RefPtr<CSSPrimitiveValue> slices[4] = { 0 };
+
+    for (size_t index = 0; index < 4; ++index) {
+        RefPtr<CSSPrimitiveValue> value = consumePercent(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            break;
+        slices[index] = value;
+    }
+    if (!slices[0])
+        return nullptr;
+    if (consumeIdent<CSSValueFill>(range)) {
+        if (fill)
+            return nullptr;
+        fill = true;
+    }
+    complete4Sides(slices);
+    // FIXME: For backwards compatibility, -webkit-border-image, -webkit-mask-box-image and -webkit-box-reflect have to do a fill by default.
+    // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? Probably just have to leave them filling...
+    if (property == CSSPropertyWebkitBorderImage || property == CSSPropertyWebkitMaskBoxImage || property == CSSPropertyWebkitBoxReflect)
+        fill = true;
+    
+    // Now build a rect value to hold all four of our primitive values.
+    // FIXME-NEWPARSER: Should just have a CSSQuadValue.
+    auto quad = Quad::create();
+    quad->setTop(slices[0].releaseNonNull());
+    quad->setRight(slices[1].releaseNonNull());
+    quad->setBottom(slices[2].releaseNonNull());
+    quad->setLeft(slices[3].releaseNonNull());
+    
+    // Make our new border image value now.
+    return CSSBorderImageSliceValue::create(CSSValuePool::singleton().createValue(WTFMove(quad)), fill);
+}
+
+static RefPtr<CSSValue> consumeBorderImageOutset(CSSParserTokenRange& range)
+{
+    RefPtr<CSSPrimitiveValue> outsets[4] = { 0 };
+
+    RefPtr<CSSPrimitiveValue> value;
+    for (size_t index = 0; index < 4; ++index) {
+        value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
+        if (!value)
+            break;
+        outsets[index] = value;
+    }
+    if (!outsets[0])
+        return nullptr;
+    complete4Sides(outsets);
+    
+    // FIXME-NEWPARSER: Should just have a CSSQuadValue.
+    auto quad = Quad::create();
+    quad->setTop(outsets[0].releaseNonNull());
+    quad->setRight(outsets[1].releaseNonNull());
+    quad->setBottom(outsets[2].releaseNonNull());
+    quad->setLeft(outsets[3].releaseNonNull());
+    
+    return CSSValuePool::singleton().createValue(WTFMove(quad));
+}
+
+static RefPtr<CSSValue> consumeBorderImageWidth(CSSParserTokenRange& range)
+{
+    RefPtr<CSSPrimitiveValue> widths[4];
+
+    RefPtr<CSSPrimitiveValue> value;
+    for (size_t index = 0; index < 4; ++index) {
+        value = consumeNumber(range, ValueRangeNonNegative);
+        if (!value)
+            value = consumeLengthOrPercent(range, HTMLStandardMode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
+        if (!value)
+            value = consumeIdent<CSSValueAuto>(range);
+        if (!value)
+            break;
+        widths[index] = value;
+    }
+    if (!widths[0])
+        return nullptr;
+    complete4Sides(widths);
+    
+    // FIXME-NEWPARSER: Should just have a CSSQuadValue.
+    auto quad = Quad::create();
+    quad->setTop(widths[0].releaseNonNull());
+    quad->setRight(widths[1].releaseNonNull());
+    quad->setBottom(widths[2].releaseNonNull());
+    quad->setLeft(widths[3].releaseNonNull());
+    
+    return CSSValuePool::singleton().createValue(WTFMove(quad));
+}
+
+static bool consumeBorderImageComponents(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, RefPtr<CSSValue>& source,
+    RefPtr<CSSValue>& slice, RefPtr<CSSValue>& width, RefPtr<CSSValue>& outset, RefPtr<CSSValue>& repeat)
+{
+    do {
+        if (!source) {
+            source = consumeImageOrNone(range, context);
+            if (source)
+                continue;
+        }
+        if (!repeat) {
+            repeat = consumeBorderImageRepeat(range);
+            if (repeat)
+                continue;
+        }
+        if (!slice) {
+            slice = consumeBorderImageSlice(property, range);
+            if (slice) {
+                ASSERT(!width && !outset);
+                if (consumeSlashIncludingWhitespace(range)) {
+                    width = consumeBorderImageWidth(range);
+                    if (consumeSlashIncludingWhitespace(range)) {
+                        outset = consumeBorderImageOutset(range);
+                        if (!outset)
+                            return false;
+                    } else if (!width) {
+                        return false;
+                    }
+                }
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    } while (!range.atEnd());
+    return true;
+}
+
+static RefPtr<CSSValue> consumeWebkitBorderImage(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValue> source;
+    RefPtr<CSSValue> slice;
+    RefPtr<CSSValue> width;
+    RefPtr<CSSValue> outset;
+    RefPtr<CSSValue> repeat;
+    if (consumeBorderImageComponents(property, range, context, source, slice, width, outset, repeat))
+        return createBorderImageValue(WTFMove(source), WTFMove(slice), WTFMove(width), WTFMove(outset), WTFMove(repeat));
+    return nullptr;
+}
+
+static RefPtr<CSSValue> consumeReflect(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    
+    RefPtr<CSSPrimitiveValue> direction = consumeIdent<CSSValueAbove, CSSValueBelow, CSSValueLeft, CSSValueRight>(range);
+    if (!direction)
+        return nullptr;
+
+    RefPtr<CSSPrimitiveValue> offset;
+    if (range.atEnd())
+        offset = CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitType::CSS_PX);
+    else {
+        offset = consumeLengthOrPercent(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid);
+        if (!offset)
+            return nullptr;
+    }
+
+    RefPtr<CSSValue> mask;
+    if (!range.atEnd()) {
+        mask = consumeWebkitBorderImage(CSSPropertyWebkitBoxReflect, range, context);
+        if (!mask)
+            return nullptr;
+    }
+    return CSSReflectValue::create(direction.releaseNonNull(), offset.releaseNonNull(), WTFMove(mask));
+}
+
+#if ENABLE(CSS_IMAGE_ORIENTATION)
+static RefPtr<CSSValue> consumeImageOrientation(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
+{
+    if (range.peek().type() != NumberToken) {
+        RefPtr<CSSPrimitiveValue> angle = consumeAngle(range, cssParserMode, unitless);
+        if (angle && angle->doubleValue() == 0)
+            return angle;
+    }
+    return nullptr;
+}
+#endif
+
+static RefPtr<CSSPrimitiveValue> consumeBackgroundBlendMode(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueNormal || id == CSSValueOverlay || (id >= CSSValueMultiply && id <= CSSValueLuminosity))
+        return consumeIdent(range);
+    return nullptr;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBackgroundAttachment(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueScroll, CSSValueFixed, CSSValueLocal>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBackgroundBox(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueBorderBox, CSSValuePaddingBox, CSSValueContentBox, CSSValueWebkitText>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBackgroundComposite(CSSParserTokenRange& range)
+{
+    return consumeIdentRange(range, CSSValueClear, CSSValuePlusLighter);
+}
+
+static RefPtr<CSSPrimitiveValue> consumeWebkitMaskSourceType(CSSParserTokenRange& range)
+{
+    return consumeIdent<CSSValueAuto, CSSValueAlpha, CSSValueLuminance>(range);
+}
+
+static RefPtr<CSSPrimitiveValue> consumePrefixedBackgroundBox(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& /*context*/)
+{
+    // The values 'border', 'padding' and 'content' are deprecated and do not apply to the version of the property that has the -webkit- prefix removed.
+    if (RefPtr<CSSPrimitiveValue> value = consumeIdentRange(range, CSSValueBorder, CSSValuePaddingBox))
+        return value;
+    if (range.peek().id() == CSSValueWebkitText || ((property == CSSPropertyWebkitBackgroundClip || property == CSSPropertyWebkitMaskClip) && range.peek().id() == CSSValueText))
+        return consumeIdent(range);
+    return nullptr;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeBackgroundSize(CSSPropertyID property, CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (identMatches<CSSValueContain, CSSValueCover>(range.peek().id()))
+        return consumeIdent(range);
+
+    // FIXME: We're allowing the unitless quirk on this property because our
+    // tests assume that. Other browser engines don't allow it though.
+    RefPtr<CSSPrimitiveValue> horizontal = consumeIdent<CSSValueAuto>(range);
+    if (!horizontal)
+        horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+
+    RefPtr<CSSPrimitiveValue> vertical;
+    if (!range.atEnd()) {
+        if (range.peek().id() == CSSValueAuto) // `auto' is the default
+            range.consumeIncludingWhitespace();
+        else
+            vertical = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+    } else if (!vertical && property == CSSPropertyWebkitBackgroundSize) {
+        // Legacy syntax: "-webkit-background-size: 10px" is equivalent to "background-size: 10px 10px".
+        vertical = horizontal;
+    }
+    if (!vertical)
+        return horizontal;
+    return createPrimitiveValuePair(horizontal.releaseNonNull(), vertical.releaseNonNull(), property == CSSPropertyWebkitBackgroundSize ? Pair::IdenticalValueEncoding::Coalesce : Pair::IdenticalValueEncoding::DoNotCoalesce);
+}
+
+static RefPtr<CSSValueList> consumeGridAutoFlow(CSSParserTokenRange& range)
+{
+    RefPtr<CSSPrimitiveValue> rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range);
+    RefPtr<CSSPrimitiveValue> denseAlgorithm = consumeIdent<CSSValueDense>(range);
+    if (!rowOrColumnValue) {
+        rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range);
+        if (!rowOrColumnValue && !denseAlgorithm)
+            return nullptr;
+    }
+    RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+    if (rowOrColumnValue)
+        parsedValues->append(rowOrColumnValue.releaseNonNull());
+    if (denseAlgorithm)
+        parsedValues->append(denseAlgorithm.releaseNonNull());
+    return parsedValues;
+}
+
+static RefPtr<CSSValue> consumeBackgroundComponent(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    switch (property) {
+    case CSSPropertyBackgroundClip:
+        return consumeBackgroundBox(range);
+    case CSSPropertyBackgroundBlendMode:
+        return consumeBackgroundBlendMode(range);
+    case CSSPropertyBackgroundAttachment:
+        return consumeBackgroundAttachment(range);
+    case CSSPropertyBackgroundOrigin:
+        return consumeBackgroundBox(range);
+    case CSSPropertyWebkitMaskComposite:
+    case CSSPropertyWebkitBackgroundComposite:
+        return consumeBackgroundComposite(range);
+    case CSSPropertyWebkitBackgroundClip:
+    case CSSPropertyWebkitBackgroundOrigin:
+    case CSSPropertyWebkitMaskClip:
+    case CSSPropertyWebkitMaskOrigin:
+        return consumePrefixedBackgroundBox(property, range, context);
+    case CSSPropertyBackgroundImage:
+    case CSSPropertyWebkitMaskImage:
+        return consumeImageOrNone(range, context);
+    case CSSPropertyWebkitMaskSourceType:
+        return consumeWebkitMaskSourceType(range);
+    case CSSPropertyBackgroundPositionX:
+    case CSSPropertyWebkitMaskPositionX:
+        return consumePositionX(range, context.mode);
+    case CSSPropertyBackgroundPositionY:
+    case CSSPropertyWebkitMaskPositionY:
+        return consumePositionY(range, context.mode);
+    case CSSPropertyBackgroundSize:
+    case CSSPropertyWebkitBackgroundSize:
+    case CSSPropertyWebkitMaskSize:
+        return consumeBackgroundSize(property, range, context.mode);
+    case CSSPropertyBackgroundColor:
+        return consumeColor(range, context.mode);
+    default:
+        break;
+    };
+    return nullptr;
+}
+
+static void addBackgroundValue(RefPtr<CSSValue>& list, Ref<CSSValue>&& value)
+{
+    if (list) {
+        if (!list->isBaseValueList()) {
+            RefPtr<CSSValue> firstValue = list;
+            list = CSSValueList::createCommaSeparated();
+            downcast<CSSValueList>(*list).append(firstValue.releaseNonNull());
+        }
+        downcast<CSSValueList>(*list).append(WTFMove(value));
+    } else {
+        // To conserve memory we don't actually wrap a single value in a list.
+        list = WTFMove(value);
+    }
+}
+
+static RefPtr<CSSValue> consumeCommaSeparatedBackgroundComponent(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValue> result;
+    do {
+        RefPtr<CSSValue> value = consumeBackgroundComponent(property, range, context);
+        if (!value)
+            return nullptr;
+        addBackgroundValue(result, value.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    return result;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeSelfPositionKeyword(CSSParserTokenRange& range)
+{
+    CSSValueID id = range.peek().id();
+    if (id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
+        || id == CSSValueSelfStart || id == CSSValueSelfEnd || id == CSSValueFlexStart
+        || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight)
+        return consumeIdent(range);
+    return nullptr;
+}
+
+static RefPtr<CSSValue> consumeSelfPositionOverflowPosition(CSSParserTokenRange& range)
+{
+    if (identMatches<CSSValueAuto, CSSValueNormal, CSSValueStretch, CSSValueBaseline, CSSValueLastBaseline>(range.peek().id()))
+        return consumeIdent(range);
+
+    RefPtr<CSSPrimitiveValue> overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
+    RefPtr<CSSPrimitiveValue> selfPosition = consumeSelfPositionKeyword(range);
+    if (!selfPosition)
+        return nullptr;
+    if (!overflowPosition)
+        overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
+    if (overflowPosition)
+        return createPrimitiveValuePair(selfPosition.releaseNonNull(), overflowPosition.releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce);
+    return selfPosition;
+}
+
+static RefPtr<CSSValue> consumeAlignItems(CSSParserTokenRange& range)
+{
+    // align-items property does not allow the 'auto' value.
+    if (identMatches<CSSValueAuto>(range.peek().id()))
+        return nullptr;
+    return consumeSelfPositionOverflowPosition(range);
+}
+
+static RefPtr<CSSValue> consumeJustifyItems(CSSParserTokenRange& range)
+{
+    CSSParserTokenRange rangeCopy = range;
+    RefPtr<CSSPrimitiveValue> legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
+    RefPtr<CSSPrimitiveValue> positionKeyword = consumeIdent<CSSValueCenter, CSSValueLeft, CSSValueRight>(rangeCopy);
+    if (!legacy)
+        legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
+    if (legacy && positionKeyword) {
+        range = rangeCopy;
+        return createPrimitiveValuePair(legacy.releaseNonNull(), positionKeyword.releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce);
+    }
+    return consumeSelfPositionOverflowPosition(range);
+}
+
+static RefPtr<CSSValue> consumeFitContent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+    RefPtr<CSSPrimitiveValue> length = consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    if (!length || !args.atEnd())
+        return nullptr;
+    range = rangeCopy;
+    RefPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueFitContent);
+    result->append(length.releaseNonNull());
+    return result;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeCustomIdentForGridLine(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto || range.peek().id() == CSSValueSpan)
+        return nullptr;
+    return consumeCustomIdent(range);
+}
+
+static RefPtr<CSSValue> consumeGridLine(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueAuto)
+        return consumeIdent(range);
+
+    RefPtr<CSSPrimitiveValue> spanValue;
+    RefPtr<CSSPrimitiveValue> gridLineName;
+    RefPtr<CSSPrimitiveValue> numericValue = consumeInteger(range);
+    if (numericValue) {
+        gridLineName = consumeCustomIdentForGridLine(range);
+        spanValue = consumeIdent<CSSValueSpan>(range);
+    } else {
+        spanValue = consumeIdent<CSSValueSpan>(range);
+        if (spanValue) {
+            numericValue = consumeInteger(range);
+            gridLineName = consumeCustomIdentForGridLine(range);
+            if (!numericValue)
+                numericValue = consumeInteger(range);
+        } else {
+            gridLineName = consumeCustomIdentForGridLine(range);
+            if (gridLineName) {
+                numericValue = consumeInteger(range);
+                spanValue = consumeIdent<CSSValueSpan>(range);
+                if (!spanValue && !numericValue)
+                    return gridLineName;
+            } else {
+                return nullptr;
+            }
+        }
+    }
+
+    if (spanValue && !numericValue && !gridLineName)
+        return nullptr; // "span" keyword alone is invalid.
+    if (spanValue && numericValue && numericValue->intValue() < 0)
+        return nullptr; // Negative numbers are not allowed for span.
+    if (numericValue && numericValue->intValue() == 0)
+        return nullptr; // An <integer> value of zero makes the declaration invalid.
+
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    if (spanValue)
+        values->append(spanValue.releaseNonNull());
+    if (numericValue)
+        values->append(numericValue.releaseNonNull());
+    if (gridLineName)
+        values->append(gridLineName.releaseNonNull());
+    ASSERT(values->length());
+    return values;
+}
+
+static bool isGridTrackFixedSized(const CSSPrimitiveValue& primitiveValue)
+{
+    CSSValueID valueID = primitiveValue.valueID();
+    if (valueID == CSSValueWebkitMinContent || valueID == CSSValueWebkitMaxContent || valueID == CSSValueAuto || primitiveValue.isFlex())
+        return false;
+
+    return true;
+}
+
+static bool isGridTrackFixedSized(const CSSValue& value)
+{
+    if (value.isPrimitiveValue())
+        return isGridTrackFixedSized(downcast<CSSPrimitiveValue>(value));
+
+    ASSERT(value.isFunctionValue());
+    auto& function = downcast<CSSFunctionValue>(value);
+    if (function.name() == CSSValueFitContent || function.length() < 2)
+        return false;
+
+    const CSSValue* minPrimitiveValue = downcast<CSSPrimitiveValue>(function.item(0));
+    const CSSValue* maxPrimitiveValue = downcast<CSSPrimitiveValue>(function.item(1));
+    return isGridTrackFixedSized(*minPrimitiveValue) || isGridTrackFixedSized(*maxPrimitiveValue);
+}
+
+static Vector<String> parseGridTemplateAreasColumnNames(const String& gridRowNames)
+{
+    ASSERT(!gridRowNames.isEmpty());
+    Vector<String> columnNames;
+    // Using StringImpl to avoid checks and indirection in every call to String::operator[].
+    StringImpl& text = *gridRowNames.impl();
+
+    StringBuilder areaName;
+    for (unsigned i = 0; i < text.length(); ++i) {
+        if (isCSSSpace(text[i])) {
+            if (!areaName.isEmpty()) {
+                columnNames.append(areaName.toString());
+                areaName.clear();
+            }
+            continue;
+        }
+        if (text[i] == '.') {
+            if (areaName == ".")
+                continue;
+            if (!areaName.isEmpty()) {
+                columnNames.append(areaName.toString());
+                areaName.clear();
+            }
+        } else {
+            if (!isNameCodePoint(text[i]))
+                return Vector<String>();
+            if (areaName == ".") {
+                columnNames.append(areaName.toString());
+                areaName.clear();
+            }
+        }
+
+        areaName.append(text[i]);
+    }
+
+    if (!areaName.isEmpty())
+        columnNames.append(areaName.toString());
+
+    return columnNames;
+}
+
+static bool parseGridTemplateAreasRow(const String& gridRowNames, NamedGridAreaMap& gridAreaMap, const size_t rowCount, size_t& columnCount)
+{
+    if (gridRowNames.isEmpty() || gridRowNames.containsOnlyWhitespace())
+        return false;
+
+    Vector<String> columnNames = parseGridTemplateAreasColumnNames(gridRowNames);
+    if (rowCount == 0) {
+        columnCount = columnNames.size();
+        if (columnCount == 0)
+            return false;
+    } else if (columnCount != columnNames.size()) {
+        // The declaration is invalid if all the rows don't have the number of columns.
+        return false;
+    }
+
+    for (size_t currentColumn = 0; currentColumn < columnCount; ++currentColumn) {
+        const String& gridAreaName = columnNames[currentColumn];
+
+        // Unamed areas are always valid (we consider them to be 1x1).
+        if (gridAreaName == ".")
+            continue;
+
+        size_t lookAheadColumn = currentColumn + 1;
+        while (lookAheadColumn < columnCount && columnNames[lookAheadColumn] == gridAreaName)
+            lookAheadColumn++;
+
+        NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName);
+        if (gridAreaIt == gridAreaMap.end()) {
+            gridAreaMap.add(gridAreaName, GridArea(GridSpan::translatedDefiniteGridSpan(rowCount, rowCount + 1), GridSpan::translatedDefiniteGridSpan(currentColumn, lookAheadColumn)));
+        } else {
+            GridArea& gridArea = gridAreaIt->value;
+
+            // The following checks test that the grid area is a single filled-in rectangle.
+            // 1. The new row is adjacent to the previously parsed row.
+            if (rowCount != gridArea.rows.endLine())
+                return false;
+
+            // 2. The new area starts at the same position as the previously parsed area.
+            if (currentColumn != gridArea.columns.startLine())
+                return false;
+
+            // 3. The new area ends at the same position as the previously parsed area.
+            if (lookAheadColumn != gridArea.columns.endLine())
+                return false;
+
+            gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
+        }
+        currentColumn = lookAheadColumn - 1;
+    }
+
+    return true;
+}
+
+static RefPtr<CSSPrimitiveValue> consumeGridBreadth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    const CSSParserToken& token = range.peek();
+    if (identMatches<CSSValueWebkitMinContent, CSSValueWebkitMaxContent, CSSValueAuto>(token.id()))
+        return consumeIdent(range);
+    if (token.type() == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::CSS_FR) {
+        if (range.peek().numericValue() < 0)
+            return nullptr;
+        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_FR);
+    }
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeGridTrackSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    const CSSParserToken& token = range.peek();
+    if (identMatches<CSSValueAuto>(token.id()))
+        return consumeIdent(range);
+
+    if (token.functionId() == CSSValueMinmax) {
+        CSSParserTokenRange rangeCopy = range;
+        CSSParserTokenRange args = consumeFunction(rangeCopy);
+        RefPtr<CSSPrimitiveValue> minTrackBreadth = consumeGridBreadth(args, cssParserMode);
+        if (!minTrackBreadth || minTrackBreadth->isFlex() || !consumeCommaIncludingWhitespace(args))
+            return nullptr;
+        RefPtr<CSSPrimitiveValue> maxTrackBreadth = consumeGridBreadth(args, cssParserMode);
+        if (!maxTrackBreadth || !args.atEnd())
+            return nullptr;
+        range = rangeCopy;
+        RefPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueMinmax);
+        result->append(minTrackBreadth.releaseNonNull());
+        result->append(maxTrackBreadth.releaseNonNull());
+        return result;
+    }
+
+    if (token.functionId() == CSSValueFitContent)
+        return consumeFitContent(range, cssParserMode);
+
+    return consumeGridBreadth(range, cssParserMode);
+}
+
+// Appends to the passed in CSSGridLineNamesValue if any, otherwise creates a new one.
+static RefPtr<CSSGridLineNamesValue> consumeGridLineNames(CSSParserTokenRange& range, CSSGridLineNamesValue* lineNames = nullptr)
+{
+    CSSParserTokenRange rangeCopy = range;
+    if (rangeCopy.consumeIncludingWhitespace().type() != LeftBracketToken)
+        return nullptr;
+    
+    RefPtr<CSSGridLineNamesValue> result = lineNames;
+    if (!result)
+        result = CSSGridLineNamesValue::create();
+    while (RefPtr<CSSPrimitiveValue> lineName = consumeCustomIdentForGridLine(rangeCopy))
+        result->append(lineName.releaseNonNull());
+    if (rangeCopy.consumeIncludingWhitespace().type() != RightBracketToken)
+        return nullptr;
+    range = rangeCopy;
+    return result;
+}
+
+static bool consumeGridTrackRepeatFunction(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSValueList& list, bool& isAutoRepeat, bool& allTracksAreFixedSized)
+{
+    CSSParserTokenRange args = consumeFunction(range);
+    // The number of repetitions for <auto-repeat> is not important at parsing level
+    // because it will be computed later, let's set it to 1.
+    size_t repetitions = 1;
+    isAutoRepeat = identMatches<CSSValueAutoFill, CSSValueAutoFit>(args.peek().id());
+    RefPtr<CSSValueList> repeatedValues;
+    if (isAutoRepeat)
+        repeatedValues = CSSGridAutoRepeatValue::create(args.consumeIncludingWhitespace().id());
+    else {
+        // FIXME: a consumeIntegerRaw would be more efficient here.
+        RefPtr<CSSPrimitiveValue> repetition = consumePositiveInteger(args);
+        if (!repetition)
+            return false;
+        repetitions = clampTo<size_t>(repetition->doubleValue(), 0, kGridMaxTracks);
+        repeatedValues = CSSValueList::createSpaceSeparated();
+    }
+    if (!consumeCommaIncludingWhitespace(args))
+        return false;
+    RefPtr<CSSGridLineNamesValue> lineNames = consumeGridLineNames(args);
+    if (lineNames)
+        repeatedValues->append(lineNames.releaseNonNull());
+
+    size_t numberOfTracks = 0;
+    while (!args.atEnd()) {
+        RefPtr<CSSValue> trackSize = consumeGridTrackSize(args, cssParserMode);
+        if (!trackSize)
+            return false;
+        if (allTracksAreFixedSized)
+            allTracksAreFixedSized = isGridTrackFixedSized(*trackSize);
+        repeatedValues->append(trackSize.releaseNonNull());
+        ++numberOfTracks;
+        lineNames = consumeGridLineNames(args);
+        if (lineNames)
+            repeatedValues->append(lineNames.releaseNonNull());
+    }
+    // We should have found at least one <track-size> or else it is not a valid <track-list>.
+    if (!numberOfTracks)
+        return false;
+
+    if (isAutoRepeat)
+        list.append(repeatedValues.releaseNonNull());
+    else {
+        // We clamp the repetitions to a multiple of the repeat() track list's size, while staying below the max grid size.
+        repetitions = std::min(repetitions, kGridMaxTracks / numberOfTracks);
+        for (size_t i = 0; i < repetitions; ++i) {
+            for (size_t j = 0; j < repeatedValues->length(); ++j)
+                list.append(*repeatedValues->itemWithoutBoundsCheck(j));
+        }
+    }
+    return true;
+}
+
+enum TrackListType { GridTemplate, GridTemplateNoRepeat, GridAuto };
+
+static RefPtr<CSSValue> consumeGridTrackList(CSSParserTokenRange& range, CSSParserMode cssParserMode, TrackListType trackListType)
+{
+    bool allowGridLineNames = trackListType != GridAuto;
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSGridLineNamesValue> lineNames = consumeGridLineNames(range);
+    if (lineNames) {
+        if (!allowGridLineNames)
+            return nullptr;
+        values->append(lineNames.releaseNonNull());
+    }
+    
+    bool allowRepeat = trackListType == GridTemplate;
+    bool seenAutoRepeat = false;
+    bool allTracksAreFixedSized = true;
+    do {
+        bool isAutoRepeat;
+        if (range.peek().functionId() == CSSValueRepeat) {
+            if (!allowRepeat)
+                return nullptr;
+            if (!consumeGridTrackRepeatFunction(range, cssParserMode, *values, isAutoRepeat, allTracksAreFixedSized))
+                return nullptr;
+            if (isAutoRepeat && seenAutoRepeat)
+                return nullptr;
+            seenAutoRepeat = seenAutoRepeat || isAutoRepeat;
+        } else if (RefPtr<CSSValue> value = consumeGridTrackSize(range, cssParserMode)) {
+            if (allTracksAreFixedSized)
+                allTracksAreFixedSized = isGridTrackFixedSized(*value);
+            values->append(value.releaseNonNull());
+        } else {
+            return nullptr;
+        }
+        if (seenAutoRepeat && !allTracksAreFixedSized)
+            return nullptr;
+        lineNames = consumeGridLineNames(range);
+        if (lineNames) {
+            if (!allowGridLineNames)
+                return nullptr;
+            values->append(lineNames.releaseNonNull());
+        }
+    } while (!range.atEnd() && range.peek().type() != DelimiterToken);
+    return values;
+}
+
+static RefPtr<CSSValue> consumeGridTemplatesRowsOrColumns(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    return consumeGridTrackList(range, cssParserMode, GridTemplate);
+}
+
+static RefPtr<CSSValue> consumeGridTemplateAreas(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    NamedGridAreaMap gridAreaMap;
+    size_t rowCount = 0;
+    size_t columnCount = 0;
+
+    while (range.peek().type() == StringToken) {
+        if (!parseGridTemplateAreasRow(range.consumeIncludingWhitespace().value().toString(), gridAreaMap, rowCount, columnCount))
+            return nullptr;
+        ++rowCount;
+    }
+
+    if (rowCount == 0)
+        return nullptr;
+    ASSERT(columnCount);
+    return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
+}
+
+#if ENABLE(CSS_REGIONS)
+static RefPtr<CSSValue> consumeFlowProperty(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValue> result;
+    if (range.peek().id() == CSSValueNone)
+        result = consumeIdent(range);
+    else
+        result = consumeCustomIdent(range);
+    return result;
+}
+#endif
+
+static RefPtr<CSSValue> consumeLineBoxContain(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    LineBoxContain lineBoxContain = LineBoxContainNone;
+    
+    while (range.peek().type() == IdentToken) {
+        auto id = range.peek().id();
+        if (id == CSSValueBlock) {
+            if (lineBoxContain & LineBoxContainBlock)
+                return nullptr;
+            lineBoxContain |= LineBoxContainBlock;
+        } else if (id == CSSValueInline) {
+            if (lineBoxContain & LineBoxContainInline)
+                return nullptr;
+            lineBoxContain |= LineBoxContainInline;
+        } else if (id == CSSValueFont) {
+            if (lineBoxContain & LineBoxContainFont)
+                return nullptr;
+            lineBoxContain |= LineBoxContainFont;
+        } else if (id == CSSValueGlyphs) {
+            if (lineBoxContain & LineBoxContainGlyphs)
+                return nullptr;
+            lineBoxContain |= LineBoxContainGlyphs;
+        } else if (id == CSSValueReplaced) {
+            if (lineBoxContain & LineBoxContainReplaced)
+                return nullptr;
+            lineBoxContain |= LineBoxContainReplaced;
+        } else if (id == CSSValueInlineBox) {
+            if (lineBoxContain & LineBoxContainInlineBox)
+                return nullptr;
+            lineBoxContain |= LineBoxContainInlineBox;
+        } else if (id == CSSValueInitialLetter) {
+            if (lineBoxContain & LineBoxContainInitialLetter)
+                return nullptr;
+            lineBoxContain |= LineBoxContainInitialLetter;
+        } else
+            return nullptr;
+        range.consumeIncludingWhitespace();
+    }
+    
+    if (!lineBoxContain)
+        return nullptr;
+    
+    return CSSLineBoxContainValue::create(lineBoxContain);
+}
+
+static RefPtr<CSSValue> consumeLineGrid(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    return consumeCustomIdent(range);
+}
+
+static RefPtr<CSSValue> consumeInitialLetter(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValue> ident = consumeIdent<CSSValueNormal>(range);
+    if (ident)
+        return ident;
+    
+    RefPtr<CSSPrimitiveValue> height = consumeNumber(range, ValueRangeNonNegative);
+    if (!height)
+        return nullptr;
+    
+    RefPtr<CSSPrimitiveValue> position;
+    if (!range.atEnd()) {
+        position = consumeNumber(range, ValueRangeNonNegative);
+        if (!position || !range.atEnd())
+            return nullptr;
+    } else
+        position = height.copyRef();
+    
+    return createPrimitiveValuePair(position.releaseNonNull(), WTFMove(height));
+}
+
+static RefPtr<CSSValue> consumeHangingPunctuation(CSSParserTokenRange& range)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    std::bitset<numCSSValueKeywords> seenValues;
+
+    bool seenForceEnd = false;
+    bool seenAllowEnd = false;
+    bool seenFirst = false;
+    bool seenLast = false;
+
+    while (!range.atEnd()) {
+        CSSValueID valueID = range.peek().id();
+        if ((valueID == CSSValueFirst && seenFirst)
+            || (valueID == CSSValueLast && seenLast)
+            || (valueID == CSSValueAllowEnd && (seenAllowEnd || seenForceEnd))
+            || (valueID == CSSValueForceEnd && (seenAllowEnd || seenForceEnd)))
+            return nullptr;
+        RefPtr<CSSValue> ident = consumeIdent<CSSValueAllowEnd, CSSValueForceEnd, CSSValueFirst, CSSValueLast>(range);
+        if (!ident)
+            return nullptr;
+        switch (valueID) {
+        case CSSValueAllowEnd:
+            seenAllowEnd = true;
+            break;
+        case CSSValueForceEnd:
+            seenForceEnd = true;
+            break;
+        case CSSValueFirst:
+            seenFirst = true;
+            break;
+        case CSSValueLast:
+            seenLast = true;
+            break;
+        default:
+            break;
+        }
+        list->append(ident.releaseNonNull());
+    }
+    
+    return list->length() ? list : nullptr;
+}
+
+static RefPtr<CSSValue> consumeWebkitMarqueeIncrement(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().type() == IdentToken)
+        return consumeIdent<CSSValueSmall, CSSValueMedium, CSSValueLarge>(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeWebkitMarqueeRepetition(CSSParserTokenRange& range)
+{
+    if (range.peek().type() == IdentToken)
+        return consumeIdent<CSSValueInfinite>(range);
+    return consumeNumber(range, ValueRangeNonNegative);
+}
+
+static RefPtr<CSSValue> consumeWebkitMarqueeSpeed(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+{
+    if (range.peek().type() == IdentToken)
+        return consumeIdent<CSSValueSlow, CSSValueNormal, CSSValueFast>(range);
+    return consumeTime(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+}
+
+static RefPtr<CSSValue> consumeAlt(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (range.peek().type() == StringToken)
+        return consumeString(range);
+    
+    if (range.peek().functionId() != CSSValueAttr)
+        return nullptr;
+    
+    return consumeAttr(consumeFunction(range), context);
+}
+
+static RefPtr<CSSValue> consumeWebkitAspectRatio(CSSParserTokenRange& range)
+{
+    if (range.peek().type() == IdentToken)
+        return consumeIdent<CSSValueAuto, CSSValueFromDimensions, CSSValueFromIntrinsic>(range);
+    
+    RefPtr<CSSPrimitiveValue> leftValue = consumeNumber(range, ValueRangeNonNegative);
+    if (!leftValue || !leftValue->floatValue() || range.atEnd() || !consumeSlashIncludingWhitespace(range))
+        return nullptr;
+    RefPtr<CSSPrimitiveValue> rightValue = consumeNumber(range, ValueRangeNonNegative);
+    if (!rightValue || !rightValue->floatValue())
+        return nullptr;
+    
+    return CSSAspectRatioValue::create(leftValue->floatValue(), rightValue->floatValue());
+}
+
+static RefPtr<CSSValue> consumeTextEmphasisPosition(CSSParserTokenRange& range)
+{
+    bool foundOverOrUnder = false;
+    CSSValueID overUnderValueID = CSSValueOver;
+    bool foundLeftOrRight = false;
+    CSSValueID leftRightValueID = CSSValueRight;
+    while (!range.atEnd()) {
+        switch (range.peek().id()) {
+        case CSSValueOver:
+            if (foundOverOrUnder)
+                return nullptr;
+            foundOverOrUnder = true;
+            overUnderValueID = CSSValueOver;
+            break;
+        case CSSValueUnder:
+            if (foundOverOrUnder)
+                return nullptr;
+            foundOverOrUnder = true;
+            overUnderValueID = CSSValueUnder;
+            break;
+        case CSSValueLeft:
+            if (foundLeftOrRight)
+                return nullptr;
+            foundLeftOrRight = true;
+            leftRightValueID = CSSValueLeft;
+            break;
+        case CSSValueRight:
+            if (foundLeftOrRight)
+                return nullptr;
+            foundLeftOrRight = true;
+            leftRightValueID = CSSValueRight;
+            break;
+        default:
+            return nullptr;
+        }
+        
+        range.consumeIncludingWhitespace();
+    }
+    if (!foundOverOrUnder)
+        return nullptr;
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    list->append(CSSValuePool::singleton().createIdentifierValue(overUnderValueID));
+    if (foundLeftOrRight)
+        list->append(CSSValuePool::singleton().createIdentifierValue(leftRightValueID));
+    return list;
+}
+    
+#if ENABLE(DASHBOARD_SUPPORT)
+
+static RefPtr<CSSValue> consumeWebkitDashboardRegion(CSSParserTokenRange& range, CSSParserMode mode)
+{
+    if (range.atEnd())
+        return nullptr;
+    
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    
+    auto firstRegion = DashboardRegion::create();
+    DashboardRegion* region = nullptr;
+    
+    bool requireCommas = false;
+    
+    while (!range.atEnd()) {
+        if (!region)
+            region = firstRegion.ptr();
+        else {
+            auto nextRegion = DashboardRegion::create();
+            region->m_next = nextRegion.copyRef();
+            region = nextRegion.ptr();
+        }
+        
+        if (range.peek().functionId() != CSSValueDashboardRegion)
+            return nullptr;
+        
+        CSSParserTokenRange rangeCopy = range;
+        CSSParserTokenRange args = consumeFunction(rangeCopy);
+        if (rangeCopy.end() == args.end())
+            return nullptr; // No ) was found. Be strict about this, since tests are.
+
+        // First arg is a label.
+        if (args.peek().type() != IdentToken)
+            return nullptr;
+        region->m_label = args.consumeIncludingWhitespace().value().toString();
+        
+        // Comma is optional, so don't fail if we can't consume one.
+        requireCommas = consumeCommaIncludingWhitespace(args);
+
+        // Second arg is a type.
+        if (args.peek().type() != IdentToken)
+            return nullptr;
+        region->m_geometryType = args.consumeIncludingWhitespace().value().toString();
+        if (equalLettersIgnoringASCIICase(region->m_geometryType, "circle"))
+            region->m_isCircle = true;
+        else if (equalLettersIgnoringASCIICase(region->m_geometryType, "rectangle"))
+            region->m_isRectangle = true;
+        else
+            return nullptr;
+        
+        if (args.atEnd()) {
+            // This originally used CSSValueInvalid by accident. It might be more logical to use something else.
+            RefPtr<CSSPrimitiveValue> amount = CSSValuePool::singleton().createIdentifierValue(CSSValueInvalid);
+            region->setTop(amount.copyRef());
+            region->setRight(amount.copyRef());
+            region->setBottom(amount.copyRef());
+            region->setLeft(WTFMove(amount));
+            range = rangeCopy;
+            continue;
+        }
+        
+        // Next four arguments must be offset numbers or auto.
+        for (int i = 0; i < 4; ++i) {
+            if (args.atEnd() || (requireCommas && !consumeCommaIncludingWhitespace(args)))
+                return nullptr;
+
+            if (args.atEnd())
+                return nullptr;
+            
+            RefPtr<CSSPrimitiveValue> amount;
+            if (args.peek().id() == CSSValueAuto)
+                amount = consumeIdent(args);
+            else
+                amount = consumeLength(args, mode, ValueRangeAll);
+        
+            if (!i)
+                region->setTop(WTFMove(amount));
+            else if (i == 1)
+                region->setRight(WTFMove(amount));
+            else if (i == 2)
+                region->setBottom(WTFMove(amount));
+            else
+                region->setLeft(WTFMove(amount));
+        }
+        
+        if (!args.atEnd())
+            return nullptr;
+        
+        range = rangeCopy;
+    }
+    
+    return CSSValuePool::singleton().createValue(RefPtr<DashboardRegion>(WTFMove(firstRegion)));
+}
+    
+#endif
+
+RefPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID property, CSSPropertyID currentShorthand)
+{
+    if (CSSParserFastPaths::isKeywordPropertyID(property)) {
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(property, m_range.peek().id(), m_context.mode))
+            return nullptr;
+        return consumeIdent(m_range);
+    }
+    switch (property) {
+    case CSSPropertyWillChange:
+        return consumeWillChange(m_range);
+    case CSSPropertyPage:
+        return consumePage(m_range);
+    case CSSPropertyQuotes:
+        return consumeQuotes(m_range);
+    case CSSPropertyFontVariantCaps:
+        return consumeFontVariantCaps(m_range);
+    case CSSPropertyFontVariantLigatures:
+        return consumeFontVariantLigatures(m_range);
+    case CSSPropertyFontVariantNumeric:
+        return consumeFontVariantNumeric(m_range);
+    case CSSPropertyFontVariantEastAsian:
+        return consumeFontVariantEastAsian(m_range);
+    case CSSPropertyFontFeatureSettings:
+        return consumeFontFeatureSettings(m_range);
+    case CSSPropertyFontFamily:
+        return consumeFontFamily(m_range);
+    case CSSPropertyFontWeight:
+        return consumeFontWeight(m_range);
+    case CSSPropertyFontSynthesis:
+        return consumeFontSynthesis(m_range);
+#if ENABLE(VARIATION_FONTS)
+    case CSSPropertyFontVariationSettings:
+        return consumeFontVariationSettings(m_range);
+#endif
+    case CSSPropertyLetterSpacing:
+        return consumeLetterSpacing(m_range, m_context.mode);
+    case CSSPropertyWordSpacing:
+        return consumeWordSpacing(m_range, m_context.mode);
+    case CSSPropertyTabSize:
+        return consumeTabSize(m_range, m_context.mode);
+#if ENABLE(TEXT_AUTOSIZING)
+    case CSSPropertyWebkitTextSizeAdjust:
+        // FIXME: Support toggling the validation of this property via a runtime setting that is independent of
+        // whether isTextAutosizingEnabled() is true. We want to enable this property on iOS, when simulating
+        // a iOS device in Safari's responsive design mode and when optionally enabled in DRT/WTR. Otherwise,
+        // this property should be disabled by default.
+#if !PLATFORM(IOS)
+        if (!m_context.textAutosizingEnabled)
+            return nullptr;
+#endif
+        return consumeTextSizeAdjust(m_range, m_context.mode);
+#endif
+    case CSSPropertyFontSize:
+        return consumeFontSize(m_range, m_context.mode, UnitlessQuirk::Allow);
+    case CSSPropertyLineHeight:
+        return consumeLineHeight(m_range, m_context.mode);
+    case CSSPropertyWebkitBorderHorizontalSpacing:
+    case CSSPropertyWebkitBorderVerticalSpacing:
+        return consumeLength(m_range, m_context.mode, ValueRangeNonNegative);
+    case CSSPropertyCounterIncrement:
+    case CSSPropertyCounterReset:
+        return consumeCounter(m_range, property == CSSPropertyCounterIncrement ? 1 : 0);
+    case CSSPropertySize:
+        return consumeSize(m_range, m_context.mode);
+    case CSSPropertyTextIndent:
+        return consumeTextIndent(m_range, m_context.mode);
+    case CSSPropertyMaxWidth:
+    case CSSPropertyMaxHeight:
+        return consumeMaxWidthOrHeight(m_range, m_context, UnitlessQuirk::Allow);
+    case CSSPropertyWebkitMaxLogicalWidth:
+    case CSSPropertyWebkitMaxLogicalHeight:
+        return consumeMaxWidthOrHeight(m_range, m_context);
+    case CSSPropertyMinWidth:
+    case CSSPropertyMinHeight:
+    case CSSPropertyWidth:
+    case CSSPropertyHeight:
+        return consumeWidthOrHeight(m_range, m_context, UnitlessQuirk::Allow);
+    case CSSPropertyWebkitMinLogicalWidth:
+    case CSSPropertyWebkitMinLogicalHeight:
+    case CSSPropertyWebkitLogicalWidth:
+    case CSSPropertyWebkitLogicalHeight:
+        return consumeWidthOrHeight(m_range, m_context);
+    case CSSPropertyMarginTop:
+    case CSSPropertyMarginRight:
+    case CSSPropertyMarginBottom:
+    case CSSPropertyMarginLeft:
+    case CSSPropertyBottom:
+    case CSSPropertyLeft:
+    case CSSPropertyRight:
+    case CSSPropertyTop:
+        return consumeMarginOrOffset(m_range, m_context.mode, UnitlessQuirk::Allow);
+    case CSSPropertyWebkitMarginStart:
+    case CSSPropertyWebkitMarginEnd:
+    case CSSPropertyWebkitMarginBefore:
+    case CSSPropertyWebkitMarginAfter:
+        return consumeMarginOrOffset(m_range, m_context.mode, UnitlessQuirk::Forbid);
+    case CSSPropertyPaddingTop:
+    case CSSPropertyPaddingRight:
+    case CSSPropertyPaddingBottom:
+    case CSSPropertyPaddingLeft:
+        return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    case CSSPropertyWebkitPaddingStart:
+    case CSSPropertyWebkitPaddingEnd:
+    case CSSPropertyWebkitPaddingBefore:
+    case CSSPropertyWebkitPaddingAfter:
+        return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
+#if ENABLE(CSS_SCROLL_SNAP)
+    case CSSPropertyScrollSnapMarginBottom:
+    case CSSPropertyScrollSnapMarginLeft:
+    case CSSPropertyScrollSnapMarginRight:
+    case CSSPropertyScrollSnapMarginTop:
+        return consumeLength(m_range, m_context.mode, ValueRangeAll);
+    case CSSPropertyScrollPaddingBottom:
+    case CSSPropertyScrollPaddingLeft:
+    case CSSPropertyScrollPaddingRight:
+    case CSSPropertyScrollPaddingTop:
+        return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeAll);
+    case CSSPropertyScrollSnapAlign:
+        return consumeScrollSnapAlign(m_range);
+    case CSSPropertyScrollSnapType:
+        return consumeScrollSnapType(m_range);
+#endif
+    case CSSPropertyClip:
+        return consumeClip(m_range, m_context.mode);
+#if ENABLE(TOUCH_EVENTS)
+    case CSSPropertyTouchAction:
+        return consumeTouchAction(m_range);
+#endif
+    case CSSPropertyObjectPosition:
+        return consumePosition(m_range, m_context.mode, UnitlessQuirk::Forbid);
+    case CSSPropertyWebkitLineClamp:
+        return consumeLineClamp(m_range);
+    case CSSPropertyWebkitFontSizeDelta:
+        return consumeLength(m_range, m_context.mode, ValueRangeAll, UnitlessQuirk::Allow);
+    case CSSPropertyWebkitHyphenateCharacter:
+    case CSSPropertyWebkitLocale:
+        return consumeLocale(m_range);
+    case CSSPropertyWebkitHyphenateLimitBefore:
+    case CSSPropertyWebkitHyphenateLimitAfter:
+        return consumeHyphenateLimit(m_range, CSSValueAuto);
+    case CSSPropertyWebkitHyphenateLimitLines:
+        return consumeHyphenateLimit(m_range, CSSValueNoLimit);
+    case CSSPropertyColumnWidth:
+        return consumeColumnWidth(m_range);
+    case CSSPropertyColumnCount:
+        return consumeColumnCount(m_range);
+    case CSSPropertyColumnGap:
+        return consumeColumnGap(m_range, m_context.mode);
+    case CSSPropertyColumnSpan:
+        return consumeColumnSpan(m_range);
+    case CSSPropertyZoom:
+        return consumeZoom(m_range, m_context);
+    case CSSPropertyAnimationDelay:
+    case CSSPropertyTransitionDelay:
+    case CSSPropertyAnimationDirection:
+    case CSSPropertyAnimationDuration:
+    case CSSPropertyTransitionDuration:
+    case CSSPropertyAnimationFillMode:
+    case CSSPropertyAnimationIterationCount:
+    case CSSPropertyAnimationName:
+    case CSSPropertyAnimationPlayState:
+    case CSSPropertyTransitionProperty:
+    case CSSPropertyAnimationTimingFunction:
+    case CSSPropertyTransitionTimingFunction:
+#if ENABLE(CSS_ANIMATIONS_LEVEL_2)
+    case CSSPropertyWebkitAnimationTrigger:
+#endif
+        return consumeAnimationPropertyList(property, m_range, m_context);
+    case CSSPropertyGridColumnGap:
+    case CSSPropertyGridRowGap:
+        return consumeLength(m_range, m_context.mode, ValueRangeNonNegative);
+    case CSSPropertyShapeMargin:
+        return consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative);
+    case CSSPropertyShapeImageThreshold:
+        return consumeNumber(m_range, ValueRangeAll);
+    case CSSPropertyWebkitBoxOrdinalGroup:
+    case CSSPropertyOrphans:
+    case CSSPropertyWidows:
+        return consumePositiveInteger(m_range);
+    case CSSPropertyWebkitTextDecorationColor:
+        return consumeColor(m_range, m_context.mode);
+    case CSSPropertyWebkitTextDecorationSkip:
+        return consumeTextDecorationSkip(m_range);
+    case CSSPropertyWebkitTextStrokeWidth:
+        return consumeTextStrokeWidth(m_range, m_context.mode);
+    case CSSPropertyWebkitTextFillColor:
+#if ENABLE(TOUCH_EVENTS)
+    case CSSPropertyWebkitTapHighlightColor:
+#endif
+    case CSSPropertyWebkitTextEmphasisColor:
+    case CSSPropertyWebkitBorderStartColor:
+    case CSSPropertyWebkitBorderEndColor:
+    case CSSPropertyWebkitBorderBeforeColor:
+    case CSSPropertyWebkitBorderAfterColor:
+    case CSSPropertyWebkitTextStrokeColor:
+    case CSSPropertyStopColor:
+    case CSSPropertyFloodColor:
+    case CSSPropertyLightingColor:
+    case CSSPropertyColumnRuleColor:
+        return consumeColor(m_range, m_context.mode);
+    case CSSPropertyColor:
+    case CSSPropertyBackgroundColor:
+        return consumeColor(m_range, m_context.mode, inQuirksMode());
+    case CSSPropertyWebkitBorderStartWidth:
+    case CSSPropertyWebkitBorderEndWidth:
+    case CSSPropertyWebkitBorderBeforeWidth:
+    case CSSPropertyWebkitBorderAfterWidth:
+        return consumeBorderWidth(m_range, m_context.mode, UnitlessQuirk::Forbid);
+    case CSSPropertyBorderBottomColor:
+    case CSSPropertyBorderLeftColor:
+    case CSSPropertyBorderRightColor:
+    case CSSPropertyBorderTopColor: {
+        bool allowQuirkyColors = inQuirksMode()
+            && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderColor);
+        return consumeColor(m_range, m_context.mode, allowQuirkyColors);
+    }
+    case CSSPropertyBorderBottomWidth:
+    case CSSPropertyBorderLeftWidth:
+    case CSSPropertyBorderRightWidth:
+    case CSSPropertyBorderTopWidth: {
+        bool allowQuirkyLengths = inQuirksMode()
+            && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderWidth);
+        UnitlessQuirk unitless = allowQuirkyLengths ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
+        return consumeBorderWidth(m_range, m_context.mode, unitless);
+    }
+    case CSSPropertyZIndex:
+        return consumeZIndex(m_range);
+    case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
+    case CSSPropertyBoxShadow:
+    case CSSPropertyWebkitBoxShadow:
+    case CSSPropertyWebkitSvgShadow:
+        return consumeShadow(m_range, m_context.mode, property == CSSPropertyBoxShadow || property == CSSPropertyWebkitBoxShadow);
+    case CSSPropertyFilter:
+#if ENABLE(FILTERS_LEVEL_2)
+    case CSSPropertyWebkitBackdropFilter:
+#endif
+        return consumeFilter(m_range, m_context);
+    case CSSPropertyTextDecoration:
+    case CSSPropertyWebkitTextDecorationsInEffect:
+    case CSSPropertyWebkitTextDecorationLine:
+        return consumeTextDecorationLine(m_range);
+    case CSSPropertyWebkitTextEmphasisStyle:
+        return consumeTextEmphasisStyle(m_range);
+    case CSSPropertyOutlineColor:
+        return consumeOutlineColor(m_range, m_context.mode);
+    case CSSPropertyOutlineOffset:
+        return consumeLength(m_range, m_context.mode, ValueRangeAll);
+    case CSSPropertyOutlineWidth:
+        return consumeLineWidth(m_range, m_context.mode, UnitlessQuirk::Forbid);
+    case CSSPropertyTransform:
+        return consumeTransform(m_range, m_context.mode);
+    case CSSPropertyTransformOriginX:
+    case CSSPropertyPerspectiveOriginX:
+        return consumePositionX(m_range, m_context.mode);
+    case CSSPropertyTransformOriginY:
+    case CSSPropertyPerspectiveOriginY:
+        return consumePositionY(m_range, m_context.mode);
+    case CSSPropertyTransformOriginZ:
+        return consumeLength(m_range, m_context.mode, ValueRangeAll);
+    case CSSPropertyFill:
+    case CSSPropertyStroke:
+        return consumePaintStroke(m_range, m_context.mode);
+    case CSSPropertyGlyphOrientationVertical:
+    case CSSPropertyGlyphOrientationHorizontal:
+        return consumeGlyphOrientation(m_range, m_context.mode, property);
+    case CSSPropertyPaintOrder:
+        return consumePaintOrder(m_range);
+    case CSSPropertyMarkerStart:
+    case CSSPropertyMarkerMid:
+    case CSSPropertyMarkerEnd:
+    case CSSPropertyClipPath:
+    case CSSPropertyMask:
+        return consumeNoneOrURI(m_range);
+    case CSSPropertyFlexBasis:
+        return consumeFlexBasis(m_range, m_context.mode);
+    case CSSPropertyFlexGrow:
+    case CSSPropertyFlexShrink:
+        return consumeNumber(m_range, ValueRangeNonNegative);
+    case CSSPropertyStrokeDasharray:
+        return consumeStrokeDasharray(m_range);
+    case CSSPropertyColumnRuleWidth:
+        return consumeColumnRuleWidth(m_range, m_context.mode);
+    case CSSPropertyStrokeOpacity:
+    case CSSPropertyFillOpacity:
+    case CSSPropertyStopOpacity:
+    case CSSPropertyFloodOpacity:
+    case CSSPropertyOpacity:
+    case CSSPropertyWebkitBoxFlex:
+        return consumeNumber(m_range, ValueRangeAll);
+    case CSSPropertyBaselineShift:
+        return consumeBaselineShift(m_range);
+    case CSSPropertyKerning:
+        return consumeKerning(m_range, m_context.mode);
+    case CSSPropertyStrokeMiterlimit:
+        return consumeNumber(m_range, ValueRangeNonNegative);
+    case CSSPropertyStrokeWidth:
+    case CSSPropertyStrokeDashoffset:
+    case CSSPropertyCx:
+    case CSSPropertyCy:
+    case CSSPropertyX:
+    case CSSPropertyY:
+    case CSSPropertyR:
+        return consumeLengthOrPercent(m_range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
+    case CSSPropertyRx:
+    case CSSPropertyRy:
+        return consumeRxOrRy(m_range);
+    case CSSPropertyCursor:
+        return consumeCursor(m_range, m_context, inQuirksMode());
+    case CSSPropertyContent:
+        return consumeContent(m_range, m_context);
+    case CSSPropertyListStyleImage:
+    case CSSPropertyBorderImageSource:
+    case CSSPropertyWebkitMaskBoxImageSource:
+        return consumeImageOrNone(m_range, m_context);
+    case CSSPropertyPerspective:
+        return consumePerspective(m_range, m_context.mode);
+    case CSSPropertyBorderTopRightRadius:
+    case CSSPropertyBorderTopLeftRadius:
+    case CSSPropertyBorderBottomLeftRadius:
+    case CSSPropertyBorderBottomRightRadius:
+        return consumeBorderRadiusCorner(m_range, m_context.mode);
+    case CSSPropertyWebkitBoxFlexGroup:
+        return consumeInteger(m_range, 0);
+    case CSSPropertyOrder:
+        return consumeInteger(m_range);
+    case CSSPropertyWebkitTextUnderlinePosition:
+        // auto | alphabetic | [ under || [ left | right ] ], but we only support auto | alphabetic | under for now
+        return consumeIdent<CSSValueAuto, CSSValueUnder, CSSValueAlphabetic>(m_range);
+    case CSSPropertyVerticalAlign:
+        return consumeVerticalAlign(m_range, m_context.mode);
+    case CSSPropertyShapeOutside:
+        return consumeShapeOutside(m_range, m_context);
+    case CSSPropertyWebkitClipPath:
+        return consumeWebkitClipPath(m_range, m_context);
+    case CSSPropertyJustifyContent:
+    case CSSPropertyAlignContent:
+        return consumeContentDistributionOverflowPosition(m_range);
+    case CSSPropertyBorderImageRepeat:
+    case CSSPropertyWebkitMaskBoxImageRepeat:
+        return consumeBorderImageRepeat(m_range);
+    case CSSPropertyBorderImageSlice:
+    case CSSPropertyWebkitMaskBoxImageSlice:
+        return consumeBorderImageSlice(property, m_range);
+    case CSSPropertyBorderImageOutset:
+    case CSSPropertyWebkitMaskBoxImageOutset:
+        return consumeBorderImageOutset(m_range);
+    case CSSPropertyBorderImageWidth:
+    case CSSPropertyWebkitMaskBoxImageWidth:
+        return consumeBorderImageWidth(m_range);
+    case CSSPropertyWebkitBorderImage:
+    case CSSPropertyWebkitMaskBoxImage:
+        return consumeWebkitBorderImage(property, m_range, m_context);
+    case CSSPropertyWebkitBoxReflect:
+        return consumeReflect(m_range, m_context);
+    case CSSPropertyWebkitLineBoxContain:
+        return consumeLineBoxContain(m_range);
+#if ENABLE(CSS_IMAGE_ORIENTATION)
+    case CSSPropertyImageOrientation:
+        return consumeImageOrientation(m_range, m_context.mode);
+#endif
+    case CSSPropertyBackgroundAttachment:
+    case CSSPropertyBackgroundBlendMode:
+    case CSSPropertyBackgroundClip:
+    case CSSPropertyBackgroundImage:
+    case CSSPropertyBackgroundOrigin:
+    case CSSPropertyBackgroundPositionX:
+    case CSSPropertyBackgroundPositionY:
+    case CSSPropertyBackgroundSize:
+    case CSSPropertyWebkitBackgroundClip:
+    case CSSPropertyWebkitBackgroundOrigin:
+    case CSSPropertyWebkitBackgroundComposite:
+    case CSSPropertyWebkitBackgroundSize:
+    case CSSPropertyWebkitMaskClip:
+    case CSSPropertyWebkitMaskComposite:
+    case CSSPropertyWebkitMaskImage:
+    case CSSPropertyWebkitMaskOrigin:
+    case CSSPropertyWebkitMaskPositionX:
+    case CSSPropertyWebkitMaskPositionY:
+    case CSSPropertyWebkitMaskSize:
+    case CSSPropertyWebkitMaskSourceType:
+        return consumeCommaSeparatedBackgroundComponent(property, m_range, m_context);
+    case CSSPropertyWebkitMaskRepeatX:
+    case CSSPropertyWebkitMaskRepeatY:
+        return nullptr;
+    case CSSPropertyAlignItems:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeAlignItems(m_range);
+    case CSSPropertyJustifySelf:
+    case CSSPropertyAlignSelf:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeSelfPositionOverflowPosition(m_range);
+    case CSSPropertyJustifyItems:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeJustifyItems(m_range);
+    case CSSPropertyGridColumnEnd:
+    case CSSPropertyGridColumnStart:
+    case CSSPropertyGridRowEnd:
+    case CSSPropertyGridRowStart:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeGridLine(m_range);
+    case CSSPropertyGridAutoColumns:
+    case CSSPropertyGridAutoRows:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeGridTrackList(m_range, m_context.mode, GridAuto);
+    case CSSPropertyGridTemplateColumns:
+    case CSSPropertyGridTemplateRows:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeGridTemplatesRowsOrColumns(m_range, m_context.mode);
+    case CSSPropertyGridTemplateAreas:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeGridTemplateAreas(m_range);
+    case CSSPropertyGridAutoFlow:
+        if (!m_context.cssGridLayoutEnabled)
+            return nullptr;
+        return consumeGridAutoFlow(m_range);
+#if ENABLE(CSS_REGIONS)
+    case CSSPropertyWebkitFlowInto:
+    case CSSPropertyWebkitFlowFrom:
+        return consumeFlowProperty(m_range);
+#endif
+    case CSSPropertyWebkitLineGrid:
+        return consumeLineGrid(m_range);
+    case CSSPropertyWebkitInitialLetter:
+        return consumeInitialLetter(m_range);
+    case CSSPropertyHangingPunctuation:
+        return consumeHangingPunctuation(m_range);
+    case CSSPropertyWebkitMarqueeIncrement:
+        return consumeWebkitMarqueeIncrement(m_range, m_context.mode);
+    case CSSPropertyWebkitMarqueeRepetition:
+        return consumeWebkitMarqueeRepetition(m_range);
+    case CSSPropertyWebkitMarqueeSpeed:
+        return consumeWebkitMarqueeSpeed(m_range, m_context.mode);
+    case CSSPropertyAlt:
+        return consumeAlt(m_range, m_context);
+    case CSSPropertyWebkitAspectRatio:
+        return consumeWebkitAspectRatio(m_range);
+    case CSSPropertyWebkitTextEmphasisPosition:
+        return consumeTextEmphasisPosition(m_range);
+#if ENABLE(DASHBOARD_SUPPORT)
+    case CSSPropertyWebkitDashboardRegion:
+        return consumeWebkitDashboardRegion(m_range, m_context.mode);
+#endif
+    default:
+        return nullptr;
+    }
+}
+
+static RefPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
+{
+    RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+
+    do {
+        const CSSParserToken& token = range.consumeIncludingWhitespace();
+        if (token.type() != UnicodeRangeToken)
+            return nullptr;
+
+        UChar32 start = token.unicodeRangeStart();
+        UChar32 end = token.unicodeRangeEnd();
+        if (start > end)
+            return nullptr;
+        values->append(CSSUnicodeRangeValue::create(start, end));
+    } while (consumeCommaIncludingWhitespace(range));
+
+    return values;
+}
+
+static RefPtr<CSSValue> consumeFontFaceSrcURI(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    String url = consumeUrlAsStringView(range).toString();
+    if (url.isNull())
+        return nullptr;
+    
+    RefPtr<CSSFontFaceSrcValue> uriValue = CSSFontFaceSrcValue::create(context.completeURL(url));
+
+    if (range.peek().functionId() != CSSValueFormat)
+        return uriValue;
+
+    // FIXME: https://drafts.csswg.org/css-fonts says that format() contains a comma-separated list of strings,
+    // but CSSFontFaceSrcValue stores only one format. Allowing one format for now.
+    // FIXME: We're allowing the format to be an identifier as well as a string, because the old
+    // parser did. It's not clear if we need to continue to support this behavior, but we have lots of
+    // layout tests that rely on it.
+    CSSParserTokenRange args = consumeFunction(range);
+    const CSSParserToken& arg = args.consumeIncludingWhitespace();
+    if ((arg.type() != StringToken && arg.type() != IdentToken) || !args.atEnd())
+        return nullptr;
+    uriValue->setFormat(arg.value().toString());
+    return uriValue;
+}
+
+static RefPtr<CSSValue> consumeFontFaceSrcLocal(CSSParserTokenRange& range)
+{
+    CSSParserTokenRange args = consumeFunction(range);
+    if (args.peek().type() == StringToken) {
+        const CSSParserToken& arg = args.consumeIncludingWhitespace();
+        if (!args.atEnd())
+            return nullptr;
+        return CSSFontFaceSrcValue::createLocal(arg.value().toString());
+    }
+    if (args.peek().type() == IdentToken) {
+        String familyName = concatenateFamilyName(args);
+        if (!args.atEnd())
+            return nullptr;
+        return CSSFontFaceSrcValue::createLocal(familyName);
+    }
+    return nullptr;
+}
+
+static RefPtr<CSSValueList> consumeFontFaceSrc(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+
+    do {
+        const CSSParserToken& token = range.peek();
+        RefPtr<CSSValue> parsedValue;
+        if (token.functionId() == CSSValueLocal)
+            parsedValue = consumeFontFaceSrcLocal(range);
+        else
+            parsedValue = consumeFontFaceSrcURI(range, context);
+        if (!parsedValue)
+            return nullptr;
+        values->append(parsedValue.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    return values;
+}
+
+bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
+{
+    RefPtr<CSSValue> parsedValue;
+    switch (propId) {
+    case CSSPropertyFontFamily:
+        parsedValue = consumeFontFamilyDescriptor(m_range);
+        break;
+    case CSSPropertySrc: // This is a list of urls or local references.
+        parsedValue = consumeFontFaceSrc(m_range, m_context);
+        break;
+    case CSSPropertyUnicodeRange:
+        parsedValue = consumeFontFaceUnicodeRange(m_range);
+        break;
+    case CSSPropertyFontStretch:
+    case CSSPropertyFontStyle: {
+        CSSValueID id = m_range.consumeIncludingWhitespace().id();
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id, m_context.mode))
+            return false;
+        parsedValue = CSSValuePool::singleton().createIdentifierValue(id);
+        break;
+    }
+    case CSSPropertyFontVariantCaps:
+        parsedValue = consumeFontVariantCaps(m_range);
+        break;
+    case CSSPropertyFontVariantLigatures:
+        parsedValue = consumeFontVariantLigatures(m_range);
+        break;
+    case CSSPropertyFontVariantNumeric:
+        parsedValue = consumeFontVariantNumeric(m_range);
+        break;
+    case CSSPropertyFontVariantEastAsian:
+        parsedValue = consumeFontVariantEastAsian(m_range);
+        break;
+    case CSSPropertyFontVariantAlternates:
+        parsedValue = consumeFontVariantAlternates(m_range);
+        break;
+    case CSSPropertyFontVariantPosition:
+        parsedValue = consumeFontVariantPosition(m_range);
+        break;
+    case CSSPropertyFontVariant:
+        return consumeFontVariantShorthand(false);
+    case CSSPropertyFontWeight:
+        parsedValue = consumeFontWeight(m_range);
+        break;
+    case CSSPropertyFontFeatureSettings:
+        parsedValue = consumeFontFeatureSettings(m_range);
+        break;
+    default:
+        break;
+    }
+
+    if (!parsedValue || !m_range.atEnd())
+        return false;
+
+    addProperty(propId, CSSPropertyInvalid, *parsedValue, false);
+    return true;
+}
+
+bool CSSPropertyParser::consumeSystemFont(bool important)
+{
+    CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id();
+    ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
+    if (!m_range.atEnd())
+        return false;
+    
+    FontCascadeDescription fontDescription;
+    RenderTheme::defaultTheme()->systemFont(systemFontID, fontDescription);
+    if (!fontDescription.isAbsoluteSize())
+        return false;
+    
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(fontDescription.italic() == FontItalicOn ? CSSValueItalic : CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, CSSValuePool::singleton().createValue(fontDescription.weight()), important);
+    addProperty(CSSPropertyFontSize, CSSPropertyFont, CSSValuePool::singleton().createValue(fontDescription.specifiedSize(), CSSPrimitiveValue::CSS_PX), important);
+    Ref<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
+    fontFamilyList->append(CSSValuePool::singleton().createFontFamilyValue(fontDescription.familyAt(0), FromSystemFontID::Yes));
+    addProperty(CSSPropertyFontFamily, CSSPropertyFont, WTFMove(fontFamilyList), important);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyLineHeight, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+
+    // FIXME_NEWPARSER: What about FontVariantNumeric and FontVariantLigatures?
+
+    return true;
+}
+
+bool CSSPropertyParser::consumeFont(bool important)
+{
+    // Let's check if there is an inherit or initial somewhere in the shorthand.
+    CSSParserTokenRange range = m_range;
+    while (!range.atEnd()) {
+        CSSValueID id = range.consumeIncludingWhitespace().id();
+        if (id == CSSValueInherit || id == CSSValueInitial)
+            return false;
+    }
+    // Optional font-style, font-variant, font-stretch and font-weight.
+    RefPtr<CSSPrimitiveValue> fontStyle;
+    RefPtr<CSSPrimitiveValue> fontVariantCaps;
+    RefPtr<CSSPrimitiveValue> fontWeight;
+    
+    // FIXME-NEWPARSER: Implement. RefPtr<CSSPrimitiveValue> fontStretch;
+    while (!m_range.atEnd()) {
+        CSSValueID id = m_range.peek().id();
+        if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStyle, id, m_context.mode)) {
+            fontStyle = consumeIdent(m_range);
+            continue;
+        }
+        if (!fontVariantCaps && (id == CSSValueNormal || id == CSSValueSmallCaps)) {
+            // Font variant in the shorthand is particular, it only accepts normal or small-caps.
+            // See https://drafts.csswg.org/css-fonts/#propdef-font
+            fontVariantCaps = consumeFontVariantCSS21(m_range);
+            if (fontVariantCaps)
+                continue;
+        }
+        if (!fontWeight) {
+            fontWeight = consumeFontWeight(m_range);
+            if (fontWeight)
+                continue;
+        }
+        /* FIXME-NEWPARSER: Implement
+         if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStretch, id, m_context.mode, m_styleSheetContents))
+            fontStretch = consumeIdent(m_range);
+        else*/
+        break;
+    }
+
+    if (m_range.atEnd())
+        return false;
+
+    bool hasStyle = fontStyle;
+    bool hasVariant = fontVariantCaps;
+    bool hasWeight = fontWeight;
+    
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, fontStyle ? fontStyle.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, !hasStyle);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, fontVariantCaps ? fontVariantCaps.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, !hasVariant);
+/*  
+    // FIXME-NEWPARSER: What do we do with these? They aren't part of our fontShorthand().
+    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
+    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
+*/
+    
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, fontWeight ? fontWeight.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, !hasWeight);
+
+    // Now a font size _must_ come.
+    RefPtr<CSSValue> fontSize = consumeFontSize(m_range, m_context.mode);
+    if (!fontSize || m_range.atEnd())
+        return false;
+
+    addProperty(CSSPropertyFontSize, CSSPropertyFont, *fontSize, important);
+
+    if (consumeSlashIncludingWhitespace(m_range)) {
+        RefPtr<CSSPrimitiveValue> lineHeight = consumeLineHeight(m_range, m_context.mode);
+        if (!lineHeight)
+            return false;
+        addProperty(CSSPropertyLineHeight, CSSPropertyFont, lineHeight.releaseNonNull(), important);
+    } else {
+        addProperty(CSSPropertyLineHeight, CSSPropertyFont, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
+    }
+
+    // Font family must come now.
+    RefPtr<CSSValue> parsedFamilyValue = consumeFontFamily(m_range);
+    if (!parsedFamilyValue)
+        return false;
+
+    addProperty(CSSPropertyFontFamily, CSSPropertyFont, parsedFamilyValue.releaseNonNull(), important);
+
+    return m_range.atEnd();
+}
+
+bool CSSPropertyParser::consumeFontVariantShorthand(bool important)
+{
+    if (identMatches<CSSValueNormal, CSSValueNone>(m_range.peek().id())) {
+        addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, consumeIdent(m_range).releaseNonNull(), important);
+        addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+        addProperty(CSSPropertyFontVariantEastAsian, CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+        addProperty(CSSPropertyFontVariantPosition, CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+        return m_range.atEnd();
+    }
+
+    RefPtr<CSSPrimitiveValue> capsValue;
+    RefPtr<CSSPrimitiveValue> alternatesValue;
+    RefPtr<CSSPrimitiveValue> positionValue;
+
+    RefPtr<CSSValue> eastAsianValue;
+    FontVariantLigaturesParser ligaturesParser;
+    FontVariantNumericParser numericParser;
+    do {
+        if (!capsValue) {
+            capsValue = consumeFontVariantCaps(m_range);
+            if (capsValue)
+                continue;
+        }
+        
+        if (!positionValue) {
+            positionValue = consumeFontVariantPosition(m_range);
+            if (positionValue)
+                continue;
+        }
+
+        if (!alternatesValue) {
+            alternatesValue = consumeFontVariantAlternates(m_range);
+            if (alternatesValue)
+                continue;
+        }
+
+        FontVariantLigaturesParser::ParseResult ligaturesParseResult = ligaturesParser.consumeLigature(m_range);
+        FontVariantNumericParser::ParseResult numericParseResult = numericParser.consumeNumeric(m_range);
+        if (ligaturesParseResult == FontVariantLigaturesParser::ParseResult::ConsumedValue
+            || numericParseResult == FontVariantNumericParser::ParseResult::ConsumedValue)
+            continue;
+
+        if (ligaturesParseResult == FontVariantLigaturesParser::ParseResult::DisallowedValue
+            || numericParseResult == FontVariantNumericParser::ParseResult::DisallowedValue)
+            return false;
+
+        if (!eastAsianValue) {
+            eastAsianValue = consumeFontVariantEastAsian(m_range);
+            if (eastAsianValue)
+            continue;
+        }
+
+        // Saw some value that didn't match anything else.
+        return false;
+
+    } while (!m_range.atEnd());
+
+    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, ligaturesParser.finalizeValue().releaseNonNull(), important);
+    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFontVariant, numericParser.finalizeValue().releaseNonNull(), important);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, capsValue ? capsValue.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantAlternates, CSSPropertyFontVariant, alternatesValue ? alternatesValue.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantPosition, CSSPropertyFontVariant, positionValue ? positionValue.releaseNonNull() : CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
+    
+    if (!eastAsianValue)
+        eastAsianValue = CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
+    addProperty(CSSPropertyFontVariantEastAsian, CSSPropertyFontVariant, eastAsianValue.releaseNonNull(), important);
+    
+    return true;
+}
+
+bool CSSPropertyParser::consumeBorderSpacing(bool important)
+{
+    RefPtr<CSSValue> horizontalSpacing = consumeLength(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    if (!horizontalSpacing)
+        return false;
+    RefPtr<CSSValue> verticalSpacing = horizontalSpacing;
+    if (!m_range.atEnd())
+        verticalSpacing = consumeLength(m_range, m_context.mode, ValueRangeNonNegative, UnitlessQuirk::Allow);
+    if (!verticalSpacing || !m_range.atEnd())
+        return false;
+    addProperty(CSSPropertyWebkitBorderHorizontalSpacing, CSSPropertyBorderSpacing, horizontalSpacing.releaseNonNull(), important);
+    addProperty(CSSPropertyWebkitBorderVerticalSpacing, CSSPropertyBorderSpacing, verticalSpacing.releaseNonNull(), important);
+    return true;
+}
+
+#if ENABLE(CSS_DEVICE_ADAPTATION)
+
+static RefPtr<CSSValue> consumeSingleViewportDescriptor(CSSParserTokenRange& range, CSSPropertyID propId, CSSParserMode cssParserMode)
+{
+    CSSValueID id = range.peek().id();
+    switch (propId) {
+    case CSSPropertyMinWidth:
+    case CSSPropertyMaxWidth:
+    case CSSPropertyMinHeight:
+    case CSSPropertyMaxHeight:
+        if (id == CSSValueAuto)
+            return consumeIdent(range);
+        return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
+    case CSSPropertyMinZoom:
+    case CSSPropertyMaxZoom:
+    case CSSPropertyZoom: {
+        if (id == CSSValueAuto)
+            return consumeIdent(range);
+        RefPtr<CSSValue> parsedValue = consumeNumber(range, ValueRangeNonNegative);
+        if (parsedValue)
+            return parsedValue;
+        return consumePercent(range, ValueRangeNonNegative);
+    }
+    case CSSPropertyUserZoom:
+        return consumeIdent<CSSValueZoom, CSSValueFixed>(range);
+    case CSSPropertyOrientation:
+        return consumeIdent<CSSValueAuto, CSSValuePortrait, CSSValueLandscape>(range);
+    default:
+        ASSERT_NOT_REACHED();
+        break;
+    }
+
+    ASSERT_NOT_REACHED();
+    return nullptr;
+}
+
+bool CSSPropertyParser::parseViewportDescriptor(CSSPropertyID propId, bool important)
+{
+    switch (propId) {
+    case CSSPropertyWidth: {
+        RefPtr<CSSValue> minWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMinWidth, m_context.mode);
+        if (!minWidth)
+            return false;
+        RefPtr<CSSValue> maxWidth = minWidth;
+        if (!m_range.atEnd())
+            maxWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxWidth, m_context.mode);
+        if (!maxWidth || !m_range.atEnd())
+            return false;
+        addProperty(CSSPropertyMinWidth, CSSPropertyInvalid, *minWidth, important);
+        addProperty(CSSPropertyMaxWidth, CSSPropertyInvalid, *maxWidth, important);
+        return true;
+    }
+    case CSSPropertyHeight: {
+        RefPtr<CSSValue> minHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMinHeight, m_context.mode);
+        if (!minHeight)
+            return false;
+        RefPtr<CSSValue> maxHeight = minHeight;
+        if (!m_range.atEnd())
+            maxHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxHeight, m_context.mode);
+        if (!maxHeight || !m_range.atEnd())
+            return false;
+        addProperty(CSSPropertyMinHeight, CSSPropertyInvalid, *minHeight, important);
+        addProperty(CSSPropertyMaxHeight, CSSPropertyInvalid, *maxHeight, important);
+        return true;
+    }
+    case CSSPropertyMinWidth:
+    case CSSPropertyMaxWidth:
+    case CSSPropertyMinHeight:
+    case CSSPropertyMaxHeight:
+    case CSSPropertyMinZoom:
+    case CSSPropertyMaxZoom:
+    case CSSPropertyZoom:
+    case CSSPropertyUserZoom:
+    case CSSPropertyOrientation: {
+        RefPtr<CSSValue> parsedValue = consumeSingleViewportDescriptor(m_range, propId, m_context.mode);
+        if (!parsedValue || !m_range.atEnd())
+            return false;
+        addProperty(propId, CSSPropertyInvalid, parsedValue.releaseNonNull(), important);
+        return true;
+    }
+    default:
+        return false;
+    }
+}
+
+#endif
+
+bool CSSPropertyParser::consumeColumns(bool important)
+{
+    RefPtr<CSSValue> columnWidth;
+    RefPtr<CSSValue> columnCount;
+    bool hasPendingExplicitAuto = false;
+    
+    for (unsigned propertiesParsed = 0; propertiesParsed < 2 && !m_range.atEnd(); ++propertiesParsed) {
+        if (!propertiesParsed && m_range.peek().id() == CSSValueAuto) {
+            // 'auto' is a valid value for any of the two longhands, and at this point
+            // we don't know which one(s) it is meant for. We need to see if there are other values first.
+            consumeIdent(m_range);
+            hasPendingExplicitAuto = true;
+        } else {
+            if (!columnWidth) {
+                if ((columnWidth = consumeColumnWidth(m_range)))
+                    continue;
+            }
+            if (!columnCount) {
+                if ((columnCount = consumeColumnCount(m_range)))
+                    continue;
+            }
+            // If we didn't find at least one match, this is an invalid shorthand and we have to ignore it.
+            return false;
+        }
+    }
+    
+    if (!m_range.atEnd())
+        return false;
+    
+    // Any unassigned property at this point will become implicit 'auto'.
+    if (columnWidth)
+        addProperty(CSSPropertyColumnWidth, CSSPropertyInvalid, columnWidth.releaseNonNull(), important);
+    else {
+        addProperty(CSSPropertyColumnWidth, CSSPropertyInvalid, CSSValuePool::singleton().createIdentifierValue(CSSValueAuto), important, !hasPendingExplicitAuto /* implicit */);
+        hasPendingExplicitAuto = false;
+    }
+    
+    if (columnCount)
+        addProperty(CSSPropertyColumnCount, CSSPropertyInvalid, columnCount.releaseNonNull(), important);
+    else
+        addProperty(CSSPropertyColumnCount, CSSPropertyInvalid, CSSValuePool::singleton().createIdentifierValue(CSSValueAuto), important, !hasPendingExplicitAuto /* implicit */);
+    
+    return true;
+}
+
+bool CSSPropertyParser::consumeShorthandGreedily(const StylePropertyShorthand& shorthand, bool important)
+{
+    ASSERT(shorthand.length() <= 6); // Existing shorthands have at most 6 longhands.
+    RefPtr<CSSValue> longhands[6];
+    const CSSPropertyID* shorthandProperties = shorthand.properties();
+    do {
+        bool foundLonghand = false;
+        for (size_t i = 0; !foundLonghand && i < shorthand.length(); ++i) {
+            if (longhands[i])
+                continue;
+            longhands[i] = parseSingleValue(shorthandProperties[i], shorthand.id());
+            if (longhands[i])
+                foundLonghand = true;
+        }
+        if (!foundLonghand)
+            return false;
+    } while (!m_range.atEnd());
+
+    for (size_t i = 0; i < shorthand.length(); ++i) {
+        if (longhands[i])
+            addProperty(shorthandProperties[i], shorthand.id(), longhands[i].releaseNonNull(), important);
+        else
+            addProperty(shorthandProperties[i], shorthand.id(), CSSValuePool::singleton().createImplicitInitialValue(), important);
+    }
+    return true;
+}
+
+bool CSSPropertyParser::consumeFlex(bool important)
+{
+    static const double unsetValue = -1;
+    double flexGrow = unsetValue;
+    double flexShrink = unsetValue;
+    RefPtr<CSSPrimitiveValue> flexBasis;
+
+    if (m_range.peek().id() == CSSValueNone) {
+        flexGrow = 0;
+        flexShrink = 0;
+        flexBasis = CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+        m_range.consumeIncludingWhitespace();
+    } else {
+        unsigned index = 0;
+        while (!m_range.atEnd() && index++ < 3) {
+            double num;
+            if (consumeNumberRaw(m_range, num)) {
+                if (num < 0)
+                    return false;
+                if (flexGrow == unsetValue)
+                    flexGrow = num;
+                else if (flexShrink == unsetValue)
+                    flexShrink = num;
+                else if (!num) // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
+                    flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::CSS_PX);
+                else
+                    return false;
+            } else if (!flexBasis) {
+                if (m_range.peek().id() == CSSValueAuto)
+                    flexBasis = consumeIdent(m_range);
+                if (!flexBasis)
+                    flexBasis = consumeLengthOrPercent(m_range, m_context.mode, ValueRangeNonNegative);
+                if (index == 2 && !m_range.atEnd())
+                    return false;
+            }
+        }
+        if (index == 0)
+            return false;
+        if (flexGrow == unsetValue)
+            flexGrow = 1;
+        if (flexShrink == unsetValue)
+            flexShrink = 1;
+        if (!flexBasis)
+            flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::CSS_PX);
+    }
+
+    if (!m_range.atEnd())
+        return false;
+    addProperty(CSSPropertyFlexGrow, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::CSS_NUMBER), important);
+    addProperty(CSSPropertyFlexShrink, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::CSS_NUMBER), important);
+    addProperty(CSSPropertyFlexBasis, CSSPropertyFlex, flexBasis.releaseNonNull(), important);
+    return true;
+}
+
+bool CSSPropertyParser::consumeBorder(bool important)
+{
+    RefPtr<CSSValue> width;
+    RefPtr<CSSValue> style;
+    RefPtr<CSSValue> color;
+
+    while (!width || !style || !color) {
+        if (!width) {
+            width = consumeLineWidth(m_range, m_context.mode, UnitlessQuirk::Forbid);
+            if (width)
+                continue;
+        }
+        if (!style) {
+            style = parseSingleValue(CSSPropertyBorderLeftStyle, CSSPropertyBorder);
+            if (style)
+                continue;
+        }
+        if (!color) {
+            color = consumeColor(m_range, m_context.mode);
+            if (color)
+                continue;
+        }
+        break;
+    }
+
+    if (!width && !style && !color)
+        return false;
+
+    if (!width)
+        width = CSSValuePool::singleton().createImplicitInitialValue();
+    if (!style)
+        style = CSSValuePool::singleton().createImplicitInitialValue();
+    if (!color)
+        color = CSSValuePool::singleton().createImplicitInitialValue();
+
+    addExpandedPropertyForValue(CSSPropertyBorderWidth, width.releaseNonNull(), important);
+    addExpandedPropertyForValue(CSSPropertyBorderStyle, style.releaseNonNull(), important);
+    addExpandedPropertyForValue(CSSPropertyBorderColor, color.releaseNonNull(), important);
+    addExpandedPropertyForValue(CSSPropertyBorderImage, CSSValuePool::singleton().createImplicitInitialValue(), important);
+
+    return m_range.atEnd();
+}
+
+bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand, bool important)
+{
+    ASSERT(shorthand.length() == 4);
+    const CSSPropertyID* longhands = shorthand.properties();
+    RefPtr<CSSValue> top = parseSingleValue(longhands[0], shorthand.id());
+    if (!top)
+        return false;
+
+    RefPtr<CSSValue> right = parseSingleValue(longhands[1], shorthand.id());
+    RefPtr<CSSValue> bottom;
+    RefPtr<CSSValue> left;
+    if (right) {
+        bottom = parseSingleValue(longhands[2], shorthand.id());
+        if (bottom)
+            left = parseSingleValue(longhands[3], shorthand.id());
+    }
+
+    bool rightImplicit = !right;
+    bool bottomImplicit = !bottom;
+    bool leftImplicit = !left;
+
+    if (!right)
+        right = top;
+    if (!bottom)
+        bottom = top;
+    if (!left)
+        left = right;
+
+    addProperty(longhands[0], shorthand.id(), top.releaseNonNull(), important);
+    addProperty(longhands[1], shorthand.id(), right.releaseNonNull(), important, rightImplicit);
+    addProperty(longhands[2], shorthand.id(), bottom.releaseNonNull(), important, bottomImplicit);
+    addProperty(longhands[3], shorthand.id(), left.releaseNonNull(), important, leftImplicit);
+
+    return m_range.atEnd();
+}
+
+bool CSSPropertyParser::consumeBorderImage(CSSPropertyID property, bool important)
+{
+    RefPtr<CSSValue> source;
+    RefPtr<CSSValue> slice;
+    RefPtr<CSSValue> width;
+    RefPtr<CSSValue> outset;
+    RefPtr<CSSValue> repeat;
+    
+    if (consumeBorderImageComponents(property, m_range, m_context, source, slice, width, outset, repeat)) {
+        if (!source)
+            source = CSSValuePool::singleton().createImplicitInitialValue();
+        if (!slice)
+            slice = CSSValuePool::singleton().createImplicitInitialValue();
+        if (!width)
+            width = CSSValuePool::singleton().createImplicitInitialValue();
+        if (!outset)
+            outset = CSSValuePool::singleton().createImplicitInitialValue();
+        if (!repeat)
+            repeat = CSSValuePool::singleton().createImplicitInitialValue();
+        switch (property) {
+        case CSSPropertyWebkitMaskBoxImage:
+            addProperty(CSSPropertyWebkitMaskBoxImageSource, CSSPropertyWebkitMaskBoxImage, source.releaseNonNull(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageSlice, CSSPropertyWebkitMaskBoxImage, slice.releaseNonNull(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageWidth, CSSPropertyWebkitMaskBoxImage, width.releaseNonNull(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageOutset, CSSPropertyWebkitMaskBoxImage, outset.releaseNonNull(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageRepeat, CSSPropertyWebkitMaskBoxImage, repeat.releaseNonNull(), important);
+            return true;
+        case CSSPropertyBorderImage:
+            addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, source.releaseNonNull(), important);
+            addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, slice.releaseNonNull(), important);
+            addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, width.releaseNonNull() , important);
+            addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, outset.releaseNonNull(), important);
+            addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, repeat.releaseNonNull(), important);
+            return true;
+        default:
+            ASSERT_NOT_REACHED();
+            return false;
+        }
+    }
+    return false;
+}
+
+static inline CSSValueID mapFromPageBreakBetween(CSSValueID value)
+{
+    if (value == CSSValueAlways)
+        return CSSValuePage;
+    if (value == CSSValueAuto || value == CSSValueLeft || value == CSSValueRight)
+        return value;
+    if (value == CSSValueAvoid)
+        return CSSValueAvoidPage;
+    return CSSValueInvalid;
+}
+
+static inline CSSValueID mapFromColumnBreakBetween(CSSValueID value)
+{
+    if (value == CSSValueAlways)
+        return CSSValueColumn;
+    if (value == CSSValueAuto)
+        return value;
+    if (value == CSSValueAvoid)
+        return CSSValueAvoidColumn;
+    return CSSValueInvalid;
+}
+
+#if ENABLE(CSS_REGIONS)
+static inline CSSValueID mapFromRegionBreakBetween(CSSValueID value)
+{
+    if (value == CSSValueAlways)
+        return CSSValueRegion;
+    if (value == CSSValueAuto)
+        return value;
+    if (value == CSSValueAvoid)
+        return CSSValueAvoidRegion;
+    return CSSValueInvalid;
+}
+#endif
+
+static inline CSSValueID mapFromColumnRegionOrPageBreakInside(CSSValueID value)
+{
+    if (value == CSSValueAuto || value == CSSValueAvoid)
+        return value;
+    return CSSValueInvalid;
+}
+
+static inline CSSPropertyID mapFromLegacyBreakProperty(CSSPropertyID property)
+{
+    if (property == CSSPropertyPageBreakAfter || property == CSSPropertyWebkitColumnBreakAfter)
+        return CSSPropertyBreakAfter;
+    if (property == CSSPropertyPageBreakBefore || property == CSSPropertyWebkitColumnBreakBefore)
+        return CSSPropertyBreakBefore;
+#if ENABLE(CSS_REGIONS)
+    if (property == CSSPropertyWebkitRegionBreakAfter)
+        return CSSPropertyBreakAfter;
+    if (property == CSSPropertyWebkitRegionBreakBefore)
+        return CSSPropertyBreakBefore;
+    ASSERT(property == CSSPropertyPageBreakInside || property == CSSPropertyWebkitColumnBreakInside || property == CSSPropertyWebkitRegionBreakInside);
+#else
+    ASSERT(property == CSSPropertyPageBreakInside || property == CSSPropertyWebkitColumnBreakInside);
+#endif
+    return CSSPropertyBreakInside;
+}
+
+bool CSSPropertyParser::consumeLegacyBreakProperty(CSSPropertyID property, bool important)
+{
+    // The fragmentation spec says that page-break-(after|before|inside) are to be treated as
+    // shorthands for their break-(after|before|inside) counterparts. We'll do the same for the
+    // non-standard properties -webkit-column-break-(after|before|inside).
+    RefPtr<CSSPrimitiveValue> keyword = consumeIdent(m_range);
+    if (!keyword)
+        return false;
+    if (!m_range.atEnd())
+        return false;
+    CSSValueID value = keyword->valueID();
+    switch (property) {
+    case CSSPropertyPageBreakAfter:
+    case CSSPropertyPageBreakBefore:
+        value = mapFromPageBreakBetween(value);
+        break;
+    case CSSPropertyWebkitColumnBreakAfter:
+    case CSSPropertyWebkitColumnBreakBefore:
+        value = mapFromColumnBreakBetween(value);
+        break;
+#if ENABLE(CSS_REGIONS)
+    case CSSPropertyWebkitRegionBreakAfter:
+    case CSSPropertyWebkitRegionBreakBefore:
+        value = mapFromRegionBreakBetween(value);
+        break;
+    case CSSPropertyWebkitRegionBreakInside:
+#endif
+    case CSSPropertyPageBreakInside:
+    case CSSPropertyWebkitColumnBreakInside:
+        value = mapFromColumnRegionOrPageBreakInside(value);
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+    if (value == CSSValueInvalid)
+        return false;
+
+    CSSPropertyID genericBreakProperty = mapFromLegacyBreakProperty(property);
+    addProperty(genericBreakProperty, property, CSSValuePool::singleton().createIdentifierValue(value), important);
+    return true;
+}
+
+static bool consumeBackgroundPosition(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless, RefPtr<CSSValue>& resultX, RefPtr<CSSValue>& resultY)
+{
+    do {
+        RefPtr<CSSPrimitiveValue> positionX;
+        RefPtr<CSSPrimitiveValue> positionY;
+        if (!consumePosition(range, context.mode, unitless, positionX, positionY))
+            return false;
+        addBackgroundValue(resultX, positionX.releaseNonNull());
+        addBackgroundValue(resultY, positionY.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    return true;
+}
+
+static bool consumeRepeatStyleComponent(CSSParserTokenRange& range, RefPtr<CSSPrimitiveValue>& value1, RefPtr<CSSPrimitiveValue>& value2, bool& implicit)
+{
+    if (consumeIdent<CSSValueRepeatX>(range)) {
+        value1 = CSSValuePool::singleton().createIdentifierValue(CSSValueRepeat);
+        value2 = CSSValuePool::singleton().createIdentifierValue(CSSValueNoRepeat);
+        implicit = true;
+        return true;
+    }
+    if (consumeIdent<CSSValueRepeatY>(range)) {
+        value1 = CSSValuePool::singleton().createIdentifierValue(CSSValueNoRepeat);
+        value2 = CSSValuePool::singleton().createIdentifierValue(CSSValueRepeat);
+        implicit = true;
+        return true;
+    }
+    value1 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, CSSValueSpace>(range);
+    if (!value1)
+        return false;
+
+    value2 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, CSSValueSpace>(range);
+    if (!value2) {
+        value2 = value1;
+        implicit = true;
+    }
+    return true;
+}
+
+static bool consumeRepeatStyle(CSSParserTokenRange& range, RefPtr<CSSValue>& resultX, RefPtr<CSSValue>& resultY, bool& implicit)
+{
+    do {
+        RefPtr<CSSPrimitiveValue> repeatX;
+        RefPtr<CSSPrimitiveValue> repeatY;
+        if (!consumeRepeatStyleComponent(range, repeatX, repeatY, implicit))
+            return false;
+        addBackgroundValue(resultX, repeatX.releaseNonNull());
+        addBackgroundValue(resultY, repeatY.releaseNonNull());
+    } while (consumeCommaIncludingWhitespace(range));
+    return true;
+}
+
+// Note: consumeBackgroundShorthand assumes y properties (for example background-position-y) follow
+// the x properties in the shorthand array.
+bool CSSPropertyParser::consumeBackgroundShorthand(const StylePropertyShorthand& shorthand, bool important)
+{
+    const unsigned longhandCount = shorthand.length();
+    RefPtr<CSSValue> longhands[10];
+    ASSERT(longhandCount <= 10);
+
+    bool implicit = false;
+    do {
+        bool parsedLonghand[10] = { false };
+        RefPtr<CSSValue> originValue;
+        do {
+            bool foundProperty = false;
+            for (size_t i = 0; i < longhandCount; ++i) {
+                if (parsedLonghand[i])
+                    continue;
+
+                RefPtr<CSSValue> value;
+                RefPtr<CSSValue> valueY;
+                CSSPropertyID property = shorthand.properties()[i];
+                if (property == CSSPropertyBackgroundRepeatX || property == CSSPropertyWebkitMaskRepeatX) {
+                    RefPtr<CSSPrimitiveValue> primitiveValue;
+                    RefPtr<CSSPrimitiveValue> primitiveValueY;
+                    consumeRepeatStyleComponent(m_range, primitiveValue, primitiveValueY, implicit);
+                    value = primitiveValue;
+                    valueY = primitiveValueY;
+                } else if (property == CSSPropertyBackgroundPositionX || property == CSSPropertyWebkitMaskPositionX) {
+                    CSSParserTokenRange rangeCopy = m_range;
+                    RefPtr<CSSPrimitiveValue> primitiveValue;
+                    RefPtr<CSSPrimitiveValue> primitiveValueY;
+                    if (!consumePosition(rangeCopy, m_context.mode, UnitlessQuirk::Forbid, primitiveValue, primitiveValueY))
+                        continue;
+                    value = primitiveValue;
+                    valueY = primitiveValueY;
+                    m_range = rangeCopy;
+                } else if (property == CSSPropertyBackgroundSize || property == CSSPropertyWebkitMaskSize) {
+                    if (!consumeSlashIncludingWhitespace(m_range))
+                        continue;
+                    value = consumeBackgroundSize(property, m_range, m_context.mode);
+                    if (!value || !parsedLonghand[i - 1]) // Position must have been parsed in the current layer.
+                        return false;
+                } else if (property == CSSPropertyBackgroundPositionY || property == CSSPropertyBackgroundRepeatY
+                    || property == CSSPropertyWebkitMaskPositionY || property == CSSPropertyWebkitMaskRepeatY) {
+                    continue;
+                } else {
+                    value = consumeBackgroundComponent(property, m_range, m_context);
+                }
+                if (value) {
+                    if (property == CSSPropertyBackgroundOrigin || property == CSSPropertyWebkitMaskOrigin)
+                        originValue = value;
+                    parsedLonghand[i] = true;
+                    foundProperty = true;
+                    addBackgroundValue(longhands[i], value.releaseNonNull());
+                    if (valueY) {
+                        parsedLonghand[i + 1] = true;
+                        addBackgroundValue(longhands[i + 1], valueY.releaseNonNull());
+                    }
+                }
+            }
+            if (!foundProperty)
+                return false;
+        } while (!m_range.atEnd() && m_range.peek().type() != CommaToken);
+
+        // FIXME: This will make invalid longhands, see crbug.com/386459
+        for (size_t i = 0; i < longhandCount; ++i) {
+            CSSPropertyID property = shorthand.properties()[i];
+            if (property == CSSPropertyBackgroundColor && !m_range.atEnd()) {
+                if (parsedLonghand[i])
+                    return false; // Colors are only allowed in the last layer.
+                continue;
+            }
+            if ((property == CSSPropertyBackgroundClip || property == CSSPropertyWebkitMaskClip) && !parsedLonghand[i] && originValue) {
+                addBackgroundValue(longhands[i], originValue.releaseNonNull());
+                continue;
+            }
+            if (!parsedLonghand[i])
+                addBackgroundValue(longhands[i], CSSValuePool::singleton().createImplicitInitialValue());
+        }
+    } while (consumeCommaIncludingWhitespace(m_range));
+    if (!m_range.atEnd())
+        return false;
+
+    for (size_t i = 0; i < longhandCount; ++i) {
+        CSSPropertyID property = shorthand.properties()[i];
+        if (property == CSSPropertyBackgroundSize && longhands[i] && m_context.useLegacyBackgroundSizeShorthandBehavior)
+            continue;
+        addProperty(property, shorthand.id(), *longhands[i], important, implicit);
+    }
+    return true;
+}
+
+// FIXME-NEWPARSER: Hack to work around the fact that we aren't using CSSCustomIdentValue
+// for stuff yet. This can be replaced by CSSValue::isCustomIdentValue() once we switch
+// to using CSSCustomIdentValue everywhere.
+static bool isCustomIdentValue(const CSSValue& value)
+{
+    return is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).isString();
+}
+
+bool CSSPropertyParser::consumeGridItemPositionShorthand(CSSPropertyID shorthandId, bool important)
+{
+    const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
+    ASSERT(shorthand.length() == 2);
+    RefPtr<CSSValue> startValue = consumeGridLine(m_range);
+    if (!startValue)
+        return false;
+
+    RefPtr<CSSValue> endValue;
+    if (consumeSlashIncludingWhitespace(m_range)) {
+        endValue = consumeGridLine(m_range);
+        if (!endValue)
+            return false;
+    } else {
+        endValue = isCustomIdentValue(*startValue) ? startValue : CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+    }
+    if (!m_range.atEnd())
+        return false;
+    addProperty(shorthand.properties()[0], shorthandId, startValue.releaseNonNull(), important);
+    addProperty(shorthand.properties()[1], shorthandId, endValue.releaseNonNull(), important);
+    return true;
+}
+
+bool CSSPropertyParser::consumeGridAreaShorthand(bool important)
+{
+    RefPtr<CSSValue> rowStartValue = consumeGridLine(m_range);
+    if (!rowStartValue)
+        return false;
+    RefPtr<CSSValue> columnStartValue;
+    RefPtr<CSSValue> rowEndValue;
+    RefPtr<CSSValue> columnEndValue;
+    if (consumeSlashIncludingWhitespace(m_range)) {
+        columnStartValue = consumeGridLine(m_range);
+        if (!columnStartValue)
+            return false;
+        if (consumeSlashIncludingWhitespace(m_range)) {
+            rowEndValue = consumeGridLine(m_range);
+            if (!rowEndValue)
+                return false;
+            if (consumeSlashIncludingWhitespace(m_range)) {
+                columnEndValue = consumeGridLine(m_range);
+                if (!columnEndValue)
+                    return false;
+            }
+        }
+    }
+    if (!m_range.atEnd())
+        return false;
+    if (!columnStartValue)
+        columnStartValue = isCustomIdentValue(*rowStartValue) ? rowStartValue : CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+    if (!rowEndValue)
+        rowEndValue = isCustomIdentValue(*rowStartValue) ? rowStartValue : CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+    if (!columnEndValue)
+        columnEndValue = isCustomIdentValue(*columnStartValue) ? columnStartValue : CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+
+    addProperty(CSSPropertyGridRowStart, CSSPropertyGridArea, rowStartValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridColumnStart, CSSPropertyGridArea, columnStartValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridRowEnd, CSSPropertyGridArea, rowEndValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridColumnEnd, CSSPropertyGridArea, columnEndValue.releaseNonNull(), important);
+    return true;
+}
+
+bool CSSPropertyParser::consumeGridTemplateRowsAndAreasAndColumns(CSSPropertyID shorthandId, bool important)
+{
+    NamedGridAreaMap gridAreaMap;
+    size_t rowCount = 0;
+    size_t columnCount = 0;
+    RefPtr<CSSValueList> templateRows = CSSValueList::createSpaceSeparated();
+
+    // Persists between loop iterations so we can use the same value for
+    // consecutive <line-names> values
+    RefPtr<CSSGridLineNamesValue> lineNames;
+
+    do {
+        // Handle leading <custom-ident>*.
+        bool hasPreviousLineNames = lineNames;
+        lineNames = consumeGridLineNames(m_range, lineNames.get());
+        if (lineNames && !hasPreviousLineNames)
+            templateRows->append(*lineNames);
+
+        // Handle a template-area's row.
+        if (m_range.peek().type() != StringToken || !parseGridTemplateAreasRow(m_range.consumeIncludingWhitespace().value().toString(), gridAreaMap, rowCount, columnCount))
+            return false;
+        ++rowCount;
+
+        // Handle template-rows's track-size.
+        RefPtr<CSSValue> value = consumeGridTrackSize(m_range, m_context.mode);
+        if (!value)
+            value = CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+        templateRows->append(*value);
+
+        // This will handle the trailing/leading <custom-ident>* in the grammar.
+        lineNames = consumeGridLineNames(m_range);
+        if (lineNames)
+            templateRows->append(lineNames.releaseNonNull());
+    } while (!m_range.atEnd() && !(m_range.peek().type() == DelimiterToken && m_range.peek().delimiter() == '/'));
+
+    RefPtr<CSSValue> columnsValue;
+    if (!m_range.atEnd()) {
+        if (!consumeSlashIncludingWhitespace(m_range))
+            return false;
+        columnsValue = consumeGridTrackList(m_range, m_context.mode, GridTemplateNoRepeat);
+        if (!columnsValue || !m_range.atEnd())
+            return false;
+    } else {
+        columnsValue = CSSValuePool::singleton().createIdentifierValue(CSSValueNone);
+    }
+    addProperty(CSSPropertyGridTemplateRows, shorthandId, templateRows.releaseNonNull(), important);
+    addProperty(CSSPropertyGridTemplateColumns, shorthandId, columnsValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridTemplateAreas, shorthandId, CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount), important);
+    return true;
+}
+
+bool CSSPropertyParser::consumeGridTemplateShorthand(CSSPropertyID shorthandId, bool important)
+{
+    CSSParserTokenRange rangeCopy = m_range;
+    RefPtr<CSSValue> rowsValue = consumeIdent<CSSValueNone>(m_range);
+
+    // 1- 'none' case.
+    if (rowsValue && m_range.atEnd()) {
+        addProperty(CSSPropertyGridTemplateRows, shorthandId, CSSValuePool::singleton().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateColumns, shorthandId, CSSValuePool::singleton().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, CSSValuePool::singleton().createIdentifierValue(CSSValueNone), important);
+        return true;
+    }
+
+    // 2- <grid-template-rows> / <grid-template-columns>
+    if (!rowsValue)
+        rowsValue = consumeGridTrackList(m_range, m_context.mode, GridTemplate);
+
+    if (rowsValue) {
+        if (!consumeSlashIncludingWhitespace(m_range))
+            return false;
+        RefPtr<CSSValue> columnsValue = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode);
+        if (!columnsValue || !m_range.atEnd())
+            return false;
+
+        addProperty(CSSPropertyGridTemplateRows, shorthandId, rowsValue.releaseNonNull(), important);
+        addProperty(CSSPropertyGridTemplateColumns, shorthandId, columnsValue.releaseNonNull(), important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, CSSValuePool::singleton().createIdentifierValue(CSSValueNone), important);
+        return true;
+    }
+
+    // 3- [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <track-list> ]?
+    m_range = rangeCopy;
+    return consumeGridTemplateRowsAndAreasAndColumns(shorthandId, important);
+}
+
+static RefPtr<CSSValue> consumeImplicitGridAutoFlow(CSSParserTokenRange& range, Ref<CSSPrimitiveValue>&& flowDirection)
+{
+    // [ auto-flow && dense? ]
+    if (range.atEnd())
+        return nullptr;
+    auto list = CSSValueList::createSpaceSeparated();
+    list->append(WTFMove(flowDirection));
+    if (range.peek().id() == CSSValueAutoFlow) {
+        range.consumeIncludingWhitespace();
+        RefPtr<CSSValue> denseIdent = consumeIdent<CSSValueDense>(range);
+        if (denseIdent)
+            list->append(denseIdent.releaseNonNull());
+    } else {
+        // Dense case
+        if (range.peek().id() != CSSValueDense)
+            return nullptr;
+        range.consumeIncludingWhitespace();
+        if (range.atEnd() || range.peek().id() != CSSValueAutoFlow)
+            return nullptr;
+        range.consumeIncludingWhitespace();
+        list->append(CSSValuePool::singleton().createIdentifierValue(CSSValueDense));
+    }
+    
+    return WTFMove(list);
+}
+
+bool CSSPropertyParser::consumeGridShorthand(bool important)
+{
+    ASSERT(shorthandForProperty(CSSPropertyGrid).length() == 8);
+
+    CSSParserTokenRange rangeCopy = m_range;
+
+    // 1- <grid-template>
+    if (consumeGridTemplateShorthand(CSSPropertyGrid, important)) {
+        // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
+        // The sub-properties not specified are set to their initial value, as normal for shorthands.
+        addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+        return true;
+    }
+
+    m_range = rangeCopy;
+
+    RefPtr<CSSValue> autoColumnsValue;
+    RefPtr<CSSValue> autoRowsValue;
+    RefPtr<CSSValue> templateRows;
+    RefPtr<CSSValue> templateColumns;
+    RefPtr<CSSValue> gridAutoFlow;
+    
+    if (m_range.peek().id() == CSSValueAutoFlow || m_range.peek().id() == CSSValueDense) {
+        // 2- [ auto-flow && dense? ] <grid-auto-rows>? / <grid-template-columns>
+        gridAutoFlow = consumeImplicitGridAutoFlow(m_range, CSSValuePool::singleton().createIdentifierValue(CSSValueRow));
+        if (!gridAutoFlow || m_range.atEnd())
+            return false;
+        if (consumeSlashIncludingWhitespace(m_range))
+            autoRowsValue = CSSValuePool::singleton().createImplicitInitialValue();
+        else {
+            autoRowsValue = consumeGridTrackList(m_range, m_context.mode, GridAuto);
+            if (!autoRowsValue)
+                return false;
+            if (!consumeSlashIncludingWhitespace(m_range))
+                return false;
+        }
+        if (m_range.atEnd())
+            return false;
+        templateColumns = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode);
+        if (!templateColumns)
+            return false;
+        templateRows = CSSValuePool::singleton().createImplicitInitialValue();
+        autoColumnsValue = CSSValuePool::singleton().createImplicitInitialValue();
+    } else {
+        // 3- <grid-template-rows> / [ auto-flow && dense? ] <grid-auto-columns>?
+        templateRows = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode);
+        if (!templateRows)
+            return false;
+        if (!consumeSlashIncludingWhitespace(m_range) || m_range.atEnd())
+            return false;
+        gridAutoFlow = consumeImplicitGridAutoFlow(m_range, CSSValuePool::singleton().createIdentifierValue(CSSValueColumn));
+        if (!gridAutoFlow)
+            return false;
+        if (m_range.atEnd())
+            autoColumnsValue = CSSValuePool::singleton().createImplicitInitialValue();
+        else {
+            autoColumnsValue = consumeGridTrackList(m_range, m_context.mode, GridAuto);
+            if (!autoColumnsValue)
+                return false;
+        }
+        templateColumns = CSSValuePool::singleton().createImplicitInitialValue();
+        autoRowsValue = CSSValuePool::singleton().createImplicitInitialValue();
+    }
+    
+    if (!m_range.atEnd())
+        return false;
+    
+    // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
+    // The sub-properties not specified are set to their initial value, as normal for shorthands.
+    addProperty(CSSPropertyGridTemplateColumns, CSSPropertyGrid, templateColumns.releaseNonNull(), important);
+    addProperty(CSSPropertyGridTemplateRows, CSSPropertyGrid, templateRows.releaseNonNull(), important);
+    addProperty(CSSPropertyGridTemplateAreas, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, gridAutoFlow.releaseNonNull(), important);
+    addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, autoColumnsValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, autoRowsValue.releaseNonNull(), important);
+    addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, CSSValuePool::singleton().createImplicitInitialValue(), important);
+    
+    return true;
+}
+
+bool CSSPropertyParser::parseShorthand(CSSPropertyID property, bool important)
+{
+    switch (property) {
+    case CSSPropertyWebkitMarginCollapse: {
+        CSSValueID id = m_range.consumeIncludingWhitespace().id();
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id, m_context.mode))
+            return false;
+        addProperty(CSSPropertyWebkitMarginBeforeCollapse, CSSPropertyWebkitMarginCollapse, CSSValuePool::singleton().createIdentifierValue(id), important);
+        if (m_range.atEnd()) {
+            addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, CSSValuePool::singleton().createIdentifierValue(id), important);
+            return true;
+        }
+        id = m_range.consumeIncludingWhitespace().id();
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginAfterCollapse, id, m_context.mode))
+            return false;
+        addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, CSSValuePool::singleton().createIdentifierValue(id), important);
+        return true;
+    }
+    case CSSPropertyOverflow: {
+        CSSValueID id = m_range.consumeIncludingWhitespace().id();
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyOverflowY, id, m_context.mode))
+            return false;
+        if (!m_range.atEnd())
+            return false;
+        RefPtr<CSSValue> overflowYValue = CSSValuePool::singleton().createIdentifierValue(id);
+        RefPtr<CSSValue> overflowXValue;
+
+        // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
+        // set using the shorthand, then for now overflow-x will default to auto, but once we implement
+        // pagination controls, it should default to hidden. If the overflow-y value is anything but
+        // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
+        if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
+            overflowXValue = CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);
+        else
+            overflowXValue = overflowYValue;
+        addProperty(CSSPropertyOverflowX, CSSPropertyOverflow, *overflowXValue, important);
+        addProperty(CSSPropertyOverflowY, CSSPropertyOverflow, *overflowYValue, important);
+        return true;
+    }
+    case CSSPropertyFont: {
+        const CSSParserToken& token = m_range.peek();
+        if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar)
+            return consumeSystemFont(important);
+        return consumeFont(important);
+    }
+    case CSSPropertyFontVariant:
+        return consumeFontVariantShorthand(important);
+    case CSSPropertyBorderSpacing:
+        return consumeBorderSpacing(important);
+    case CSSPropertyColumns:
+        return consumeColumns(important);
+    case CSSPropertyAnimation:
+        return consumeAnimationShorthand(animationShorthandForParsing(), important);
+    case CSSPropertyTransition:
+        return consumeAnimationShorthand(transitionShorthandForParsing(), important);
+    case CSSPropertyTextDecoration:
+    case CSSPropertyWebkitTextDecoration:
+        // FIXME-NEWPARSER: We need to unprefix -line/-style/-color ASAP and get rid
+        // of -webkit-text-decoration completely.
+        return consumeShorthandGreedily(webkitTextDecorationShorthand(), important);
+    case CSSPropertyMargin:
+        return consume4Values(marginShorthand(), important);
+    case CSSPropertyPadding:
+        return consume4Values(paddingShorthand(), important);
+#if ENABLE(CSS_SCROLL_SNAP)
+    case CSSPropertyScrollSnapMargin:
+        return consume4Values(scrollSnapMarginShorthand(), important);
+    case CSSPropertyScrollPadding:
+        return consume4Values(scrollPaddingShorthand(), important);
+#endif
+    case CSSPropertyWebkitTextEmphasis:
+        return consumeShorthandGreedily(webkitTextEmphasisShorthand(), important);
+    case CSSPropertyOutline:
+        return consumeShorthandGreedily(outlineShorthand(), important);
+    case CSSPropertyWebkitBorderStart:
+        return consumeShorthandGreedily(webkitBorderStartShorthand(), important);
+    case CSSPropertyWebkitBorderEnd:
+        return consumeShorthandGreedily(webkitBorderEndShorthand(), important);
+    case CSSPropertyWebkitBorderBefore:
+        return consumeShorthandGreedily(webkitBorderBeforeShorthand(), important);
+    case CSSPropertyWebkitBorderAfter:
+        return consumeShorthandGreedily(webkitBorderAfterShorthand(), important);
+    case CSSPropertyWebkitTextStroke:
+        return consumeShorthandGreedily(webkitTextStrokeShorthand(), important);
+    case CSSPropertyMarker: {
+        RefPtr<CSSValue> marker = parseSingleValue(CSSPropertyMarkerStart);
+        if (!marker || !m_range.atEnd())
+            return false;
+        auto markerRef = marker.releaseNonNull();
+        addProperty(CSSPropertyMarkerStart, CSSPropertyMarker, markerRef.copyRef(), important);
+        addProperty(CSSPropertyMarkerMid, CSSPropertyMarker, markerRef.copyRef(), important);
+        addProperty(CSSPropertyMarkerEnd, CSSPropertyMarker, markerRef.copyRef(), important);
+        return true;
+    }
+    case CSSPropertyFlex:
+        return consumeFlex(important);
+    case CSSPropertyFlexFlow:
+        return consumeShorthandGreedily(flexFlowShorthand(), important);
+    case CSSPropertyColumnRule:
+        return consumeShorthandGreedily(columnRuleShorthand(), important);
+    case CSSPropertyListStyle:
+        return consumeShorthandGreedily(listStyleShorthand(), important);
+    case CSSPropertyBorderRadius:
+    case CSSPropertyWebkitBorderRadius: {
+        RefPtr<CSSPrimitiveValue> horizontalRadii[4];
+        RefPtr<CSSPrimitiveValue> verticalRadii[4];
+        if (!consumeRadii(horizontalRadii, verticalRadii, m_range, m_context.mode, property == CSSPropertyWebkitBorderRadius))
+            return false;
+        addProperty(CSSPropertyBorderTopLeftRadius, CSSPropertyBorderRadius, createPrimitiveValuePair(horizontalRadii[0].releaseNonNull(), verticalRadii[0].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce), important);
+        addProperty(CSSPropertyBorderTopRightRadius, CSSPropertyBorderRadius, createPrimitiveValuePair(horizontalRadii[1].releaseNonNull(), verticalRadii[1].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce), important);
+        addProperty(CSSPropertyBorderBottomRightRadius, CSSPropertyBorderRadius, createPrimitiveValuePair(horizontalRadii[2].releaseNonNull(), verticalRadii[2].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce), important);
+        addProperty(CSSPropertyBorderBottomLeftRadius, CSSPropertyBorderRadius, createPrimitiveValuePair(horizontalRadii[3].releaseNonNull(), verticalRadii[3].releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce), important);
+        return true;
+    }
+    case CSSPropertyBorderColor:
+        return consume4Values(borderColorShorthand(), important);
+    case CSSPropertyBorderStyle:
+        return consume4Values(borderStyleShorthand(), important);
+    case CSSPropertyBorderWidth:
+        return consume4Values(borderWidthShorthand(), important);
+    case CSSPropertyBorderTop:
+        return consumeShorthandGreedily(borderTopShorthand(), important);
+    case CSSPropertyBorderRight:
+        return consumeShorthandGreedily(borderRightShorthand(), important);
+    case CSSPropertyBorderBottom:
+        return consumeShorthandGreedily(borderBottomShorthand(), important);
+    case CSSPropertyBorderLeft:
+        return consumeShorthandGreedily(borderLeftShorthand(), important);
+    case CSSPropertyBorder:
+        return consumeBorder(important);
+    case CSSPropertyBorderImage:
+        return consumeBorderImage(property, important);
+    case CSSPropertyWebkitMaskPosition:
+    case CSSPropertyBackgroundPosition: {
+        RefPtr<CSSValue> resultX;
+        RefPtr<CSSValue> resultY;
+        if (!consumeBackgroundPosition(m_range, m_context, UnitlessQuirk::Allow, resultX, resultY) || !m_range.atEnd())
+            return false;
+        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionX : CSSPropertyWebkitMaskPositionX, property, resultX.releaseNonNull(), important);
+        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionY : CSSPropertyWebkitMaskPositionY, property, resultY.releaseNonNull(), important);
+        return true;
+    }
+    case CSSPropertyBackgroundRepeat:
+    case CSSPropertyWebkitMaskRepeat: {
+        RefPtr<CSSValue> resultX;
+        RefPtr<CSSValue> resultY;
+        bool implicit = false;
+        if (!consumeRepeatStyle(m_range, resultX, resultY, implicit) || !m_range.atEnd())
+            return false;
+        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatX : CSSPropertyWebkitMaskRepeatX, property, resultX.releaseNonNull(), important, implicit);
+        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatY : CSSPropertyWebkitMaskRepeatY, property, resultY.releaseNonNull(), important, implicit);
+        return true;
+    }
+    case CSSPropertyBackground:
+        return consumeBackgroundShorthand(backgroundShorthand(), important);
+    case CSSPropertyWebkitMask:
+        return consumeBackgroundShorthand(webkitMaskShorthand(), important);
+    case CSSPropertyTransformOrigin:
+        return consumeTransformOrigin(important);
+    case CSSPropertyPerspectiveOrigin:
+        return consumePerspectiveOrigin(important);
+    case CSSPropertyGridGap: {
+        RefPtr<CSSValue> rowGap = consumeLength(m_range, m_context.mode, ValueRangeNonNegative);
+        RefPtr<CSSValue> columnGap = consumeLength(m_range, m_context.mode, ValueRangeNonNegative);
+        if (!rowGap || !m_range.atEnd())
+            return false;
+        if (!columnGap)
+            columnGap = rowGap;
+        addProperty(CSSPropertyGridRowGap, CSSPropertyGridGap, rowGap.releaseNonNull(), important);
+        addProperty(CSSPropertyGridColumnGap, CSSPropertyGridGap, columnGap.releaseNonNull(), important);
+        return true;
+    }
+    case CSSPropertyGridColumn:
+    case CSSPropertyGridRow:
+        return consumeGridItemPositionShorthand(property, important);
+    case CSSPropertyGridArea:
+        return consumeGridAreaShorthand(important);
+    case CSSPropertyGridTemplate:
+        return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
+    case CSSPropertyGrid:
+        return consumeGridShorthand(important);
+    case CSSPropertyWebkitMarquee:
+        return consumeShorthandGreedily(webkitMarqueeShorthand(), important);
+    default:
+        return false;
+    }
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSPropertyParser.h b/Source/WebCore/css/parser/CSSPropertyParser.h
new file mode 100644
index 000000000..76d3c712d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSPropertyParser.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010, 2016 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
+ * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. 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 "CSSParserTokenRange.h"
+#include "StyleRule.h"
+#include <wtf/text/StringView.h>
+
+namespace WebCore {
+
+class CSSProperty;
+class CSSValue;
+class StylePropertyShorthand;
+class StyleSheetContents;
+    
+// Inputs: PropertyID, isImportant bool, CSSParserTokenRange.
+// Outputs: Vector of CSSProperties
+
+class CSSPropertyParser {
+    WTF_MAKE_NONCOPYABLE(CSSPropertyParser);
+public:
+    static bool parseValue(CSSPropertyID, bool important,
+        const CSSParserTokenRange&, const CSSParserContext&, StyleSheetContents*,
+        Vector<CSSProperty, 256>&, StyleRule::Type);
+
+    // Parses a non-shorthand CSS property
+    static RefPtr<CSSValue> parseSingleValue(CSSPropertyID, const CSSParserTokenRange&, const CSSParserContext&, StyleSheetContents*);
+
+private:
+    CSSPropertyParser(const CSSParserTokenRange&, const CSSParserContext&, StyleSheetContents*, Vector<CSSProperty, 256>*);
+
+    // FIXME: Rename once the CSSParserValue-based parseValue is removed
+    bool parseValueStart(CSSPropertyID, bool important);
+    bool consumeCSSWideKeyword(CSSPropertyID, bool important);
+    RefPtr<CSSValue> parseSingleValue(CSSPropertyID, CSSPropertyID = CSSPropertyInvalid);
+
+    bool inQuirksMode() const { return m_context.mode == HTMLQuirksMode; }
+
+    bool parseViewportDescriptor(CSSPropertyID propId, bool important);
+    bool parseFontFaceDescriptor(CSSPropertyID);
+
+    void addProperty(CSSPropertyID, CSSPropertyID, Ref<CSSValue>&&, bool important, bool implicit = false);
+    void addExpandedPropertyForValue(CSSPropertyID propId, Ref<CSSValue>&&, bool);
+
+    bool consumeBorder(bool important);
+
+    bool parseShorthand(CSSPropertyID, bool important);
+    bool consumeShorthandGreedily(const StylePropertyShorthand&, bool important);
+    bool consume4Values(const StylePropertyShorthand&, bool important);
+
+    // Legacy parsing allows <string>s for animation-name
+    bool consumeAnimationShorthand(const StylePropertyShorthand&, bool important);
+    bool consumeBackgroundShorthand(const StylePropertyShorthand&, bool important);
+
+    bool consumeColumns(bool important);
+
+    bool consumeGridItemPositionShorthand(CSSPropertyID, bool important);
+    bool consumeGridTemplateRowsAndAreasAndColumns(CSSPropertyID, bool important);
+    bool consumeGridTemplateShorthand(CSSPropertyID, bool important);
+    bool consumeGridShorthand(bool important);
+    bool consumeGridAreaShorthand(bool important);
+
+    bool consumeFont(bool important);
+    bool consumeFontVariantShorthand(bool important);
+    bool consumeSystemFont(bool important);
+
+    bool consumeBorderSpacing(bool important);
+
+    // CSS3 Parsing Routines (for properties specific to CSS3)
+    bool consumeBorderImage(CSSPropertyID, bool important);
+
+    bool consumeFlex(bool important);
+
+    bool consumeLegacyBreakProperty(CSSPropertyID, bool important);
+
+    bool consumeTransformOrigin(bool important);
+    bool consumePerspectiveOrigin(bool important);
+
+private:
+    // Inputs:
+    CSSParserTokenRange m_range;
+    const CSSParserContext& m_context;
+    StyleSheetContents* m_styleSheetContents;
+
+    // Outputs:
+    Vector<CSSProperty, 256>* m_parsedProperties;
+};
+
+CSSPropertyID cssPropertyID(StringView);
+CSSValueID cssValueKeywordID(StringView);
+bool isCustomPropertyName(const String&);
+
+#if PLATFORM(IOS)
+void cssPropertyNameIOSAliasing(const char* propertyName, const char*& propertyNameAlias, unsigned& newLength);
+#endif
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp b/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
new file mode 100644
index 000000000..a917ed28b
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
@@ -0,0 +1,1348 @@
+// Copyright 2016 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 "CSSPropertyParserHelpers.h"
+
+#include "CSSCalculationValue.h"
+#include "CSSCanvasValue.h"
+#include "CSSCrossfadeValue.h"
+#include "CSSFilterImageValue.h"
+#include "CSSGradientValue.h"
+#include "CSSImageSetValue.h"
+#include "CSSImageValue.h"
+#include "CSSNamedImageValue.h"
+#include "CSSParserIdioms.h"
+#include "CSSValuePool.h"
+#include "Pair.h"
+#include "StyleColor.h"
+
+namespace WebCore {
+
+namespace CSSPropertyParserHelpers {
+
+bool consumeCommaIncludingWhitespace(CSSParserTokenRange& range)
+{
+    CSSParserToken value = range.peek();
+    if (value.type() != CommaToken)
+        return false;
+    range.consumeIncludingWhitespace();
+    return true;
+}
+
+bool consumeSlashIncludingWhitespace(CSSParserTokenRange& range)
+{
+    CSSParserToken value = range.peek();
+    if (value.type() != DelimiterToken || value.delimiter() != '/')
+        return false;
+    range.consumeIncludingWhitespace();
+    return true;
+}
+
+CSSParserTokenRange consumeFunction(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == FunctionToken);
+    CSSParserTokenRange contents = range.consumeBlock();
+    range.consumeWhitespace();
+    contents.consumeWhitespace();
+    return contents;
+}
+
+// FIXME: consider pulling in the parsing logic from CSSCalculationValue.cpp.
+class CalcParser {
+
+public:
+    explicit CalcParser(CSSParserTokenRange& range, ValueRange valueRange = ValueRangeAll)
+        : m_sourceRange(range)
+        , m_range(range)
+    {
+        const CSSParserToken& token = range.peek();
+        if (token.functionId() == CSSValueCalc || token.functionId() == CSSValueWebkitCalc)
+            m_calcValue = CSSCalcValue::create(consumeFunction(m_range), valueRange);
+    }
+
+    const CSSCalcValue* value() const { return m_calcValue.get(); }
+    RefPtr<CSSPrimitiveValue> consumeValue()
+    {
+        if (!m_calcValue)
+            return nullptr;
+        m_sourceRange = m_range;
+        return CSSValuePool::singleton().createValue(m_calcValue.release());
+    }
+    RefPtr<CSSPrimitiveValue> consumeNumber()
+    {
+        if (!m_calcValue)
+            return nullptr;
+        m_sourceRange = m_range;
+        return CSSValuePool::singleton().createValue(m_calcValue->doubleValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
+    }
+
+    bool consumeNumberRaw(double& result)
+    {
+        if (!m_calcValue || m_calcValue->category() != CalcNumber)
+            return false;
+        m_sourceRange = m_range;
+        result = m_calcValue->doubleValue();
+        return true;
+    }
+    
+    bool consumePositiveIntegerRaw(int& result)
+    {
+        if (!m_calcValue || m_calcValue->category() != CalcNumber || !m_calcValue->isInt())
+            return false;
+        result = static_cast<int>(m_calcValue->doubleValue());
+        if (result < 1)
+            return false;
+        m_sourceRange = m_range;
+        return true;
+    }
+
+private:
+    CSSParserTokenRange& m_sourceRange;
+    CSSParserTokenRange m_range;
+    RefPtr<CSSCalcValue> m_calcValue;
+};
+
+RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, double minimumValue)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == NumberToken) {
+        if (token.numericValueType() == NumberValueType || token.numericValue() < minimumValue)
+            return nullptr;
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
+    }
+    CalcParser calcParser(range);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (calculation->category() != CalcNumber || !calculation->isInt())
+            return nullptr;
+        double value = calculation->doubleValue();
+        if (value < minimumValue)
+            return nullptr;
+        return calcParser.consumeNumber();
+    }
+    return nullptr;
+}
+
+RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange& range)
+{
+    return consumeInteger(range, 1);
+}
+
+bool consumePositiveIntegerRaw(CSSParserTokenRange& range, int& result)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == NumberToken) {
+        if (token.numericValueType() == NumberValueType || token.numericValue() < 1)
+            return false;
+        result = range.consumeIncludingWhitespace().numericValue();
+        return true;
+    }
+    CalcParser calcParser(range);
+    return calcParser.consumePositiveIntegerRaw(result);
+}
+    
+bool consumeNumberRaw(CSSParserTokenRange& range, double& result)
+{
+    if (range.peek().type() == NumberToken) {
+        result = range.consumeIncludingWhitespace().numericValue();
+        return true;
+    }
+    CalcParser calcParser(range, ValueRangeAll);
+    return calcParser.consumeNumberRaw(result);
+}
+
+// FIXME: Work out if this can just call consumeNumberRaw
+RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange& range, ValueRange valueRange)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == NumberToken) {
+        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
+            return nullptr;
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
+    }
+    CalcParser calcParser(range, ValueRangeAll);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        // FIXME: Calcs should not be subject to parse time range checks.
+        // spec: https://drafts.csswg.org/css-values-3/#calc-range
+        if (calculation->category() != CalcNumber || (valueRange == ValueRangeNonNegative && calculation->isNegative()))
+            return nullptr;
+        return calcParser.consumeNumber();
+    }
+    return nullptr;
+}
+
+inline bool shouldAcceptUnitlessValue(double value, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    // FIXME: Presentational HTML attributes shouldn't use the CSS parser for lengths
+    return value == 0
+        || isUnitLessValueParsingEnabledForMode(cssParserMode)
+        || (cssParserMode == HTMLQuirksMode && unitless == UnitlessQuirk::Allow);
+}
+
+RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == DimensionToken) {
+        switch (token.unitType()) {
+        case CSSPrimitiveValue::UnitType::CSS_QUIRKY_EMS:
+            if (cssParserMode != UASheetMode)
+                return nullptr;
+            FALLTHROUGH;
+        case CSSPrimitiveValue::UnitType::CSS_EMS:
+        case CSSPrimitiveValue::UnitType::CSS_REMS:
+        case CSSPrimitiveValue::UnitType::CSS_CHS:
+        case CSSPrimitiveValue::UnitType::CSS_EXS:
+        case CSSPrimitiveValue::UnitType::CSS_PX:
+        case CSSPrimitiveValue::UnitType::CSS_CM:
+        case CSSPrimitiveValue::UnitType::CSS_MM:
+        case CSSPrimitiveValue::UnitType::CSS_IN:
+        case CSSPrimitiveValue::UnitType::CSS_PT:
+        case CSSPrimitiveValue::UnitType::CSS_PC:
+        case CSSPrimitiveValue::UnitType::CSS_VW:
+        case CSSPrimitiveValue::UnitType::CSS_VH:
+        case CSSPrimitiveValue::UnitType::CSS_VMIN:
+        case CSSPrimitiveValue::UnitType::CSS_VMAX:
+            break;
+        default:
+            return nullptr;
+        }
+        if ((valueRange == ValueRangeNonNegative && token.numericValue() < 0) || std::isinf(token.numericValue()))
+            return nullptr;
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
+    }
+    if (token.type() == NumberToken) {
+        if (!shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless)
+            || (valueRange == ValueRangeNonNegative && token.numericValue() < 0))
+            return nullptr;
+        if (std::isinf(token.numericValue()))
+            return nullptr;
+        CSSPrimitiveValue::UnitType unitType = CSSPrimitiveValue::UnitType::CSS_PX;
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unitType);
+    }
+    CalcParser calcParser(range, valueRange);
+    if (calcParser.value() && calcParser.value()->category() == CalcLength)
+        return calcParser.consumeValue();
+    return nullptr;
+}
+
+RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange& range, ValueRange valueRange)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == PercentageToken) {
+        if ((valueRange == ValueRangeNonNegative && token.numericValue() < 0) || std::isinf(token.numericValue()))
+            return nullptr;
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+    }
+    CalcParser calcParser(range, valueRange);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (calculation->category() == CalcPercent)
+            return calcParser.consumeValue();
+    }
+    return nullptr;
+}
+
+static bool canConsumeCalcValue(CalculationCategory category, CSSParserMode cssParserMode)
+{
+    if (category == CalcLength || category == CalcPercent || category == CalcPercentLength)
+        return true;
+
+    if (cssParserMode != SVGAttributeMode)
+        return false;
+
+    if (category == CalcNumber || category == CalcPercentNumber)
+        return true;
+
+    return false;
+}
+
+RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == DimensionToken || token.type() == NumberToken)
+        return consumeLength(range, cssParserMode, valueRange, unitless);
+    if (token.type() == PercentageToken)
+        return consumePercent(range, valueRange);
+    CalcParser calcParser(range, valueRange);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (canConsumeCalcValue(calculation->category(), cssParserMode))
+            return calcParser.consumeValue();
+    }
+    return nullptr;
+}
+
+RefPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == DimensionToken) {
+        switch (token.unitType()) {
+        case CSSPrimitiveValue::UnitType::CSS_DEG:
+        case CSSPrimitiveValue::UnitType::CSS_RAD:
+        case CSSPrimitiveValue::UnitType::CSS_GRAD:
+        case CSSPrimitiveValue::UnitType::CSS_TURN:
+            return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
+        default:
+            return nullptr;
+        }
+    }
+    if (token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless)) {
+        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_DEG);
+    }
+
+    CalcParser calcParser(range, ValueRangeAll);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (calculation->category() == CalcAngle)
+            return calcParser.consumeValue();
+    }
+    return nullptr;
+}
+
+RefPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange& range, CSSParserMode cssParserMode, ValueRange valueRange, UnitlessQuirk unitless)
+{
+    const CSSParserToken& token = range.peek();
+    CSSPrimitiveValue::UnitType unit = token.unitType();
+    bool acceptUnitless = token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless);
+    if (acceptUnitless)
+        unit = CSSPrimitiveValue::UnitType::CSS_MS;
+    if (token.type() == DimensionToken || acceptUnitless) {
+        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
+            return nullptr;
+        if (unit == CSSPrimitiveValue::UnitType::CSS_MS || unit == CSSPrimitiveValue::UnitType::CSS_S)
+            return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unit);
+        return nullptr;
+    }
+    CalcParser calcParser(range, valueRange);
+    if (const CSSCalcValue* calculation = calcParser.value()) {
+        if (calculation->category() == CalcTime)
+            return calcParser.consumeValue();
+    }
+    return nullptr;
+}
+
+RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != IdentToken)
+        return nullptr;
+    return CSSValuePool::singleton().createIdentifierValue(range.consumeIncludingWhitespace().id());
+}
+
+RefPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
+{
+    if (range.peek().id() < lower || range.peek().id() > upper)
+        return nullptr;
+    return consumeIdent(range);
+}
+
+// FIXME-NEWPARSER: Eventually we'd like this to use CSSCustomIdentValue, but we need
+// to do other plumbing work first (like changing Pair to CSSValuePair and make it not
+// use only primitive values).
+RefPtr<CSSPrimitiveValue> consumeCustomIdent(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != IdentToken || isCSSWideKeyword(range.peek().id()))
+        return nullptr;
+    return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
+}
+
+RefPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != StringToken)
+        return nullptr;
+    return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
+}
+
+StringView consumeUrlAsStringView(CSSParserTokenRange& range)
+{
+    const CSSParserToken& token = range.peek();
+    if (token.type() == UrlToken) {
+        range.consumeIncludingWhitespace();
+        return token.value();
+    }
+    if (token.functionId() == CSSValueUrl) {
+        CSSParserTokenRange urlRange = range;
+        CSSParserTokenRange urlArgs = urlRange.consumeBlock();
+        const CSSParserToken& next = urlArgs.consumeIncludingWhitespace();
+        if (next.type() == BadStringToken || !urlArgs.atEnd())
+            return StringView();
+        ASSERT(next.type() == StringToken);
+        range = urlRange;
+        range.consumeWhitespace();
+        return next.value();
+    }
+
+    return StringView();
+}
+
+RefPtr<CSSPrimitiveValue> consumeUrl(CSSParserTokenRange& range)
+{
+    StringView url = consumeUrlAsStringView(range);
+    if (url.isNull())
+        return nullptr;
+    return CSSValuePool::singleton().createValue(url.toString(), CSSPrimitiveValue::UnitType::CSS_URI);
+}
+
+static int clampRGBComponent(const CSSPrimitiveValue& value)
+{
+    double result = value.doubleValue();
+    // FIXME: Multiply by 2.55 and round instead of floor.
+    if (value.isPercentage())
+        result *= 2.56;
+    return clampTo<int>(result, 0, 255);
+}
+
+static Color parseRGBParameters(CSSParserTokenRange& range, bool parseAlpha)
+{
+    ASSERT(range.peek().functionId() == CSSValueRgb || range.peek().functionId() == CSSValueRgba);
+    Color result;
+    CSSParserTokenRange args = consumeFunction(range);
+    RefPtr<CSSPrimitiveValue> colorParameter = consumeInteger(args);
+    if (!colorParameter)
+        colorParameter = consumePercent(args, ValueRangeAll);
+    if (!colorParameter)
+        return Color();
+    const bool isPercent = colorParameter->isPercentage();
+    int colorArray[3];
+    colorArray[0] = clampRGBComponent(*colorParameter);
+    for (int i = 1; i < 3; i++) {
+        if (!consumeCommaIncludingWhitespace(args))
+            return Color();
+        colorParameter = isPercent ? consumePercent(args, ValueRangeAll) : consumeInteger(args);
+        if (!colorParameter)
+            return Color();
+        colorArray[i] = clampRGBComponent(*colorParameter);
+    }
+    if (parseAlpha) {
+        if (!consumeCommaIncludingWhitespace(args))
+            return Color();
+        double alpha;
+        if (!consumeNumberRaw(args, alpha))
+            return Color();
+        // Convert the floating pointer number of alpha to an integer in the range [0, 256),
+        // with an equal distribution across all 256 values.
+        int alphaComponent = static_cast<int>(clampTo<double>(alpha, 0.0, 1.0) * nextafter(256.0, 0.0));
+        result = Color(makeRGBA(colorArray[0], colorArray[1], colorArray[2], alphaComponent));
+    } else {
+        result = Color(makeRGB(colorArray[0], colorArray[1], colorArray[2]));
+    }
+
+    if (!args.atEnd())
+        return Color();
+
+    return result;
+}
+
+static Color parseHSLParameters(CSSParserTokenRange& range, bool parseAlpha)
+{
+    ASSERT(range.peek().functionId() == CSSValueHsl || range.peek().functionId() == CSSValueHsla);
+    CSSParserTokenRange args = consumeFunction(range);
+    RefPtr<CSSPrimitiveValue> hslValue = consumeNumber(args, ValueRangeAll);
+    if (!hslValue)
+        return Color();
+    double colorArray[3];
+    colorArray[0] = (((hslValue->intValue() % 360) + 360) % 360) / 360.0;
+    for (int i = 1; i < 3; i++) {
+        if (!consumeCommaIncludingWhitespace(args))
+            return Color();
+        hslValue = consumePercent(args, ValueRangeAll);
+        if (!hslValue)
+            return Color();
+        double doubleValue = hslValue->doubleValue();
+        colorArray[i] = clampTo<double>(doubleValue, 0.0, 100.0) / 100.0; // Needs to be value between 0 and 1.0.
+    }
+    double alpha = 1.0;
+    if (parseAlpha) {
+        if (!consumeCommaIncludingWhitespace(args))
+            return Color();
+        if (!consumeNumberRaw(args, alpha))
+            return Color();
+        alpha = clampTo<double>(alpha, 0.0, 1.0);
+    }
+
+    if (!args.atEnd())
+        return Color();
+
+    return Color(makeRGBAFromHSLA(colorArray[0], colorArray[1], colorArray[2], alpha));
+}
+
+static Color parseColorFunctionParameters(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().functionId() == CSSValueColor);
+    CSSParserTokenRange args = consumeFunction(range);
+
+    ColorSpace colorSpace;
+    switch (args.peek().id()) {
+    case CSSValueSRGB:
+        colorSpace = ColorSpaceSRGB;
+        break;
+    case CSSValueDisplayP3:
+        colorSpace = ColorSpaceDisplayP3;
+        break;
+    default:
+        return Color();
+    }
+    consumeIdent(args);
+
+    double colorChannels[4] = { 0, 0, 0, 1 };
+    for (int i = 0; i < 3; ++i) {
+        double value;
+        if (consumeNumberRaw(args, value))
+            colorChannels[i] = std::max(0.0, std::min(1.0, value));
+        else
+            break;
+    }
+
+    if (consumeSlashIncludingWhitespace(args)) {
+        auto alphaParameter = consumePercent(args, ValueRangeAll);
+        if (!alphaParameter)
+            alphaParameter = consumeNumber(args, ValueRangeAll);
+        if (!alphaParameter)
+            return Color();
+
+        colorChannels[3] = std::max(0.0, std::min(1.0, alphaParameter->isPercentage() ? (alphaParameter->doubleValue() / 100) : alphaParameter->doubleValue()));
+    }
+
+    // FIXME: Support the comma-separated list of fallback color values.
+
+    if (!args.atEnd())
+        return Color();
+    
+    return Color(colorChannels[0], colorChannels[1], colorChannels[2], colorChannels[3], colorSpace);
+}
+
+static Color parseHexColor(CSSParserTokenRange& range, bool acceptQuirkyColors)
+{
+    RGBA32 result;
+    const CSSParserToken& token = range.peek();
+    if (token.type() == HashToken) {
+        if (!Color::parseHexColor(token.value(), result))
+            return Color();
+    } else if (acceptQuirkyColors) {
+        String color;
+        if (token.type() == NumberToken || token.type() == DimensionToken) {
+            if (token.numericValueType() != IntegerValueType
+                || token.numericValue() < 0. || token.numericValue() >= 1000000.)
+                return Color();
+            if (token.type() == NumberToken) // e.g. 112233
+                color = String::format("%d", static_cast<int>(token.numericValue()));
+            else // e.g. 0001FF
+                color = String::number(static_cast<int>(token.numericValue())) + token.value().toString();
+            while (color.length() < 6)
+                color = "0" + color;
+        } else if (token.type() == IdentToken) { // e.g. FF0000
+            color = token.value().toString();
+        }
+        unsigned length = color.length();
+        if (length != 3 && length != 6)
+            return Color();
+        if (!Color::parseHexColor(color, result))
+            return Color();
+    } else {
+        return Color();
+    }
+    range.consumeIncludingWhitespace();
+    return Color(result);
+}
+
+static Color parseColorFunction(CSSParserTokenRange& range)
+{
+    CSSParserTokenRange colorRange = range;
+    CSSValueID functionId = range.peek().functionId();
+    Color color;
+    switch (functionId) {
+    case CSSValueRgb:
+    case CSSValueRgba:
+        color = parseRGBParameters(colorRange, functionId == CSSValueRgba);
+        break;
+    case CSSValueHsl:
+    case CSSValueHsla:
+        color = parseHSLParameters(colorRange, functionId == CSSValueHsla);
+        break;
+    case CSSValueColor:
+        color = parseColorFunctionParameters(colorRange);
+        break;
+    default:
+        return Color();
+    }
+    range = colorRange;
+    return color;
+}
+
+RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool acceptQuirkyColors)
+{
+    CSSValueID id = range.peek().id();
+    if (StyleColor::isColorKeyword(id)) {
+        if (!isValueAllowedInMode(id, cssParserMode))
+            return nullptr;
+        return consumeIdent(range);
+    }
+    Color color = parseHexColor(range, acceptQuirkyColors);
+    if (!color.isValid())
+        color = parseColorFunction(range);
+    if (!color.isValid())
+        return nullptr;
+    return CSSValuePool::singleton().createValue(color);
+}
+
+static RefPtr<CSSPrimitiveValue> consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    if (range.peek().type() == IdentToken)
+        return consumeIdent<CSSValueLeft, CSSValueTop, CSSValueBottom, CSSValueRight, CSSValueCenter>(range);
+    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
+}
+
+static bool isHorizontalPositionKeywordOnly(const CSSPrimitiveValue& value)
+{
+    return value.isValueID() && (value.valueID() == CSSValueLeft || value.valueID() == CSSValueRight);
+}
+
+static bool isVerticalPositionKeywordOnly(const CSSPrimitiveValue& value)
+{
+    return value.isValueID() && (value.valueID() == CSSValueTop || value.valueID() == CSSValueBottom);
+}
+
+static void positionFromOneValue(CSSPrimitiveValue& value, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
+{
+    bool valueAppliesToYAxisOnly = isVerticalPositionKeywordOnly(value);
+    resultX = &value;
+    resultY = CSSPrimitiveValue::createIdentifier(CSSValueCenter);
+    if (valueAppliesToYAxisOnly)
+        std::swap(resultX, resultY);
+}
+
+static bool positionFromTwoValues(CSSPrimitiveValue& value1, CSSPrimitiveValue& value2,
+    RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
+{
+    bool mustOrderAsXY = isHorizontalPositionKeywordOnly(value1) || isVerticalPositionKeywordOnly(value2)
+        || !value1.isValueID() || !value2.isValueID();
+    bool mustOrderAsYX = isVerticalPositionKeywordOnly(value1) || isHorizontalPositionKeywordOnly(value2);
+    if (mustOrderAsXY && mustOrderAsYX)
+        return false;
+    resultX = &value1;
+    resultY = &value2;
+    if (mustOrderAsYX)
+        std::swap(resultX, resultY);
+    return true;
+}
+
+    
+template<typename... Args>
+static Ref<CSSPrimitiveValue> createPrimitiveValuePair(Args&&... args)
+{
+    return CSSValuePool::singleton().createValue(Pair::create(std::forward<Args>(args)...));
+}
+
+static bool positionFromThreeOrFourValues(CSSPrimitiveValue** values, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
+{
+    CSSPrimitiveValue* center = nullptr;
+    for (int i = 0; values[i]; i++) {
+        CSSPrimitiveValue* currentValue = values[i];
+        if (!currentValue->isValueID())
+            return false;
+        CSSValueID id = currentValue->valueID();
+
+        if (id == CSSValueCenter) {
+            if (center)
+                return false;
+            center = currentValue;
+            continue;
+        }
+
+        RefPtr<CSSPrimitiveValue> result;
+        if (values[i + 1] && !values[i + 1]->isValueID())
+            result = createPrimitiveValuePair(currentValue, values[++i]);
+        else
+            result = currentValue;
+
+        if (id == CSSValueLeft || id == CSSValueRight) {
+            if (resultX)
+                return false;
+            resultX = result;
+        } else {
+            ASSERT(id == CSSValueTop || id == CSSValueBottom);
+            if (resultY)
+                return false;
+            resultY = result;
+        }
+    }
+
+    if (center) {
+        ASSERT(resultX || resultY);
+        if (resultX && resultY)
+            return false;
+        if (!resultX)
+            resultX = center;
+        else
+            resultY = center;
+    }
+
+    ASSERT(resultX && resultY);
+    return true;
+}
+
+// FIXME: This may consume from the range upon failure. The background
+// shorthand works around it, but we should just fix it here.
+bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
+{
+    RefPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
+    if (!value1)
+        return false;
+
+    RefPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
+    if (!value2) {
+        positionFromOneValue(*value1, resultX, resultY);
+        return true;
+    }
+
+    RefPtr<CSSPrimitiveValue> value3 = consumePositionComponent(range, cssParserMode, unitless);
+    if (!value3)
+        return positionFromTwoValues(*value1, *value2, resultX, resultY);
+
+    RefPtr<CSSPrimitiveValue> value4 = consumePositionComponent(range, cssParserMode, unitless);
+    CSSPrimitiveValue* values[5];
+    values[0] = value1.get();
+    values[1] = value2.get();
+    values[2] = value3.get();
+    values[3] = value4.get();
+    values[4] = nullptr;
+    return positionFromThreeOrFourValues(values, resultX, resultY);
+}
+
+RefPtr<CSSPrimitiveValue> consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+{
+    RefPtr<CSSPrimitiveValue> resultX;
+    RefPtr<CSSPrimitiveValue> resultY;
+    if (consumePosition(range, cssParserMode, unitless, resultX, resultY))
+        return createPrimitiveValuePair(resultX.releaseNonNull(), resultY.releaseNonNull());
+    return nullptr;
+}
+
+bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY)
+{
+    RefPtr<CSSPrimitiveValue> value1 = consumePositionComponent(range, cssParserMode, unitless);
+    if (!value1)
+        return false;
+    RefPtr<CSSPrimitiveValue> value2 = consumePositionComponent(range, cssParserMode, unitless);
+    if (!value2) {
+        positionFromOneValue(*value1, resultX, resultY);
+        return true;
+    }
+    return positionFromTwoValues(*value1, *value2, resultX, resultY);
+}
+
+// This should go away once we drop support for -webkit-gradient
+static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientPoint(CSSParserTokenRange& args, bool horizontal)
+{
+    if (args.peek().type() == IdentToken) {
+        if ((horizontal && consumeIdent<CSSValueLeft>(args)) || (!horizontal && consumeIdent<CSSValueTop>(args)))
+            return CSSValuePool::singleton().createValue(0., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+        if ((horizontal && consumeIdent<CSSValueRight>(args)) || (!horizontal && consumeIdent<CSSValueBottom>(args)))
+            return CSSValuePool::singleton().createValue(100., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+        if (consumeIdent<CSSValueCenter>(args))
+            return CSSValuePool::singleton().createValue(50., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
+        return nullptr;
+    }
+    RefPtr<CSSPrimitiveValue> result = consumePercent(args, ValueRangeAll);
+    if (!result)
+        result = consumeNumber(args, ValueRangeAll);
+    return result;
+}
+
+// Used to parse colors for -webkit-gradient(...).
+static RefPtr<CSSPrimitiveValue> consumeDeprecatedGradientStopColor(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+{
+    if (args.peek().id() == CSSValueCurrentcolor)
+        return nullptr;
+    return consumeColor(args, cssParserMode);
+}
+
+static bool consumeDeprecatedGradientColorStop(CSSParserTokenRange& range, CSSGradientColorStop& stop, CSSParserMode cssParserMode)
+{
+    CSSValueID id = range.peek().functionId();
+    if (id != CSSValueFrom && id != CSSValueTo && id != CSSValueColorStop)
+        return false;
+
+    CSSParserTokenRange args = consumeFunction(range);
+    double position;
+    if (id == CSSValueFrom || id == CSSValueTo) {
+        position = (id == CSSValueFrom) ? 0 : 1;
+    } else {
+        ASSERT(id == CSSValueColorStop);
+        const CSSParserToken& arg = args.consumeIncludingWhitespace();
+        if (arg.type() == PercentageToken)
+            position = arg.numericValue() / 100.0;
+        else if (arg.type() == NumberToken)
+            position = arg.numericValue();
+        else
+            return false;
+
+        if (!consumeCommaIncludingWhitespace(args))
+            return false;
+    }
+
+    stop.m_position = CSSValuePool::singleton().createValue(position, CSSPrimitiveValue::UnitType::CSS_NUMBER);
+    stop.m_color = consumeDeprecatedGradientStopColor(args, cssParserMode);
+    return stop.m_color && args.atEnd();
+}
+
+static RefPtr<CSSValue> consumeDeprecatedGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+{
+    RefPtr<CSSGradientValue> result;
+    CSSValueID id = args.consumeIncludingWhitespace().id();
+    bool isDeprecatedRadialGradient = (id == CSSValueRadial);
+    if (isDeprecatedRadialGradient)
+        result = CSSRadialGradientValue::create(NonRepeating, CSSDeprecatedRadialGradient);
+    else if (id == CSSValueLinear)
+        result = CSSLinearGradientValue::create(NonRepeating, CSSDeprecatedLinearGradient);
+    if (!result || !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    RefPtr<CSSPrimitiveValue> point = consumeDeprecatedGradientPoint(args, true);
+    if (!point)
+        return nullptr;
+    result->setFirstX(point.copyRef());
+    point = consumeDeprecatedGradientPoint(args, false);
+    if (!point)
+        return nullptr;
+    result->setFirstY(point.copyRef());
+
+    if (!consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    // For radial gradients only, we now expect a numeric radius.
+    if (isDeprecatedRadialGradient) {
+        RefPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
+        if (!radius || !consumeCommaIncludingWhitespace(args))
+            return nullptr;
+        downcast<CSSRadialGradientValue>(result.get())->setFirstRadius(radius.copyRef());
+    }
+
+    point = consumeDeprecatedGradientPoint(args, true);
+    if (!point)
+        return nullptr;
+    result->setSecondX(point.copyRef());
+    point = consumeDeprecatedGradientPoint(args, false);
+    if (!point)
+        return nullptr;
+    result->setSecondY(point.copyRef());
+
+    // For radial gradients only, we now expect the second radius.
+    if (isDeprecatedRadialGradient) {
+        if (!consumeCommaIncludingWhitespace(args))
+            return nullptr;
+        RefPtr<CSSPrimitiveValue> radius = consumeNumber(args, ValueRangeAll);
+        if (!radius)
+            return nullptr;
+        downcast<CSSRadialGradientValue>(result.get())->setSecondRadius(radius.copyRef());
+    }
+
+    CSSGradientColorStop stop;
+    while (consumeCommaIncludingWhitespace(args)) {
+        if (!consumeDeprecatedGradientColorStop(args, stop, cssParserMode))
+            return nullptr;
+        result->addStop(stop);
+    }
+
+    return result;
+}
+
+static bool consumeGradientColorStops(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSGradientValue* gradient)
+{
+    bool supportsColorHints = gradient->gradientType() == CSSLinearGradient || gradient->gradientType() == CSSRadialGradient;
+
+    // The first color stop cannot be a color hint.
+    bool previousStopWasColorHint = true;
+    do {
+        CSSGradientColorStop stop;
+        stop.m_color = consumeColor(range, cssParserMode);
+        // Two hints in a row are not allowed.
+        if (!stop.m_color && (!supportsColorHints || previousStopWasColorHint))
+            return false;
+        
+        previousStopWasColorHint = !stop.m_color;
+        
+        // FIXME-NEWPARSER: This boolean could be removed. Null checking color would be sufficient.
+        stop.isMidpoint = !stop.m_color;
+
+        stop.m_position = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
+        if (!stop.m_color && !stop.m_position)
+            return false;
+        gradient->addStop(stop);
+    } while (consumeCommaIncludingWhitespace(range));
+
+    // The last color stop cannot be a color hint.
+    if (previousStopWasColorHint)
+        return false;
+
+    // Must have 2 or more stops to be valid.
+    return gradient->stopCount() >= 2;
+}
+
+static RefPtr<CSSValue> consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
+{
+    RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
+    RefPtr<CSSPrimitiveValue> centerX;
+    RefPtr<CSSPrimitiveValue> centerY;
+    consumeOneOrTwoValuedPosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
+    if ((centerX || centerY) && !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    result->setFirstX(centerX.copyRef());
+    result->setFirstY(centerY.copyRef());
+    result->setSecondX(centerX.copyRef());
+    result->setSecondY(centerY.copyRef());
+
+    RefPtr<CSSPrimitiveValue> shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
+    RefPtr<CSSPrimitiveValue> sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
+    if (!shape)
+        shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
+    result->setShape(shape.copyRef());
+    result->setSizingBehavior(sizeKeyword.copyRef());
+
+    // Or, two lengths or percentages
+    if (!shape && !sizeKeyword) {
+        RefPtr<CSSPrimitiveValue> horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+        RefPtr<CSSPrimitiveValue> verticalSize;
+        if (horizontalSize) {
+            verticalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+            if (!verticalSize)
+                return nullptr;
+            consumeCommaIncludingWhitespace(args);
+            result->setEndHorizontalSize(horizontalSize.copyRef());
+            result->setEndVerticalSize(verticalSize.copyRef());
+        }
+    } else {
+        consumeCommaIncludingWhitespace(args);
+    }
+    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
+        return nullptr;
+
+    return result;
+}
+
+static RefPtr<CSSValue> consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
+{
+    RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
+
+    RefPtr<CSSPrimitiveValue> shape;
+    RefPtr<CSSPrimitiveValue> sizeKeyword;
+    RefPtr<CSSPrimitiveValue> horizontalSize;
+    RefPtr<CSSPrimitiveValue> verticalSize;
+
+    // First part of grammar, the size/shape clause:
+    // [ circle || <length> ] |
+    // [ ellipse || [ <length> | <percentage> ]{2} ] |
+    // [ [ circle | ellipse] || <size-keyword> ]
+    for (int i = 0; i < 3; ++i) {
+        if (args.peek().type() == IdentToken) {
+            CSSValueID id = args.peek().id();
+            if (id == CSSValueCircle || id == CSSValueEllipse) {
+                if (shape)
+                    return nullptr;
+                shape = consumeIdent(args);
+            } else if (id == CSSValueClosestSide || id == CSSValueClosestCorner || id == CSSValueFarthestSide || id == CSSValueFarthestCorner) {
+                if (sizeKeyword)
+                    return nullptr;
+                sizeKeyword = consumeIdent(args);
+            } else {
+                break;
+            }
+        } else {
+            RefPtr<CSSPrimitiveValue> center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+            if (!center)
+                break;
+            if (horizontalSize)
+                return nullptr;
+            horizontalSize = center;
+            center = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
+            if (center) {
+                verticalSize = center;
+                ++i;
+            }
+        }
+    }
+
+    // You can specify size as a keyword or a length/percentage, not both.
+    if (sizeKeyword && horizontalSize)
+        return nullptr;
+    // Circles must have 0 or 1 lengths.
+    if (shape && shape->valueID() == CSSValueCircle && verticalSize)
+        return nullptr;
+    // Ellipses must have 0 or 2 length/percentages.
+    if (shape && shape->valueID() == CSSValueEllipse && horizontalSize && !verticalSize)
+        return nullptr;
+    // If there's only one size, it must be a length.
+    if (!verticalSize && horizontalSize && horizontalSize->isPercentage())
+        return nullptr;
+    if ((horizontalSize && horizontalSize->isCalculatedPercentageWithLength())
+        || (verticalSize && verticalSize->isCalculatedPercentageWithLength()))
+        return nullptr;
+
+    result->setShape(shape.copyRef());
+    result->setSizingBehavior(sizeKeyword.copyRef());
+    result->setEndHorizontalSize(horizontalSize.copyRef());
+    result->setEndVerticalSize(verticalSize.copyRef());
+
+    RefPtr<CSSPrimitiveValue> centerX;
+    RefPtr<CSSPrimitiveValue> centerY;
+    if (args.peek().id() == CSSValueAt) {
+        args.consumeIncludingWhitespace();
+        consumePosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
+        if (!(centerX && centerY))
+            return nullptr;
+        
+        result->setFirstX(centerX.copyRef());
+        result->setFirstY(centerY.copyRef());
+        
+        // Right now, CSS radial gradients have the same start and end centers.
+        result->setSecondX(centerX.copyRef());
+        result->setSecondY(centerY.copyRef());
+    }
+
+    if ((shape || sizeKeyword || horizontalSize || centerX || centerY) && !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
+        return nullptr;
+    return result;
+}
+
+static RefPtr<CSSValue> consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
+{
+    RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, gradientType);
+
+    bool expectComma = true;
+    RefPtr<CSSPrimitiveValue> angle = consumeAngle(args, cssParserMode, UnitlessQuirk::Forbid);
+    if (angle)
+        result->setAngle(angle.releaseNonNull());
+    else if (gradientType == CSSPrefixedLinearGradient || consumeIdent<CSSValueTo>(args)) {
+        RefPtr<CSSPrimitiveValue> endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
+        RefPtr<CSSPrimitiveValue> endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
+        if (!endX && !endY) {
+            if (gradientType == CSSLinearGradient)
+                return nullptr;
+            endY = CSSPrimitiveValue::createIdentifier(CSSValueTop);
+            expectComma = false;
+        } else if (!endX) {
+            endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
+        }
+
+        result->setFirstX(endX.copyRef());
+        result->setFirstY(endY.copyRef());
+    } else {
+        expectComma = false;
+    }
+
+    if (expectComma && !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+    if (!consumeGradientColorStops(args, cssParserMode, result.get()))
+        return nullptr;
+    return result;
+}
+
+RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange& range, CSSParserContext context)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+    return consumeImage(range, context);
+}
+
+static RefPtr<CSSValue> consumeCrossFade(CSSParserTokenRange& args, CSSParserContext context, bool prefixed)
+{
+    RefPtr<CSSValue> fromImageValue = consumeImageOrNone(args, context);
+    if (!fromImageValue || !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+    RefPtr<CSSValue> toImageValue = consumeImageOrNone(args, context);
+    if (!toImageValue || !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    RefPtr<CSSPrimitiveValue> percentage;
+    const CSSParserToken& percentageArg = args.consumeIncludingWhitespace();
+    if (percentageArg.type() == PercentageToken)
+        percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitType::CSS_NUMBER);
+    else if (percentageArg.type() == NumberToken)
+        percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue(), 0, 1), CSSPrimitiveValue::UnitType::CSS_NUMBER);
+
+    if (!percentage)
+        return nullptr;
+    return CSSCrossfadeValue::create(fromImageValue.releaseNonNull(), toImageValue.releaseNonNull(), percentage.releaseNonNull(), prefixed);
+}
+
+static RefPtr<CSSValue> consumeWebkitCanvas(CSSParserTokenRange& args)
+{
+    if (args.peek().type() != IdentToken)
+        return nullptr;
+    auto canvasName = args.consumeIncludingWhitespace().value().toString();
+    if (!args.atEnd())
+        return nullptr;
+    return CSSCanvasValue::create(canvasName);
+}
+
+static RefPtr<CSSValue> consumeWebkitNamedImage(CSSParserTokenRange& args)
+{
+    if (args.peek().type() != IdentToken)
+        return nullptr;
+    auto imageName = args.consumeIncludingWhitespace().value().toString();
+    if (!args.atEnd())
+        return nullptr;
+    return CSSNamedImageValue::create(imageName);
+}
+
+static RefPtr<CSSValue> consumeFilterImage(CSSParserTokenRange& args, const CSSParserContext& context)
+{
+    auto imageValue = consumeImageOrNone(args, context);
+    if (!imageValue || !consumeCommaIncludingWhitespace(args))
+        return nullptr;
+
+    auto filterValue = consumeFilter(args, context);
+
+    if (!filterValue)
+        return nullptr;
+
+    if (!args.atEnd())
+        return nullptr;
+
+    return CSSFilterImageValue::create(imageValue.releaseNonNull(), filterValue.releaseNonNull());
+}
+
+static RefPtr<CSSValue> consumeGeneratedImage(CSSParserTokenRange& range, CSSParserContext context)
+{
+    CSSValueID id = range.peek().functionId();
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+    RefPtr<CSSValue> result;
+    if (id == CSSValueRadialGradient)
+        result = consumeRadialGradient(args, context.mode, NonRepeating);
+    else if (id == CSSValueRepeatingRadialGradient)
+        result = consumeRadialGradient(args, context.mode, Repeating);
+    else if (id == CSSValueWebkitLinearGradient)
+        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSPrefixedLinearGradient);
+    else if (id == CSSValueWebkitRepeatingLinearGradient)
+        result = consumeLinearGradient(args, context.mode, Repeating, CSSPrefixedLinearGradient);
+    else if (id == CSSValueRepeatingLinearGradient)
+        result = consumeLinearGradient(args, context.mode, Repeating, CSSLinearGradient);
+    else if (id == CSSValueLinearGradient)
+        result = consumeLinearGradient(args, context.mode, NonRepeating, CSSLinearGradient);
+    else if (id == CSSValueWebkitGradient)
+        result = consumeDeprecatedGradient(args, context.mode);
+    else if (id == CSSValueWebkitRadialGradient)
+        result = consumeDeprecatedRadialGradient(args, context.mode, NonRepeating);
+    else if (id == CSSValueWebkitRepeatingRadialGradient)
+        result = consumeDeprecatedRadialGradient(args, context.mode, Repeating);
+    else if (id == CSSValueWebkitCrossFade || id == CSSValueCrossFade)
+        result = consumeCrossFade(args, context, id == CSSValueWebkitCrossFade);
+    else if (id == CSSValueWebkitCanvas)
+        result = consumeWebkitCanvas(args);
+    else if (id == CSSValueWebkitNamedImage)
+        result = consumeWebkitNamedImage(args);
+    else if (id == CSSValueWebkitFilter || id == CSSValueFilter)
+        result = consumeFilterImage(args, context);
+    if (!result || !args.atEnd())
+        return nullptr;
+    range = rangeCopy;
+    return result;
+}
+
+static RefPtr<CSSValue> consumeImageSet(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    CSSParserTokenRange rangeCopy = range;
+    CSSParserTokenRange args = consumeFunction(rangeCopy);
+    RefPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
+    do {
+        AtomicString urlValue = consumeUrlAsStringView(args).toAtomicString();
+        if (urlValue.isNull())
+            return nullptr;
+
+        RefPtr<CSSValue> image = CSSImageValue::create(completeURL(context, urlValue));
+        imageSet->append(image.releaseNonNull());
+
+        const CSSParserToken& token = args.consumeIncludingWhitespace();
+        if (token.type() != DimensionToken)
+            return nullptr;
+        if (token.value() != "x")
+            return nullptr;
+        ASSERT(token.unitType() == CSSPrimitiveValue::UnitType::CSS_UNKNOWN);
+        double imageScaleFactor = token.numericValue();
+        if (imageScaleFactor <= 0)
+            return nullptr;
+        imageSet->append(CSSValuePool::singleton().createValue(imageScaleFactor, CSSPrimitiveValue::UnitType::CSS_NUMBER));
+    } while (consumeCommaIncludingWhitespace(args));
+    if (!args.atEnd())
+        return nullptr;
+    range = rangeCopy;
+    return imageSet;
+}
+
+static bool isGeneratedImage(CSSValueID id)
+{
+    return id == CSSValueLinearGradient || id == CSSValueRadialGradient
+        || id == CSSValueRepeatingLinearGradient || id == CSSValueRepeatingRadialGradient
+        || id == CSSValueWebkitLinearGradient || id == CSSValueWebkitRadialGradient
+        || id == CSSValueWebkitRepeatingLinearGradient || id == CSSValueWebkitRepeatingRadialGradient
+        || id == CSSValueWebkitGradient || id == CSSValueWebkitCrossFade || id == CSSValueWebkitCanvas
+        || id == CSSValueCrossFade || id == CSSValueWebkitNamedImage || id == CSSValueWebkitFilter || id == CSSValueFilter;
+}
+    
+static bool isValidPrimitiveFilterFunction(CSSValueID filterFunction)
+{
+    switch (filterFunction) {
+    case CSSValueBlur:
+    case CSSValueBrightness:
+    case CSSValueContrast:
+    case CSSValueDropShadow:
+    case CSSValueGrayscale:
+    case CSSValueHueRotate:
+    case CSSValueInvert:
+    case CSSValueOpacity:
+    case CSSValueSaturate:
+    case CSSValueSepia:
+        return true;
+    default:
+        return false;
+    }
+}
+
+RefPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    CSSValueID filterType = range.peek().functionId();
+    if (!isValidPrimitiveFilterFunction(filterType))
+        return nullptr;
+    CSSParserTokenRange args = consumeFunction(range);
+    RefPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
+    RefPtr<CSSValue> parsedValue;
+
+    if (filterType == CSSValueDropShadow)
+        parsedValue = consumeSingleShadow(args, context.mode, false, false);
+    else {
+        if (args.atEnd())
+            return filterValue;
+        if (filterType == CSSValueBrightness) {
+            parsedValue = consumePercent(args, ValueRangeAll);
+            if (!parsedValue)
+                parsedValue = consumeNumber(args, ValueRangeAll);
+        } else if (filterType == CSSValueHueRotate)
+            parsedValue = consumeAngle(args, context.mode, UnitlessQuirk::Forbid);
+        else if (filterType == CSSValueBlur)
+            parsedValue = consumeLength(args, HTMLStandardMode, ValueRangeNonNegative);
+        else {
+            parsedValue = consumePercent(args, ValueRangeNonNegative);
+            if (!parsedValue)
+                parsedValue = consumeNumber(args, ValueRangeNonNegative);
+            if (parsedValue && filterType != CSSValueSaturate && filterType != CSSValueContrast) {
+                bool isPercentage = downcast<CSSPrimitiveValue>(*parsedValue).isPercentage();
+                double maxAllowed = isPercentage ? 100.0 : 1.0;
+                if (downcast<CSSPrimitiveValue>(*parsedValue).doubleValue() > maxAllowed)
+                    parsedValue = CSSPrimitiveValue::create(maxAllowed, isPercentage ? CSSPrimitiveValue::UnitType::CSS_PERCENTAGE : CSSPrimitiveValue::UnitType::CSS_NUMBER);
+            }
+        }
+    }
+    if (!parsedValue || !args.atEnd())
+        return nullptr;
+    filterValue->append(parsedValue.releaseNonNull());
+    return filterValue;
+}
+
+RefPtr<CSSValue> consumeFilter(CSSParserTokenRange& range, const CSSParserContext& context)
+{
+    if (range.peek().id() == CSSValueNone)
+        return consumeIdent(range);
+
+    auto list = CSSValueList::createSpaceSeparated();
+    do {
+        RefPtr<CSSValue> filterValue = consumeUrl(range);
+        if (!filterValue) {
+            filterValue = consumeFilterFunction(range, context);
+            if (!filterValue)
+                return nullptr;
+        }
+        list->append(filterValue.releaseNonNull());
+    } while (!range.atEnd());
+
+    return list.ptr();
+}
+
+RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool allowInset, bool allowSpread)
+{
+    RefPtr<CSSPrimitiveValue> style;
+    RefPtr<CSSPrimitiveValue> color;
+
+    if (range.atEnd())
+        return nullptr;
+    if (range.peek().id() == CSSValueInset) {
+        if (!allowInset)
+            return nullptr;
+        style = consumeIdent(range);
+    }
+    color = consumeColor(range, cssParserMode);
+
+    auto horizontalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
+    if (!horizontalOffset)
+        return nullptr;
+
+    auto verticalOffset = consumeLength(range, cssParserMode, ValueRangeAll);
+    if (!verticalOffset)
+        return nullptr;
+
+    auto blurRadius = consumeLength(range, cssParserMode, ValueRangeAll);
+    RefPtr<CSSPrimitiveValue> spreadDistance;
+    if (blurRadius) {
+        // Blur radius must be non-negative.
+        if (blurRadius->doubleValue() < 0)
+            return nullptr;
+        if (allowSpread)
+            spreadDistance = consumeLength(range, cssParserMode, ValueRangeAll);
+    }
+
+    if (!range.atEnd()) {
+        if (!color)
+            color = consumeColor(range, cssParserMode);
+        if (range.peek().id() == CSSValueInset) {
+            if (!allowInset || style)
+                return nullptr;
+            style = consumeIdent(range);
+        }
+    }
+
+    return CSSShadowValue::create(WTFMove(horizontalOffset), WTFMove(verticalOffset), WTFMove(blurRadius), WTFMove(spreadDistance), WTFMove(style), WTFMove(color));
+}
+
+RefPtr<CSSValue> consumeImage(CSSParserTokenRange& range, CSSParserContext context, ConsumeGeneratedImage generatedImage)
+{
+    AtomicString uri = consumeUrlAsStringView(range).toAtomicString();
+    if (!uri.isNull())
+        return CSSImageValue::create(completeURL(context, uri));
+    if (range.peek().type() == FunctionToken) {
+        CSSValueID id = range.peek().functionId();
+        if (id == CSSValueWebkitImageSet || id == CSSValueImageSet)
+            return consumeImageSet(range, context);
+        if (generatedImage == ConsumeGeneratedImage::Allow && isGeneratedImage(id))
+            return consumeGeneratedImage(range, context);
+    }
+    return nullptr;
+}
+
+} // namespace CSSPropertyParserHelpers
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSPropertyParserHelpers.h b/Source/WebCore/css/parser/CSSPropertyParserHelpers.h
new file mode 100644
index 000000000..754e3e5eb
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSPropertyParserHelpers.h
@@ -0,0 +1,122 @@
+// Copyright 2016 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 "CSSCustomIdentValue.h"
+#include "CSSFunctionValue.h"
+#include "CSSParserMode.h"
+#include "CSSParserTokenRange.h"
+#include "CSSPrimitiveValue.h"
+#include "CSSShadowValue.h"
+#include "CSSValuePool.h"
+#include "Length.h" // For ValueRange
+
+namespace WebCore {
+
+// When these functions are successful, they will consume all the relevant
+// tokens from the range and also consume any whitespace which follows. When
+// the start of the range doesn't match the type we're looking for, the range
+// will not be modified.
+namespace CSSPropertyParserHelpers {
+
+// FIXME: These should probably just be consumeComma and consumeSlash.
+bool consumeCommaIncludingWhitespace(CSSParserTokenRange&);
+bool consumeSlashIncludingWhitespace(CSSParserTokenRange&);
+// consumeFunction expects the range starts with a FunctionToken.
+CSSParserTokenRange consumeFunction(CSSParserTokenRange&);
+
+enum class UnitlessQuirk {
+    Allow,
+    Forbid
+};
+
+RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange&, double minimumValue = -std::numeric_limits<double>::max());
+bool consumePositiveIntegerRaw(CSSParserTokenRange&, int& result);
+RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange&);
+bool consumeNumberRaw(CSSParserTokenRange&, double& result);
+RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange&, ValueRange);
+RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
+RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange&, ValueRange);
+RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
+RefPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk = UnitlessQuirk::Forbid);
+RefPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
+
+RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
+RefPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange&, CSSValueID lower, CSSValueID upper);
+template<CSSValueID, CSSValueID...> inline bool identMatches(CSSValueID id);
+template<CSSValueID... allowedIdents> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
+
+RefPtr<CSSPrimitiveValue> consumeCustomIdent(CSSParserTokenRange&);
+RefPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange&);
+StringView consumeUrlAsStringView(CSSParserTokenRange&);
+RefPtr<CSSPrimitiveValue> consumeUrl(CSSParserTokenRange&);
+
+RefPtr<CSSPrimitiveValue> consumeColor(CSSParserTokenRange&, CSSParserMode, bool acceptQuirkyColors = false);
+
+RefPtr<CSSPrimitiveValue> consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
+bool consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY);
+bool consumeOneOrTwoValuedPosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, RefPtr<CSSPrimitiveValue>& resultX, RefPtr<CSSPrimitiveValue>& resultY);
+
+enum class ConsumeGeneratedImage {
+    Allow,
+    Forbid
+};
+
+RefPtr<CSSValue> consumeImage(CSSParserTokenRange&, CSSParserContext, ConsumeGeneratedImage = ConsumeGeneratedImage::Allow);
+RefPtr<CSSValue> consumeImageOrNone(CSSParserTokenRange&, CSSParserContext);
+
+RefPtr<CSSValue> consumeFilter(CSSParserTokenRange&, const CSSParserContext&);
+RefPtr<CSSFunctionValue> consumeFilterFunction(CSSParserTokenRange&, const CSSParserContext&);
+RefPtr<CSSShadowValue> consumeSingleShadow(CSSParserTokenRange&, CSSParserMode, bool allowInset, bool allowSpread);
+
+// Template implementations are at the bottom of the file for readability.
+
+template<typename... emptyBaseCase> inline bool identMatches(CSSValueID) { return false; }
+template<CSSValueID head, CSSValueID... tail> inline bool identMatches(CSSValueID id)
+{
+    return id == head || identMatches<tail...>(id);
+}
+
+// FIXME-NEWPARSER - converted to a RefPtr return type from a raw ptr.
+template<CSSValueID... names> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
+        return nullptr;
+    return CSSValuePool::singleton().createIdentifierValue(range.consumeIncludingWhitespace().id());
+}
+
+static inline bool isCSSWideKeyword(const CSSValueID& id)
+{
+    return id == CSSValueInitial || id == CSSValueInherit || id == CSSValueUnset || id == CSSValueRevert || id == CSSValueDefault;
+}
+
+} // namespace CSSPropertyParserHelpers
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSSelectorParser.cpp b/Source/WebCore/css/parser/CSSSelectorParser.cpp
new file mode 100644
index 000000000..08892c955
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSSelectorParser.cpp
@@ -0,0 +1,891 @@
+// 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 "CSSSelectorParser.h"
+
+#include "CSSParserIdioms.h"
+#include "CSSParserMode.h"
+#include "CSSSelectorList.h"
+#include "StyleSheetContents.h"
+#include <memory>
+
+namespace WebCore {
+
+CSSSelectorList CSSSelectorParser::parseSelector(CSSParserTokenRange range, const CSSParserContext& context, StyleSheetContents* styleSheet)
+{
+    CSSSelectorParser parser(context, styleSheet);
+    range.consumeWhitespace();
+    CSSSelectorList result = parser.consumeComplexSelectorList(range);
+    if (!range.atEnd())
+        return CSSSelectorList();
+    return result;
+}
+
+CSSSelectorParser::CSSSelectorParser(const CSSParserContext& context, StyleSheetContents* styleSheet)
+    : m_context(context)
+    , m_styleSheet(styleSheet)
+{
+}
+
+CSSSelectorList CSSSelectorParser::consumeComplexSelectorList(CSSParserTokenRange& range)
+{
+    Vector<std::unique_ptr<CSSParserSelector>> selectorList;
+    std::unique_ptr<CSSParserSelector> selector = consumeComplexSelector(range);
+    if (!selector)
+        return CSSSelectorList();
+    selectorList.append(WTFMove(selector));
+    while (!range.atEnd() && range.peek().type() == CommaToken) {
+        range.consumeIncludingWhitespace();
+        selector = consumeComplexSelector(range);
+        if (!selector)
+            return CSSSelectorList();
+        selectorList.append(WTFMove(selector));
+    }
+
+    CSSSelectorList list;
+    if (m_failedParsing)
+        return list;
+    list.adoptSelectorVector(selectorList);
+    return list;
+}
+
+CSSSelectorList CSSSelectorParser::consumeCompoundSelectorList(CSSParserTokenRange& range)
+{
+    Vector<std::unique_ptr<CSSParserSelector>> selectorList;
+    std::unique_ptr<CSSParserSelector> selector = consumeCompoundSelector(range);
+    range.consumeWhitespace();
+    if (!selector)
+        return CSSSelectorList();
+    selectorList.append(WTFMove(selector));
+    while (!range.atEnd() && range.peek().type() == CommaToken) {
+        range.consumeIncludingWhitespace();
+        selector = consumeCompoundSelector(range);
+        range.consumeWhitespace();
+        if (!selector)
+            return CSSSelectorList();
+        selectorList.append(WTFMove(selector));
+    }
+
+    CSSSelectorList list;
+    if (m_failedParsing)
+        return list;
+    list.adoptSelectorVector(selectorList);
+    return list;
+}
+
+static bool consumeLangArgumentList(std::unique_ptr<Vector<AtomicString>>& argumentList, CSSParserTokenRange& range)
+{
+    const CSSParserToken& ident = range.consumeIncludingWhitespace();
+    if (ident.type() != IdentToken && ident.type() != StringToken)
+        return false;
+    StringView string = ident.value();
+    if (string.startsWith("--"))
+        return false;
+    argumentList->append(string.toAtomicString());
+    while (!range.atEnd() && range.peek().type() == CommaToken) {
+        range.consumeIncludingWhitespace();
+        const CSSParserToken& ident = range.consumeIncludingWhitespace();
+        if (ident.type() != IdentToken && ident.type() != StringToken)
+            return false;
+        StringView string = ident.value();
+        if (string.startsWith("--"))
+            return false;
+        argumentList->append(string.toAtomicString());
+    }
+    return range.atEnd();
+}
+
+namespace {
+
+enum CompoundSelectorFlags {
+    HasPseudoElementForRightmostCompound = 1 << 0,
+    HasContentPseudoElement = 1 << 1
+};
+
+unsigned extractCompoundFlags(const CSSParserSelector& simpleSelector, CSSParserMode parserMode)
+{
+    if (simpleSelector.match() != CSSSelector::PseudoElement)
+        return 0;
+    
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=161747
+    // The UASheetMode check is a work-around to allow this selector in mediaControls(New).css:
+    // input[type="range" i]::-webkit-media-slider-container > div {
+    if (parserMode == UASheetMode && simpleSelector.pseudoElementType() == CSSSelector::PseudoElementWebKitCustom)
+        return 0;
+    return HasPseudoElementForRightmostCompound;
+}
+
+} // namespace
+
+static bool isDescendantCombinator(CSSSelector::RelationType relation)
+{
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+    return relation == CSSSelector::DescendantSpace || relation == CSSSelector::DescendantDoubleChild;
+#else
+    return relation == CSSSelector::DescendantSpace;
+#endif
+}
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeComplexSelector(CSSParserTokenRange& range)
+{
+    std::unique_ptr<CSSParserSelector> selector = consumeCompoundSelector(range);
+    if (!selector)
+        return nullptr;
+
+    unsigned previousCompoundFlags = 0;
+
+    for (CSSParserSelector* simple = selector.get(); simple && !previousCompoundFlags; simple = simple->tagHistory())
+        previousCompoundFlags |= extractCompoundFlags(*simple, m_context.mode);
+
+    while (auto combinator = consumeCombinator(range)) {
+        std::unique_ptr<CSSParserSelector> nextSelector = consumeCompoundSelector(range);
+        if (!nextSelector)
+            return isDescendantCombinator(combinator) ? WTFMove(selector) : nullptr;
+        if (previousCompoundFlags & HasPseudoElementForRightmostCompound)
+            return nullptr;
+        CSSParserSelector* end = nextSelector.get();
+        unsigned compoundFlags = extractCompoundFlags(*end, m_context.mode);
+        while (end->tagHistory()) {
+            end = end->tagHistory();
+            compoundFlags |= extractCompoundFlags(*end, m_context.mode);
+        }
+        end->setRelation(combinator);
+        previousCompoundFlags = compoundFlags;
+        end->setTagHistory(WTFMove(selector));
+
+        selector = WTFMove(nextSelector);
+    }
+
+    return selector;
+}
+
+namespace {
+
+bool isScrollbarPseudoClass(CSSSelector::PseudoClassType pseudo)
+{
+    switch (pseudo) {
+    case CSSSelector::PseudoClassEnabled:
+    case CSSSelector::PseudoClassDisabled:
+    case CSSSelector::PseudoClassHover:
+    case CSSSelector::PseudoClassActive:
+    case CSSSelector::PseudoClassHorizontal:
+    case CSSSelector::PseudoClassVertical:
+    case CSSSelector::PseudoClassDecrement:
+    case CSSSelector::PseudoClassIncrement:
+    case CSSSelector::PseudoClassStart:
+    case CSSSelector::PseudoClassEnd:
+    case CSSSelector::PseudoClassDoubleButton:
+    case CSSSelector::PseudoClassSingleButton:
+    case CSSSelector::PseudoClassNoButton:
+    case CSSSelector::PseudoClassCornerPresent:
+    case CSSSelector::PseudoClassWindowInactive:
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool isUserActionPseudoClass(CSSSelector::PseudoClassType pseudo)
+{
+    switch (pseudo) {
+    case CSSSelector::PseudoClassHover:
+    case CSSSelector::PseudoClassFocus:
+    case CSSSelector::PseudoClassActive:
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool isPseudoClassValidAfterPseudoElement(CSSSelector::PseudoClassType pseudoClass, CSSSelector::PseudoElementType compoundPseudoElement)
+{
+    switch (compoundPseudoElement) {
+    case CSSSelector::PseudoElementResizer:
+    case CSSSelector::PseudoElementScrollbar:
+    case CSSSelector::PseudoElementScrollbarCorner:
+    case CSSSelector::PseudoElementScrollbarButton:
+    case CSSSelector::PseudoElementScrollbarThumb:
+    case CSSSelector::PseudoElementScrollbarTrack:
+    case CSSSelector::PseudoElementScrollbarTrackPiece:
+        return isScrollbarPseudoClass(pseudoClass);
+    case CSSSelector::PseudoElementSelection:
+        return pseudoClass == CSSSelector::PseudoClassWindowInactive;
+    case CSSSelector::PseudoElementWebKitCustom:
+    case CSSSelector::PseudoElementWebKitCustomLegacyPrefixed:
+        return isUserActionPseudoClass(pseudoClass);
+    default:
+        return false;
+    }
+}
+
+bool isSimpleSelectorValidAfterPseudoElement(const CSSParserSelector& simpleSelector, CSSSelector::PseudoElementType compoundPseudoElement)
+{
+    if (compoundPseudoElement == CSSSelector::PseudoElementUnknown)
+        return true;
+    // FIXME-NEWPARSER: This doesn't exist for us.
+    // if (compoundPseudoElement == CSSSelector::PseudoElementContent)
+    //    return simpleSelector.match() != CSSSelector::PseudoElement;
+    if (simpleSelector.match() != CSSSelector::PseudoClass)
+        return false;
+    CSSSelector::PseudoClassType pseudo = simpleSelector.pseudoClassType();
+    if (pseudo == CSSSelector::PseudoClassNot) {
+        ASSERT(simpleSelector.selectorList());
+        ASSERT(simpleSelector.selectorList()->first());
+        pseudo = simpleSelector.selectorList()->first()->pseudoClassType();
+    }
+    return isPseudoClassValidAfterPseudoElement(pseudo, compoundPseudoElement);
+}
+
+} // namespace
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSParserTokenRange& range)
+{
+    std::unique_ptr<CSSParserSelector> compoundSelector;
+
+    AtomicString namespacePrefix;
+    AtomicString elementName;
+    CSSSelector::PseudoElementType compoundPseudoElement = CSSSelector::PseudoElementUnknown;
+    if (!consumeName(range, elementName, namespacePrefix)) {
+        compoundSelector = consumeSimpleSelector(range);
+        if (!compoundSelector)
+            return nullptr;
+        if (compoundSelector->match() == CSSSelector::PseudoElement)
+            compoundPseudoElement = compoundSelector->pseudoElementType();
+    }
+
+    while (std::unique_ptr<CSSParserSelector> simpleSelector = consumeSimpleSelector(range)) {
+        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=161747
+        // The UASheetMode check is a work-around to allow this selector in mediaControls(New).css:
+        // video::-webkit-media-text-track-region-container.scrolling
+        if (m_context.mode != UASheetMode && !isSimpleSelectorValidAfterPseudoElement(*simpleSelector.get(), compoundPseudoElement)) {
+            m_failedParsing = true;
+            return nullptr;
+        }
+        if (simpleSelector->match() == CSSSelector::PseudoElement)
+            compoundPseudoElement = simpleSelector->pseudoElementType();
+
+        if (compoundSelector)
+            compoundSelector = addSimpleSelectorToCompound(WTFMove(compoundSelector), WTFMove(simpleSelector));
+        else
+            compoundSelector = WTFMove(simpleSelector);
+    }
+
+    if (!compoundSelector) {
+        AtomicString namespaceURI = determineNamespace(namespacePrefix);
+        if (namespaceURI.isNull()) {
+            m_failedParsing = true;
+            return nullptr;
+        }
+        if (namespaceURI == defaultNamespace())
+            namespacePrefix = nullAtom;
+        
+        CSSParserSelector* rawSelector = new CSSParserSelector(QualifiedName(namespacePrefix, elementName, namespaceURI));
+        std::unique_ptr<CSSParserSelector> selector = std::unique_ptr<CSSParserSelector>(rawSelector);
+        return selector;
+    }
+    prependTypeSelectorIfNeeded(namespacePrefix, elementName, compoundSelector.get());
+    return splitCompoundAtImplicitShadowCrossingCombinator(WTFMove(compoundSelector), m_context);
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeSimpleSelector(CSSParserTokenRange& range)
+{
+    const CSSParserToken& token = range.peek();
+    std::unique_ptr<CSSParserSelector> selector;
+    if (token.type() == HashToken)
+        selector = consumeId(range);
+    else if (token.type() == DelimiterToken && token.delimiter() == '.')
+        selector = consumeClass(range);
+    else if (token.type() == LeftBracketToken)
+        selector = consumeAttribute(range);
+    else if (token.type() == ColonToken)
+        selector = consumePseudo(range);
+    else
+        return nullptr;
+    if (!selector)
+        m_failedParsing = true;
+    return selector;
+}
+
+bool CSSSelectorParser::consumeName(CSSParserTokenRange& range, AtomicString& name, AtomicString& namespacePrefix)
+{
+    name = nullAtom;
+    namespacePrefix = nullAtom;
+
+    const CSSParserToken& firstToken = range.peek();
+    if (firstToken.type() == IdentToken) {
+        name = firstToken.value().toAtomicString();
+        range.consume();
+    } else if (firstToken.type() == DelimiterToken && firstToken.delimiter() == '*') {
+        name = starAtom;
+        range.consume();
+    } else if (firstToken.type() == DelimiterToken && firstToken.delimiter() == '|') {
+        // This is an empty namespace, which'll get assigned this value below
+        name = emptyAtom;
+    } else
+        return false;
+
+    if (range.peek().type() != DelimiterToken || range.peek().delimiter() != '|')
+        return true;
+    range.consume();
+
+    namespacePrefix = name;
+    const CSSParserToken& nameToken = range.consume();
+    if (nameToken.type() == IdentToken) {
+        name = nameToken.value().toAtomicString();
+    } else if (nameToken.type() == DelimiterToken && nameToken.delimiter() == '*')
+        name = starAtom;
+    else {
+        name = nullAtom;
+        namespacePrefix = nullAtom;
+        return false;
+    }
+
+    return true;
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeId(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == HashToken);
+    if (range.peek().getHashTokenType() != HashTokenId)
+        return nullptr;
+    std::unique_ptr<CSSParserSelector> selector = std::unique_ptr<CSSParserSelector>(new CSSParserSelector());
+    selector->setMatch(CSSSelector::Id);
+    
+    // FIXME-NEWPARSER: Avoid having to do this, but the old parser does and we need
+    // to be compatible for now.
+    CSSParserToken token = range.consume();
+    selector->setValue(token.value().toAtomicString(), m_context.mode == HTMLQuirksMode);
+    return selector;
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeClass(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == DelimiterToken);
+    ASSERT(range.peek().delimiter() == '.');
+    range.consume();
+    if (range.peek().type() != IdentToken)
+        return nullptr;
+    std::unique_ptr<CSSParserSelector> selector = std::unique_ptr<CSSParserSelector>(new CSSParserSelector());
+    selector->setMatch(CSSSelector::Class);
+    
+    // FIXME-NEWPARSER: Avoid having to do this, but the old parser does and we need
+    // to be compatible for now.
+    CSSParserToken token = range.consume();
+    selector->setValue(token.value().toAtomicString(), m_context.mode == HTMLQuirksMode);
+
+    return selector;
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == LeftBracketToken);
+    CSSParserTokenRange block = range.consumeBlock();
+    if (block.end() == range.end())
+        return nullptr; // No ] was found. Be strict about this.
+
+    block.consumeWhitespace();
+
+    AtomicString namespacePrefix;
+    AtomicString attributeName;
+    if (!consumeName(block, attributeName, namespacePrefix))
+        return nullptr;
+    block.consumeWhitespace();
+
+    AtomicString namespaceURI = determineNamespace(namespacePrefix);
+    if (namespaceURI.isNull())
+        return nullptr;
+
+    QualifiedName qualifiedName = namespacePrefix.isNull()
+        ? QualifiedName(nullAtom, attributeName, nullAtom)
+        : QualifiedName(namespacePrefix, attributeName, namespaceURI);
+
+    std::unique_ptr<CSSParserSelector> selector = std::unique_ptr<CSSParserSelector>(new CSSParserSelector());
+
+    if (block.atEnd()) {
+        selector->setAttribute(qualifiedName, m_context.isHTMLDocument, CSSSelector::CaseSensitive);
+        selector->setMatch(CSSSelector::Set);
+        return selector;
+    }
+
+    selector->setMatch(consumeAttributeMatch(block));
+
+    const CSSParserToken& attributeValue = block.consumeIncludingWhitespace();
+    if (attributeValue.type() != IdentToken && attributeValue.type() != StringToken)
+        return nullptr;
+    selector->setValue(attributeValue.value().toAtomicString());
+    
+    selector->setAttribute(qualifiedName, m_context.isHTMLDocument, consumeAttributeFlags(block));
+
+    if (!block.atEnd())
+        return nullptr;
+    return selector;
+}
+
+static bool isOnlyPseudoClassFunction(CSSSelector::PseudoClassType pseudoClassType)
+{
+    switch (pseudoClassType) {
+    case CSSSelector::PseudoClassNot:
+    case CSSSelector::PseudoClassMatches:
+    case CSSSelector::PseudoClassNthChild:
+    case CSSSelector::PseudoClassNthLastChild:
+    case CSSSelector::PseudoClassNthOfType:
+    case CSSSelector::PseudoClassNthLastOfType:
+    case CSSSelector::PseudoClassLang:
+    case CSSSelector::PseudoClassAny:
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+    case CSSSelector::PseudoClassDir:
+    case CSSSelector::PseudoClassRole:
+#endif
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+    
+static bool isOnlyPseudoElementFunction(CSSSelector::PseudoElementType pseudoElementType)
+{
+    // Note that we omit cue since it can be both an ident or a function.
+    switch (pseudoElementType) {
+    case CSSSelector::PseudoElementSlotted:
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == ColonToken);
+    range.consume();
+
+    int colons = 1;
+    if (range.peek().type() == ColonToken) {
+        range.consume();
+        colons++;
+    }
+
+    const CSSParserToken& token = range.peek();
+    if (token.type() != IdentToken && token.type() != FunctionToken)
+        return nullptr;
+
+    std::unique_ptr<CSSParserSelector> selector;
+    
+    auto lowercasedValue = token.value().toString().convertToASCIILowercase();
+    auto value = StringView { lowercasedValue };
+
+    if (colons == 1)
+        selector = std::unique_ptr<CSSParserSelector>(CSSParserSelector::parsePseudoClassSelectorFromStringView(value));
+    else {
+        selector = std::unique_ptr<CSSParserSelector>(CSSParserSelector::parsePseudoElementSelectorFromStringView(value));
+#if ENABLE(VIDEO_TRACK)
+        // Treat the ident version of cue as PseudoElementWebkitCustom.
+        if (token.type() == IdentToken && selector && selector->match() == CSSSelector::PseudoElement && selector->pseudoElementType() == CSSSelector::PseudoElementCue)
+            selector->setPseudoElementType(CSSSelector::PseudoElementWebKitCustom);
+#endif
+    }
+
+    if (!selector || (selector->match() == CSSSelector::PseudoElement && m_disallowPseudoElements))
+        return nullptr;
+
+    if (token.type() == IdentToken) {
+        range.consume();
+        if ((selector->match() == CSSSelector::PseudoElement && (selector->pseudoElementType() == CSSSelector::PseudoElementUnknown || isOnlyPseudoElementFunction(selector->pseudoElementType())))
+            || (selector->match() == CSSSelector::PseudoClass && (selector->pseudoClassType() == CSSSelector::PseudoClassUnknown || isOnlyPseudoClassFunction(selector->pseudoClassType()))))
+            return nullptr;
+        return selector;
+    }
+
+    CSSParserTokenRange block = range.consumeBlock();
+    if (block.end() == range.end())
+        return nullptr; // No ) was found. Be strict about this.
+    block.consumeWhitespace();
+    if (token.type() != FunctionToken)
+        return nullptr;
+    
+    const auto& argumentStart = block.peek();
+    
+    if (selector->match() == CSSSelector::PseudoClass) {
+        switch (selector->pseudoClassType()) {
+        case CSSSelector::PseudoClassNot: {
+            DisallowPseudoElementsScope scope(this);
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeComplexSelectorList(block);
+            if (!selectorList->componentCount() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+        case CSSSelector::PseudoClassNthChild:
+        case CSSSelector::PseudoClassNthLastChild:
+        case CSSSelector::PseudoClassNthOfType:
+        case CSSSelector::PseudoClassNthLastOfType: {
+            std::pair<int, int> ab;
+            if (!consumeANPlusB(block, ab))
+                return nullptr;
+            block.consumeWhitespace();
+            const auto& argumentEnd = block.peek();
+            auto rangeOfANPlusB = block.makeSubRange(&argumentStart, &argumentEnd);
+            auto argument = rangeOfANPlusB.serialize();
+            selector->setArgument(argument.stripWhiteSpace());
+            if (!block.atEnd()) {
+                if (block.peek().type() != IdentToken)
+                    return nullptr;
+                const CSSParserToken& ident = block.consume();
+                if (!equalIgnoringASCIICase(ident.value(), "of"))
+                    return nullptr;
+                if (block.peek().type() != WhitespaceToken)
+                    return nullptr;
+                DisallowPseudoElementsScope scope(this);
+                block.consumeWhitespace();
+                std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+                *selectorList = consumeComplexSelectorList(block);
+                if (!selectorList->componentCount() || !block.atEnd())
+                    return nullptr;
+                selector->setSelectorList(WTFMove(selectorList));
+            }
+            selector->setNth(ab.first, ab.second);
+            return selector;
+        }
+        case CSSSelector::PseudoClassLang: {
+            // FIXME: CSS Selectors Level 4 allows :lang(*-foo)
+            auto argumentList = std::make_unique<Vector<AtomicString>>();
+            if (!consumeLangArgumentList(argumentList, block))
+                return nullptr;
+            selector->setLangArgumentList(WTFMove(argumentList));
+            return selector;
+        }
+        case CSSSelector::PseudoClassMatches: {
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeComplexSelectorList(block);
+            if (!selectorList->componentCount() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+        case CSSSelector::PseudoClassAny:
+        case CSSSelector::PseudoClassHost: {
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeCompoundSelectorList(block);
+            if (!selectorList->componentCount() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+        case CSSSelector::PseudoClassDir:
+        case CSSSelector::PseudoClassRole: {
+            const CSSParserToken& ident = block.consumeIncludingWhitespace();
+            if (ident.type() != IdentToken || !block.atEnd())
+                return nullptr;
+            selector->setArgument(ident.value().toAtomicString());
+            return selector;
+        }
+#endif
+        default:
+            break;
+        }
+
+    }
+    
+    if (selector->match() == CSSSelector::PseudoElement) {
+        switch (selector->pseudoElementType()) {
+#if ENABLE(VIDEO_TRACK)
+        case CSSSelector::PseudoElementCue: {
+            DisallowPseudoElementsScope scope(this);
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeCompoundSelectorList(block);
+            if (!selectorList->isValid() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+#endif
+        case CSSSelector::PseudoElementSlotted: {
+            DisallowPseudoElementsScope scope(this);
+
+            std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
+            block.consumeWhitespace();
+            if (!innerSelector || !block.atEnd())
+                return nullptr;
+            Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
+            selectorVector.append(WTFMove(innerSelector));
+            selector->adoptSelectorVector(selectorVector);
+            return selector;
+        }
+        default:
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+CSSSelector::RelationType CSSSelectorParser::consumeCombinator(CSSParserTokenRange& range)
+{
+    auto fallbackResult = CSSSelector::Subselector;
+    while (range.peek().type() == WhitespaceToken) {
+        range.consume();
+        fallbackResult = CSSSelector::DescendantSpace;
+    }
+
+    if (range.peek().type() != DelimiterToken)
+        return fallbackResult;
+
+    UChar delimiter = range.peek().delimiter();
+
+    if (delimiter == '+' || delimiter == '~' || delimiter == '>') {
+        if (delimiter == '+') {
+            range.consumeIncludingWhitespace();
+            return CSSSelector::DirectAdjacent;
+        }
+        
+        if (delimiter == '~') {
+            range.consumeIncludingWhitespace();
+            return CSSSelector::IndirectAdjacent;
+        }
+        
+#if ENABLE(CSS_SELECTORS_LEVEL4)
+        range.consume();
+        if (range.peek().type() == DelimiterToken && range.peek().delimiter() == '>') {
+            range.consumeIncludingWhitespace();
+            return CSSSelector::DescendantDoubleChild;
+        }
+        range.consumeWhitespace();
+#else
+        range.consumeIncludingWhitespace();
+#endif
+        return CSSSelector::Child;
+    }
+
+    return fallbackResult;
+}
+
+CSSSelector::Match CSSSelectorParser::consumeAttributeMatch(CSSParserTokenRange& range)
+{
+    const CSSParserToken& token = range.consumeIncludingWhitespace();
+    switch (token.type()) {
+    case IncludeMatchToken:
+        return CSSSelector::List;
+    case DashMatchToken:
+        return CSSSelector::Hyphen;
+    case PrefixMatchToken:
+        return CSSSelector::Begin;
+    case SuffixMatchToken:
+        return CSSSelector::End;
+    case SubstringMatchToken:
+        return CSSSelector::Contain;
+    case DelimiterToken:
+        if (token.delimiter() == '=')
+            return CSSSelector::Exact;
+        FALLTHROUGH;
+    default:
+        m_failedParsing = true;
+        return CSSSelector::Exact;
+    }
+}
+
+CSSSelector::AttributeMatchType CSSSelectorParser::consumeAttributeFlags(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != IdentToken)
+        return CSSSelector::CaseSensitive;
+    const CSSParserToken& flag = range.consumeIncludingWhitespace();
+    if (equalIgnoringASCIICase(flag.value(), "i"))
+        return CSSSelector::CaseInsensitive;
+    m_failedParsing = true;
+    return CSSSelector::CaseSensitive;
+}
+
+bool CSSSelectorParser::consumeANPlusB(CSSParserTokenRange& range, std::pair<int, int>& result)
+{
+    const CSSParserToken& token = range.consume();
+    if (token.type() == NumberToken && token.numericValueType() == IntegerValueType) {
+        result = std::make_pair(0, static_cast<int>(token.numericValue()));
+        return true;
+    }
+    if (token.type() == IdentToken) {
+        if (equalIgnoringASCIICase(token.value(), "odd")) {
+            result = std::make_pair(2, 1);
+            return true;
+        }
+        if (equalIgnoringASCIICase(token.value(), "even")) {
+            result = std::make_pair(2, 0);
+            return true;
+        }
+    }
+
+    // The 'n' will end up as part of an ident or dimension. For a valid <an+b>,
+    // this will store a string of the form 'n', 'n-', or 'n-123'.
+    String nString;
+
+    if (token.type() == DelimiterToken && token.delimiter() == '+' && range.peek().type() == IdentToken) {
+        result.first = 1;
+        nString = range.consume().value().toString();
+    } else if (token.type() == DimensionToken && token.numericValueType() == IntegerValueType) {
+        result.first = token.numericValue();
+        nString = token.value().toString();
+    } else if (token.type() == IdentToken) {
+        if (token.value()[0] == '-') {
+            result.first = -1;
+            nString = token.value().toString().substring(1);
+        } else {
+            result.first = 1;
+            nString = token.value().toString();
+        }
+    }
+
+    range.consumeWhitespace();
+
+    if (nString.isEmpty() || !isASCIIAlphaCaselessEqual(nString[0], 'n'))
+        return false;
+    if (nString.length() > 1 && nString[1] != '-')
+        return false;
+
+    if (nString.length() > 2) {
+        bool valid;
+        result.second = nString.substring(1).toIntStrict(&valid);
+        return valid;
+    }
+
+    NumericSign sign = nString.length() == 1 ? NoSign : MinusSign;
+    if (sign == NoSign && range.peek().type() == DelimiterToken) {
+        char delimiterSign = range.consumeIncludingWhitespace().delimiter();
+        if (delimiterSign == '+')
+            sign = PlusSign;
+        else if (delimiterSign == '-')
+            sign = MinusSign;
+        else
+            return false;
+    }
+
+    if (sign == NoSign && range.peek().type() != NumberToken) {
+        result.second = 0;
+        return true;
+    }
+
+    const CSSParserToken& b = range.consume();
+    if (b.type() != NumberToken || b.numericValueType() != IntegerValueType)
+        return false;
+    if ((b.numericSign() == NoSign) == (sign == NoSign))
+        return false;
+    result.second = b.numericValue();
+    if (sign == MinusSign)
+        result.second = -result.second;
+    return true;
+}
+
+const AtomicString& CSSSelectorParser::defaultNamespace() const
+{
+    if (!m_styleSheet)
+        return starAtom;
+    return m_styleSheet->defaultNamespace();
+}
+
+const AtomicString& CSSSelectorParser::determineNamespace(const AtomicString& prefix)
+{
+    if (prefix.isNull())
+        return defaultNamespace();
+    if (prefix.isEmpty())
+        return emptyAtom; // No namespace. If an element/attribute has a namespace, we won't match it.
+    if (prefix == starAtom)
+        return starAtom; // We'll match any namespace.
+    if (!m_styleSheet)
+        return nullAtom; // Cannot resolve prefix to namespace without a stylesheet, syntax error.
+    return m_styleSheet->namespaceURIFromPrefix(prefix);
+}
+
+void CSSSelectorParser::prependTypeSelectorIfNeeded(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* compoundSelector)
+{
+    bool isShadowDOM = compoundSelector->needsImplicitShadowCombinatorForMatching();
+    
+    if (elementName.isNull() && defaultNamespace() == starAtom && !isShadowDOM)
+        return;
+
+    AtomicString determinedElementName = elementName.isNull() ? starAtom : elementName;
+    AtomicString namespaceURI = determineNamespace(namespacePrefix);
+    if (namespaceURI.isNull()) {
+        m_failedParsing = true;
+        return;
+    }
+    AtomicString determinedPrefix = namespacePrefix;
+    if (namespaceURI == defaultNamespace())
+        determinedPrefix = nullAtom;
+    QualifiedName tag = QualifiedName(determinedPrefix, determinedElementName, namespaceURI);
+
+    // *:host never matches, so we can't discard the *,
+    // otherwise we can't tell the difference between *:host and just :host.
+    //
+    // Also, selectors where we use a ShadowPseudo combinator between the
+    // element and the pseudo element for matching (custom pseudo elements,
+    // ::cue), we need a universal selector to set the combinator
+    // (relation) on in the cases where there are no simple selectors preceding
+    // the pseudo element.
+    bool explicitForHost = compoundSelector->isHostPseudoSelector() && !elementName.isNull();
+    if (tag != anyQName() || explicitForHost || isShadowDOM)
+        compoundSelector->prependTagSelector(tag, determinedPrefix == nullAtom && determinedElementName == starAtom && !explicitForHost);
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::addSimpleSelectorToCompound(std::unique_ptr<CSSParserSelector> compoundSelector, std::unique_ptr<CSSParserSelector> simpleSelector)
+{
+    compoundSelector->appendTagHistory(CSSSelector::Subselector, WTFMove(simpleSelector));
+    return compoundSelector;
+}
+
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::splitCompoundAtImplicitShadowCrossingCombinator(std::unique_ptr<CSSParserSelector> compoundSelector, const CSSParserContext& context)
+{
+    // The tagHistory is a linked list that stores combinator separated compound selectors
+    // from right-to-left. Yet, within a single compound selector, stores the simple selectors
+    // from left-to-right.
+    //
+    // ".a.b > div#id" is stored in a tagHistory as [div, #id, .a, .b], each element in the
+    // list stored with an associated relation (combinator or Subselector).
+    //
+    // ::cue, ::shadow, and custom pseudo elements have an implicit ShadowPseudo combinator
+    // to their left, which really makes for a new compound selector, yet it's consumed by
+    // the selector parser as a single compound selector.
+    //
+    // Example: input#x::-webkit-clear-button -> [ ::-webkit-clear-button, input, #x ]
+    //
+    CSSParserSelector* splitAfter = compoundSelector.get();
+    while (splitAfter->tagHistory() && !splitAfter->tagHistory()->needsImplicitShadowCombinatorForMatching())
+        splitAfter = splitAfter->tagHistory();
+    
+    if (!splitAfter || !splitAfter->tagHistory())
+        return compoundSelector;
+
+    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=161747
+    // We have to recur, since we have rules in media controls like video::a::b. This should not be allowed, and
+    // we should remove this recursion once those rules are gone.
+    std::unique_ptr<CSSParserSelector> secondCompound = context.mode != UASheetMode ? splitAfter->releaseTagHistory() : splitCompoundAtImplicitShadowCrossingCombinator(splitAfter->releaseTagHistory(), context);
+    secondCompound->appendTagHistory(CSSSelector::ShadowDescendant, WTFMove(compoundSelector));
+    return secondCompound;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSSelectorParser.h b/Source/WebCore/css/parser/CSSSelectorParser.h
new file mode 100644
index 000000000..283028737
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSSelectorParser.h
@@ -0,0 +1,108 @@
+// 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 "CSSParserSelector.h"
+#include "CSSParserTokenRange.h"
+#include <memory>
+
+namespace WebCore {
+
+struct CSSParserContext;
+class CSSSelectorList;
+class StyleSheetContents;
+
+// FIXME: We should consider building CSSSelectors directly instead of using
+// the intermediate CSSParserSelector.
+class CSSSelectorParser {
+public:
+    static CSSSelectorList parseSelector(CSSParserTokenRange, const CSSParserContext&, StyleSheetContents*);
+
+    static bool consumeANPlusB(CSSParserTokenRange&, std::pair<int, int>&);
+
+private:
+    CSSSelectorParser(const CSSParserContext&, StyleSheetContents*);
+
+    // These will all consume trailing comments if successful
+
+    CSSSelectorList consumeComplexSelectorList(CSSParserTokenRange&);
+    CSSSelectorList consumeCompoundSelectorList(CSSParserTokenRange&);
+
+    std::unique_ptr<CSSParserSelector> consumeComplexSelector(CSSParserTokenRange&);
+    std::unique_ptr<CSSParserSelector> consumeCompoundSelector(CSSParserTokenRange&);
+    // This doesn't include element names, since they're handled specially
+    std::unique_ptr<CSSParserSelector> consumeSimpleSelector(CSSParserTokenRange&);
+
+    bool consumeName(CSSParserTokenRange&, AtomicString& name, AtomicString& namespacePrefix);
+
+    // These will return nullptr when the selector is invalid
+    std::unique_ptr<CSSParserSelector> consumeId(CSSParserTokenRange&);
+    std::unique_ptr<CSSParserSelector> consumeClass(CSSParserTokenRange&);
+    std::unique_ptr<CSSParserSelector> consumePseudo(CSSParserTokenRange&);
+    std::unique_ptr<CSSParserSelector> consumeAttribute(CSSParserTokenRange&);
+
+    CSSSelector::RelationType consumeCombinator(CSSParserTokenRange&);
+    CSSSelector::Match consumeAttributeMatch(CSSParserTokenRange&);
+    CSSSelector::AttributeMatchType consumeAttributeFlags(CSSParserTokenRange&);
+
+    const AtomicString& defaultNamespace() const;
+    const AtomicString& determineNamespace(const AtomicString& prefix);
+    void prependTypeSelectorIfNeeded(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
+    static std::unique_ptr<CSSParserSelector> addSimpleSelectorToCompound(std::unique_ptr<CSSParserSelector> compoundSelector, std::unique_ptr<CSSParserSelector> simpleSelector);
+    static std::unique_ptr<CSSParserSelector> splitCompoundAtImplicitShadowCrossingCombinator(std::unique_ptr<CSSParserSelector> compoundSelector, const CSSParserContext&);
+
+    const CSSParserContext& m_context;
+    RefPtr<StyleSheetContents> m_styleSheet; // FIXME: Should be const
+
+    bool m_failedParsing = false;
+    bool m_disallowPseudoElements = false;
+
+    class DisallowPseudoElementsScope {
+        WTF_MAKE_NONCOPYABLE(DisallowPseudoElementsScope);
+    public:
+        DisallowPseudoElementsScope(CSSSelectorParser* parser)
+            : m_parser(parser), m_wasDisallowed(m_parser->m_disallowPseudoElements)
+        {
+            m_parser->m_disallowPseudoElements = true;
+        }
+
+        ~DisallowPseudoElementsScope()
+        {
+            m_parser->m_disallowPseudoElements = m_wasDisallowed;
+        }
+
+    private:
+        CSSSelectorParser* m_parser;
+        bool m_wasDisallowed;
+    };
+};
+
+} // namespace WebCore
+
diff --git a/Source/WebCore/css/parser/CSSSupportsParser.cpp b/Source/WebCore/css/parser/CSSSupportsParser.cpp
new file mode 100644
index 000000000..0d71bec1c
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSSupportsParser.cpp
@@ -0,0 +1,127 @@
+// 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 || range.peek().type() == FunctionToken)
+        return consumeNegation(range);
+
+    bool result;
+    ClauseType clauseType = Unresolved;
+    
+    auto previousTokenType = IdentToken;
+
+    while (true) {
+        SupportsResult nextResult = consumeConditionInParenthesis(range, previousTokenType);
+        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;
+        range.consumeWhitespace();
+        if (range.atEnd())
+            break;
+
+        const CSSParserToken& token = range.peek();
+        if (token.type() != IdentToken && token.type() != FunctionToken)
+            return Invalid;
+        
+        previousTokenType = token.type();
+        
+        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 (token.type() == IdentToken)
+            range.consumeIncludingWhitespace();
+    }
+    return result ? Supported : Unsupported;
+}
+
+CSSSupportsParser::SupportsResult CSSSupportsParser::consumeNegation(CSSParserTokenRange range)
+{
+    ASSERT(range.peek().type() == IdentToken || range.peek().type() == FunctionToken);
+    auto tokenType = range.peek().type();
+    if (!equalIgnoringASCIICase(range.peek().value(), "not"))
+        return Invalid;
+    if (range.peek().type() == IdentToken)
+        range.consumeIncludingWhitespace();
+    SupportsResult result = consumeConditionInParenthesis(range, tokenType);
+    range.consumeWhitespace();
+    if (!range.atEnd() || result == Invalid)
+        return Invalid;
+    return result ? Unsupported : Supported;
+}
+
+CSSSupportsParser::SupportsResult CSSSupportsParser::consumeConditionInParenthesis(CSSParserTokenRange& range, CSSParserTokenType startTokenType)
+{
+    if (startTokenType == IdentToken && range.peek().type() != LeftParenthesisToken)
+        return Invalid;
+
+    CSSParserTokenRange innerRange = range.consumeBlock();
+    innerRange.consumeWhitespace();
+    SupportsResult result = consumeCondition(innerRange);
+    if (result != Invalid)
+        return result;
+    
+    if (innerRange.peek().type() == FunctionToken) {
+        innerRange.consumeComponentValue();
+        return Unsupported;
+    }
+
+    return innerRange.peek().type() == IdentToken && m_parser.supportsDeclaration(innerRange) ? Supported : Unsupported;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSSupportsParser.h b/Source/WebCore/css/parser/CSSSupportsParser.h
new file mode 100644
index 000000000..ecf3c805d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSSupportsParser.h
@@ -0,0 +1,61 @@
+// 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
+
+#include "CSSParserToken.h"
+
+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&, CSSParserTokenType);
+
+    CSSParserImpl& m_parser;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSTokenizer.cpp b/Source/WebCore/css/parser/CSSTokenizer.cpp
new file mode 100644
index 000000000..1f1a23e4d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSTokenizer.cpp
@@ -0,0 +1,879 @@
+// 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 "CSSTokenizer.h"
+
+#include "CSSParserIdioms.h"
+#include "CSSParserObserverWrapper.h"
+#include "CSSParserTokenRange.h"
+#include "CSSTokenizerInputStream.h"
+#include "HTMLParserIdioms.h"
+#include <wtf/text/StringBuilder.h>
+#include <wtf/unicode/CharacterNames.h>
+
+namespace WebCore {
+
+CSSTokenizer::CSSTokenizer(const String& string)
+    : m_input(string)
+{
+    // According to the spec, we should perform preprocessing here.
+    // See: http://dev.w3.org/csswg/css-syntax/#input-preprocessing
+    //
+    // However, we can skip this step since:
+    // * We're using HTML spaces (which accept \r and \f as a valid white space)
+    // * Do not count white spaces
+    // * CSSTokenizerInputStream::nextInputChar() replaces NULLs for replacement characters
+
+    if (string.isEmpty())
+        return;
+
+    // To avoid resizing we err on the side of reserving too much space.
+    // Most strings we tokenize have about 3.5 to 5 characters per token.
+    m_tokens.reserveInitialCapacity(string.length() / 3);
+
+    while (true) {
+        CSSParserToken token = nextToken();
+        if (token.type() == CommentToken)
+            continue;
+        if (token.type() == EOFToken)
+            return;
+        m_tokens.append(token);
+    }
+}
+
+CSSTokenizer::CSSTokenizer(const String& string, CSSParserObserverWrapper& wrapper)
+    : m_input(string)
+{
+    if (string.isEmpty())
+        return;
+
+    unsigned offset = 0;
+    while (true) {
+        CSSParserToken token = nextToken();
+        if (token.type() == EOFToken)
+            break;
+        if (token.type() == CommentToken)
+            wrapper.addComment(offset, m_input.offset(), m_tokens.size());
+        else {
+            m_tokens.append(token);
+            wrapper.addToken(offset);
+        }
+        offset = m_input.offset();
+    }
+
+    wrapper.addToken(offset);
+    wrapper.finalizeConstruction(m_tokens.begin());
+}
+
+CSSParserTokenRange CSSTokenizer::tokenRange() const
+{
+    return m_tokens;
+}
+
+unsigned CSSTokenizer::tokenCount()
+{
+    return m_tokens.size();
+}
+
+static bool isNewLine(UChar cc)
+{
+    // We check \r and \f here, since we have no preprocessing stage
+    return (cc == '\r' || cc == '\n' || cc == '\f');
+}
+
+// http://dev.w3.org/csswg/css-syntax/#check-if-two-code-points-are-a-valid-escape
+static bool twoCharsAreValidEscape(UChar first, UChar second)
+{
+    return first == '\\' && !isNewLine(second);
+}
+
+void CSSTokenizer::reconsume(UChar c)
+{
+    m_input.pushBack(c);
+}
+
+UChar CSSTokenizer::consume()
+{
+    UChar current = m_input.nextInputChar();
+    m_input.advance();
+    return current;
+}
+
+CSSParserToken CSSTokenizer::whiteSpace(UChar /*cc*/)
+{
+    m_input.advanceUntilNonWhitespace();
+    return CSSParserToken(WhitespaceToken);
+}
+
+CSSParserToken CSSTokenizer::blockStart(CSSParserTokenType type)
+{
+    m_blockStack.append(type);
+    return CSSParserToken(type, CSSParserToken::BlockStart);
+}
+
+CSSParserToken CSSTokenizer::blockStart(CSSParserTokenType blockType, CSSParserTokenType type, StringView name)
+{
+    m_blockStack.append(blockType);
+    return CSSParserToken(type, name, CSSParserToken::BlockStart);
+}
+
+CSSParserToken CSSTokenizer::blockEnd(CSSParserTokenType type, CSSParserTokenType startType)
+{
+    if (!m_blockStack.isEmpty() && m_blockStack.last() == startType) {
+        m_blockStack.removeLast();
+        return CSSParserToken(type, CSSParserToken::BlockEnd);
+    }
+    return CSSParserToken(type);
+}
+
+CSSParserToken CSSTokenizer::leftParenthesis(UChar /*cc*/)
+{
+    return blockStart(LeftParenthesisToken);
+}
+
+CSSParserToken CSSTokenizer::rightParenthesis(UChar /*cc*/)
+{
+    return blockEnd(RightParenthesisToken, LeftParenthesisToken);
+}
+
+CSSParserToken CSSTokenizer::leftBracket(UChar /*cc*/)
+{
+    return blockStart(LeftBracketToken);
+}
+
+CSSParserToken CSSTokenizer::rightBracket(UChar /*cc*/)
+{
+    return blockEnd(RightBracketToken, LeftBracketToken);
+}
+
+CSSParserToken CSSTokenizer::leftBrace(UChar /*cc*/)
+{
+    return blockStart(LeftBraceToken);
+}
+
+CSSParserToken CSSTokenizer::rightBrace(UChar /*cc*/)
+{
+    return blockEnd(RightBraceToken, LeftBraceToken);
+}
+
+CSSParserToken CSSTokenizer::plusOrFullStop(UChar cc)
+{
+    if (nextCharsAreNumber(cc)) {
+        reconsume(cc);
+        return consumeNumericToken();
+    }
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+CSSParserToken CSSTokenizer::asterisk(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '*');
+    if (consumeIfNext('='))
+        return CSSParserToken(SubstringMatchToken);
+    return CSSParserToken(DelimiterToken, '*');
+}
+
+CSSParserToken CSSTokenizer::lessThan(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '<');
+    if (m_input.peekWithoutReplacement(0) == '!'
+        && m_input.peekWithoutReplacement(1) == '-'
+        && m_input.peekWithoutReplacement(2) == '-') {
+        m_input.advance(3);
+        return CSSParserToken(CDOToken);
+    }
+    return CSSParserToken(DelimiterToken, '<');
+}
+
+CSSParserToken CSSTokenizer::comma(UChar /*cc*/)
+{
+    return CSSParserToken(CommaToken);
+}
+
+CSSParserToken CSSTokenizer::hyphenMinus(UChar cc)
+{
+    if (nextCharsAreNumber(cc)) {
+        reconsume(cc);
+        return consumeNumericToken();
+    }
+    if (m_input.peekWithoutReplacement(0) == '-'
+        && m_input.peekWithoutReplacement(1) == '>') {
+        m_input.advance(2);
+        return CSSParserToken(CDCToken);
+    }
+    if (nextCharsAreIdentifier(cc)) {
+        reconsume(cc);
+        return consumeIdentLikeToken();
+    }
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+CSSParserToken CSSTokenizer::solidus(UChar cc)
+{
+    if (consumeIfNext('*')) {
+        // These get ignored, but we need a value to return.
+        consumeUntilCommentEndFound();
+        return CSSParserToken(CommentToken);
+    }
+
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+CSSParserToken CSSTokenizer::colon(UChar /*cc*/)
+{
+    return CSSParserToken(ColonToken);
+}
+
+CSSParserToken CSSTokenizer::semiColon(UChar /*cc*/)
+{
+    return CSSParserToken(SemicolonToken);
+}
+
+CSSParserToken CSSTokenizer::hash(UChar cc)
+{
+    UChar nextChar = m_input.peekWithoutReplacement(0);
+    if (isNameCodePoint(nextChar) || twoCharsAreValidEscape(nextChar, m_input.peekWithoutReplacement(1))) {
+        HashTokenType type = nextCharsAreIdentifier() ? HashTokenId : HashTokenUnrestricted;
+        return CSSParserToken(type, consumeName());
+    }
+
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+CSSParserToken CSSTokenizer::circumflexAccent(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '^');
+    if (consumeIfNext('='))
+        return CSSParserToken(PrefixMatchToken);
+    return CSSParserToken(DelimiterToken, '^');
+}
+
+CSSParserToken CSSTokenizer::dollarSign(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '$');
+    if (consumeIfNext('='))
+        return CSSParserToken(SuffixMatchToken);
+    return CSSParserToken(DelimiterToken, '$');
+}
+
+CSSParserToken CSSTokenizer::verticalLine(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '|');
+    if (consumeIfNext('='))
+        return CSSParserToken(DashMatchToken);
+    if (consumeIfNext('|'))
+        return CSSParserToken(ColumnToken);
+    return CSSParserToken(DelimiterToken, '|');
+}
+
+CSSParserToken CSSTokenizer::tilde(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '~');
+    if (consumeIfNext('='))
+        return CSSParserToken(IncludeMatchToken);
+    return CSSParserToken(DelimiterToken, '~');
+}
+
+CSSParserToken CSSTokenizer::commercialAt(UChar cc)
+{
+    ASSERT_UNUSED(cc, cc == '@');
+    if (nextCharsAreIdentifier())
+        return CSSParserToken(AtKeywordToken, consumeName());
+    return CSSParserToken(DelimiterToken, '@');
+}
+
+CSSParserToken CSSTokenizer::reverseSolidus(UChar cc)
+{
+    if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
+        reconsume(cc);
+        return consumeIdentLikeToken();
+    }
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+CSSParserToken CSSTokenizer::asciiDigit(UChar cc)
+{
+    reconsume(cc);
+    return consumeNumericToken();
+}
+
+CSSParserToken CSSTokenizer::letterU(UChar cc)
+{
+    if (m_input.peekWithoutReplacement(0) == '+'
+        && (isASCIIHexDigit(m_input.peekWithoutReplacement(1))
+            || m_input.peekWithoutReplacement(1) == '?')) {
+        m_input.advance();
+        return consumeUnicodeRange();
+    }
+    reconsume(cc);
+    return consumeIdentLikeToken();
+}
+
+CSSParserToken CSSTokenizer::nameStart(UChar cc)
+{
+    reconsume(cc);
+    return consumeIdentLikeToken();
+}
+
+CSSParserToken CSSTokenizer::stringStart(UChar cc)
+{
+    return consumeStringTokenUntil(cc);
+}
+
+CSSParserToken CSSTokenizer::endOfFile(UChar /*cc*/)
+{
+    return CSSParserToken(EOFToken);
+}
+
+const CSSTokenizer::CodePoint CSSTokenizer::codePoints[128] = {
+    &CSSTokenizer::endOfFile,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    &CSSTokenizer::whiteSpace,
+    &CSSTokenizer::whiteSpace,
+    0,
+    &CSSTokenizer::whiteSpace,
+    &CSSTokenizer::whiteSpace,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    &CSSTokenizer::whiteSpace,
+    0,
+    &CSSTokenizer::stringStart,
+    &CSSTokenizer::hash,
+    &CSSTokenizer::dollarSign,
+    0,
+    0,
+    &CSSTokenizer::stringStart,
+    &CSSTokenizer::leftParenthesis,
+    &CSSTokenizer::rightParenthesis,
+    &CSSTokenizer::asterisk,
+    &CSSTokenizer::plusOrFullStop,
+    &CSSTokenizer::comma,
+    &CSSTokenizer::hyphenMinus,
+    &CSSTokenizer::plusOrFullStop,
+    &CSSTokenizer::solidus,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::asciiDigit,
+    &CSSTokenizer::colon,
+    &CSSTokenizer::semiColon,
+    &CSSTokenizer::lessThan,
+    0,
+    0,
+    0,
+    &CSSTokenizer::commercialAt,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::letterU,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::leftBracket,
+    &CSSTokenizer::reverseSolidus,
+    &CSSTokenizer::rightBracket,
+    &CSSTokenizer::circumflexAccent,
+    &CSSTokenizer::nameStart,
+    0,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::letterU,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::nameStart,
+    &CSSTokenizer::leftBrace,
+    &CSSTokenizer::verticalLine,
+    &CSSTokenizer::rightBrace,
+    &CSSTokenizer::tilde,
+    0,
+};
+#if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
+const unsigned codePointsNumber = 128;
+#endif
+
+CSSParserToken CSSTokenizer::nextToken()
+{
+    // Unlike the HTMLTokenizer, the CSS Syntax spec is written
+    // as a stateless, (fixed-size) look-ahead tokenizer.
+    // We could move to the stateful model and instead create
+    // states for all the "next 3 codepoints are X" cases.
+    // State-machine tokenizers are easier to write to handle
+    // incremental tokenization of partial sources.
+    // However, for now we follow the spec exactly.
+    UChar cc = consume();
+    CodePoint codePointFunc = 0;
+
+    if (isASCII(cc)) {
+        ASSERT_WITH_SECURITY_IMPLICATION(cc < codePointsNumber);
+        codePointFunc = codePoints[cc];
+    } else
+        codePointFunc = &CSSTokenizer::nameStart;
+
+    if (codePointFunc)
+        return ((this)->*(codePointFunc))(cc);
+    return CSSParserToken(DelimiterToken, cc);
+}
+
+// This method merges the following spec sections for efficiency
+// http://www.w3.org/TR/css3-syntax/#consume-a-number
+// http://www.w3.org/TR/css3-syntax/#convert-a-string-to-a-number
+CSSParserToken CSSTokenizer::consumeNumber()
+{
+    ASSERT(nextCharsAreNumber());
+
+    NumericValueType type = IntegerValueType;
+    NumericSign sign = NoSign;
+    unsigned numberLength = 0;
+
+    UChar next = m_input.peekWithoutReplacement(0);
+    if (next == '+') {
+        ++numberLength;
+        sign = PlusSign;
+    } else if (next == '-') {
+        ++numberLength;
+        sign = MinusSign;
+    }
+
+    numberLength = m_input.skipWhilePredicate<isASCIIDigit>(numberLength);
+    next = m_input.peekWithoutReplacement(numberLength);
+    if (next == '.' && isASCIIDigit(m_input.peekWithoutReplacement(numberLength + 1))) {
+        type = NumberValueType;
+        numberLength = m_input.skipWhilePredicate<isASCIIDigit>(numberLength + 2);
+        next = m_input.peekWithoutReplacement(numberLength);
+    }
+
+    if (next == 'E' || next == 'e') {
+        next = m_input.peekWithoutReplacement(numberLength + 1);
+        if (isASCIIDigit(next)) {
+            type = NumberValueType;
+            numberLength = m_input.skipWhilePredicate<isASCIIDigit>(numberLength + 1);
+        } else if ((next == '+' || next == '-') && isASCIIDigit(m_input.peekWithoutReplacement(numberLength + 2))) {
+            type = NumberValueType;
+            numberLength = m_input.skipWhilePredicate<isASCIIDigit>(numberLength + 3);
+        }
+    }
+
+    double value = m_input.getDouble(0, numberLength);
+    m_input.advance(numberLength);
+
+    return CSSParserToken(NumberToken, value, type, sign);
+}
+
+// http://www.w3.org/TR/css3-syntax/#consume-a-numeric-token
+CSSParserToken CSSTokenizer::consumeNumericToken()
+{
+    CSSParserToken token = consumeNumber();
+    if (nextCharsAreIdentifier())
+        token.convertToDimensionWithUnit(consumeName());
+    else if (consumeIfNext('%'))
+        token.convertToPercentage();
+    return token;
+}
+
+// http://dev.w3.org/csswg/css-syntax/#consume-ident-like-token
+CSSParserToken CSSTokenizer::consumeIdentLikeToken()
+{
+    StringView name = consumeName();
+    if (consumeIfNext('(')) {
+        if (equalIgnoringASCIICase(name, "url")) {
+            // The spec is slightly different so as to avoid dropping whitespace
+            // tokens, but they wouldn't be used and this is easier.
+            m_input.advanceUntilNonWhitespace();
+            UChar next = m_input.peekWithoutReplacement(0);
+            if (next != '"' && next != '\'')
+                return consumeUrlToken();
+        }
+        return blockStart(LeftParenthesisToken, FunctionToken, name);
+    }
+    return CSSParserToken(IdentToken, name);
+}
+
+// http://dev.w3.org/csswg/css-syntax/#consume-a-string-token
+CSSParserToken CSSTokenizer::consumeStringTokenUntil(UChar endingCodePoint)
+{
+    // Strings without escapes get handled without allocations
+    for (unsigned size = 0; ; size++) {
+        UChar cc = m_input.peekWithoutReplacement(size);
+        if (cc == endingCodePoint) {
+            unsigned startOffset = m_input.offset();
+            m_input.advance(size + 1);
+            return CSSParserToken(StringToken, m_input.rangeAt(startOffset, size));
+        }
+        if (isNewLine(cc)) {
+            m_input.advance(size);
+            return CSSParserToken(BadStringToken);
+        }
+        if (cc == '\0' || cc == '\\')
+            break;
+    }
+
+    StringBuilder output;
+    while (true) {
+        UChar cc = consume();
+        if (cc == endingCodePoint || cc == kEndOfFileMarker)
+            return CSSParserToken(StringToken, registerString(output.toString()));
+        if (isNewLine(cc)) {
+            reconsume(cc);
+            return CSSParserToken(BadStringToken);
+        }
+        if (cc == '\\') {
+            if (m_input.nextInputChar() == kEndOfFileMarker)
+                continue;
+            if (isNewLine(m_input.peekWithoutReplacement(0)))
+                consumeSingleWhitespaceIfNext(); // This handles \r\n for us
+            else
+                output.append(consumeEscape());
+        } else
+            output.append(cc);
+    }
+}
+
+CSSParserToken CSSTokenizer::consumeUnicodeRange()
+{
+    ASSERT(isASCIIHexDigit(m_input.peekWithoutReplacement(0)) || m_input.peekWithoutReplacement(0) == '?');
+    int lengthRemaining = 6;
+    UChar32 start = 0;
+
+    while (lengthRemaining && isASCIIHexDigit(m_input.peekWithoutReplacement(0))) {
+        start = start * 16 + toASCIIHexValue(consume());
+        --lengthRemaining;
+    }
+
+    UChar32 end = start;
+    if (lengthRemaining && consumeIfNext('?')) {
+        do {
+            start *= 16;
+            end = end * 16 + 0xF;
+            --lengthRemaining;
+        } while (lengthRemaining && consumeIfNext('?'));
+    } else if (m_input.peekWithoutReplacement(0) == '-' && isASCIIHexDigit(m_input.peekWithoutReplacement(1))) {
+        m_input.advance();
+        lengthRemaining = 6;
+        end = 0;
+        do {
+            end = end * 16 + toASCIIHexValue(consume());
+            --lengthRemaining;
+        } while (lengthRemaining && isASCIIHexDigit(m_input.peekWithoutReplacement(0)));
+    }
+
+    return CSSParserToken(UnicodeRangeToken, start, end);
+}
+
+// http://dev.w3.org/csswg/css-syntax/#non-printable-code-point
+static bool isNonPrintableCodePoint(UChar cc)
+{
+    return cc <= '\x8' || cc == '\xb' || (cc >= '\xe' && cc <= '\x1f') || cc == '\x7f';
+}
+
+// http://dev.w3.org/csswg/css-syntax/#consume-url-token
+CSSParserToken CSSTokenizer::consumeUrlToken()
+{
+    m_input.advanceUntilNonWhitespace();
+
+    // URL tokens without escapes get handled without allocations
+    for (unsigned size = 0; ; size++) {
+        UChar cc = m_input.peekWithoutReplacement(size);
+        if (cc == ')') {
+            unsigned startOffset = m_input.offset();
+            m_input.advance(size + 1);
+            return CSSParserToken(UrlToken, m_input.rangeAt(startOffset, size));
+        }
+        if (cc <= ' ' || cc == '\\' || cc == '"' || cc == '\'' || cc == '(' || cc == '\x7f')
+            break;
+    }
+
+    StringBuilder result;
+    while (true) {
+        UChar cc = consume();
+        if (cc == ')' || cc == kEndOfFileMarker)
+            return CSSParserToken(UrlToken, registerString(result.toString()));
+
+        if (isHTMLSpace(cc)) {
+            m_input.advanceUntilNonWhitespace();
+            if (consumeIfNext(')') || m_input.nextInputChar() == kEndOfFileMarker)
+                return CSSParserToken(UrlToken, registerString(result.toString()));
+            break;
+        }
+
+        if (cc == '"' || cc == '\'' || cc == '(' || isNonPrintableCodePoint(cc))
+            break;
+
+        if (cc == '\\') {
+            if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
+                result.append(consumeEscape());
+                continue;
+            }
+            break;
+        }
+
+        result.append(cc);
+    }
+
+    consumeBadUrlRemnants();
+    return CSSParserToken(BadUrlToken);
+}
+
+// http://dev.w3.org/csswg/css-syntax/#consume-the-remnants-of-a-bad-url
+void CSSTokenizer::consumeBadUrlRemnants()
+{
+    while (true) {
+        UChar cc = consume();
+        if (cc == ')' || cc == kEndOfFileMarker)
+            return;
+        if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0)))
+            consumeEscape();
+    }
+}
+
+void CSSTokenizer::consumeSingleWhitespaceIfNext()
+{
+    // We check for \r\n and HTML spaces since we don't do preprocessing
+    UChar next = m_input.peekWithoutReplacement(0);
+    if (next == '\r' && m_input.peekWithoutReplacement(1) == '\n')
+        m_input.advance(2);
+    else if (isHTMLSpace(next))
+        m_input.advance();
+}
+
+void CSSTokenizer::consumeUntilCommentEndFound()
+{
+    UChar c = consume();
+    while (true) {
+        if (c == kEndOfFileMarker)
+            return;
+        if (c != '*') {
+            c = consume();
+            continue;
+        }
+        c = consume();
+        if (c == '/')
+            return;
+    }
+}
+
+bool CSSTokenizer::consumeIfNext(UChar character)
+{
+    // Since we're not doing replacement we can't tell the difference from
+    // a NUL in the middle and the kEndOfFileMarker, so character must not be
+    // NUL.
+    ASSERT(character);
+    if (m_input.peekWithoutReplacement(0) == character) {
+        m_input.advance();
+        return true;
+    }
+    return false;
+}
+
+// http://www.w3.org/TR/css3-syntax/#consume-a-name
+StringView CSSTokenizer::consumeName()
+{
+    // Names without escapes get handled without allocations
+    for (unsigned size = 0; ; ++size) {
+        UChar cc = m_input.peekWithoutReplacement(size);
+        if (isNameCodePoint(cc))
+            continue;
+        // peekWithoutReplacement will return NUL when we hit the end of the
+        // input. In that case we want to still use the rangeAt() fast path
+        // below.
+        if (cc == '\0' && m_input.offset() + size < m_input.length())
+            break;
+        if (cc == '\\')
+            break;
+        unsigned startOffset = m_input.offset();
+        m_input.advance(size);
+        return m_input.rangeAt(startOffset, size);
+    }
+
+    StringBuilder result;
+    while (true) {
+        UChar cc = consume();
+        if (isNameCodePoint(cc)) {
+            result.append(cc);
+            continue;
+        }
+        if (twoCharsAreValidEscape(cc, m_input.peekWithoutReplacement(0))) {
+            result.append(consumeEscape());
+            continue;
+        }
+        reconsume(cc);
+        return registerString(result.toString());
+    }
+}
+
+// http://dev.w3.org/csswg/css-syntax/#consume-an-escaped-code-point
+UChar32 CSSTokenizer::consumeEscape()
+{
+    UChar cc = consume();
+    ASSERT(!isNewLine(cc));
+    if (isASCIIHexDigit(cc)) {
+        unsigned consumedHexDigits = 1;
+        StringBuilder hexChars;
+        hexChars.append(cc);
+        while (consumedHexDigits < 6 && isASCIIHexDigit(m_input.peekWithoutReplacement(0))) {
+            cc = consume();
+            hexChars.append(cc);
+            consumedHexDigits++;
+        };
+        consumeSingleWhitespaceIfNext();
+        bool ok = false;
+        UChar32 codePoint = hexChars.toString().toUIntStrict(&ok, 16);
+        ASSERT(ok);
+        if (!codePoint || (0xD800 <= codePoint && codePoint <= 0xDFFF) || codePoint > 0x10FFFF)
+            return replacementCharacter;
+        return codePoint;
+    }
+
+    if (cc == kEndOfFileMarker)
+        return replacementCharacter;
+    return cc;
+}
+
+bool CSSTokenizer::nextTwoCharsAreValidEscape()
+{
+    return twoCharsAreValidEscape(m_input.peekWithoutReplacement(0), m_input.peekWithoutReplacement(1));
+}
+
+// http://www.w3.org/TR/css3-syntax/#starts-with-a-number
+bool CSSTokenizer::nextCharsAreNumber(UChar first)
+{
+    UChar second = m_input.peekWithoutReplacement(0);
+    if (isASCIIDigit(first))
+        return true;
+    if (first == '+' || first == '-')
+        return ((isASCIIDigit(second)) || (second == '.' && isASCIIDigit(m_input.peekWithoutReplacement(1))));
+    if (first =='.')
+        return (isASCIIDigit(second));
+    return false;
+}
+
+bool CSSTokenizer::nextCharsAreNumber()
+{
+    UChar first = consume();
+    bool areNumber = nextCharsAreNumber(first);
+    reconsume(first);
+    return areNumber;
+}
+
+// http://dev.w3.org/csswg/css-syntax/#would-start-an-identifier
+bool CSSTokenizer::nextCharsAreIdentifier(UChar first)
+{
+    UChar second = m_input.peekWithoutReplacement(0);
+    if (isNameStartCodePoint(first) || twoCharsAreValidEscape(first, second))
+        return true;
+
+    if (first == '-')
+        return isNameStartCodePoint(second) || second == '-' || nextTwoCharsAreValidEscape();
+
+    return false;
+}
+
+bool CSSTokenizer::nextCharsAreIdentifier()
+{
+    UChar first = consume();
+    bool areIdentifier = nextCharsAreIdentifier(first);
+    reconsume(first);
+    return areIdentifier;
+}
+
+StringView CSSTokenizer::registerString(const String& string)
+{
+    m_stringPool.append(string);
+    return string;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSTokenizer.h b/Source/WebCore/css/parser/CSSTokenizer.h
new file mode 100644
index 000000000..a83ff978d
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSTokenizer.h
@@ -0,0 +1,128 @@
+// 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 "CSSParserToken.h"
+#include "CSSTokenizerInputStream.h"
+#include <climits>
+#include <wtf/text/StringView.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSTokenizerInputStream;
+class CSSParserObserverWrapper;
+class CSSParserTokenRange;
+
+class CSSTokenizer {
+    WTF_MAKE_NONCOPYABLE(CSSTokenizer);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    CSSTokenizer(const String&);
+    CSSTokenizer(const String&, CSSParserObserverWrapper&); // For the inspector
+
+    CSSParserTokenRange tokenRange() const;
+    unsigned tokenCount();
+
+    Vector<String>&& escapedStringsForAdoption() { return WTFMove(m_stringPool); }
+
+private:
+    CSSParserToken nextToken();
+
+    UChar consume();
+    void reconsume(UChar);
+
+    CSSParserToken consumeNumericToken();
+    CSSParserToken consumeIdentLikeToken();
+    CSSParserToken consumeNumber();
+    CSSParserToken consumeStringTokenUntil(UChar);
+    CSSParserToken consumeUnicodeRange();
+    CSSParserToken consumeUrlToken();
+
+    void consumeBadUrlRemnants();
+    void consumeSingleWhitespaceIfNext();
+    void consumeUntilCommentEndFound();
+
+    bool consumeIfNext(UChar);
+    StringView consumeName();
+    UChar32 consumeEscape();
+
+    bool nextTwoCharsAreValidEscape();
+    bool nextCharsAreNumber(UChar);
+    bool nextCharsAreNumber();
+    bool nextCharsAreIdentifier(UChar);
+    bool nextCharsAreIdentifier();
+
+    CSSParserToken blockStart(CSSParserTokenType);
+    CSSParserToken blockStart(CSSParserTokenType blockType, CSSParserTokenType, StringView);
+    CSSParserToken blockEnd(CSSParserTokenType, CSSParserTokenType startType);
+
+    CSSParserToken whiteSpace(UChar);
+    CSSParserToken leftParenthesis(UChar);
+    CSSParserToken rightParenthesis(UChar);
+    CSSParserToken leftBracket(UChar);
+    CSSParserToken rightBracket(UChar);
+    CSSParserToken leftBrace(UChar);
+    CSSParserToken rightBrace(UChar);
+    CSSParserToken plusOrFullStop(UChar);
+    CSSParserToken comma(UChar);
+    CSSParserToken hyphenMinus(UChar);
+    CSSParserToken asterisk(UChar);
+    CSSParserToken lessThan(UChar);
+    CSSParserToken solidus(UChar);
+    CSSParserToken colon(UChar);
+    CSSParserToken semiColon(UChar);
+    CSSParserToken hash(UChar);
+    CSSParserToken circumflexAccent(UChar);
+    CSSParserToken dollarSign(UChar);
+    CSSParserToken verticalLine(UChar);
+    CSSParserToken tilde(UChar);
+    CSSParserToken commercialAt(UChar);
+    CSSParserToken reverseSolidus(UChar);
+    CSSParserToken asciiDigit(UChar);
+    CSSParserToken letterU(UChar);
+    CSSParserToken nameStart(UChar);
+    CSSParserToken stringStart(UChar);
+    CSSParserToken endOfFile(UChar);
+
+    StringView registerString(const String&);
+
+    using CodePoint = CSSParserToken (CSSTokenizer::*)(UChar);
+    static const CodePoint codePoints[];
+
+    Vector<CSSParserTokenType, 8> m_blockStack;
+    CSSTokenizerInputStream m_input;
+    
+    Vector<CSSParserToken, 32> m_tokens;
+    // We only allocate strings when escapes are used.
+    Vector<String> m_stringPool;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSTokenizerInputStream.cpp b/Source/WebCore/css/parser/CSSTokenizerInputStream.cpp
new file mode 100644
index 000000000..620e6b0f3
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSTokenizerInputStream.cpp
@@ -0,0 +1,73 @@
+// 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 "CSSTokenizerInputStream.h"
+
+#include "HTMLParserIdioms.h"
+
+namespace WebCore {
+
+CSSTokenizerInputStream::CSSTokenizerInputStream(const String& input)
+    : m_offset(0)
+    , m_stringLength(input.length())
+    , m_string(input.impl())
+{
+}
+
+void CSSTokenizerInputStream::advanceUntilNonWhitespace()
+{
+    // Using HTML space here rather than CSS space since we don't do preprocessing
+    if (m_string->is8Bit()) {
+        const LChar* characters = m_string->characters8();
+        while (m_offset < m_stringLength && isHTMLSpace(characters[m_offset]))
+            ++m_offset;
+    } else {
+        const UChar* characters = m_string->characters16();
+        while (m_offset < m_stringLength && isHTMLSpace(characters[m_offset]))
+            ++m_offset;
+    }
+}
+
+double CSSTokenizerInputStream::getDouble(unsigned start, unsigned end) const
+{
+    ASSERT(start <= end && ((m_offset + end) <= m_stringLength));
+    bool isResultOK = false;
+    double result = 0.0;
+    if (start < end) {
+        if (m_string->is8Bit())
+            result = charactersToDouble(m_string->characters8() + m_offset + start, end - start, &isResultOK);
+        else
+            result = charactersToDouble(m_string->characters16() + m_offset + start, end - start, &isResultOK);
+    }
+    // FIXME: It looks like callers ensure we have a valid number
+    return isResultOK ? result : 0.0;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSTokenizerInputStream.h b/Source/WebCore/css/parser/CSSTokenizerInputStream.h
new file mode 100644
index 000000000..96e6e69d0
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSTokenizerInputStream.h
@@ -0,0 +1,107 @@
+// 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 <wtf/text/StringView.h>
+
+namespace WebCore {
+
+constexpr LChar kEndOfFileMarker = 0;
+
+class CSSTokenizerInputStream {
+    WTF_MAKE_NONCOPYABLE(CSSTokenizerInputStream);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    explicit CSSTokenizerInputStream(const String& input);
+
+    // Gets the char in the stream replacing NUL characters with a unicode
+    // replacement character. Will return (NUL) kEndOfFileMarker when at the
+    // end of the stream.
+    UChar nextInputChar() const
+    {
+        if (m_offset >= m_stringLength)
+            return '\0';
+        UChar result = (*m_string)[m_offset];
+        return result ? result : 0xFFFD;
+    }
+
+    // Gets the char at lookaheadOffset from the current stream position. Will
+    // return NUL (kEndOfFileMarker) if the stream position is at the end.
+    // NOTE: This may *also* return NUL if there's one in the input! Never
+    // compare the return value to '\0'.
+    UChar peekWithoutReplacement(unsigned lookaheadOffset) const
+    {
+        if ((m_offset + lookaheadOffset) >= m_stringLength)
+            return '\0';
+        return (*m_string)[m_offset + lookaheadOffset];
+    }
+
+    void advance(unsigned offset = 1) { m_offset += offset; }
+    void pushBack(UChar cc)
+    {
+        --m_offset;
+        ASSERT_UNUSED(cc, nextInputChar() == cc);
+    }
+
+    double getDouble(unsigned start, unsigned end) const;
+
+    template<bool characterPredicate(UChar)>
+    unsigned skipWhilePredicate(unsigned offset)
+    {
+        if (m_string->is8Bit()) {
+            const LChar* characters8 = m_string->characters8();
+            while ((m_offset + offset) < m_stringLength && characterPredicate(characters8[m_offset + offset]))
+                ++offset;
+        } else {
+            const UChar* characters16 = m_string->characters16();
+            while ((m_offset + offset) < m_stringLength && characterPredicate(characters16[m_offset + offset]))
+                ++offset;
+        }
+        return offset;
+    }
+
+    void advanceUntilNonWhitespace();
+
+    unsigned length() const { return m_stringLength; }
+    unsigned offset() const { return std::min(m_offset, m_stringLength); }
+
+    StringView rangeAt(unsigned start, unsigned length) const
+    {
+        ASSERT(start + length <= m_stringLength);
+        return StringView(m_string.get()).substring(start, length); // FIXME: Should make a constructor on StringView for this.
+    }
+
+private:
+    size_t m_offset;
+    const size_t m_stringLength;
+    RefPtr<StringImpl> m_string;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSVariableParser.cpp b/Source/WebCore/css/parser/CSSVariableParser.cpp
new file mode 100644
index 000000000..6acda4f83
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSVariableParser.cpp
@@ -0,0 +1,166 @@
+// 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 "CSSVariableParser.h"
+
+#include "CSSCustomPropertyValue.h"
+#include "CSSParserTokenRange.h"
+
+namespace WebCore {
+
+bool CSSVariableParser::isValidVariableName(const CSSParserToken& token)
+{
+    if (token.type() != IdentToken)
+        return false;
+
+    StringView value = token.value();
+    return value.length() >= 2 && value[0] == '-' && value[1] == '-';
+}
+
+bool CSSVariableParser::isValidVariableName(const String& string)
+{
+    return string.length() >= 2 && string[0] == '-' && string[1] == '-';
+}
+
+bool isValidVariableReference(CSSParserTokenRange, bool& hasAtApplyRule);
+
+static bool classifyBlock(CSSParserTokenRange range, bool& hasReferences, bool& hasAtApplyRule, bool isTopLevelBlock = true)
+{
+    while (!range.atEnd()) {
+        if (range.peek().getBlockType() == CSSParserToken::BlockStart) {
+            const CSSParserToken& token = range.peek();
+            CSSParserTokenRange block = range.consumeBlock();
+            if (token.functionId() == CSSValueVar) {
+                if (!isValidVariableReference(block, hasAtApplyRule))
+                    return false; // Bail if any references are invalid
+                hasReferences = true;
+                continue;
+            }
+            if (!classifyBlock(block, hasReferences, hasAtApplyRule, false))
+                return false;
+            continue;
+        }
+
+        ASSERT(range.peek().getBlockType() != CSSParserToken::BlockEnd);
+
+        const CSSParserToken& token = range.consume();
+        switch (token.type()) {
+        case AtKeywordToken: {
+            if (equalIgnoringASCIICase(token.value(), "apply")) {
+                range.consumeWhitespace();
+                const CSSParserToken& variableName = range.consumeIncludingWhitespace();
+                if (!CSSVariableParser::isValidVariableName(variableName)
+                    || !(range.atEnd() || range.peek().type() == SemicolonToken || range.peek().type() == RightBraceToken))
+                    return false;
+                hasAtApplyRule = true;
+            }
+            break;
+        }
+        case DelimiterToken: {
+            if (token.delimiter() == '!' && isTopLevelBlock)
+                return false;
+            break;
+        }
+        case RightParenthesisToken:
+        case RightBraceToken:
+        case RightBracketToken:
+        case BadStringToken:
+        case BadUrlToken:
+            return false;
+        case SemicolonToken:
+            if (isTopLevelBlock)
+                return false;
+            break;
+        default:
+            break;
+        }
+    }
+    return true;
+}
+
+bool isValidVariableReference(CSSParserTokenRange range, bool& hasAtApplyRule)
+{
+    range.consumeWhitespace();
+    if (!CSSVariableParser::isValidVariableName(range.consumeIncludingWhitespace()))
+        return false;
+    if (range.atEnd())
+        return true;
+
+    if (range.consume().type() != CommaToken)
+        return false;
+    if (range.atEnd())
+        return false;
+
+    bool hasReferences = false;
+    return classifyBlock(range, hasReferences, hasAtApplyRule);
+}
+
+static CSSValueID classifyVariableRange(CSSParserTokenRange range, bool& hasReferences, bool& hasAtApplyRule)
+{
+    hasReferences = false;
+    hasAtApplyRule = false;
+
+    range.consumeWhitespace();
+    if (range.peek().type() == IdentToken) {
+        CSSValueID id = range.consumeIncludingWhitespace().id();
+        if (range.atEnd() && (id == CSSValueInherit || id == CSSValueInitial || id == CSSValueUnset || id == CSSValueRevert))
+            return id;
+    }
+
+    if (classifyBlock(range, hasReferences, hasAtApplyRule))
+        return CSSValueInternalVariableValue;
+    return CSSValueInvalid;
+}
+
+bool CSSVariableParser::containsValidVariableReferences(CSSParserTokenRange range)
+{
+    bool hasReferences;
+    bool hasAtApplyRule;
+    CSSValueID type = classifyVariableRange(range, hasReferences, hasAtApplyRule);
+    return type == CSSValueInternalVariableValue && hasReferences && !hasAtApplyRule;
+}
+
+RefPtr<CSSCustomPropertyValue> CSSVariableParser::parseDeclarationValue(const AtomicString& variableName, CSSParserTokenRange range)
+{
+    if (range.atEnd())
+        return nullptr;
+
+    bool hasReferences;
+    bool hasAtApplyRule;
+    CSSValueID type = classifyVariableRange(range, hasReferences, hasAtApplyRule);
+
+    if (type == CSSValueInvalid)
+        return nullptr;
+    if (type == CSSValueInternalVariableValue)
+        return CSSCustomPropertyValue::createWithVariableData(variableName, CSSVariableData::create(range, hasReferences || hasAtApplyRule));
+    return CSSCustomPropertyValue::createWithID(variableName, type);
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSVariableParser.h b/Source/WebCore/css/parser/CSSVariableParser.h
new file mode 100644
index 000000000..238ebd67e
--- /dev/null
+++ b/Source/WebCore/css/parser/CSSVariableParser.h
@@ -0,0 +1,50 @@
+// 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
+
+#include "CSSParserTokenRange.h"
+#include <wtf/RefPtr.h>
+#include <wtf/text/AtomicString.h>
+
+namespace WebCore {
+
+class CSSCustomPropertyValue;
+
+class CSSVariableParser {
+public:
+    static bool containsValidVariableReferences(CSSParserTokenRange);
+
+    static RefPtr<CSSCustomPropertyValue> parseDeclarationValue(const AtomicString&, CSSParserTokenRange);
+
+    static bool isValidVariableName(const CSSParserToken&);
+    static bool isValidVariableName(const String&);
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/MediaQueryBlockWatcher.cpp b/Source/WebCore/css/parser/MediaQueryBlockWatcher.cpp
new file mode 100644
index 000000000..97333a661
--- /dev/null
+++ b/Source/WebCore/css/parser/MediaQueryBlockWatcher.cpp
@@ -0,0 +1,51 @@
+// 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 "MediaQueryBlockWatcher.h"
+
+#include "CSSParserToken.h"
+
+namespace WebCore {
+
+MediaQueryBlockWatcher::MediaQueryBlockWatcher()
+{
+}
+
+void MediaQueryBlockWatcher::handleToken(const CSSParserToken& token)
+{
+    if (token.getBlockType() == CSSParserToken::BlockStart)
+        ++m_blockLevel;
+    else if (token.getBlockType() == CSSParserToken::BlockEnd) {
+        ASSERT(m_blockLevel);
+        --m_blockLevel;
+    }
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/MediaQueryBlockWatcher.h b/Source/WebCore/css/parser/MediaQueryBlockWatcher.h
new file mode 100644
index 000000000..1e6c2e1a5
--- /dev/null
+++ b/Source/WebCore/css/parser/MediaQueryBlockWatcher.h
@@ -0,0 +1,46 @@
+// 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
+
+namespace WebCore {
+
+class CSSParserToken;
+
+class MediaQueryBlockWatcher {
+public:
+    MediaQueryBlockWatcher();
+    void handleToken(const CSSParserToken&);
+    unsigned blockLevel() const { return m_blockLevel; }
+
+private:
+    unsigned m_blockLevel { 0 };
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/MediaQueryParser.cpp b/Source/WebCore/css/parser/MediaQueryParser.cpp
new file mode 100644
index 000000000..a4c9afe98
--- /dev/null
+++ b/Source/WebCore/css/parser/MediaQueryParser.cpp
@@ -0,0 +1,310 @@
+// 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 "MediaQueryParser.h"
+
+#include "CSSParserIdioms.h"
+#include "CSSTokenizer.h"
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+RefPtr<MediaQuerySet> MediaQueryParser::parseMediaQuerySet(const String& queryString)
+{
+    return parseMediaQuerySet(CSSTokenizer(queryString).tokenRange());
+}
+
+RefPtr<MediaQuerySet> MediaQueryParser::parseMediaQuerySet(CSSParserTokenRange range)
+{
+    return MediaQueryParser(MediaQuerySetParser).parseInternal(range);
+}
+
+RefPtr<MediaQuerySet> MediaQueryParser::parseMediaCondition(CSSParserTokenRange range)
+{
+    return MediaQueryParser(MediaConditionParser).parseInternal(range);
+}
+
+const MediaQueryParser::State MediaQueryParser::ReadRestrictor = &MediaQueryParser::readRestrictor;
+const MediaQueryParser::State MediaQueryParser::ReadMediaNot = &MediaQueryParser::readMediaNot;
+const MediaQueryParser::State MediaQueryParser::ReadMediaType = &MediaQueryParser::readMediaType;
+const MediaQueryParser::State MediaQueryParser::ReadAnd = &MediaQueryParser::readAnd;
+const MediaQueryParser::State MediaQueryParser::ReadFeatureStart = &MediaQueryParser::readFeatureStart;
+const MediaQueryParser::State MediaQueryParser::ReadFeature = &MediaQueryParser::readFeature;
+const MediaQueryParser::State MediaQueryParser::ReadFeatureColon = &MediaQueryParser::readFeatureColon;
+const MediaQueryParser::State MediaQueryParser::ReadFeatureValue = &MediaQueryParser::readFeatureValue;
+const MediaQueryParser::State MediaQueryParser::ReadFeatureEnd = &MediaQueryParser::readFeatureEnd;
+const MediaQueryParser::State MediaQueryParser::SkipUntilComma = &MediaQueryParser::skipUntilComma;
+const MediaQueryParser::State MediaQueryParser::SkipUntilBlockEnd = &MediaQueryParser::skipUntilBlockEnd;
+const MediaQueryParser::State MediaQueryParser::Done = &MediaQueryParser::done;
+
+MediaQueryParser::MediaQueryParser(ParserType parserType)
+    : m_parserType(parserType)
+    , m_querySet(MediaQuerySet::create())
+{
+    if (parserType == MediaQuerySetParser)
+        m_state = &MediaQueryParser::readRestrictor;
+    else // MediaConditionParser
+        m_state = &MediaQueryParser::readMediaNot;
+}
+
+MediaQueryParser::~MediaQueryParser() { }
+
+void MediaQueryParser::setStateAndRestrict(State state, MediaQuery::Restrictor restrictor)
+{
+    m_mediaQueryData.setRestrictor(restrictor);
+    m_state = state;
+}
+
+// State machine member functions start here
+void MediaQueryParser::readRestrictor(CSSParserTokenType type, const CSSParserToken& token)
+{
+    readMediaType(type, token);
+}
+
+void MediaQueryParser::readMediaNot(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == IdentToken && equalIgnoringASCIICase(token.value(), "not"))
+        setStateAndRestrict(ReadFeatureStart, MediaQuery::Not);
+    else
+        readFeatureStart(type, token);
+}
+
+static bool isRestrictorOrLogicalOperator(const CSSParserToken& token)
+{
+    // FIXME: it would be more efficient to use lower-case always for tokenValue.
+    return equalIgnoringASCIICase(token.value(), "not")
+        || equalIgnoringASCIICase(token.value(), "and")
+        || equalIgnoringASCIICase(token.value(), "or")
+        || equalIgnoringASCIICase(token.value(), "only");
+}
+
+void MediaQueryParser::readMediaType(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == LeftParenthesisToken) {
+        if (m_mediaQueryData.restrictor() != MediaQuery::None)
+            m_state = SkipUntilComma;
+        else
+            m_state = ReadFeature;
+    } else if (type == IdentToken) {
+        if (m_state == ReadRestrictor && equalIgnoringASCIICase(token.value(), "not"))
+            setStateAndRestrict(ReadMediaType, MediaQuery::Not);
+        else if (m_state == ReadRestrictor && equalIgnoringASCIICase(token.value(), "only"))
+            setStateAndRestrict(ReadMediaType, MediaQuery::Only);
+        else if (m_mediaQueryData.restrictor() != MediaQuery::None
+            && isRestrictorOrLogicalOperator(token)) {
+            m_state = SkipUntilComma;
+        } else {
+            m_mediaQueryData.setMediaType(token.value().toString());
+            m_state = ReadAnd;
+        }
+    } else if (type == EOFToken && (!m_querySet->queryVector().size() || m_state != ReadRestrictor))
+        m_state = Done;
+    else {
+        m_state = SkipUntilComma;
+        if (type == CommaToken)
+            skipUntilComma(type, token);
+    }
+}
+
+void MediaQueryParser::commitMediaQuery()
+{
+    // FIXME-NEWPARSER: Convoluted and awful, but we can't change the MediaQuerySet yet because of the
+    // old parser.
+    MediaQuery mediaQuery = MediaQuery(m_mediaQueryData.restrictor(), m_mediaQueryData.mediaType(), WTFMove(m_mediaQueryData.expressions()));
+    m_mediaQueryData.clear();
+    m_querySet->addMediaQuery(WTFMove(mediaQuery));
+}
+
+void MediaQueryParser::readAnd(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == IdentToken && equalIgnoringASCIICase(token.value(), "and")) {
+        m_state = ReadFeatureStart;
+    } else if (type == CommaToken && m_parserType != MediaConditionParser) {
+        commitMediaQuery();
+        m_state = ReadRestrictor;
+    } else if (type == EOFToken)
+        m_state = Done;
+    else
+        m_state = SkipUntilComma;
+}
+
+void MediaQueryParser::readFeatureStart(CSSParserTokenType type, const CSSParserToken& /*token*/)
+{
+    if (type == LeftParenthesisToken)
+        m_state = ReadFeature;
+    else
+        m_state = SkipUntilComma;
+}
+
+void MediaQueryParser::readFeature(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == IdentToken) {
+        m_mediaQueryData.setMediaFeature(token.value().toString());
+        m_state = ReadFeatureColon;
+    } else
+        m_state = SkipUntilComma;
+}
+
+void MediaQueryParser::readFeatureColon(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == ColonToken)
+        m_state = ReadFeatureValue;
+    else if (type == RightParenthesisToken || type == EOFToken)
+        readFeatureEnd(type, token);
+    else
+        m_state = SkipUntilBlockEnd;
+}
+
+void MediaQueryParser::readFeatureValue(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::CSS_UNKNOWN)
+        m_state = SkipUntilComma;
+    else {
+        if (m_mediaQueryData.tryAddParserToken(type, token))
+            m_state = ReadFeatureEnd;
+        else
+            m_state = SkipUntilBlockEnd;
+    }
+}
+
+void MediaQueryParser::readFeatureEnd(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == RightParenthesisToken || type == EOFToken) {
+        if (type != EOFToken && m_mediaQueryData.addExpression())
+            m_state = ReadAnd;
+        else
+            m_state = SkipUntilComma;
+    } else if (type == DelimiterToken && token.delimiter() == '/') {
+        m_mediaQueryData.tryAddParserToken(type, token);
+        m_state = ReadFeatureValue;
+    } else
+        m_state = SkipUntilBlockEnd;
+}
+
+void MediaQueryParser::skipUntilComma(CSSParserTokenType type, const CSSParserToken& /*token*/)
+{
+    if ((type == CommaToken && !m_blockWatcher.blockLevel()) || type == EOFToken) {
+        m_state = ReadRestrictor;
+        m_mediaQueryData.clear();
+        MediaQuery query = MediaQuery(MediaQuery::Not, "all", Vector<MediaQueryExpression>());
+        m_querySet->addMediaQuery(WTFMove(query));
+    }
+}
+
+void MediaQueryParser::skipUntilBlockEnd(CSSParserTokenType /*type */, const CSSParserToken& token)
+{
+    if (token.getBlockType() == CSSParserToken::BlockEnd && !m_blockWatcher.blockLevel())
+        m_state = SkipUntilComma;
+}
+
+void MediaQueryParser::done(CSSParserTokenType /*type*/, const CSSParserToken& /*token*/) { }
+
+void MediaQueryParser::handleBlocks(const CSSParserToken& token)
+{
+    if (token.getBlockType() == CSSParserToken::BlockStart
+        && (token.type() != LeftParenthesisToken || m_blockWatcher.blockLevel()))
+            m_state = SkipUntilBlockEnd;
+}
+
+void MediaQueryParser::processToken(const CSSParserToken& token)
+{
+    CSSParserTokenType type = token.type();
+
+    handleBlocks(token);
+    m_blockWatcher.handleToken(token);
+
+    // Call the function that handles current state
+    if (type != WhitespaceToken)
+        ((this)->*(m_state))(type, token);
+}
+
+// The state machine loop
+RefPtr<MediaQuerySet> MediaQueryParser::parseInternal(CSSParserTokenRange range)
+{
+    while (!range.atEnd())
+        processToken(range.consume());
+
+    // FIXME: Can we get rid of this special case?
+    if (m_parserType == MediaQuerySetParser)
+        processToken(CSSParserToken(EOFToken));
+
+    if (m_state != ReadAnd && m_state != ReadRestrictor && m_state != Done && m_state != ReadMediaNot) {
+        MediaQuery query = MediaQuery(MediaQuery::Not, "all", Vector<MediaQueryExpression>());
+        m_querySet->addMediaQuery(WTFMove(query));
+    } else if (m_mediaQueryData.currentMediaQueryChanged())
+        commitMediaQuery();
+
+    return m_querySet;
+}
+
+MediaQueryData::MediaQueryData()
+    : m_restrictor(MediaQuery::None)
+    , m_mediaType("all")
+    , m_mediaTypeSet(false)
+{
+}
+
+void MediaQueryData::clear()
+{
+    m_restrictor = MediaQuery::None;
+    m_mediaType = "all";
+    m_mediaTypeSet = false;
+    m_mediaFeature = String();
+    m_valueList.clear();
+    m_expressions.clear();
+}
+
+bool MediaQueryData::addExpression()
+{
+    MediaQueryExpression expression = MediaQueryExpression(m_mediaFeature, m_valueList);
+    bool isValid = expression.isValid();
+    m_expressions.append(WTFMove(expression));
+    m_valueList.clear();
+    return isValid;
+}
+
+bool MediaQueryData::tryAddParserToken(CSSParserTokenType type, const CSSParserToken& token)
+{
+    if (type == NumberToken || type == PercentageToken || type == DimensionToken
+        || type == DelimiterToken || type == IdentToken) {
+        m_valueList.append(token);
+        return true;
+    }
+
+    return false;
+}
+
+void MediaQueryData::setMediaType(const String& mediaType)
+{
+    m_mediaType = mediaType;
+    m_mediaTypeSet = true;
+}
+
+} // namespace WebCsore
diff --git a/Source/WebCore/css/parser/MediaQueryParser.h b/Source/WebCore/css/parser/MediaQueryParser.h
new file mode 100644
index 000000000..e51d6c32a
--- /dev/null
+++ b/Source/WebCore/css/parser/MediaQueryParser.h
@@ -0,0 +1,136 @@
+// 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 "CSSParserToken.h"
+#include "CSSParserTokenRange.h"
+#include "MediaList.h"
+#include "MediaQuery.h"
+#include "MediaQueryBlockWatcher.h"
+#include "MediaQueryExpression.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class MediaQuerySet;
+
+class MediaQueryData {
+    WTF_MAKE_NONCOPYABLE(MediaQueryData);
+public:
+    MediaQueryData();
+    void clear();
+    bool addExpression();
+    bool tryAddParserToken(CSSParserTokenType, const CSSParserToken&);
+    void setMediaType(const String&);
+    
+    MediaQuery::Restrictor restrictor() const { return m_restrictor; };
+    Vector<MediaQueryExpression>& expressions() { return m_expressions; }
+    String mediaType() const { return m_mediaType; }
+    
+    inline bool currentMediaQueryChanged() const
+    {
+        return (m_restrictor != MediaQuery::None || m_mediaTypeSet || m_expressions.size() > 0);
+    }
+    inline MediaQuery::Restrictor restrictor() { return m_restrictor; }
+
+    inline void setRestrictor(MediaQuery::Restrictor restrictor) { m_restrictor = restrictor; }
+
+    inline void setMediaFeature(const String& str) { m_mediaFeature = str; }
+
+private:
+    MediaQuery::Restrictor m_restrictor;
+    String m_mediaType;
+    Vector<MediaQueryExpression> m_expressions;
+    String m_mediaFeature;
+    Vector<CSSParserToken, 4> m_valueList;
+    bool m_mediaTypeSet;
+};
+
+class MediaQueryParser {
+    WTF_MAKE_NONCOPYABLE(MediaQueryParser);
+public:
+    static RefPtr<MediaQuerySet> parseMediaQuerySet(const String&);
+    static RefPtr<MediaQuerySet> parseMediaQuerySet(CSSParserTokenRange);
+    static RefPtr<MediaQuerySet> parseMediaCondition(CSSParserTokenRange);
+
+private:
+    enum ParserType {
+        MediaQuerySetParser,
+        MediaConditionParser,
+    };
+
+    MediaQueryParser(ParserType);
+    virtual ~MediaQueryParser();
+
+    RefPtr<MediaQuerySet> parseInternal(CSSParserTokenRange);
+
+    void processToken(const CSSParserToken&);
+
+    void readRestrictor(CSSParserTokenType, const CSSParserToken&);
+    void readMediaNot(CSSParserTokenType, const CSSParserToken&);
+    void readMediaType(CSSParserTokenType, const CSSParserToken&);
+    void readAnd(CSSParserTokenType, const CSSParserToken&);
+    void readFeatureStart(CSSParserTokenType, const CSSParserToken&);
+    void readFeature(CSSParserTokenType, const CSSParserToken&);
+    void readFeatureColon(CSSParserTokenType, const CSSParserToken&);
+    void readFeatureValue(CSSParserTokenType, const CSSParserToken&);
+    void readFeatureEnd(CSSParserTokenType, const CSSParserToken&);
+    void skipUntilComma(CSSParserTokenType, const CSSParserToken&);
+    void skipUntilBlockEnd(CSSParserTokenType, const CSSParserToken&);
+    void done(CSSParserTokenType, const CSSParserToken&);
+
+    using State = void (MediaQueryParser::*)(CSSParserTokenType, const CSSParserToken&);
+
+    void setStateAndRestrict(State, MediaQuery::Restrictor);
+    void handleBlocks(const CSSParserToken&);
+    
+    void commitMediaQuery();
+
+    State m_state;
+    ParserType m_parserType;
+    MediaQueryData m_mediaQueryData;
+    RefPtr<MediaQuerySet> m_querySet;
+    MediaQueryBlockWatcher m_blockWatcher;
+
+    const static State ReadRestrictor;
+    const static State ReadMediaNot;
+    const static State ReadMediaType;
+    const static State ReadAnd;
+    const static State ReadFeatureStart;
+    const static State ReadFeature;
+    const static State ReadFeatureColon;
+    const static State ReadFeatureValue;
+    const static State ReadFeatureEnd;
+    const static State SkipUntilComma;
+    const static State SkipUntilBlockEnd;
+    const static State Done;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/SizesAttributeParser.cpp b/Source/WebCore/css/parser/SizesAttributeParser.cpp
new file mode 100644
index 000000000..7b7969bba
--- /dev/null
+++ b/Source/WebCore/css/parser/SizesAttributeParser.cpp
@@ -0,0 +1,166 @@
+// 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 "SizesAttributeParser.h"
+
+#include "CSSPrimitiveValue.h"
+#include "CSSToLengthConversionData.h"
+#include "CSSTokenizer.h"
+#include "MediaQueryEvaluator.h"
+#include "RenderView.h"
+#include "SizesCalcParser.h"
+#include "StyleScope.h"
+
+namespace WebCore {
+
+float SizesAttributeParser::computeLength(double value, CSSPrimitiveValue::UnitType type, const Document& document)
+{
+    auto* renderer = document.renderView();
+    if (!renderer)
+        return 0;
+    auto& style = renderer->style();
+
+    CSSToLengthConversionData conversionData(&style, &style, renderer);
+    
+    // Because we evaluate "sizes" at parse time (before style has been resolved), the font metrics used for these specific units
+    // are not available. The font selector's internal consistency isn't guaranteed just yet, so we can just temporarily clear
+    // the pointer to it for the duration of the unit evaluation. This is acceptible because the style always comes from the
+    // RenderView, which has its font information hardcoded in resolveForDocument() to be -webkit-standard, whose operations
+    // don't require a font selector.
+    if (type == CSSPrimitiveValue::CSS_EXS || type == CSSPrimitiveValue::CSS_CHS) {
+        RefPtr<FontSelector> fontSelector = style.fontCascade().fontSelector();
+        style.fontCascade().update(nullptr);
+        float result = CSSPrimitiveValue::computeNonCalcLengthDouble(conversionData, type, value);
+        style.fontCascade().update(fontSelector.get());
+        return result;
+    }
+    
+    return clampTo<float>(CSSPrimitiveValue::computeNonCalcLengthDouble(conversionData, type, value));
+}
+    
+SizesAttributeParser::SizesAttributeParser(const String& attribute, const Document& document)
+    : m_document(document)
+    , m_length(0)
+    , m_lengthWasSet(false)
+{
+    // Ensure iframes have correct view size.
+    if (m_document.ownerElement())
+        m_document.ownerElement()->document().updateLayoutIgnorePendingStylesheets();
+
+    m_isValid = parse(CSSTokenizer(attribute).tokenRange());
+}
+
+float SizesAttributeParser::length()
+{
+    if (m_isValid)
+        return effectiveSize();
+    return effectiveSizeDefaultValue();
+}
+
+bool SizesAttributeParser::calculateLengthInPixels(CSSParserTokenRange range, float& result)
+{
+    const CSSParserToken& startToken = range.peek();
+    CSSParserTokenType type = startToken.type();
+    if (type == DimensionToken) {
+        if (!CSSPrimitiveValue::isLength(startToken.unitType()))
+            return false;
+        result = computeLength(startToken.numericValue(), startToken.unitType(), m_document);
+        if (result >= 0)
+            return true;
+    } else if (type == FunctionToken) {
+        SizesCalcParser calcParser(range, m_document);
+        if (!calcParser.isValid())
+            return false;
+        result = calcParser.result();
+        return true;
+    } else if (type == NumberToken && !startToken.numericValue()) {
+        result = 0;
+        return true;
+    }
+
+    return false;
+}
+
+bool SizesAttributeParser::mediaConditionMatches(const MediaQuerySet& mediaCondition)
+{
+    // A Media Condition cannot have a media type other than screen.
+    auto* renderer = m_document.renderView();
+    if (!renderer)
+        return false;
+    auto& style = renderer->style();
+    return MediaQueryEvaluator { "screen", m_document, &style }.evaluate(mediaCondition, const_cast<Style::Scope&>(m_document.styleScope()).resolverIfExists());
+}
+
+bool SizesAttributeParser::parse(CSSParserTokenRange range)
+{
+    // Split on a comma token and parse the result tokens as (media-condition, length) pairs
+    while (!range.atEnd()) {
+        const CSSParserToken* mediaConditionStart = &range.peek();
+        // The length is the last component value before the comma which isn't whitespace or a comment
+        const CSSParserToken* lengthTokenStart = &range.peek();
+        const CSSParserToken* lengthTokenEnd = &range.peek();
+        while (!range.atEnd() && range.peek().type() != CommaToken) {
+            lengthTokenStart = &range.peek();
+            range.consumeComponentValue();
+            lengthTokenEnd = &range.peek();
+            range.consumeWhitespace();
+        }
+        range.consume();
+
+        float length;
+        if (!calculateLengthInPixels(range.makeSubRange(lengthTokenStart, lengthTokenEnd), length))
+            continue;
+        RefPtr<MediaQuerySet> mediaCondition = MediaQueryParser::parseMediaCondition(range.makeSubRange(mediaConditionStart, lengthTokenStart));
+        if (!mediaCondition || !mediaConditionMatches(*mediaCondition))
+            continue;
+        m_length = length;
+        m_lengthWasSet = true;
+        return true;
+    }
+    return false;
+}
+
+float SizesAttributeParser::effectiveSize()
+{
+    if (m_lengthWasSet)
+        return m_length;
+    return effectiveSizeDefaultValue();
+}
+
+unsigned SizesAttributeParser::effectiveSizeDefaultValue()
+{
+    auto* renderer = m_document.renderView();
+    if (!renderer)
+        return 0;
+    auto& style = renderer->style();
+    return clampTo<float>(CSSPrimitiveValue::computeNonCalcLengthDouble({ &style, &style, renderer }, CSSPrimitiveValue::CSS_VW, 100.0));
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/SizesAttributeParser.h b/Source/WebCore/css/parser/SizesAttributeParser.h
new file mode 100644
index 000000000..38395cf8c
--- /dev/null
+++ b/Source/WebCore/css/parser/SizesAttributeParser.h
@@ -0,0 +1,64 @@
+// 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 "MediaQueryBlockWatcher.h"
+#include "MediaQueryParser.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSValue;
+class Document;
+    
+class SizesAttributeParser {
+public:
+    SizesAttributeParser(const String&, const Document&);
+
+    float length();
+
+    static float defaultLength(const Document&);
+    static float computeLength(double value, CSSPrimitiveValue::UnitType, const Document&);
+
+private:
+    bool parse(CSSParserTokenRange);
+    float effectiveSize();
+    bool calculateLengthInPixels(CSSParserTokenRange, float& result);
+    bool mediaConditionMatches(const MediaQuerySet& mediaCondition);
+    unsigned effectiveSizeDefaultValue();
+
+    const Document& m_document;
+    RefPtr<MediaQuerySet> m_mediaCondition;
+    float m_length;
+    bool m_lengthWasSet;
+    bool m_isValid;
+};
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/SizesCalcParser.cpp b/Source/WebCore/css/parser/SizesCalcParser.cpp
new file mode 100644
index 000000000..4c36c740a
--- /dev/null
+++ b/Source/WebCore/css/parser/SizesCalcParser.cpp
@@ -0,0 +1,259 @@
+// 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 "SizesCalcParser.h"
+
+#include "CSSParserToken.h"
+#include "RenderView.h"
+#include "SizesAttributeParser.h"
+
+namespace WebCore {
+
+SizesCalcParser::SizesCalcParser(CSSParserTokenRange range, const Document& document)
+    : m_result(0)
+    , m_document(document)
+{
+    m_isValid = calcToReversePolishNotation(range) && calculate();
+}
+
+float SizesCalcParser::result() const
+{
+    ASSERT(m_isValid);
+    return m_result;
+}
+
+static bool operatorPriority(UChar cc, bool& highPriority)
+{
+    if (cc == '+' || cc == '-')
+        highPriority = false;
+    else if (cc == '*' || cc == '/')
+        highPriority = true;
+    else
+        return false;
+    return true;
+}
+
+bool SizesCalcParser::handleOperator(Vector<CSSParserToken>& stack, const CSSParserToken& token)
+{
+    // If the token is an operator, o1, then:
+    // while there is an operator token, o2, at the top of the stack, and
+    // either o1 is left-associative and its precedence is equal to that of o2,
+    // or o1 has precedence less than that of o2,
+    // pop o2 off the stack, onto the output queue;
+    // push o1 onto the stack.
+    bool stackOperatorPriority;
+    bool incomingOperatorPriority;
+
+    if (!operatorPriority(token.delimiter(), incomingOperatorPriority))
+        return false;
+    if (!stack.isEmpty() && stack.last().type() == DelimiterToken) {
+        if (!operatorPriority(stack.last().delimiter(), stackOperatorPriority))
+            return false;
+        if (!incomingOperatorPriority || stackOperatorPriority) {
+            appendOperator(stack.last());
+            stack.removeLast();
+        }
+    }
+    stack.append(token);
+    return true;
+}
+
+void SizesCalcParser::appendNumber(const CSSParserToken& token)
+{
+    SizesCalcValue value;
+    value.value = token.numericValue();
+    m_valueList.append(value);
+}
+
+bool SizesCalcParser::appendLength(const CSSParserToken& token)
+{
+    SizesCalcValue value;
+    double result = SizesAttributeParser::computeLength(token.numericValue(), token.unitType(), m_document);
+    value.value = result;
+    value.isLength = true;
+    m_valueList.append(value);
+    return true;
+}
+
+void SizesCalcParser::appendOperator(const CSSParserToken& token)
+{
+    SizesCalcValue value;
+    value.operation = token.delimiter();
+    m_valueList.append(value);
+}
+
+bool SizesCalcParser::calcToReversePolishNotation(CSSParserTokenRange range)
+{
+    // This method implements the shunting yard algorithm, to turn the calc syntax into a reverse polish notation.
+    // http://en.wikipedia.org/wiki/Shunting-yard_algorithm
+
+    Vector<CSSParserToken> stack;
+    while (!range.atEnd()) {
+        const CSSParserToken& token = range.consume();
+        switch (token.type()) {
+        case NumberToken:
+            appendNumber(token);
+            break;
+        case DimensionToken:
+            if (!CSSPrimitiveValue::isLength(token.unitType()) || !appendLength(token))
+                return false;
+            break;
+        case DelimiterToken:
+            if (!handleOperator(stack, token))
+                return false;
+            break;
+        case FunctionToken:
+            if (!equalIgnoringASCIICase(token.value(), "calc"))
+                return false;
+            // "calc(" is the same as "("
+            FALLTHROUGH;
+        case LeftParenthesisToken:
+            // If the token is a left parenthesis, then push it onto the stack.
+            stack.append(token);
+            break;
+        case RightParenthesisToken:
+            // If the token is a right parenthesis:
+            // Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue.
+            while (!stack.isEmpty() && stack.last().type() != LeftParenthesisToken && stack.last().type() != FunctionToken) {
+                appendOperator(stack.last());
+                stack.removeLast();
+            }
+            // If the stack runs out without finding a left parenthesis, then there are mismatched parentheses.
+            if (stack.isEmpty())
+                return false;
+            // Pop the left parenthesis from the stack, but not onto the output queue.
+            stack.removeLast();
+            break;
+        case WhitespaceToken:
+        case EOFToken:
+            break;
+        case CDOToken:
+        case CDCToken:
+        case AtKeywordToken:
+        case HashToken:
+        case UrlToken:
+        case BadUrlToken:
+        case PercentageToken:
+        case IncludeMatchToken:
+        case DashMatchToken:
+        case PrefixMatchToken:
+        case SuffixMatchToken:
+        case SubstringMatchToken:
+        case ColumnToken:
+        case UnicodeRangeToken:
+        case IdentToken:
+        case CommaToken:
+        case ColonToken:
+        case SemicolonToken:
+        case LeftBraceToken:
+        case LeftBracketToken:
+        case RightBraceToken:
+        case RightBracketToken:
+        case StringToken:
+        case BadStringToken:
+            return false;
+        case CommentToken:
+            ASSERT_NOT_REACHED();
+            return false;
+        }
+    }
+
+    // When there are no more tokens to read:
+    // While there are still operator tokens in the stack:
+    while (!stack.isEmpty()) {
+        // If the operator token on the top of the stack is a parenthesis, then there are mismatched parentheses.
+        CSSParserTokenType type = stack.last().type();
+        if (type == LeftParenthesisToken || type == FunctionToken)
+            return false;
+        // Pop the operator onto the output queue.
+        appendOperator(stack.last());
+        stack.removeLast();
+    }
+    return true;
+}
+
+static bool operateOnStack(Vector<SizesCalcValue>& stack, UChar operation)
+{
+    if (stack.size() < 2)
+        return false;
+    SizesCalcValue rightOperand = stack.last();
+    stack.removeLast();
+    SizesCalcValue leftOperand = stack.last();
+    stack.removeLast();
+    bool isLength;
+    switch (operation) {
+    case '+':
+        if (rightOperand.isLength != leftOperand.isLength)
+            return false;
+        isLength = (rightOperand.isLength && leftOperand.isLength);
+        stack.append(SizesCalcValue(leftOperand.value + rightOperand.value, isLength));
+        break;
+    case '-':
+        if (rightOperand.isLength != leftOperand.isLength)
+            return false;
+        isLength = (rightOperand.isLength && leftOperand.isLength);
+        stack.append(SizesCalcValue(leftOperand.value - rightOperand.value, isLength));
+        break;
+    case '*':
+        if (rightOperand.isLength && leftOperand.isLength)
+            return false;
+        isLength = (rightOperand.isLength || leftOperand.isLength);
+        stack.append(SizesCalcValue(leftOperand.value * rightOperand.value, isLength));
+        break;
+    case '/':
+        if (rightOperand.isLength || !rightOperand.value)
+            return false;
+        stack.append(SizesCalcValue(leftOperand.value / rightOperand.value, leftOperand.isLength));
+        break;
+    default:
+        return false;
+    }
+    return true;
+}
+
+bool SizesCalcParser::calculate()
+{
+    Vector<SizesCalcValue> stack;
+    for (const auto& value : m_valueList) {
+        if (!value.operation)
+            stack.append(value);
+        else {
+            if (!operateOnStack(stack, value.operation))
+                return false;
+        }
+    }
+    if (stack.size() == 1 && stack.last().isLength) {
+        m_result = std::max(clampTo<float>(stack.last().value), (float)0.0);
+        return true;
+    }
+    return false;
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/css/parser/SizesCalcParser.h b/Source/WebCore/css/parser/SizesCalcParser.h
new file mode 100644
index 000000000..4ea7c797a
--- /dev/null
+++ b/Source/WebCore/css/parser/SizesCalcParser.h
@@ -0,0 +1,81 @@
+// 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 "CSSParserToken.h"
+#include "CSSParserTokenRange.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class Document;
+
+struct SizesCalcValue {
+    double value;
+    bool isLength;
+    UChar operation;
+
+    SizesCalcValue()
+        : value(0)
+        , isLength(false)
+        , operation(0)
+    {
+    }
+
+    SizesCalcValue(double numericValue, bool length)
+        : value(numericValue)
+        , isLength(length)
+        , operation(0)
+    {
+    }
+};
+
+class SizesCalcParser {
+public:
+    SizesCalcParser(CSSParserTokenRange, const Document&);
+
+    float result() const;
+    bool isValid() const { return m_isValid; }
+
+private:
+    bool calcToReversePolishNotation(CSSParserTokenRange);
+    bool calculate();
+    void appendNumber(const CSSParserToken&);
+    bool appendLength(const CSSParserToken&);
+    bool handleOperator(Vector<CSSParserToken>& stack, const CSSParserToken&);
+    void appendOperator(const CSSParserToken&);
+
+    Vector<SizesCalcValue> m_valueList;
+    bool m_isValid;
+    float m_result;
+    const Document& m_document;
+};
+
+} // namespace WebCore