2009-02-04 Dimitri Glazkov <dglazkov@chromium.org>
[WebKit-https.git] / WebCore / platform / graphics / FontCache.cpp
1 /*
2  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "FontCache.h"
32
33 #include "Font.h"
34 #include "FontFallbackList.h"
35 #include "FontPlatformData.h"
36 #include "FontSelector.h"
37 #include "StringHash.h"
38 #include <wtf/HashMap.h>
39 #include <wtf/ListHashSet.h>
40 #include <wtf/StdLibExtras.h>
41
42 using namespace WTF;
43
44 namespace WebCore {
45
46 FontCache* fontCache()
47 {
48     DEFINE_STATIC_LOCAL(FontCache, globalFontCache, ());
49     return &globalFontCache;
50 }
51
52 FontCache::FontCache()
53 {
54 }
55
56 struct FontPlatformDataCacheKey {
57     FontPlatformDataCacheKey(const AtomicString& family = AtomicString(), unsigned size = 0, unsigned weight = 0, bool italic = false,
58                              bool isPrinterFont = false, FontRenderingMode renderingMode = NormalRenderingMode)
59         : m_family(family)
60         , m_size(size)
61         , m_weight(weight)
62         , m_italic(italic)
63         , m_printerFont(isPrinterFont)
64         , m_renderingMode(renderingMode)
65     {
66     }
67
68     FontPlatformDataCacheKey(HashTableDeletedValueType) : m_size(hashTableDeletedSize()) { }
69     bool isHashTableDeletedValue() const { return m_size == hashTableDeletedSize(); }
70
71     bool operator==(const FontPlatformDataCacheKey& other) const
72     {
73         return equalIgnoringCase(m_family, other.m_family) && m_size == other.m_size && 
74                m_weight == other.m_weight && m_italic == other.m_italic && m_printerFont == other.m_printerFont &&
75                m_renderingMode == other.m_renderingMode;
76     }
77
78     AtomicString m_family;
79     unsigned m_size;
80     unsigned m_weight;
81     bool m_italic;
82     bool m_printerFont;
83     FontRenderingMode m_renderingMode;
84
85 private:
86     static unsigned hashTableDeletedSize() { return 0xFFFFFFFFU; }
87 };
88
89 inline unsigned computeHash(const FontPlatformDataCacheKey& fontKey)
90 {
91     unsigned hashCodes[4] = {
92         CaseFoldingHash::hash(fontKey.m_family),
93         fontKey.m_size,
94         fontKey.m_weight,
95         static_cast<unsigned>(fontKey.m_italic) << 2 | static_cast<unsigned>(fontKey.m_printerFont) << 1 | static_cast<unsigned>(fontKey.m_renderingMode)
96     };
97     return StringImpl::computeHash(reinterpret_cast<UChar*>(hashCodes), sizeof(hashCodes) / sizeof(UChar));
98 }
99
100 struct FontPlatformDataCacheKeyHash {
101     static unsigned hash(const FontPlatformDataCacheKey& font)
102     {
103         return computeHash(font);
104     }
105          
106     static bool equal(const FontPlatformDataCacheKey& a, const FontPlatformDataCacheKey& b)
107     {
108         return a == b;
109     }
110
111     static const bool safeToCompareToEmptyOrDeleted = true;
112 };
113
114 struct FontPlatformDataCacheKeyTraits : WTF::GenericHashTraits<FontPlatformDataCacheKey> {
115     static const bool emptyValueIsZero = true;
116     static const FontPlatformDataCacheKey& emptyValue()
117     {
118         DEFINE_STATIC_LOCAL(FontPlatformDataCacheKey, key, (nullAtom));
119         return key;
120     }
121     static void constructDeletedValue(FontPlatformDataCacheKey& slot)
122     {
123         new (&slot) FontPlatformDataCacheKey(HashTableDeletedValue);
124     }
125     static bool isDeletedValue(const FontPlatformDataCacheKey& value)
126     {
127         return value.isHashTableDeletedValue();
128     }
129 };
130
131 typedef HashMap<FontPlatformDataCacheKey, FontPlatformData*, FontPlatformDataCacheKeyHash, FontPlatformDataCacheKeyTraits> FontPlatformDataCache;
132
133 static FontPlatformDataCache* gFontPlatformDataCache = 0;
134
135 static const AtomicString& alternateFamilyName(const AtomicString& familyName)
136 {
137     // Alias Courier <-> Courier New
138     DEFINE_STATIC_LOCAL(AtomicString, courier, ("Courier"));
139     DEFINE_STATIC_LOCAL(AtomicString, courierNew, ("Courier New"));
140     if (equalIgnoringCase(familyName, courier))
141         return courierNew;
142 #if !PLATFORM(WIN_OS)
143     // On Windows, Courier New (truetype font) is always present and
144     // Courier is a bitmap font. So, we don't want to map Courier New to
145     // Courier.
146     if (equalIgnoringCase(familyName, courierNew))
147         return courier;
148 #endif
149
150     // Alias Times and Times New Roman.
151     DEFINE_STATIC_LOCAL(AtomicString, times, ("Times"));
152     DEFINE_STATIC_LOCAL(AtomicString, timesNewRoman, ("Times New Roman"));
153     if (equalIgnoringCase(familyName, times))
154         return timesNewRoman;
155     if (equalIgnoringCase(familyName, timesNewRoman))
156         return times;
157     
158     // Alias Arial and Helvetica
159     DEFINE_STATIC_LOCAL(AtomicString, arial, ("Arial"));
160     DEFINE_STATIC_LOCAL(AtomicString, helvetica, ("Helvetica"));
161     if (equalIgnoringCase(familyName, arial))
162         return helvetica;
163     if (equalIgnoringCase(familyName, helvetica))
164         return arial;
165
166 #if PLATFORM(WIN_OS)
167     // On Windows, bitmap fonts are blocked altogether so that we have to 
168     // alias MS Sans Serif (bitmap font) -> Microsoft Sans Serif (truetype font)
169     DEFINE_STATIC_LOCAL(AtomicString, msSans, ("MS Sans Serif"));
170     DEFINE_STATIC_LOCAL(AtomicString, microsoftSans, ("Microsoft Sans Serif"));
171     if (equalIgnoringCase(familyName, msSans))
172         return microsoftSans;
173
174     // Alias MS Serif (bitmap) -> Times New Roman (truetype font). There's no 
175     // 'Microsoft Sans Serif-equivalent' for Serif. 
176     static AtomicString msSerif("MS Serif");
177     if (equalIgnoringCase(familyName, msSerif))
178         return timesNewRoman;
179 #endif
180
181     return emptyAtom;
182 }
183
184 FontPlatformData* FontCache::getCachedFontPlatformData(const FontDescription& fontDescription, 
185                                                        const AtomicString& familyName,
186                                                        bool checkingAlternateName)
187 {
188     if (!gFontPlatformDataCache) {
189         gFontPlatformDataCache = new FontPlatformDataCache;
190         platformInit();
191     }
192
193     FontPlatformDataCacheKey key(familyName, fontDescription.computedPixelSize(), fontDescription.weight(), fontDescription.italic(),
194                                  fontDescription.usePrinterFont(), fontDescription.renderingMode());
195     FontPlatformData* result = 0;
196     bool foundResult;
197     FontPlatformDataCache::iterator it = gFontPlatformDataCache->find(key);
198     if (it == gFontPlatformDataCache->end()) {
199         result = createFontPlatformData(fontDescription, familyName);
200         gFontPlatformDataCache->set(key, result);
201         foundResult = result;
202     } else {
203         result = it->second;
204         foundResult = true;
205     }
206
207     if (!foundResult && !checkingAlternateName) {
208         // We were unable to find a font.  We have a small set of fonts that we alias to other names, 
209         // e.g., Arial/Helvetica, Courier/Courier New, etc.  Try looking up the font under the aliased name.
210         const AtomicString& alternateName = alternateFamilyName(familyName);
211         if (!alternateName.isEmpty())
212             result = getCachedFontPlatformData(fontDescription, alternateName, true);
213         if (result)
214             gFontPlatformDataCache->set(key, new FontPlatformData(*result)); // Cache the result under the old name.
215     }
216
217     return result;
218 }
219
220 struct FontDataCacheKeyHash {
221     static unsigned hash(const FontPlatformData& platformData)
222     {
223         return platformData.hash();
224     }
225          
226     static bool equal(const FontPlatformData& a, const FontPlatformData& b)
227     {
228         return a == b;
229     }
230
231     static const bool safeToCompareToEmptyOrDeleted = true;
232 };
233
234 struct FontDataCacheKeyTraits : WTF::GenericHashTraits<FontPlatformData> {
235     static const bool emptyValueIsZero = true;
236     static const bool needsDestruction = true;
237     static const FontPlatformData& emptyValue()
238     {
239         DEFINE_STATIC_LOCAL(FontPlatformData, key, ());
240         return key;
241     }
242     static void constructDeletedValue(FontPlatformData& slot)
243     {
244         new (&slot) FontPlatformData(HashTableDeletedValue);
245     }
246     static bool isDeletedValue(const FontPlatformData& value)
247     {
248         return value.isHashTableDeletedValue();
249     }
250 };
251
252 typedef HashMap<FontPlatformData, pair<SimpleFontData*, unsigned>, FontDataCacheKeyHash, FontDataCacheKeyTraits> FontDataCache;
253
254 static FontDataCache* gFontDataCache = 0;
255
256 const int cMaxInactiveFontData = 120;  // Pretty Low Threshold
257 const float cTargetInactiveFontData = 100;
258 static ListHashSet<const SimpleFontData*>* gInactiveFontData = 0;
259
260 SimpleFontData* FontCache::getCachedFontData(const FontPlatformData* platformData)
261 {
262     if (!platformData)
263         return 0;
264
265     if (!gFontDataCache) {
266         gFontDataCache = new FontDataCache;
267         gInactiveFontData = new ListHashSet<const SimpleFontData*>;
268     }
269     
270     FontDataCache::iterator result = gFontDataCache->find(*platformData);
271     if (result == gFontDataCache->end()) {
272         pair<SimpleFontData*, unsigned> newValue(new SimpleFontData(*platformData), 1);
273         gFontDataCache->set(*platformData, newValue);
274         return newValue.first;
275     }
276     if (!result.get()->second.second++) {
277         ASSERT(gInactiveFontData->contains(result.get()->second.first));
278         gInactiveFontData->remove(result.get()->second.first);
279     }
280
281     return result.get()->second.first;
282 }
283
284 void FontCache::releaseFontData(const SimpleFontData* fontData)
285 {
286     ASSERT(gFontDataCache);
287     ASSERT(!fontData->isCustomFont());
288
289     FontDataCache::iterator it = gFontDataCache->find(fontData->platformData());
290     ASSERT(it != gFontDataCache->end());
291
292     if (!--it->second.second) {
293         gInactiveFontData->add(fontData);
294         if (gInactiveFontData->size() > cMaxInactiveFontData)
295             purgeInactiveFontData(gInactiveFontData->size() - cTargetInactiveFontData);
296     }
297 }
298
299 void FontCache::purgeInactiveFontData(int count)
300 {
301     if (!gInactiveFontData)
302         return;
303
304     static bool isPurging;  // Guard against reentry when e.g. a deleted FontData releases its small caps FontData.
305     if (isPurging)
306         return;
307
308     isPurging = true;
309
310     ListHashSet<const SimpleFontData*>::iterator end = gInactiveFontData->end();
311     ListHashSet<const SimpleFontData*>::iterator it = gInactiveFontData->begin();
312     for (int i = 0; i < count && it != end; ++it, ++i) {
313         const SimpleFontData* fontData = *it.get();
314         gFontDataCache->remove(fontData->platformData());
315         delete fontData;
316     }
317
318     if (it == end) {
319         // Removed everything
320         gInactiveFontData->clear();
321     } else {
322         for (int i = 0; i < count; ++i)
323             gInactiveFontData->remove(gInactiveFontData->begin());
324     }
325
326     Vector<FontPlatformDataCacheKey> keysToRemove;
327     keysToRemove.reserveInitialCapacity(gFontPlatformDataCache->size());
328     FontPlatformDataCache::iterator platformDataEnd = gFontPlatformDataCache->end();
329     for (FontPlatformDataCache::iterator platformData = gFontPlatformDataCache->begin(); platformData != platformDataEnd; ++platformData) {
330         if (platformData->second && !gFontDataCache->contains(*platformData->second))
331             keysToRemove.append(platformData->first);
332     }
333
334     size_t keysToRemoveCount = keysToRemove.size();
335     for (size_t i = 0; i < keysToRemoveCount; ++i)
336         delete gFontPlatformDataCache->take(keysToRemove[i]);
337
338     isPurging = false;
339 }
340
341 size_t FontCache::fontDataCount()
342 {
343     if (gFontDataCache)
344         return gFontDataCache->size();
345     return 0;
346 }
347
348 size_t FontCache::inactiveFontDataCount()
349 {
350     if (gInactiveFontData)
351         return gInactiveFontData->size();
352     return 0;
353 }
354
355 const FontData* FontCache::getFontData(const Font& font, int& familyIndex, FontSelector* fontSelector)
356 {
357     FontPlatformData* result = 0;
358
359     int startIndex = familyIndex;
360     const FontFamily* startFamily = &font.fontDescription().family();
361     for (int i = 0; startFamily && i < startIndex; i++)
362         startFamily = startFamily->next();
363     const FontFamily* currFamily = startFamily;
364     while (currFamily && !result) {
365         familyIndex++;
366         if (currFamily->family().length()) {
367             if (fontSelector) {
368                 FontData* data = fontSelector->getFontData(font.fontDescription(), currFamily->family());
369                 if (data)
370                     return data;
371             }
372             result = getCachedFontPlatformData(font.fontDescription(), currFamily->family());
373         }
374         currFamily = currFamily->next();
375     }
376
377     if (!currFamily)
378         familyIndex = cAllFamiliesScanned;
379
380     if (!result)
381         // We didn't find a font. Try to find a similar font using our own specific knowledge about our platform.
382         // For example on OS X, we know to map any families containing the words Arabic, Pashto, or Urdu to the
383         // Geeza Pro font.
384         result = getSimilarFontPlatformData(font);
385
386     if (!result && startIndex == 0) {
387         // If it's the primary font that we couldn't find, we try the following. In all other cases, we will
388         // just use per-character system fallback.
389
390         if (fontSelector) {
391             // Try the user's preferred standard font.
392             if (FontData* data = fontSelector->getFontData(font.fontDescription(), "-webkit-standard"))
393                 return data;
394         }
395
396         // Still no result.  Hand back our last resort fallback font.
397         result = getLastResortFallbackFont(font.fontDescription());
398     }
399
400     // Now that we have a result, we need to go from FontPlatformData -> FontData.
401     return getCachedFontData(result);
402 }
403
404 static HashSet<FontSelector*>* gClients;
405
406 void FontCache::addClient(FontSelector* client)
407 {
408     if (!gClients)
409         gClients = new HashSet<FontSelector*>;
410
411     ASSERT(!gClients->contains(client));
412     gClients->add(client);
413 }
414
415 void FontCache::removeClient(FontSelector* client)
416 {
417     ASSERT(gClients);
418     ASSERT(gClients->contains(client));
419
420     gClients->remove(client);
421 }
422
423 static unsigned gGeneration = 0;
424
425 unsigned FontCache::generation()
426 {
427     return gGeneration;
428 }
429
430 void FontCache::invalidate()
431 {
432     if (!gClients) {
433         ASSERT(!gFontPlatformDataCache);
434         return;
435     }
436
437     if (gFontPlatformDataCache) {
438         deleteAllValues(*gFontPlatformDataCache);
439         delete gFontPlatformDataCache;
440         gFontPlatformDataCache = new FontPlatformDataCache;
441     }
442
443     gGeneration++;
444
445     Vector<RefPtr<FontSelector> > clients;
446     size_t numClients = gClients->size();
447     clients.reserveInitialCapacity(numClients);
448     HashSet<FontSelector*>::iterator end = gClients->end();
449     for (HashSet<FontSelector*>::iterator it = gClients->begin(); it != end; ++it)
450         clients.append(*it);
451
452     ASSERT(numClients == clients.size());
453     for (size_t i = 0; i < numClients; ++i)
454         clients[i]->fontCacheInvalidated();
455
456     purgeInactiveFontData();
457 }
458
459 } // namespace WebCore