Add parseFontFaceDescriptor for @font-face handling

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 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 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 408 matching lines @@
     if (!value)
         return false;
 
     if (inViewport()) {
         // Allow @viewport rules from UA stylesheets even if the feature is disabled.
         if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode()))
             return false;
 
         return parseViewportProperty(propId, important);
     }
+    if (m_ruleType == StyleRule::FontFace) {
+        if (important)
+            return false;
+        return parseFontFaceDescriptor(propId);
+    }
 
     // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
     // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
     ASSERT(!m_parsedCalculation);
 
     CSSValueID id = value->id;
 
     if (id == CSSValueInherit) {
         if (m_valueList->size() != 1)
             return false;
@@ skipping 480 matching lines @@
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FNumber | FPercent | FNonNeg);
         if (validPrimitive && m_context.useCounter()
             && !(id == CSSValueNormal
                 || (value->unit == CSSPrimitiveValue::CSS_NUMBER && value->fValue == 1)
                 || (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE && value->fValue == 100)))
             m_context.useCounter()->count(UseCounter::CSSZoomNotEqualToOne);
         break;
 
-    case CSSPropertySrc: // Only used within @font-face so cannot use inherit | initial or be !important. This is a list of urls or local references.
-        parsedValue = parseFontFaceSrc();
-        break;
-
+    case CSSPropertySrc:
     case CSSPropertyUnicodeRange:
-        parsedValue = parseFontFaceUnicodeRange();
+        /* @font-face only descriptors */
         break;
 
     /* CSS3 properties */
 
     case CSSPropertyBorderImage:
     case CSSPropertyWebkitMaskBoxImage:
         return parseBorderImageShorthand(propId, important);
     case CSSPropertyWebkitBorderImage: {
         if (RefPtrWillBeRawPtr<CSSValue> result = parseBorderImage(propId)) {
             addProperty(propId, result, important);
@@ skipping 6688 matching lines @@
 
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
+bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
+{
+    CSSParserValue* value = m_valueList->current();
+    ASSERT(value);
+    CSSValueID id = value->id;
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+
+    switch (propId) {
+    case CSSPropertyFontFamily:
+        // <family-name>
+        // TODO(rwlbuis): check there is only one family-name
+        parsedValue = parseFontFamily();
+        break;
+    case CSSPropertySrc: // This is a list of urls or local references.
+        parsedValue = parseFontFaceSrc();
+        break;
+    case CSSPropertyUnicodeRange:
+        parsedValue = parseFontFaceUnicodeRange();
+        break;
+    case CSSPropertyFontWeight: // normal | bold | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
+        if (m_valueList->size() != 1)
+            return false;
+        return parseFontWeight(false);
+    case CSSPropertyFontStretch:
+    case CSSPropertyFontStyle:
+        if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
+            return false;
+        addProperty(propId, cssValuePool().createIdentifierValue(id), false);
+        return true;
+    case CSSPropertyFontVariant: // normal | small-caps | inherit
+        return parseFontVariant(false);
+    case CSSPropertyWebkitFontFeatureSettings:
+        if (id == CSSValueNormal) {
+            parsedValue = parseValidPrimitive(id, value);

[Timothy Loh, 2015/05/04 02:05:18]

Maybe better to just createIdentifierValue. Not really a fan of
parseValidPrimitive.

+            m_valueList->next();
+        } else {
+            parsedValue = parseFontFeatureSettings();
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!parsedValue || m_valueList->current())
+        return false;
+
+    addProperty(propId, parsedValue.release(), false);
+    return true;
+}
+
 bool CSSPropertyParser::parseViewportProperty(CSSPropertyID propId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     CSSValueID id = value->id;
     bool validPrimitive = false;
@@ skipping 752 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink