Implement CSS font-display

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 110 matching lines @@
 
     RefPtrWillBeRawPtr<FontFace> fontFace = adoptRefWillBeNoop(new FontFace(document));
 
     if (fontFace->setFamilyValue(*family)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontStyle)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontWeight)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontStretch)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyUnicodeRange)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontVariant)
         && fontFace->setPropertyFromStyle(properties, CSSPropertyFontFeatureSettings)
+        && fontFace->setPropertyFromStyle(properties, CSSPropertyFontDisplay)
         && !fontFace->family().isEmpty()
         && fontFace->traits().bitfield()) {
         fontFace->initCSSFontFace(document, src);
         return fontFace.release();
     }
     return nullptr;
 }
 
 FontFace::FontFace(ExecutionContext* context)
     : ActiveDOMObject(context)
@@ skipping 116 matching lines @@
         if (value && !value->isValueList())
             return false;
         m_unicodeRange = value;
         break;
     case CSSPropertyFontVariant:
         m_variant = value;
         break;
     case CSSPropertyFontFeatureSettings:
         m_featureSettings = value;
         break;
+    case CSSPropertyFontDisplay:
+        m_display = value;
+        break;
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
     return true;
 }
 
 bool FontFace::setFamilyValue(const CSSValue& familyValue)
 {
     AtomicString family;
@@ skipping 244 matching lines @@
                 break;
             default:
                 break;
             }
         }
     }
 
     return FontTraits(style, variant, weight, stretch);
 }
 
+static FontDisplay CSSValueToFontDisplay(CSSValue* value)
+{
+    if (value && value->isPrimitiveValue()) {
+        switch (toCSSPrimitiveValue(value)->getValueID()) {
+        case CSSValueAuto:
+            return FontDisplayAuto;
+        case CSSValueBlock:
+            return FontDisplayBlock;
+        case CSSValueSwap:
+            return FontDisplaySwap;
+        case CSSValueFallback:
+            return FontDisplayFallback;
+        case CSSValueOptional:
+            return FontDisplayOptional;
+        default:
+            break;
+        }
+    }
+    return FontDisplayAuto;
+}
+
 static PassOwnPtrWillBeRawPtr<CSSFontFace> createCSSFontFace(FontFace* fontFace, CSSValue* unicodeRange)
 {
     Vector<CSSFontFace::UnicodeRange> ranges;
     if (CSSValueList* rangeList = toCSSValueList(unicodeRange)) {
         unsigned numRanges = rangeList->length();
         for (unsigned i = 0; i < numRanges; i++) {
             CSSUnicodeRangeValue* range = toCSSUnicodeRangeValue(rangeList->item(i));
             ranges.append(CSSFontFace::UnicodeRange(range->from(), range->to()));
         }
     }
@@ skipping 18 matching lines @@
         CSSFontFaceSrcValue* item = toCSSFontFaceSrcValue(srcList->item(i));
         OwnPtrWillBeRawPtr<CSSFontFaceSource> source = nullptr;
 
         if (!item->isLocal()) {
             const Settings* settings = document ? document->settings() : nullptr;
             bool allowDownloading = settings && settings->downloadableBinaryFontsEnabled();
             if (allowDownloading && item->isSupportedFormat() && document) {
                 FontResource* fetched = item->fetch(document);
                 if (fetched) {
                     FontLoader* fontLoader = document->styleEngine().fontSelector()->fontLoader();
-                    source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched, fontLoader));
+                    source = adoptPtrWillBeNoop(new RemoteFontFaceSource(fetched, fontLoader, CSSValueToFontDisplay(m_display.get())));
                 }
             }
         } else {
             source = adoptPtrWillBeNoop(new LocalFontFaceSource(item->resource()));
         }
 
         if (source)
             m_cssFontFace->addSource(source.release());
     }
 }
@@ skipping 14 matching lines @@
 }
 
 DEFINE_TRACE(FontFace)
 {
     visitor->trace(m_style);
     visitor->trace(m_weight);
     visitor->trace(m_stretch);
     visitor->trace(m_unicodeRange);
     visitor->trace(m_variant);
     visitor->trace(m_featureSettings);
+    visitor->trace(m_display);
     visitor->trace(m_error);
     visitor->trace(m_loadedProperty);
     visitor->trace(m_cssFontFace);
     visitor->trace(m_callbacks);
     ActiveDOMObject::trace(visitor);
 }
 
 bool FontFace::hadBlankText() const
 {
     return m_cssFontFace->hadBlankText();
 }
 
 bool FontFace::hasPendingActivity() const
 {
     return m_status == Loading && executionContext() && !executionContext()->activeDOMObjectsAreStopped();
 }
 
 } // namespace blink