FontFace WIP

third_party/WebKit/Source/core/css/FontFace.cpp

 /*
  * Copyright (C) 2013 Google 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
@@ skipping 93 matching lines @@
     RefPtrWillBeRawPtr<FontFace> fontFace = adoptRefWillBeNoop(new FontFace(context, family, descriptors));
     fontFace->initCSSFontFace(static_cast<const unsigned char*>(source->baseAddress()), source->byteLength());
     return fontFace.release();
 }
 
 PassRefPtrWillBeRawPtr<FontFace> FontFace::create(Document* document, const StyleRuleFontFace* fontFaceRule)
 {
     const StylePropertySet& properties = fontFaceRule->properties();
 
     // Obtain the font-family property and the src property. Both must be defined.
-    RefPtrWillBeRawPtr<CSSValue> family = properties.getPropertyCSSValue(CSSPropertyFontFamily);
-    if (!family || !family->isPrimitiveValue())
-        return nullptr;
     RefPtrWillBeRawPtr<CSSValue> src = properties.getPropertyCSSValue(CSSPropertySrc);
     if (!src || !src->isValueList())
         return nullptr;
 
     RefPtrWillBeRawPtr<FontFace> fontFace = adoptRefWillBeNoop(new FontFace(document));
 
-    if (fontFace->setFamilyValue(toCSSPrimitiveValue(family.get()))
+    if (fontFace->setPropertyFromStyle(properties, CSSPropertyFontFamily)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontStyle)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontWeight)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontStretch)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyUnicodeRange)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontVariant)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyWebkitFontFeatureSettings)
         && !fontFace->family().isEmpty()
         && fontFace->traits().bitfield()) {
         fontFace->initCSSFontFace(document, src);
         return fontFace.release();
     }
     return nullptr;
 }
 
 FontFace::FontFace(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_status(Unloaded)
 {
     suspendIfNeeded();
 }
 
 FontFace::FontFace(ExecutionContext* context, const AtomicString& family, const FontFaceDescriptors& descriptors)
     : ActiveDOMObject(context)
-    , m_family(family)
     , m_status(Unloaded)
 {
     Document* document = toDocument(context);
+    setPropertyFromString(document, family, CSSPropertyFontFamily);
     setPropertyFromString(document, descriptors.style(), CSSPropertyFontStyle);
     setPropertyFromString(document, descriptors.weight(), CSSPropertyFontWeight);
     setPropertyFromString(document, descriptors.stretch(), CSSPropertyFontStretch);
     setPropertyFromString(document, descriptors.unicodeRange(), CSSPropertyUnicodeRange);
     setPropertyFromString(document, descriptors.variant(), CSSPropertyFontVariant);
     setPropertyFromString(document, descriptors.featureSettings(), CSSPropertyWebkitFontFeatureSettings);
 
     suspendIfNeeded();
 }
 
@@ skipping 24 matching lines @@
 String FontFace::variant() const
 {
     return m_variant ? m_variant->cssText() : "normal";
 }
 
 String FontFace::featureSettings() const
 {
     return m_featureSettings ? m_featureSettings->cssText() : "normal";
 }
 
+void FontFace::setFamily(ExecutionContext* context, const String& s, ExceptionState& exceptionState)
+{
+    setPropertyFromString(toDocument(context), s, CSSPropertyFontFamily, &exceptionState);
+}
+
 void FontFace::setStyle(ExecutionContext* context, const String& s, ExceptionState& exceptionState)
 {
     setPropertyFromString(toDocument(context), s, CSSPropertyFontStyle, &exceptionState);
 }
 
 void FontFace::setWeight(ExecutionContext* context, const String& s, ExceptionState& exceptionState)
 {
     setPropertyFromString(toDocument(context), s, CSSPropertyFontWeight, &exceptionState);
 }
 
@@ skipping 31 matching lines @@
 }
 
 bool FontFace::setPropertyFromStyle(const StylePropertySet& properties, CSSPropertyID propertyID)
 {
     return setPropertyValue(properties.getPropertyCSSValue(propertyID), propertyID);
 }
 
 bool FontFace::setPropertyValue(PassRefPtrWillBeRawPtr<CSSValue> value, CSSPropertyID propertyID)
 {
     switch (propertyID) {
+    case CSSPropertyFontFamily:
+        if (!value || !value->isPrimitiveValue())
+            return false;
+        m_family = AtomicString(toCSSPrimitiveValue(value.get())->getStringValue());
+        break;
     case CSSPropertyFontStyle:
         m_style = value;
         break;
     case CSSPropertyFontWeight:
         m_weight = value;
         break;
     case CSSPropertyFontStretch:
         m_stretch = value;
         break;
     case CSSPropertyUnicodeRange:
         if (value && !value->isValueList())
             return false;
         m_unicodeRange = value;
         break;
     case CSSPropertyFontVariant:
         m_variant = value;
         break;
     case CSSPropertyWebkitFontFeatureSettings:
         m_featureSettings = value;
         break;
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
     return true;
 }
 
-bool FontFace::setFamilyValue(CSSPrimitiveValue* familyValue)
-{
-    AtomicString family;
-    if (familyValue->isCustomIdent()) {
-        family = AtomicString(familyValue->getStringValue());
-    } else if (familyValue->isValueID()) {
-        // We need to use the raw text for all the generic family types, since @font-face is a way of actually
-        // defining what font to use for those types.
-        switch (familyValue->getValueID()) {
-        case CSSValueSerif:
-            family =  FontFamilyNames::webkit_serif;
-            break;
-        case CSSValueSansSerif:
-            family =  FontFamilyNames::webkit_sans_serif;
-            break;
-        case CSSValueCursive:
-            family =  FontFamilyNames::webkit_cursive;
-            break;
-        case CSSValueFantasy:
-            family =  FontFamilyNames::webkit_fantasy;
-            break;
-        case CSSValueMonospace:
-            family =  FontFamilyNames::webkit_monospace;
-            break;
-        case CSSValueWebkitPictograph:
-            family =  FontFamilyNames::webkit_pictograph;
-            break;
-        default:
-            return false;
-        }
-    }
-    m_family = family;
-    return true;
-}
-
 String FontFace::status() const
 {
     switch (m_status) {
     case Unloaded:
         return "unloaded";
     case Loading:
         return "loading";
     case Loaded:
         return "loaded";
     case Error:
@@ skipping 294 matching lines @@
 {
     return m_cssFontFace->hadBlankText();
 }
 
 bool FontFace::hasPendingActivity() const
 {
     return m_status == Loading && executionContext() && !executionContext()->activeDOMObjectsAreStopped();
 }
 
 } // namespace blink