FontCache should only deal with SimpleFontData
[WebKit-https.git] / Source / WebCore / platform / graphics / Font.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2000 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #include "config.h"
25 #include "Font.h"
26
27 #include "FloatRect.h"
28 #include "FontCache.h"
29 #include "GlyphBuffer.h"
30 #include "LayoutRect.h"
31 #include "TextRun.h"
32 #include "WidthIterator.h"
33 #include <wtf/MainThread.h>
34 #include <wtf/MathExtras.h>
35 #include <wtf/text/AtomicStringHash.h>
36 #include <wtf/text/StringBuilder.h>
37
38 using namespace WTF;
39 using namespace Unicode;
40
41 namespace WTF {
42
43 // allow compilation of OwnPtr<TextLayout> in source files that don't have access to the TextLayout class definition
44 template <> void deleteOwnedPtr<WebCore::TextLayout>(WebCore::TextLayout* ptr)
45 {
46     WebCore::Font::deleteLayout(ptr);
47 }
48
49 }
50
51 namespace WebCore {
52
53 static Ref<FontGlyphs> retrieveOrAddCachedFontGlyphs(const FontDescription&, PassRefPtr<FontSelector>);
54
55 const uint8_t Font::s_roundingHackCharacterTable[256] = {
56     0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*\t*/, 1 /*\n*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57     1 /*space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*-*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*?*/,
58     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
60     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61     1 /*no-break space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
62     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
64 };
65
66 static bool isDrawnWithSVGFont(const TextRun& run)
67 {
68     return run.renderingContext();
69 }
70
71 static bool useBackslashAsYenSignForFamily(const AtomicString& family)
72 {
73     if (family.isEmpty())
74         return false;
75     static HashSet<AtomicString>* set;
76     if (!set) {
77         set = new HashSet<AtomicString>;
78         set->add("MS PGothic");
79         UChar unicodeNameMSPGothic[] = {0xFF2D, 0xFF33, 0x0020, 0xFF30, 0x30B4, 0x30B7, 0x30C3, 0x30AF};
80         set->add(AtomicString(unicodeNameMSPGothic, WTF_ARRAY_LENGTH(unicodeNameMSPGothic)));
81
82         set->add("MS PMincho");
83         UChar unicodeNameMSPMincho[] = {0xFF2D, 0xFF33, 0x0020, 0xFF30, 0x660E, 0x671D};
84         set->add(AtomicString(unicodeNameMSPMincho, WTF_ARRAY_LENGTH(unicodeNameMSPMincho)));
85
86         set->add("MS Gothic");
87         UChar unicodeNameMSGothic[] = {0xFF2D, 0xFF33, 0x0020, 0x30B4, 0x30B7, 0x30C3, 0x30AF};
88         set->add(AtomicString(unicodeNameMSGothic, WTF_ARRAY_LENGTH(unicodeNameMSGothic)));
89
90         set->add("MS Mincho");
91         UChar unicodeNameMSMincho[] = {0xFF2D, 0xFF33, 0x0020, 0x660E, 0x671D};
92         set->add(AtomicString(unicodeNameMSMincho, WTF_ARRAY_LENGTH(unicodeNameMSMincho)));
93
94         set->add("Meiryo");
95         UChar unicodeNameMeiryo[] = {0x30E1, 0x30A4, 0x30EA, 0x30AA};
96         set->add(AtomicString(unicodeNameMeiryo, WTF_ARRAY_LENGTH(unicodeNameMeiryo)));
97     }
98     return set->contains(family);
99 }
100
101 Font::CodePath Font::s_codePath = Auto;
102
103 TypesettingFeatures Font::s_defaultTypesettingFeatures = 0;
104
105 // ============================================================================================
106 // Font Implementation (Cross-Platform Portion)
107 // ============================================================================================
108
109 Font::Font()
110     : m_letterSpacing(0)
111     , m_wordSpacing(0)
112     , m_useBackslashAsYenSymbol(false)
113     , m_typesettingFeatures(0)
114 {
115 }
116
117 Font::Font(const FontDescription& fd, float letterSpacing, float wordSpacing)
118     : m_fontDescription(fd)
119     , m_letterSpacing(letterSpacing)
120     , m_wordSpacing(wordSpacing)
121     , m_useBackslashAsYenSymbol(useBackslashAsYenSignForFamily(fd.firstFamily()))
122     , m_typesettingFeatures(computeTypesettingFeatures())
123 {
124 }
125
126 // FIXME: We should make this constructor platform-independent.
127 Font::Font(const FontPlatformData& fontData, bool isPrinterFont, FontSmoothingMode fontSmoothingMode)
128     : m_glyphs(FontGlyphs::createForPlatformFont(fontData))
129     , m_letterSpacing(0)
130     , m_wordSpacing(0)
131     , m_useBackslashAsYenSymbol(false)
132     , m_typesettingFeatures(computeTypesettingFeatures())
133 {
134     m_fontDescription.setUsePrinterFont(isPrinterFont);
135     m_fontDescription.setFontSmoothing(fontSmoothingMode);
136 #if PLATFORM(IOS)
137     m_fontDescription.setSpecifiedSize(CTFontGetSize(fontData.font()));
138     m_fontDescription.setComputedSize(CTFontGetSize(fontData.font()));
139     m_fontDescription.setItalic(CTFontGetSymbolicTraits(fontData.font()) & kCTFontTraitItalic);
140     m_fontDescription.setWeight((CTFontGetSymbolicTraits(fontData.font()) & kCTFontTraitBold) ? FontWeightBold : FontWeightNormal);
141 #endif
142 }
143
144 // FIXME: We should make this constructor platform-independent.
145 #if PLATFORM(IOS)
146 Font::Font(const FontPlatformData& fontData, PassRefPtr<FontSelector> fontSelector)
147     : m_glyphs(FontGlyphs::createForPlatformFont(fontData))
148     , m_letterSpacing(0)
149     , m_wordSpacing(0)
150     , m_typesettingFeatures(computeTypesettingFeatures())
151 {
152     CTFontRef primaryFont = fontData.font();
153     m_fontDescription.setSpecifiedSize(CTFontGetSize(primaryFont));
154     m_fontDescription.setComputedSize(CTFontGetSize(primaryFont));
155     m_fontDescription.setItalic(CTFontGetSymbolicTraits(primaryFont) & kCTFontTraitItalic);
156     m_fontDescription.setWeight((CTFontGetSymbolicTraits(primaryFont) & kCTFontTraitBold) ? FontWeightBold : FontWeightNormal);
157     m_fontDescription.setUsePrinterFont(fontData.isPrinterFont());
158     m_glyphs = retrieveOrAddCachedFontGlyphs(m_fontDescription, fontSelector.get());
159 }
160 #endif
161
162 Font::Font(const Font& other)
163     : m_fontDescription(other.m_fontDescription)
164     , m_glyphs(other.m_glyphs)
165     , m_letterSpacing(other.m_letterSpacing)
166     , m_wordSpacing(other.m_wordSpacing)
167     , m_useBackslashAsYenSymbol(other.m_useBackslashAsYenSymbol)
168     , m_typesettingFeatures(computeTypesettingFeatures())
169 {
170 }
171
172 Font& Font::operator=(const Font& other)
173 {
174     m_fontDescription = other.m_fontDescription;
175     m_glyphs = other.m_glyphs;
176     m_letterSpacing = other.m_letterSpacing;
177     m_wordSpacing = other.m_wordSpacing;
178     m_useBackslashAsYenSymbol = other.m_useBackslashAsYenSymbol;
179     m_typesettingFeatures = other.m_typesettingFeatures;
180     return *this;
181 }
182
183 bool Font::operator==(const Font& other) const
184 {
185     if (isLoadingCustomFonts() || other.isLoadingCustomFonts())
186         return false;
187
188     if (m_fontDescription != other.m_fontDescription || m_letterSpacing != other.m_letterSpacing || m_wordSpacing != other.m_wordSpacing)
189         return false;
190     if (m_glyphs == other.m_glyphs)
191         return true;
192     if (!m_glyphs || !other.m_glyphs)
193         return false;
194     if (m_glyphs->fontSelector() != other.m_glyphs->fontSelector())
195         return false;
196     // Can these cases actually somehow occur? All fonts should get wiped out by full style recalc.
197     if (m_glyphs->fontSelectorVersion() != other.m_glyphs->fontSelectorVersion())
198         return false;
199     if (m_glyphs->generation() != other.m_glyphs->generation())
200         return false;
201     return true;
202 }
203
204 struct FontGlyphsCacheKey {
205     // This part of the key is shared with the lower level FontCache (caching FontData objects).
206     FontDescriptionFontDataCacheKey fontDescriptionCacheKey;
207     Vector<AtomicString, 3> families;
208     unsigned fontSelectorId;
209     unsigned fontSelectorVersion;
210     unsigned fontSelectorFlags;
211 };
212
213 struct FontGlyphsCacheEntry {
214     WTF_MAKE_FAST_ALLOCATED;
215 public:
216     FontGlyphsCacheEntry(FontGlyphsCacheKey&& k, Ref<FontGlyphs>&& g)
217         : key(WTF::move(k))
218         , glyphs(WTF::move(g))
219     { }
220     FontGlyphsCacheKey key;
221     Ref<FontGlyphs> glyphs;
222 };
223
224 typedef HashMap<unsigned, std::unique_ptr<FontGlyphsCacheEntry>, AlreadyHashed> FontGlyphsCache;
225
226 static bool operator==(const FontGlyphsCacheKey& a, const FontGlyphsCacheKey& b)
227 {
228     if (a.fontDescriptionCacheKey != b.fontDescriptionCacheKey)
229         return false;
230     if (a.fontSelectorId != b.fontSelectorId || a.fontSelectorVersion != b.fontSelectorVersion || a.fontSelectorFlags != b.fontSelectorFlags)
231         return false;
232     if (a.families.size() != b.families.size())
233         return false;
234     for (unsigned i = 0; i < a.families.size(); ++i) {
235         if (!equalIgnoringCase(a.families[i].impl(), b.families[i].impl()))
236             return false;
237     }
238     return true;
239 }
240
241 static FontGlyphsCache& fontGlyphsCache()
242 {
243     DEPRECATED_DEFINE_STATIC_LOCAL(FontGlyphsCache, cache, ());
244     return cache;
245 }
246
247 void invalidateFontGlyphsCache()
248 {
249     fontGlyphsCache().clear();
250 }
251
252 void clearWidthCaches()
253 {
254     for (auto it = fontGlyphsCache().begin(), end = fontGlyphsCache().end(); it != end; ++it)
255         it->value->glyphs.get().widthCache().clear();
256 }
257
258 static unsigned makeFontSelectorFlags(const FontDescription& description)
259 {
260     return static_cast<unsigned>(description.script()) << 1 | static_cast<unsigned>(description.smallCaps());
261 }
262
263 static void makeFontGlyphsCacheKey(FontGlyphsCacheKey& key, const FontDescription& description, FontSelector* fontSelector)
264 {
265     key.fontDescriptionCacheKey = FontDescriptionFontDataCacheKey(description);
266     for (unsigned i = 0; i < description.familyCount(); ++i)
267         key.families.append(description.familyAt(i));
268     key.fontSelectorId = fontSelector ? fontSelector->uniqueId() : 0;
269     key.fontSelectorVersion = fontSelector ? fontSelector->version() : 0;
270     key.fontSelectorFlags = fontSelector && fontSelector->resolvesFamilyFor(description) ? makeFontSelectorFlags(description) : 0;
271 }
272
273 static unsigned computeFontGlyphsCacheHash(const FontGlyphsCacheKey& key)
274 {
275     Vector<unsigned, 7> hashCodes;
276     hashCodes.reserveInitialCapacity(4 + key.families.size());
277
278     hashCodes.uncheckedAppend(key.fontDescriptionCacheKey.computeHash());
279     hashCodes.uncheckedAppend(key.fontSelectorId);
280     hashCodes.uncheckedAppend(key.fontSelectorVersion);
281     hashCodes.uncheckedAppend(key.fontSelectorFlags);
282     for (unsigned i = 0; i < key.families.size(); ++i)
283         hashCodes.uncheckedAppend(key.families[i].impl() ? CaseFoldingHash::hash(key.families[i]) : 0);
284
285     return StringHasher::hashMemory(hashCodes.data(), hashCodes.size() * sizeof(unsigned));
286 }
287
288 void pruneUnreferencedEntriesFromFontGlyphsCache()
289 {
290     Vector<unsigned, 50> toRemove;
291     FontGlyphsCache::iterator end = fontGlyphsCache().end();
292     for (FontGlyphsCache::iterator it = fontGlyphsCache().begin(); it != end; ++it) {
293         if (it->value->glyphs.get().hasOneRef())
294             toRemove.append(it->key);
295     }
296     for (unsigned i = 0; i < toRemove.size(); ++i)
297         fontGlyphsCache().remove(toRemove[i]);
298 }
299
300 static Ref<FontGlyphs> retrieveOrAddCachedFontGlyphs(const FontDescription& fontDescription, PassRefPtr<FontSelector> fontSelector)
301 {
302     FontGlyphsCacheKey key;
303     makeFontGlyphsCacheKey(key, fontDescription, fontSelector.get());
304
305     unsigned hash = computeFontGlyphsCacheHash(key);
306     FontGlyphsCache::AddResult addResult = fontGlyphsCache().add(hash, std::unique_ptr<FontGlyphsCacheEntry>());
307     if (!addResult.isNewEntry && addResult.iterator->value->key == key)
308         return addResult.iterator->value->glyphs.get();
309
310     std::unique_ptr<FontGlyphsCacheEntry>& newEntry = addResult.iterator->value;
311     newEntry = std::make_unique<FontGlyphsCacheEntry>(WTF::move(key), FontGlyphs::create(fontSelector));
312     Ref<FontGlyphs> glyphs = newEntry->glyphs.get();
313
314     static const unsigned unreferencedPruneInterval = 50;
315     static const int maximumEntries = 400;
316     static unsigned pruneCounter;
317     // Referenced FontGlyphs would exist anyway so pruning them saves little memory.
318     if (!(++pruneCounter % unreferencedPruneInterval))
319         pruneUnreferencedEntriesFromFontGlyphsCache();
320     // Prevent pathological growth.
321     if (fontGlyphsCache().size() > maximumEntries)
322         fontGlyphsCache().remove(fontGlyphsCache().begin());
323     return glyphs;
324 }
325
326 void Font::update(PassRefPtr<FontSelector> fontSelector) const
327 {
328     m_glyphs = retrieveOrAddCachedFontGlyphs(m_fontDescription, fontSelector.get());
329     m_useBackslashAsYenSymbol = useBackslashAsYenSignForFamily(firstFamily());
330     m_typesettingFeatures = computeTypesettingFeatures();
331 }
332
333 float Font::drawText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to, CustomFontNotReadyAction customFontNotReadyAction) const
334 {
335     // Don't draw anything while we are using custom fonts that are in the process of loading,
336     // except if the 'force' argument is set to true (in which case it will use a fallback
337     // font).
338     if (isLoadingCustomFonts() && customFontNotReadyAction == DoNotPaintIfFontNotReady)
339         return 0;
340
341     to = (to == -1 ? run.length() : to);
342
343     CodePath codePathToUse = codePath(run);
344     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
345     if (codePathToUse != Complex && typesettingFeatures() && (from || static_cast<unsigned>(to) != run.length()) && !isDrawnWithSVGFont(run))
346         codePathToUse = Complex;
347
348     if (codePathToUse != Complex)
349         return drawSimpleText(context, run, point, from, to);
350
351     return drawComplexText(context, run, point, from, to);
352 }
353
354 void Font::drawEmphasisMarks(GraphicsContext* context, const TextRun& run, const AtomicString& mark, const FloatPoint& point, int from, int to) const
355 {
356     if (isLoadingCustomFonts())
357         return;
358
359     if (to < 0)
360         to = run.length();
361
362     CodePath codePathToUse = codePath(run);
363     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
364     if (codePathToUse != Complex && typesettingFeatures() && (from || static_cast<unsigned>(to) != run.length()) && !isDrawnWithSVGFont(run))
365         codePathToUse = Complex;
366
367     if (codePathToUse != Complex)
368         drawEmphasisMarksForSimpleText(context, run, mark, point, from, to);
369     else
370         drawEmphasisMarksForComplexText(context, run, mark, point, from, to);
371 }
372
373 float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
374 {
375     CodePath codePathToUse = codePath(run);
376     if (codePathToUse != Complex) {
377         // The complex path is more restrictive about returning fallback fonts than the simple path, so we need an explicit test to make their behaviors match.
378         if (!canReturnFallbackFontsForComplexText())
379             fallbackFonts = 0;
380         // The simple path can optimize the case where glyph overflow is not observable.
381         if (codePathToUse != SimpleWithGlyphOverflow && (glyphOverflow && !glyphOverflow->computeBounds))
382             glyphOverflow = 0;
383     }
384
385     bool hasKerningOrLigatures = typesettingFeatures() & (Kerning | Ligatures);
386     bool hasWordSpacingOrLetterSpacing = wordSpacing() || letterSpacing();
387     float* cacheEntry = m_glyphs->widthCache().add(run, std::numeric_limits<float>::quiet_NaN(), hasKerningOrLigatures, hasWordSpacingOrLetterSpacing, glyphOverflow);
388     if (cacheEntry && !std::isnan(*cacheEntry))
389         return *cacheEntry;
390
391     HashSet<const SimpleFontData*> localFallbackFonts;
392     if (!fallbackFonts)
393         fallbackFonts = &localFallbackFonts;
394
395     float result;
396     if (codePathToUse == Complex)
397         result = floatWidthForComplexText(run, fallbackFonts, glyphOverflow);
398     else
399         result = floatWidthForSimpleText(run, fallbackFonts, glyphOverflow);
400
401     if (cacheEntry && fallbackFonts->isEmpty())
402         *cacheEntry = result;
403     return result;
404 }
405
406 float Font::width(const TextRun& run, int& charsConsumed, String& glyphName) const
407 {
408 #if ENABLE(SVG_FONTS)
409     if (isDrawnWithSVGFont(run))
410         return run.renderingContext()->floatWidthUsingSVGFont(*this, run, charsConsumed, glyphName);
411 #endif
412
413     charsConsumed = run.length();
414     glyphName = "";
415     return width(run);
416 }
417
418 GlyphData Font::glyphDataForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
419 {
420     if (variant == AutoVariant) {
421         if (m_fontDescription.smallCaps() && !primaryFontData().isSVGFont()) {
422             UChar32 upperC = u_toupper(c);
423             if (upperC != c) {
424                 c = upperC;
425                 variant = SmallCapsVariant;
426             } else
427                 variant = NormalVariant;
428         } else
429             variant = NormalVariant;
430     }
431
432     if (mirror)
433         c = u_charMirror(c);
434
435     return m_glyphs->glyphDataForCharacter(c, m_fontDescription, variant);
436 }
437
438 #if !PLATFORM(COCOA)
439 PassOwnPtr<TextLayout> Font::createLayout(RenderText*, float, bool) const
440 {
441     return nullptr;
442 }
443
444 void Font::deleteLayout(TextLayout*)
445 {
446 }
447
448 float Font::width(TextLayout&, unsigned, unsigned, HashSet<const SimpleFontData*>*)
449 {
450     ASSERT_NOT_REACHED();
451     return 0;
452 }
453 #endif
454
455
456
457 static const char* fontFamiliesWithInvalidCharWidth[] = {
458     "American Typewriter",
459     "Arial Hebrew",
460     "Chalkboard",
461     "Cochin",
462     "Corsiva Hebrew",
463     "Courier",
464     "Euphemia UCAS",
465     "Geneva",
466     "Gill Sans",
467     "Hei",
468     "Helvetica",
469     "Hoefler Text",
470     "InaiMathi",
471     "Kai",
472     "Lucida Grande",
473     "Marker Felt",
474     "Monaco",
475     "Mshtakan",
476     "New Peninim MT",
477     "Osaka",
478     "Raanana",
479     "STHeiti",
480     "Symbol",
481     "Times",
482     "Apple Braille",
483     "Apple LiGothic",
484     "Apple LiSung",
485     "Apple Symbols",
486     "AppleGothic",
487     "AppleMyungjo",
488     "#GungSeo",
489     "#HeadLineA",
490     "#PCMyungjo",
491     "#PilGi",
492 };
493
494 // For font families where any of the fonts don't have a valid entry in the OS/2 table
495 // for avgCharWidth, fallback to the legacy webkit behavior of getting the avgCharWidth
496 // from the width of a '0'. This only seems to apply to a fixed number of Mac fonts,
497 // but, in order to get similar rendering across platforms, we do this check for
498 // all platforms.
499 bool Font::hasValidAverageCharWidth() const
500 {
501     AtomicString family = firstFamily();
502     if (family.isEmpty())
503         return false;
504
505 #if PLATFORM(MAC) || PLATFORM(IOS)
506     // Internal fonts on OS X and iOS also have an invalid entry in the table for avgCharWidth.
507     if (primaryFontDataIsSystemFont())
508         return false;
509 #endif
510
511     static HashSet<AtomicString>* fontFamiliesWithInvalidCharWidthMap = 0;
512
513     if (!fontFamiliesWithInvalidCharWidthMap) {
514         fontFamiliesWithInvalidCharWidthMap = new HashSet<AtomicString>;
515
516         for (size_t i = 0; i < WTF_ARRAY_LENGTH(fontFamiliesWithInvalidCharWidth); ++i)
517             fontFamiliesWithInvalidCharWidthMap->add(AtomicString(fontFamiliesWithInvalidCharWidth[i]));
518     }
519
520     return !fontFamiliesWithInvalidCharWidthMap->contains(family);
521 }
522
523 bool Font::fastAverageCharWidthIfAvailable(float& width) const
524 {
525     bool success = hasValidAverageCharWidth();
526     if (success)
527         width = roundf(primaryFontData().avgCharWidth()); // FIXME: primaryFontData() might not correspond to firstFamily().
528     return success;
529 }
530
531 void Font::adjustSelectionRectForText(const TextRun& run, LayoutRect& selectionRect, int from, int to) const
532 {
533     to = (to == -1 ? run.length() : to);
534
535     CodePath codePathToUse = codePath(run);
536     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
537     if (codePathToUse != Complex && typesettingFeatures() && (from || static_cast<unsigned>(to) != run.length()) && !isDrawnWithSVGFont(run))
538         codePathToUse = Complex;
539
540     if (codePathToUse != Complex)
541         return adjustSelectionRectForSimpleText(run, selectionRect, from, to);
542
543     return adjustSelectionRectForComplexText(run, selectionRect, from, to);
544 }
545
546 int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
547 {
548     // FIXME: Use the fast code path once it handles partial runs with kerning and ligatures. See http://webkit.org/b/100050
549     if (codePath(run) != Complex && (!typesettingFeatures() || isDrawnWithSVGFont(run)))
550         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
551
552     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
553 }
554
555 template <typename CharacterType>
556 static inline String normalizeSpacesInternal(const CharacterType* characters, unsigned length)
557 {
558     StringBuilder normalized;
559     normalized.reserveCapacity(length);
560
561     for (unsigned i = 0; i < length; ++i)
562         normalized.append(Font::normalizeSpaces(characters[i]));
563
564     return normalized.toString();
565 }
566
567 String Font::normalizeSpaces(const LChar* characters, unsigned length)
568 {
569     return normalizeSpacesInternal(characters, length);
570 }
571
572 String Font::normalizeSpaces(const UChar* characters, unsigned length)
573 {
574     return normalizeSpacesInternal(characters, length);
575 }
576
577 static bool shouldUseFontSmoothing = true;
578
579 void Font::setShouldUseSmoothing(bool shouldUseSmoothing)
580 {
581     ASSERT(isMainThread());
582     shouldUseFontSmoothing = shouldUseSmoothing;
583 }
584
585 bool Font::shouldUseSmoothing()
586 {
587     return shouldUseFontSmoothing;
588 }
589
590 void Font::setCodePath(CodePath p)
591 {
592     s_codePath = p;
593 }
594
595 Font::CodePath Font::codePath()
596 {
597     return s_codePath;
598 }
599
600 void Font::setDefaultTypesettingFeatures(TypesettingFeatures typesettingFeatures)
601 {
602     s_defaultTypesettingFeatures = typesettingFeatures;
603 }
604
605 TypesettingFeatures Font::defaultTypesettingFeatures()
606 {
607     return s_defaultTypesettingFeatures;
608 }
609
610 Font::CodePath Font::codePath(const TextRun& run) const
611 {
612     if (s_codePath != Auto)
613         return s_codePath;
614
615 #if ENABLE(SVG_FONTS)
616     if (isDrawnWithSVGFont(run))
617         return Simple;
618 #endif
619
620     if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0)
621         return Complex;
622     
623     if (run.length() > 1 && !WidthIterator::supportsTypesettingFeatures(*this))
624         return Complex;
625
626     if (!run.characterScanForCodePath())
627         return Simple;
628
629     if (run.is8Bit())
630         return Simple;
631
632     // Start from 0 since drawing and highlighting also measure the characters before run->from.
633     return characterRangeCodePath(run.characters16(), run.length());
634 }
635
636 Font::CodePath Font::characterRangeCodePath(const UChar* characters, unsigned len)
637 {
638     // FIXME: Should use a UnicodeSet in ports where ICU is used. Note that we 
639     // can't simply use UnicodeCharacter Property/class because some characters
640     // are not 'combining', but still need to go to the complex path.
641     // Alternatively, we may as well consider binary search over a sorted
642     // list of ranges.
643     CodePath result = Simple;
644     for (unsigned i = 0; i < len; i++) {
645         const UChar c = characters[i];
646         if (c < 0x2E5) // U+02E5 through U+02E9 (Modifier Letters : Tone letters)  
647             continue;
648         if (c <= 0x2E9) 
649             return Complex;
650
651         if (c < 0x300) // U+0300 through U+036F Combining diacritical marks
652             continue;
653         if (c <= 0x36F)
654             return Complex;
655
656         if (c < 0x0591 || c == 0x05BE) // U+0591 through U+05CF excluding U+05BE Hebrew combining marks, Hebrew punctuation Paseq, Sof Pasuq and Nun Hafukha
657             continue;
658         if (c <= 0x05CF)
659             return Complex;
660
661         // U+0600 through U+109F Arabic, Syriac, Thaana, NKo, Samaritan, Mandaic,
662         // Devanagari, Bengali, Gurmukhi, Gujarati, Oriya, Tamil, Telugu, Kannada, 
663         // Malayalam, Sinhala, Thai, Lao, Tibetan, Myanmar
664         if (c < 0x0600) 
665             continue;
666         if (c <= 0x109F)
667             return Complex;
668
669         // U+1100 through U+11FF Hangul Jamo (only Ancient Korean should be left here if you precompose;
670         // Modern Korean will be precomposed as a result of step A)
671         if (c < 0x1100)
672             continue;
673         if (c <= 0x11FF)
674             return Complex;
675
676         if (c < 0x135D) // U+135D through U+135F Ethiopic combining marks
677             continue;
678         if (c <= 0x135F)
679             return Complex;
680
681         if (c < 0x1700) // U+1780 through U+18AF Tagalog, Hanunoo, Buhid, Taghanwa,Khmer, Mongolian
682             continue;
683         if (c <= 0x18AF)
684             return Complex;
685
686         if (c < 0x1900) // U+1900 through U+194F Limbu (Unicode 4.0)
687             continue;
688         if (c <= 0x194F)
689             return Complex;
690
691         if (c < 0x1980) // U+1980 through U+19DF New Tai Lue
692             continue;
693         if (c <= 0x19DF)
694             return Complex;
695
696         if (c < 0x1A00) // U+1A00 through U+1CFF Buginese, Tai Tham, Balinese, Batak, Lepcha, Vedic
697             continue;
698         if (c <= 0x1CFF)
699             return Complex;
700
701         if (c < 0x1DC0) // U+1DC0 through U+1DFF Comining diacritical mark supplement
702             continue;
703         if (c <= 0x1DFF)
704             return Complex;
705
706         // U+1E00 through U+2000 characters with diacritics and stacked diacritics
707         if (c <= 0x2000) {
708             result = SimpleWithGlyphOverflow;
709             continue;
710         }
711
712         if (c < 0x20D0) // U+20D0 through U+20FF Combining marks for symbols
713             continue;
714         if (c <= 0x20FF)
715             return Complex;
716
717         if (c < 0x2CEF) // U+2CEF through U+2CF1 Combining marks for Coptic
718             continue;
719         if (c <= 0x2CF1)
720             return Complex;
721
722         if (c < 0x302A) // U+302A through U+302F Ideographic and Hangul Tone marks
723             continue;
724         if (c <= 0x302F)
725             return Complex;
726
727         if (c < 0xA67C) // U+A67C through U+A67D Combining marks for old Cyrillic
728             continue;
729         if (c <= 0xA67D)
730             return Complex;
731
732         if (c < 0xA6F0) // U+A6F0 through U+A6F1 Combining mark for Bamum
733             continue;
734         if (c <= 0xA6F1)
735             return Complex;
736
737        // U+A800 through U+ABFF Nagri, Phags-pa, Saurashtra, Devanagari Extended,
738        // Hangul Jamo Ext. A, Javanese, Myanmar Extended A, Tai Viet, Meetei Mayek,
739         if (c < 0xA800) 
740             continue;
741         if (c <= 0xABFF)
742             return Complex;
743
744         if (c < 0xD7B0) // U+D7B0 through U+D7FF Hangul Jamo Ext. B
745             continue;
746         if (c <= 0xD7FF)
747             return Complex;
748
749         if (c <= 0xDBFF) {
750             // High surrogate
751
752             if (i == len - 1)
753                 continue;
754
755             UChar next = characters[++i];
756             if (!U16_IS_TRAIL(next))
757                 continue;
758
759             UChar32 supplementaryCharacter = U16_GET_SUPPLEMENTARY(c, next);
760
761             if (supplementaryCharacter < 0x1F1E6) // U+1F1E6 through U+1F1FF Regional Indicator Symbols
762                 continue;
763             if (supplementaryCharacter <= 0x1F1FF)
764                 return Complex;
765
766             if (supplementaryCharacter < 0xE0100) // U+E0100 through U+E01EF Unicode variation selectors.
767                 continue;
768             if (supplementaryCharacter <= 0xE01EF)
769                 return Complex;
770
771             // FIXME: Check for Brahmi (U+11000 block), Kaithi (U+11080 block) and other complex scripts
772             // in plane 1 or higher.
773
774             continue;
775         }
776
777         if (c < 0xFE00) // U+FE00 through U+FE0F Unicode variation selectors
778             continue;
779         if (c <= 0xFE0F)
780             return Complex;
781
782         if (c < 0xFE20) // U+FE20 through U+FE2F Combining half marks
783             continue;
784         if (c <= 0xFE2F)
785             return Complex;
786     }
787     return result;
788 }
789
790 bool Font::isCJKIdeograph(UChar32 c)
791 {
792     // The basic CJK Unified Ideographs block.
793     if (c >= 0x4E00 && c <= 0x9FFF)
794         return true;
795     
796     // CJK Unified Ideographs Extension A.
797     if (c >= 0x3400 && c <= 0x4DBF)
798         return true;
799     
800     // CJK Radicals Supplement.
801     if (c >= 0x2E80 && c <= 0x2EFF)
802         return true;
803     
804     // Kangxi Radicals.
805     if (c >= 0x2F00 && c <= 0x2FDF)
806         return true;
807     
808     // CJK Strokes.
809     if (c >= 0x31C0 && c <= 0x31EF)
810         return true;
811     
812     // CJK Compatibility Ideographs.
813     if (c >= 0xF900 && c <= 0xFAFF)
814         return true;
815     
816     // CJK Unified Ideographs Extension B.
817     if (c >= 0x20000 && c <= 0x2A6DF)
818         return true;
819         
820     // CJK Unified Ideographs Extension C.
821     if (c >= 0x2A700 && c <= 0x2B73F)
822         return true;
823     
824     // CJK Unified Ideographs Extension D.
825     if (c >= 0x2B740 && c <= 0x2B81F)
826         return true;
827     
828     // CJK Compatibility Ideographs Supplement.
829     if (c >= 0x2F800 && c <= 0x2FA1F)
830         return true;
831
832     return false;
833 }
834
835 bool Font::isCJKIdeographOrSymbol(UChar32 c)
836 {
837     // 0x2C7 Caron, Mandarin Chinese 3rd Tone
838     // 0x2CA Modifier Letter Acute Accent, Mandarin Chinese 2nd Tone
839     // 0x2CB Modifier Letter Grave Access, Mandarin Chinese 4th Tone 
840     // 0x2D9 Dot Above, Mandarin Chinese 5th Tone 
841     if ((c == 0x2C7) || (c == 0x2CA) || (c == 0x2CB) || (c == 0x2D9))
842         return true;
843
844     if ((c == 0x2020) || (c == 0x2021) || (c == 0x2030) || (c == 0x203B) || (c == 0x203C)
845         || (c == 0x2042) || (c == 0x2047) || (c == 0x2048) || (c == 0x2049) || (c == 0x2051)
846         || (c == 0x20DD) || (c == 0x20DE) || (c == 0x2100) || (c == 0x2103) || (c == 0x2105)
847         || (c == 0x2109) || (c == 0x210A) || (c == 0x2113) || (c == 0x2116) || (c == 0x2121)
848         || (c == 0x212B) || (c == 0x213B) || (c == 0x2150) || (c == 0x2151) || (c == 0x2152))
849         return true;
850
851     if (c >= 0x2156 && c <= 0x215A)
852         return true;
853
854     if (c >= 0x2160 && c <= 0x216B)
855         return true;
856
857     if (c >= 0x2170 && c <= 0x217B)
858         return true;
859
860     if ((c == 0x217F) || (c == 0x2189) || (c == 0x2307) || (c == 0x2312) || (c == 0x23BE) || (c == 0x23BF))
861         return true;
862
863     if (c >= 0x23C0 && c <= 0x23CC)
864         return true;
865
866     if ((c == 0x23CE) || (c == 0x2423))
867         return true;
868
869     if (c >= 0x2460 && c <= 0x2492)
870         return true;
871
872     if (c >= 0x249C && c <= 0x24FF)
873         return true;
874
875     if ((c == 0x25A0) || (c == 0x25A1) || (c == 0x25A2) || (c == 0x25AA) || (c == 0x25AB))
876         return true;
877
878     if ((c == 0x25B1) || (c == 0x25B2) || (c == 0x25B3) || (c == 0x25B6) || (c == 0x25B7) || (c == 0x25BC) || (c == 0x25BD))
879         return true;
880     
881     if ((c == 0x25C0) || (c == 0x25C1) || (c == 0x25C6) || (c == 0x25C7) || (c == 0x25C9) || (c == 0x25CB) || (c == 0x25CC))
882         return true;
883
884     if (c >= 0x25CE && c <= 0x25D3)
885         return true;
886
887     if (c >= 0x25E2 && c <= 0x25E6)
888         return true;
889
890     if (c == 0x25EF)
891         return true;
892
893     if (c >= 0x2600 && c <= 0x2603)
894         return true;
895
896     if ((c == 0x2605) || (c == 0x2606) || (c == 0x260E) || (c == 0x2616) || (c == 0x2617) || (c == 0x2640) || (c == 0x2642))
897         return true;
898
899     if (c >= 0x2660 && c <= 0x266F)
900         return true;
901
902     if (c >= 0x2672 && c <= 0x267D)
903         return true;
904
905     if ((c == 0x26A0) || (c == 0x26BD) || (c == 0x26BE) || (c == 0x2713) || (c == 0x271A) || (c == 0x273F) || (c == 0x2740) || (c == 0x2756))
906         return true;
907
908     if (c >= 0x2776 && c <= 0x277F)
909         return true;
910
911     if (c == 0x2B1A)
912         return true;
913
914     // Ideographic Description Characters.
915     if (c >= 0x2FF0 && c <= 0x2FFF)
916         return true;
917     
918     // CJK Symbols and Punctuation, excluding 0x3030.
919     if (c >= 0x3000 && c < 0x3030)
920         return true;
921
922     if (c > 0x3030 && c <= 0x303F)
923         return true;
924
925     // Hiragana
926     if (c >= 0x3040 && c <= 0x309F)
927         return true;
928
929     // Katakana 
930     if (c >= 0x30A0 && c <= 0x30FF)
931         return true;
932
933     // Bopomofo
934     if (c >= 0x3100 && c <= 0x312F)
935         return true;
936
937     if (c >= 0x3190 && c <= 0x319F)
938         return true;
939
940     // Bopomofo Extended
941     if (c >= 0x31A0 && c <= 0x31BF)
942         return true;
943  
944     // Enclosed CJK Letters and Months.
945     if (c >= 0x3200 && c <= 0x32FF)
946         return true;
947     
948     // CJK Compatibility.
949     if (c >= 0x3300 && c <= 0x33FF)
950         return true;
951
952     if (c >= 0xF860 && c <= 0xF862)
953         return true;
954
955     // CJK Compatibility Forms.
956     if (c >= 0xFE30 && c <= 0xFE4F)
957         return true;
958
959     if ((c == 0xFE10) || (c == 0xFE11) || (c == 0xFE12) || (c == 0xFE19))
960         return true;
961
962     if ((c == 0xFF0D) || (c == 0xFF1B) || (c == 0xFF1C) || (c == 0xFF1E))
963         return false;
964
965     // Halfwidth and Fullwidth Forms
966     // Usually only used in CJK
967     if (c >= 0xFF00 && c <= 0xFFEF)
968         return true;
969
970     // Emoji.
971     if (c == 0x1F100)
972         return true;
973
974     if (c >= 0x1F110 && c <= 0x1F129)
975         return true;
976
977     if (c >= 0x1F130 && c <= 0x1F149)
978         return true;
979
980     if (c >= 0x1F150 && c <= 0x1F169)
981         return true;
982
983     if (c >= 0x1F170 && c <= 0x1F189)
984         return true;
985
986     if (c >= 0x1F200 && c <= 0x1F6C5)
987         return true;
988
989     return isCJKIdeograph(c);
990 }
991
992 unsigned Font::expansionOpportunityCountInternal(const LChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion)
993 {
994     unsigned count = 0;
995     if (direction == LTR) {
996         for (size_t i = 0; i < length; ++i) {
997             if (treatAsSpace(characters[i])) {
998                 count++;
999                 isAfterExpansion = true;
1000             } else
1001                 isAfterExpansion = false;
1002         }
1003     } else {
1004         for (size_t i = length; i > 0; --i) {
1005             if (treatAsSpace(characters[i - 1])) {
1006                 count++;
1007                 isAfterExpansion = true;
1008             } else
1009                 isAfterExpansion = false;
1010         }
1011     }
1012     return count;
1013 }
1014
1015 unsigned Font::expansionOpportunityCountInternal(const UChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion)
1016 {
1017     static bool expandAroundIdeographs = canExpandAroundIdeographsInComplexText();
1018     unsigned count = 0;
1019     if (direction == LTR) {
1020         for (size_t i = 0; i < length; ++i) {
1021             UChar32 character = characters[i];
1022             if (treatAsSpace(character)) {
1023                 count++;
1024                 isAfterExpansion = true;
1025                 continue;
1026             }
1027             if (U16_IS_LEAD(character) && i + 1 < length && U16_IS_TRAIL(characters[i + 1])) {
1028                 character = U16_GET_SUPPLEMENTARY(character, characters[i + 1]);
1029                 i++;
1030             }
1031             if (expandAroundIdeographs && isCJKIdeographOrSymbol(character)) {
1032                 if (!isAfterExpansion)
1033                     count++;
1034                 count++;
1035                 isAfterExpansion = true;
1036                 continue;
1037             }
1038             isAfterExpansion = false;
1039         }
1040     } else {
1041         for (size_t i = length; i > 0; --i) {
1042             UChar32 character = characters[i - 1];
1043             if (treatAsSpace(character)) {
1044                 count++;
1045                 isAfterExpansion = true;
1046                 continue;
1047             }
1048             if (U16_IS_TRAIL(character) && i > 1 && U16_IS_LEAD(characters[i - 2])) {
1049                 character = U16_GET_SUPPLEMENTARY(characters[i - 2], character);
1050                 i--;
1051             }
1052             if (expandAroundIdeographs && isCJKIdeographOrSymbol(character)) {
1053                 if (!isAfterExpansion)
1054                     count++;
1055                 count++;
1056                 isAfterExpansion = true;
1057                 continue;
1058             }
1059             isAfterExpansion = false;
1060         }
1061     }
1062     return count;
1063 }
1064
1065 unsigned Font::expansionOpportunityCount(const StringView& stringView, TextDirection direction, bool& isAfterExpansion)
1066 {
1067     if (stringView.is8Bit())
1068         return expansionOpportunityCountInternal(stringView.characters8(), stringView.length(), direction, isAfterExpansion);
1069     return expansionOpportunityCountInternal(stringView.characters16(), stringView.length(), direction, isAfterExpansion);
1070 }
1071
1072 bool Font::canReceiveTextEmphasis(UChar32 c)
1073 {
1074     if (U_GET_GC_MASK(c) & (U_GC_Z_MASK | U_GC_CN_MASK | U_GC_CC_MASK | U_GC_CF_MASK))
1075         return false;
1076
1077     // Additional word-separator characters listed in CSS Text Level 3 Editor's Draft 3 November 2010.
1078     if (c == ethiopicWordspace || c == aegeanWordSeparatorLine || c == aegeanWordSeparatorDot
1079         || c == ugariticWordDivider || c == tibetanMarkIntersyllabicTsheg || c == tibetanMarkDelimiterTshegBstar)
1080         return false;
1081
1082     return true;
1083 }
1084
1085 bool Font::isLoadingCustomFonts() const
1086 {
1087     return m_glyphs && m_glyphs->isLoadingCustomFonts();
1088 }
1089     
1090 GlyphToPathTranslator::GlyphUnderlineType computeUnderlineType(const TextRun& textRun, const GlyphBuffer& glyphBuffer, int index)
1091 {
1092     // In general, we want to skip descenders. However, skipping descenders on CJK characters leads to undesirable renderings,
1093     // so we want to draw through CJK characters (on a character-by-character basis).
1094     UChar32 baseCharacter;
1095     unsigned offsetInString = glyphBuffer.offsetInString(index);
1096
1097     if (offsetInString == GlyphBuffer::noOffset) {
1098         // We have no idea which character spawned this glyph. Bail.
1099         return GlyphToPathTranslator::GlyphUnderlineType::DrawOverGlyph;
1100     }
1101     
1102     if (textRun.is8Bit())
1103         baseCharacter = textRun.characters8()[offsetInString];
1104     else
1105         U16_NEXT(textRun.characters16(), offsetInString, textRun.length(), baseCharacter);
1106     
1107     // u_getIntPropertyValue with UCHAR_IDEOGRAPHIC doesn't return true for Japanese or Korean codepoints.
1108     // Instead, we can use the "Unicode allocation block" for the character.
1109     UBlockCode blockCode = ublock_getCode(baseCharacter);
1110     switch (blockCode) {
1111     case UBLOCK_CJK_RADICALS_SUPPLEMENT:
1112     case UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION:
1113     case UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS:
1114     case UBLOCK_CJK_COMPATIBILITY:
1115     case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A:
1116     case UBLOCK_CJK_UNIFIED_IDEOGRAPHS:
1117     case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS:
1118     case UBLOCK_CJK_COMPATIBILITY_FORMS:
1119     case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B:
1120     case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT:
1121     case UBLOCK_CJK_STROKES:
1122     case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C:
1123     case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D:
1124     case UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS:
1125     case UBLOCK_LINEAR_B_IDEOGRAMS:
1126     case UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT:
1127     case UBLOCK_HIRAGANA:
1128     case UBLOCK_KATAKANA:
1129     case UBLOCK_BOPOMOFO:
1130     case UBLOCK_BOPOMOFO_EXTENDED:
1131     case UBLOCK_HANGUL_JAMO:
1132     case UBLOCK_HANGUL_COMPATIBILITY_JAMO:
1133     case UBLOCK_HANGUL_SYLLABLES:
1134     case UBLOCK_HANGUL_JAMO_EXTENDED_A:
1135     case UBLOCK_HANGUL_JAMO_EXTENDED_B:
1136         return GlyphToPathTranslator::GlyphUnderlineType::DrawOverGlyph;
1137     default:
1138         return GlyphToPathTranslator::GlyphUnderlineType::SkipDescenders;
1139     }
1140 }
1141
1142 }