04b7a0dc3c6db963eb77fde3982301798392e79a
[WebKit-https.git] / Source / WebCore / css / CSSFontFace.cpp
1 /*
2  * Copyright (C) 2007, 2008, 2011, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "CSSFontFace.h"
28
29 #include "CSSFontFaceSource.h"
30 #include "CSSFontFaceSrcValue.h"
31 #include "CSSFontFamily.h"
32 #include "CSSFontFeatureValue.h"
33 #include "CSSFontSelector.h"
34 #include "CSSPrimitiveValueMappings.h"
35 #include "CSSSegmentedFontFace.h"
36 #include "CSSUnicodeRangeValue.h"
37 #include "CSSValue.h"
38 #include "CSSValueList.h"
39 #include "Document.h"
40 #include "Font.h"
41 #include "FontDescription.h"
42 #include "FontFace.h"
43 #include "FontVariantBuilder.h"
44 #include "RuntimeEnabledFeatures.h"
45 #include "Settings.h"
46 #include "StyleProperties.h"
47 #include "StyleRule.h"
48
49 namespace WebCore {
50
51 template<typename T> void iterateClients(HashSet<CSSFontFace::Client*>& clients, T callback)
52 {
53     Vector<Ref<CSSFontFace::Client>> clientsCopy;
54     clientsCopy.reserveInitialCapacity(clients.size());
55     for (auto* client : clients)
56         clientsCopy.uncheckedAppend(*client);
57
58     for (auto* client : clients)
59         callback(*client);
60 }
61
62 void CSSFontFace::appendSources(CSSFontFace& fontFace, CSSValueList& srcList, Document* document, bool isInitiatingElementInUserAgentShadowTree)
63 {
64     for (auto& src : srcList) {
65         // An item in the list either specifies a string (local font name) or a URL (remote font to download).
66         CSSFontFaceSrcValue& item = downcast<CSSFontFaceSrcValue>(src.get());
67         std::unique_ptr<CSSFontFaceSource> source;
68         SVGFontFaceElement* fontFaceElement = nullptr;
69         bool foundSVGFont = false;
70
71 #if ENABLE(SVG_FONTS)
72         foundSVGFont = item.isSVGFontFaceSrc() || item.svgFontFaceElement();
73         fontFaceElement = item.svgFontFaceElement();
74 #endif
75         if (!item.isLocal()) {
76             Settings* settings = document ? document->settings() : nullptr;
77             bool allowDownloading = foundSVGFont || (settings && settings->downloadableBinaryFontsEnabled());
78             if (allowDownloading && item.isSupportedFormat() && document) {
79                 if (CachedFont* cachedFont = item.cachedFont(document, foundSVGFont, isInitiatingElementInUserAgentShadowTree))
80                     source = std::make_unique<CSSFontFaceSource>(fontFace, item.resource(), cachedFont);
81             }
82         } else
83             source = std::make_unique<CSSFontFaceSource>(fontFace, item.resource(), nullptr, fontFaceElement);
84
85         if (source)
86             fontFace.adoptSource(WTFMove(source));
87     }
88     fontFace.sourcesPopulated();
89 }
90
91 CSSFontFace::CSSFontFace(CSSFontSelector* fontSelector, StyleRuleFontFace* cssConnection, FontFace* wrapper, bool isLocalFallback)
92     : m_fontSelector(fontSelector)
93     , m_cssConnection(cssConnection)
94     , m_wrapper(wrapper ? wrapper->createWeakPtr() : WeakPtr<FontFace>())
95     , m_isLocalFallback(isLocalFallback)
96 {
97 }
98
99 CSSFontFace::~CSSFontFace()
100 {
101 }
102
103 bool CSSFontFace::setFamilies(CSSValue& family)
104 {
105     if (!is<CSSValueList>(family))
106         return false;
107
108     CSSValueList& familyList = downcast<CSSValueList>(family);
109     if (!familyList.length())
110         return false;
111
112     RefPtr<CSSValueList> oldFamilies = m_families;
113     m_families = &familyList;
114
115     iterateClients(m_clients, [&](Client& client) {
116         client.fontPropertyChanged(*this, oldFamilies.get());
117     });
118
119     return true;
120 }
121
122 Optional<FontTraitsMask> CSSFontFace::calculateStyleMask(CSSValue& style)
123 {
124     if (!is<CSSPrimitiveValue>(style))
125         return Nullopt;
126
127     switch (downcast<CSSPrimitiveValue>(style).getValueID()) {
128     case CSSValueNormal:
129         return FontStyleNormalMask;
130     case CSSValueItalic:
131     case CSSValueOblique:
132         return FontStyleItalicMask;
133     default:
134         return FontStyleNormalMask;
135     }
136
137     return FontStyleNormalMask;
138 }
139
140 bool CSSFontFace::setStyle(CSSValue& style)
141 {
142     if (auto mask = calculateStyleMask(style)) {
143         m_traitsMask = static_cast<FontTraitsMask>((static_cast<unsigned>(m_traitsMask) & (~FontStyleMask)) | mask.value());
144
145         iterateClients(m_clients, [&](Client& client) {
146             client.fontPropertyChanged(*this);
147         });
148
149         return true;
150     }
151     return false;
152 }
153
154 Optional<FontTraitsMask> CSSFontFace::calculateWeightMask(CSSValue& weight)
155 {
156     if (!is<CSSPrimitiveValue>(weight))
157         return Nullopt;
158
159     switch (downcast<CSSPrimitiveValue>(weight).getValueID()) {
160     case CSSValueBold:
161     case CSSValueBolder:
162     case CSSValue700:
163         return FontWeight700Mask;
164     case CSSValueNormal:
165     case CSSValue400:
166         return FontWeight400Mask;
167     case CSSValue900:
168         return FontWeight900Mask;
169     case CSSValue800:
170         return FontWeight800Mask;
171     case CSSValue600:
172         return FontWeight600Mask;
173     case CSSValue500:
174         return FontWeight500Mask;
175     case CSSValue300:
176         return FontWeight300Mask;
177     case CSSValueLighter:
178     case CSSValue200:
179         return FontWeight200Mask;
180     case CSSValue100:
181         return FontWeight100Mask;
182     default:
183         return FontWeight400Mask;
184     }
185
186     return FontWeight400Mask;
187 }
188
189 bool CSSFontFace::setWeight(CSSValue& weight)
190 {
191     if (auto mask = calculateWeightMask(weight)) {
192         m_traitsMask = static_cast<FontTraitsMask>((static_cast<unsigned>(m_traitsMask) & (~FontWeightMask)) | mask.value());
193
194         iterateClients(m_clients, [&](Client& client) {
195             client.fontPropertyChanged(*this);
196         });
197
198         return true;
199     }
200
201     return false;
202 }
203
204 bool CSSFontFace::setUnicodeRange(CSSValue& unicodeRange)
205 {
206     if (!is<CSSValueList>(unicodeRange))
207         return false;
208
209     m_ranges.clear();
210     auto& list = downcast<CSSValueList>(unicodeRange);
211     for (auto& rangeValue : list) {
212         CSSUnicodeRangeValue& range = downcast<CSSUnicodeRangeValue>(rangeValue.get());
213         m_ranges.append(UnicodeRange(range.from(), range.to()));
214     }
215
216     iterateClients(m_clients, [&](Client& client) {
217         client.fontPropertyChanged(*this);
218     });
219
220     return true;
221 }
222
223 bool CSSFontFace::setVariantLigatures(CSSValue& variantLigatures)
224 {
225     auto ligatures = extractFontVariantLigatures(variantLigatures);
226     m_variantSettings.commonLigatures = ligatures.commonLigatures;
227     m_variantSettings.discretionaryLigatures = ligatures.discretionaryLigatures;
228     m_variantSettings.historicalLigatures = ligatures.historicalLigatures;
229     m_variantSettings.contextualAlternates = ligatures.contextualAlternates;
230
231     iterateClients(m_clients, [&](Client& client) {
232         client.fontPropertyChanged(*this);
233     });
234
235     return true;
236 }
237
238 bool CSSFontFace::setVariantPosition(CSSValue& variantPosition)
239 {
240     if (!is<CSSPrimitiveValue>(variantPosition))
241         return false;
242     m_variantSettings.position = downcast<CSSPrimitiveValue>(variantPosition);
243
244     iterateClients(m_clients, [&](Client& client) {
245         client.fontPropertyChanged(*this);
246     });
247
248     return true;
249 }
250
251 bool CSSFontFace::setVariantCaps(CSSValue& variantCaps)
252 {
253     if (!is<CSSPrimitiveValue>(variantCaps))
254         return false;
255     m_variantSettings.caps = downcast<CSSPrimitiveValue>(variantCaps);
256
257     iterateClients(m_clients, [&](Client& client) {
258         client.fontPropertyChanged(*this);
259     });
260
261     return true;
262 }
263
264 bool CSSFontFace::setVariantNumeric(CSSValue& variantNumeric)
265 {
266     auto numeric = extractFontVariantNumeric(variantNumeric);
267     m_variantSettings.numericFigure = numeric.figure;
268     m_variantSettings.numericSpacing = numeric.spacing;
269     m_variantSettings.numericFraction = numeric.fraction;
270     m_variantSettings.numericOrdinal = numeric.ordinal;
271     m_variantSettings.numericSlashedZero = numeric.slashedZero;
272
273     iterateClients(m_clients, [&](Client& client) {
274         client.fontPropertyChanged(*this);
275     });
276
277     return true;
278 }
279
280 bool CSSFontFace::setVariantAlternates(CSSValue& variantAlternates)
281 {
282     if (!is<CSSPrimitiveValue>(variantAlternates))
283         return false;
284     m_variantSettings.alternates = downcast<CSSPrimitiveValue>(variantAlternates);
285
286     iterateClients(m_clients, [&](Client& client) {
287         client.fontPropertyChanged(*this);
288     });
289
290     return true;
291 }
292
293 bool CSSFontFace::setVariantEastAsian(CSSValue& variantEastAsian)
294 {
295     auto eastAsian = extractFontVariantEastAsian(variantEastAsian);
296     m_variantSettings.eastAsianVariant = eastAsian.variant;
297     m_variantSettings.eastAsianWidth = eastAsian.width;
298     m_variantSettings.eastAsianRuby = eastAsian.ruby;
299
300     iterateClients(m_clients, [&](Client& client) {
301         client.fontPropertyChanged(*this);
302     });
303
304     return true;
305 }
306
307 bool CSSFontFace::setFeatureSettings(CSSValue& featureSettings)
308 {
309     if (!is<CSSValueList>(featureSettings))
310         return false;
311
312     m_featureSettings = FontFeatureSettings();
313     auto& list = downcast<CSSValueList>(featureSettings);
314     for (auto& rangeValue : list) {
315         CSSFontFeatureValue& feature = downcast<CSSFontFeatureValue>(rangeValue.get());
316         m_featureSettings.insert(FontFeature(feature.tag(), feature.value()));
317     }
318
319     iterateClients(m_clients, [&](Client& client) {
320         client.fontPropertyChanged(*this);
321     });
322
323     return true;
324 }
325
326 bool CSSFontFace::allSourcesFailed() const
327 {
328     for (auto& source : m_sources) {
329         if (source->status() != CSSFontFaceSource::Status::Failure)
330             return false;
331     }
332     return true;
333 }
334
335 void CSSFontFace::addClient(Client& client)
336 {
337     m_clients.add(&client);
338 }
339
340 void CSSFontFace::removeClient(Client& client)
341 {
342     ASSERT(m_clients.contains(&client));
343     m_clients.remove(&client);
344 }
345
346 Ref<FontFace> CSSFontFace::wrapper()
347 {
348     if (m_wrapper)
349         return Ref<FontFace>(*m_wrapper.get());
350
351     Ref<FontFace> wrapper = FontFace::create(*this);
352     switch (m_status) {
353     case Status::Pending:
354         break;
355     case Status::Loading:
356         wrapper->fontStateChanged(*this, Status::Pending, Status::Loading);
357         break;
358     case Status::TimedOut:
359         wrapper->fontStateChanged(*this, Status::Pending, Status::Loading);
360         wrapper->fontStateChanged(*this, Status::Loading, Status::TimedOut);
361         break;
362     case Status::Success:
363         wrapper->fontStateChanged(*this, Status::Pending, Status::Loading);
364         wrapper->fontStateChanged(*this, Status::Pending, Status::Success);
365         break;
366     case Status::Failure:
367         wrapper->fontStateChanged(*this, Status::Pending, Status::Loading);
368         wrapper->fontStateChanged(*this, Status::Pending, Status::Failure);
369         break;
370     }
371     m_wrapper = wrapper->createWeakPtr();
372     return wrapper;
373 }
374
375 void CSSFontFace::adoptSource(std::unique_ptr<CSSFontFaceSource>&& source)
376 {
377     m_sources.append(WTFMove(source));
378
379     // We should never add sources in the middle of loading.
380     ASSERT(!m_sourcesPopulated);
381 }
382
383 void CSSFontFace::setStatus(Status newStatus)
384 {
385     switch (newStatus) {
386     case Status::Pending:
387         ASSERT_NOT_REACHED();
388         break;
389     case Status::Loading:
390         ASSERT(m_status == Status::Pending);
391         break;
392     case Status::TimedOut:
393         ASSERT(m_status == Status::Loading);
394         break;
395     case Status::Success:
396         ASSERT(m_status == Status::Loading || m_status == Status::TimedOut);
397         break;
398     case Status::Failure:
399         ASSERT(m_status == Status::Loading || m_status == Status::TimedOut);
400         break;
401     }
402
403     iterateClients(m_clients, [&](Client& client) {
404         client.fontStateChanged(*this, m_status, newStatus);
405     });
406
407     m_status = newStatus;
408 }
409
410 void CSSFontFace::fontLoaded(CSSFontFaceSource&)
411 {
412     // If the font is already in the cache, CSSFontFaceSource may report it's loaded before it is added here as a source.
413     // Let's not pump the state machine until we've got all our sources. font() and load() are smart enough to act correctly
414     // when a source is failed or succeeded before we have asked it to load.
415     if (m_sourcesPopulated)
416         pump();
417
418     ASSERT(m_fontSelector);
419     m_fontSelector->fontLoaded();
420
421     iterateClients(m_clients, [&](Client& client) {
422         client.fontLoaded(*this);
423     });
424 }
425
426 size_t CSSFontFace::pump()
427 {
428     size_t i;
429     for (i = 0; i < m_sources.size(); ++i) {
430         auto& source = m_sources[i];
431
432         if (source->status() == CSSFontFaceSource::Status::Pending) {
433             ASSERT(m_status == Status::Pending || m_status == Status::Loading || m_status == Status::TimedOut);
434             ASSERT(m_fontSelector);
435             if (m_status == Status::Pending)
436                 setStatus(Status::Loading);
437             source->load(*m_fontSelector);
438         }
439
440         switch (source->status()) {
441         case CSSFontFaceSource::Status::Pending:
442             ASSERT_NOT_REACHED();
443             break;
444         case CSSFontFaceSource::Status::Loading:
445             ASSERT(m_status == Status::Pending || m_status == Status::Loading);
446             if (m_status == Status::Pending)
447                 setStatus(Status::Loading);
448             return i;
449         case CSSFontFaceSource::Status::Success:
450             ASSERT(m_status == Status::Pending || m_status == Status::Loading || m_status == Status::TimedOut || m_status == Status::Success);
451             if (m_status == Status::Pending)
452                 setStatus(Status::Loading);
453             if (m_status == Status::Loading || m_status == Status::TimedOut)
454                 setStatus(Status::Success);
455             return i;
456         case CSSFontFaceSource::Status::Failure:
457             if (m_status == Status::Pending)
458                 setStatus(Status::Loading);
459             break;
460         }
461     }
462     if (m_sources.isEmpty() && m_status == Status::Pending)
463         setStatus(Status::Loading);
464     if (m_status == Status::Loading || m_status == Status::TimedOut)
465         setStatus(Status::Failure);
466     return m_sources.size();
467 }
468
469 void CSSFontFace::load()
470 {
471     pump();
472 }
473
474 RefPtr<Font> CSSFontFace::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic)
475 {
476     if (allSourcesFailed())
477         return nullptr;
478
479     // Our status is derived from the first non-failed source. However, this source may
480     // return null from font(), which means we need to continue looping through the remainder
481     // of the sources to try to find a font to use. These subsequent tries should not affect
482     // our own state, though.
483     size_t startIndex = pump();
484     for (size_t i = startIndex; i < m_sources.size(); ++i) {
485         auto& source = m_sources[i];
486         if (source->status() == CSSFontFaceSource::Status::Pending) {
487             ASSERT(m_fontSelector);
488             source->load(*m_fontSelector);
489         }
490
491         switch (source->status()) {
492         case CSSFontFaceSource::Status::Pending:
493             ASSERT_NOT_REACHED();
494             break;
495         case CSSFontFaceSource::Status::Loading:
496             return Font::create(FontCache::singleton().lastResortFallbackFont(fontDescription)->platformData(), true, true);
497         case CSSFontFaceSource::Status::Success:
498             if (RefPtr<Font> result = source->font(fontDescription, syntheticBold, syntheticItalic, m_featureSettings, m_variantSettings))
499                 return result;
500             break;
501         case CSSFontFaceSource::Status::Failure:
502             break;
503         }
504     }
505
506     return nullptr;
507 }
508
509 #if ENABLE(SVG_FONTS)
510 bool CSSFontFace::hasSVGFontFaceSource() const
511 {
512     size_t size = m_sources.size();
513     for (size_t i = 0; i < size; i++) {
514         if (m_sources[i]->isSVGFontFaceSource())
515             return true;
516     }
517     return false;
518 }
519 #endif
520
521 }