Apply std::unique_ptr to FooFont classes
[WebKit-https.git] / Source / WebCore / platform / graphics / mac / SimpleFontDataMac.mm
1 /*
2  * Copyright (C) 2005, 2006, 2010, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov
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  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #import "config.h"
28 #import "SimpleFontData.h"
29
30 #import "BlockExceptions.h"
31 #import "Color.h"
32 #import "FloatRect.h"
33 #import "Font.h"
34 #import "FontCache.h"
35 #import "FontDescription.h"
36 #import "SharedBuffer.h"
37 #import "WebCoreSystemInterface.h"
38 #if USE(APPKIT)
39 #import <AppKit/AppKit.h>
40 #import <ApplicationServices/ApplicationServices.h>
41 #else
42 #import <CoreText/CoreText.h>
43 #endif
44 #import <float.h>
45 #import <unicode/uchar.h>
46 #import <wtf/Assertions.h>
47 #import <wtf/StdLibExtras.h>
48 #import <wtf/RetainPtr.h>
49
50 #if defined(__has_include) && __has_include(<CoreText/CTFontDescriptorPriv.h>)
51 #import <CoreText/CTFontDescriptorPriv.h>
52 #endif
53 extern "C" bool CTFontDescriptorIsSystemUIFont(CTFontDescriptorRef);
54
55 #if defined(__has_include) && __has_include(<CoreGraphics/CGFontGlyphSupport.h>)
56 #import <CoreGraphics/CGFontGlyphSupport.h>
57 #endif
58 extern "C" bool CGFontGetGlyphAdvancesForStyle(CGFontRef font,
59     const CGAffineTransform *t, CGFontRenderingStyle style,
60     const CGGlyph glyphs[], size_t count, CGSize advances[]);
61
62 #if !PLATFORM(IOS)
63 @interface NSFont (WebAppKitSecretAPI)
64 - (BOOL)_isFakeFixedPitch;
65 @end
66 #endif
67
68 namespace WebCore {
69
70 #if USE(APPKIT)
71 static bool fontHasVerticalGlyphs(CTFontRef ctFont)
72 {
73     // The check doesn't look neat but this is what AppKit does for vertical writing...
74     RetainPtr<CFArrayRef> tableTags = adoptCF(CTFontCopyAvailableTables(ctFont, kCTFontTableOptionNoOptions));
75     CFIndex numTables = CFArrayGetCount(tableTags.get());
76     for (CFIndex index = 0; index < numTables; ++index) {
77         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
78         if (tag == kCTFontTableVhea || tag == kCTFontTableVORG)
79             return true;
80     }
81     return false;
82 }
83
84 static bool initFontData(SimpleFontData* fontData)
85 {
86     if (!fontData->platformData().cgFont())
87         return false;
88
89     return true;
90 }
91
92 static NSString *webFallbackFontFamily(void)
93 {
94     static NSString *webFallbackFontFamily = [[[NSFont systemFontOfSize:16.0f] familyName] retain];
95     return webFallbackFontFamily;
96 }
97
98 const SimpleFontData* SimpleFontData::getCompositeFontReferenceFontData(NSFont *key) const
99 {
100     if (key && !CFEqual(adoptCF(CTFontCopyPostScriptName(CTFontRef(key))).get(), CFSTR("LastResort"))) {
101         if (!m_derivedFontData)
102             m_derivedFontData = std::make_unique<DerivedFontData>(isCustomFont());
103         if (!m_derivedFontData->compositeFontReferences)
104             m_derivedFontData->compositeFontReferences = adoptCF(CFDictionaryCreateMutable(kCFAllocatorDefault, 1, &kCFTypeDictionaryKeyCallBacks, NULL));
105         else {
106             const SimpleFontData* found = static_cast<const SimpleFontData*>(CFDictionaryGetValue(m_derivedFontData->compositeFontReferences.get(), static_cast<const void *>(key)));
107             if (found)
108                 return found;
109         }
110         if (CFMutableDictionaryRef dictionary = m_derivedFontData->compositeFontReferences.get()) {
111             bool isUsingPrinterFont = platformData().isPrinterFont();
112             NSFont *substituteFont = isUsingPrinterFont ? [key printerFont] : [key screenFont];
113
114             CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(toCTFontRef(substituteFont));
115             bool syntheticBold = platformData().syntheticBold() && !(traits & kCTFontBoldTrait);
116             bool syntheticOblique = platformData().syntheticOblique() && !(traits & kCTFontItalicTrait);
117
118             FontPlatformData substitutePlatform(substituteFont, platformData().size(), isUsingPrinterFont, syntheticBold, syntheticOblique, platformData().orientation(), platformData().widthVariant());
119             if (RefPtr<SimpleFontData> value = adoptRef(new SimpleFontData(substitutePlatform, isCustomFont()))) {
120                 SimpleFontData* valuePtr = value.get();
121                 CFDictionaryAddValue(dictionary, key, value.release().leakRef());
122                 return valuePtr;
123             }
124         }
125     }
126     return 0;
127 }
128
129 void SimpleFontData::platformInit()
130 {
131     m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
132
133     bool failedSetup = false;
134     if (!initFontData(this)) {
135         // Ack! Something very bad happened, like a corrupt font.
136         // Try looking for an alternate 'base' font for this renderer.
137
138         // Special case hack to use "Times New Roman" in place of "Times".
139         // "Times RO" is a common font whose family name is "Times".
140         // It overrides the normal "Times" family font.
141         // It also appears to have a corrupt regular variant.
142         NSString *fallbackFontFamily;
143         if ([[m_platformData.font() familyName] isEqual:@"Times"])
144             fallbackFontFamily = @"Times New Roman";
145         else
146             fallbackFontFamily = webFallbackFontFamily();
147         
148         // Try setting up the alternate font.
149         // This is a last ditch effort to use a substitute font when something has gone wrong.
150 #if !ERROR_DISABLED
151         RetainPtr<NSFont> initialFont = m_platformData.font();
152 #endif
153         if (m_platformData.font())
154             m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:fallbackFontFamily]);
155         else
156             m_platformData.setFont([NSFont fontWithName:fallbackFontFamily size:m_platformData.size()]);
157         if (!initFontData(this)) {
158             if ([fallbackFontFamily isEqual:@"Times New Roman"]) {
159                 // OK, couldn't setup Times New Roman as an alternate to Times, fallback
160                 // on the system font.  If this fails we have no alternative left.
161                 m_platformData.setFont([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toFamily:webFallbackFontFamily()]);
162                 if (!initFontData(this)) {
163                     // We tried, Times, Times New Roman, and the system font. No joy. We have to give up.
164                     LOG_ERROR("unable to initialize with font %@", initialFont.get());
165                     failedSetup = true;
166                 }
167             } else {
168                 // We tried the requested font and the system font. No joy. We have to give up.
169                 LOG_ERROR("unable to initialize with font %@", initialFont.get());
170                 failedSetup = true;
171             }
172         }
173
174         // Report the problem.
175         LOG_ERROR("Corrupt font detected, using %@ in place of %@.",
176             [m_platformData.font() familyName], [initialFont.get() familyName]);
177     }
178
179     // If all else fails, try to set up using the system font.
180     // This is probably because Times and Times New Roman are both unavailable.
181     if (failedSetup) {
182         m_platformData.setFont([NSFont systemFontOfSize:[m_platformData.font() pointSize]]);
183         LOG_ERROR("failed to set up font, using system font %s", m_platformData.font());
184         initFontData(this);
185     }
186     
187     int iAscent;
188     int iDescent;
189     int iCapHeight;
190     int iLineGap;
191     unsigned unitsPerEm;
192     iAscent = CGFontGetAscent(m_platformData.cgFont());
193     // Some fonts erroneously specify a positive descender value. We follow Core Text in assuming that
194     // such fonts meant the same distance, but in the reverse direction.
195     iDescent = -abs(CGFontGetDescent(m_platformData.cgFont()));
196     iCapHeight = CGFontGetCapHeight(m_platformData.cgFont());
197     iLineGap = CGFontGetLeading(m_platformData.cgFont());
198     unitsPerEm = CGFontGetUnitsPerEm(m_platformData.cgFont());
199
200     float pointSize = m_platformData.m_size;
201     float ascent = scaleEmToUnits(iAscent, unitsPerEm) * pointSize;
202     float descent = -scaleEmToUnits(iDescent, unitsPerEm) * pointSize;
203     float capHeight = scaleEmToUnits(iCapHeight, unitsPerEm) * pointSize;
204     
205     float lineGap = scaleEmToUnits(iLineGap, unitsPerEm) * pointSize;
206
207     // We need to adjust Times, Helvetica, and Courier to closely match the
208     // vertical metrics of their Microsoft counterparts that are the de facto
209     // web standard. The AppKit adjustment of 20% is too big and is
210     // incorrectly added to line spacing, so we use a 15% adjustment instead
211     // and add it to the ascent.
212     NSString *familyName = [m_platformData.font() familyName];
213     if ([familyName isEqualToString:@"Times"] || [familyName isEqualToString:@"Helvetica"] || [familyName isEqualToString:@"Courier"])
214         ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
215
216     // Compute and store line spacing, before the line metrics hacks are applied.
217     m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
218
219     // Hack Hiragino line metrics to allow room for marked text underlines.
220     // <rdar://problem/5386183>
221     if (descent < 3 && lineGap >= 3 && [familyName hasPrefix:@"Hiragino"]) {
222         lineGap -= 3 - descent;
223         descent = 3;
224     }
225     
226     if (platformData().orientation() == Vertical && !isTextOrientationFallback())
227         m_hasVerticalGlyphs = fontHasVerticalGlyphs(m_platformData.ctFont());
228
229     float xHeight;
230
231     if (platformData().orientation() == Horizontal) {
232         // Measure the actual character "x", since it's possible for it to extend below the baseline, and we need the
233         // reported x-height to only include the portion of the glyph that is above the baseline.
234         GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
235         NSGlyph xGlyph = glyphPageZero ? glyphPageZero->glyphDataForCharacter('x').glyph : 0;
236         if (xGlyph)
237             xHeight = -CGRectGetMinY(platformBoundsForGlyph(xGlyph));
238         else
239             xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
240     } else
241         xHeight = verticalRightOrientationFontData()->fontMetrics().xHeight();
242
243     m_fontMetrics.setUnitsPerEm(unitsPerEm);
244     m_fontMetrics.setAscent(ascent);
245     m_fontMetrics.setDescent(descent);
246     m_fontMetrics.setCapHeight(capHeight);
247     m_fontMetrics.setLineGap(lineGap);
248     m_fontMetrics.setXHeight(xHeight);
249 }
250
251 static CFDataRef copyFontTableForTag(FontPlatformData& platformData, FourCharCode tableName)
252 {
253     return CGFontCopyTableForTag(platformData.cgFont(), tableName);
254 }
255
256 void SimpleFontData::platformCharWidthInit()
257 {
258     m_avgCharWidth = 0;
259     m_maxCharWidth = 0;
260     
261     RetainPtr<CFDataRef> os2Table = adoptCF(copyFontTableForTag(m_platformData, 'OS/2'));
262     if (os2Table && CFDataGetLength(os2Table.get()) >= 4) {
263         const UInt8* os2 = CFDataGetBytePtr(os2Table.get());
264         SInt16 os2AvgCharWidth = os2[2] * 256 + os2[3];
265         m_avgCharWidth = scaleEmToUnits(os2AvgCharWidth, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
266     }
267
268     RetainPtr<CFDataRef> headTable = adoptCF(copyFontTableForTag(m_platformData, 'head'));
269     if (headTable && CFDataGetLength(headTable.get()) >= 42) {
270         const UInt8* head = CFDataGetBytePtr(headTable.get());
271         ushort uxMin = head[36] * 256 + head[37];
272         ushort uxMax = head[40] * 256 + head[41];
273         SInt16 xMin = static_cast<SInt16>(uxMin);
274         SInt16 xMax = static_cast<SInt16>(uxMax);
275         float diff = static_cast<float>(xMax - xMin);
276         m_maxCharWidth = scaleEmToUnits(diff, m_fontMetrics.unitsPerEm()) * m_platformData.m_size;
277     }
278
279     // Fallback to a cross-platform estimate, which will populate these values if they are non-positive.
280     initCharWidths();
281 }
282 #endif // USE(APPKIT)
283
284 void SimpleFontData::platformDestroy()
285 {
286     if (!isCustomFont() && m_derivedFontData) {
287         // These come from the cache.
288         if (m_derivedFontData->smallCaps)
289             fontCache().releaseFontData(m_derivedFontData->smallCaps.get());
290
291         if (m_derivedFontData->emphasisMark)
292             fontCache().releaseFontData(m_derivedFontData->emphasisMark.get());
293     }
294 }
295
296 #if !PLATFORM(IOS)
297 PassRefPtr<SimpleFontData> SimpleFontData::platformCreateScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
298 {
299     if (isCustomFont()) {
300         FontPlatformData scaledFontData(m_platformData);
301         scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
302         return SimpleFontData::create(scaledFontData, true, false);
303     }
304
305     BEGIN_BLOCK_OBJC_EXCEPTIONS;
306     float size = m_platformData.size() * scaleFactor;
307     FontPlatformData scaledFontData([[NSFontManager sharedFontManager] convertFont:m_platformData.font() toSize:size], size, m_platformData.isPrinterFont(), false, false, m_platformData.orientation());
308
309     // AppKit resets the type information (screen/printer) when you convert a font to a different size.
310     // We have to fix up the font that we're handed back.
311     scaledFontData.setFont(fontDescription.usePrinterFont() ? [scaledFontData.font() printerFont] : [scaledFontData.font() screenFont]);
312
313     if (scaledFontData.font()) {
314         NSFontManager *fontManager = [NSFontManager sharedFontManager];
315         NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_platformData.font()];
316
317         if (m_platformData.m_syntheticBold)
318             fontTraits |= NSBoldFontMask;
319         if (m_platformData.m_syntheticOblique)
320             fontTraits |= NSItalicFontMask;
321
322         NSFontTraitMask scaledFontTraits = [fontManager traitsOfFont:scaledFontData.font()];
323         scaledFontData.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(scaledFontTraits & NSBoldFontMask);
324         scaledFontData.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(scaledFontTraits & NSItalicFontMask);
325
326         // SimpleFontData::platformDestroy() takes care of not deleting the cached font data twice.
327         return fontCache().getCachedFontData(&scaledFontData);
328     }
329     END_BLOCK_OBJC_EXCEPTIONS;
330
331     return 0;
332 }
333 #endif // !PLATFORM(IOS)
334
335 #if !PLATFORM(IOS)
336 bool SimpleFontData::containsCharacters(const UChar* characters, int length) const
337 {
338     NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<unichar*>(characters) length:length freeWhenDone:NO];
339     NSCharacterSet *set = [[m_platformData.font() coveredCharacterSet] invertedSet];
340     bool result = set && [string rangeOfCharacterFromSet:set].location == NSNotFound;
341     [string release];
342     return result;
343 }
344
345 void SimpleFontData::determinePitch()
346 {
347     NSFont* f = m_platformData.font();
348     // Special case Osaka-Mono.
349     // According to <rdar://problem/3999467>, we should treat Osaka-Mono as fixed pitch.
350     // Note that the AppKit does not report Osaka-Mono as fixed pitch.
351
352     // Special case MS-PGothic.
353     // According to <rdar://problem/4032938>, we should not treat MS-PGothic as fixed pitch.
354     // Note that AppKit does report MS-PGothic as fixed pitch.
355
356     // Special case MonotypeCorsiva
357     // According to <rdar://problem/5454704>, we should not treat MonotypeCorsiva as fixed pitch.
358     // Note that AppKit does report MonotypeCorsiva as fixed pitch.
359
360     NSString *name = [f fontName];
361     m_treatAsFixedPitch = ([f isFixedPitch] || [f _isFakeFixedPitch] ||
362            [name caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame) &&
363            [name caseInsensitiveCompare:@"MS-PGothic"] != NSOrderedSame &&
364            [name caseInsensitiveCompare:@"MonotypeCorsiva"] != NSOrderedSame;
365 }
366 #endif // !PLATFORM(IOS)
367
368 FloatRect SimpleFontData::platformBoundsForGlyph(Glyph glyph) const
369 {
370     FloatRect boundingBox;
371     boundingBox = CTFontGetBoundingRectsForGlyphs(m_platformData.ctFont(), platformData().orientation() == Vertical ? kCTFontVerticalOrientation : kCTFontHorizontalOrientation, &glyph, 0, 1);
372     boundingBox.setY(-boundingBox.maxY());
373     if (m_syntheticBoldOffset)
374         boundingBox.setWidth(boundingBox.width() + m_syntheticBoldOffset);
375
376     return boundingBox;
377 }
378
379 #if PLATFORM(MAC)
380 inline CGFontRenderingStyle SimpleFontData::renderingStyle() const
381 {
382     CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing | kCGFontRenderingStyleSubpixelPositioning | kCGFontRenderingStyleSubpixelQuantization;
383     NSFont *font = platformData().font();
384     if (font) {
385         switch ([font renderingMode]) {
386         case NSFontIntegerAdvancementsRenderingMode:
387             style = 0;
388             break;
389         case NSFontAntialiasedIntegerAdvancementsRenderingMode:
390             style = kCGFontRenderingStyleAntialiasing;
391             break;
392         default:
393             break;
394         }
395     }
396     return style;
397 }
398
399 inline bool SimpleFontData::advanceForColorBitmapFont(Glyph glyph, CGSize& advance) const
400 {
401     NSFont *font = platformData().font();
402     if (!font || !platformData().isColorBitmapFont())
403         return false;
404     advance = NSSizeToCGSize([font advancementForGlyph:glyph]);
405     return true;
406 }
407 #endif
408
409 static bool hasCustomTracking(CTFontRef font)
410 {
411 #if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 1090
412     UNUSED_PARAM(font);
413     return false;
414 #else
415     return CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(font)).get());
416 #endif
417 }
418
419 static inline bool isEmoji(const FontPlatformData& platformData)
420 {
421 #if PLATFORM(IOS)
422     return platformData.m_isEmoji;
423 #else
424     UNUSED_PARAM(platformData);
425     return false;
426 #endif
427 }
428
429 inline bool SimpleFontData::canUseFastGlyphAdvanceGetter(Glyph glyph, CGSize& advance, bool& populatedAdvance) const
430 {
431     // Fast getter doesn't take custom tracking into account
432     if (hasCustomTracking(platformData().ctFont()))
433         return false;
434     // Fast getter doesn't work for emoji
435     if (isEmoji(platformData()))
436         return false;
437     // ... or for any bitmap fonts in general
438     if (advanceForColorBitmapFont(glyph, advance)) {
439         populatedAdvance = true;
440         return false;
441     }
442     return true;
443 }
444
445 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
446 {
447     CGSize advance = CGSizeZero;
448     bool horizontal = platformData().orientation() == Horizontal;
449     bool populatedAdvance = false;
450     if ((horizontal || m_isBrokenIdeographFallback) && canUseFastGlyphAdvanceGetter(glyph, advance, populatedAdvance)) {
451         float pointSize = platformData().m_size;
452         CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
453         if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, renderingStyle(), &glyph, 1, &advance)) {
454             RetainPtr<CFStringRef> fullName = adoptCF(CGFontCopyFullName(platformData().cgFont()));
455             LOG_ERROR("Unable to cache glyph widths for %@ %f", fullName.get(), pointSize);
456             advance.width = 0;
457         }
458     } else if (!populatedAdvance)
459         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), horizontal ? kCTFontHorizontalOrientation : kCTFontVerticalOrientation, &glyph, &advance, 1);
460
461     return advance.width + m_syntheticBoldOffset;
462 }
463
464 struct ProviderInfo {
465     const UChar* characters;
466     size_t length;
467     CFDictionaryRef attributes;
468 };
469
470 static const UniChar* provideStringAndAttributes(CFIndex stringIndex, CFIndex* count, CFDictionaryRef* attributes, void* context)
471 {
472     ProviderInfo* info = static_cast<struct ProviderInfo*>(context);
473     if (stringIndex < 0 || static_cast<size_t>(stringIndex) >= info->length)
474         return 0;
475
476     *count = info->length - stringIndex;
477     *attributes = info->attributes;
478     return info->characters + stringIndex;
479 }
480
481 bool SimpleFontData::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
482 {
483     ASSERT(isMainThread());
484
485     if (!m_combiningCharacterSequenceSupport)
486         m_combiningCharacterSequenceSupport = adoptPtr(new HashMap<String, bool>);
487
488     WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
489     if (!addResult.isNewEntry)
490         return addResult.iterator->value;
491
492     RetainPtr<CGFontRef> cgFont = adoptCF(CTFontCopyGraphicsFont(platformData().ctFont(), 0));
493
494     ProviderInfo info = { characters, length, getCFStringAttributes(0, platformData().orientation()) };
495     RetainPtr<CTLineRef> line = adoptCF(wkCreateCTLineWithUniCharProvider(&provideStringAndAttributes, 0, &info));
496
497     CFArrayRef runArray = CTLineGetGlyphRuns(line.get());
498     CFIndex runCount = CFArrayGetCount(runArray);
499
500     for (CFIndex r = 0; r < runCount; r++) {
501         CTRunRef ctRun = static_cast<CTRunRef>(CFArrayGetValueAtIndex(runArray, r));
502         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
503         CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
504         CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
505         RetainPtr<CGFontRef> runCGFont = adoptCF(CTFontCopyGraphicsFont(runFont, 0));
506         if (!CFEqual(runCGFont.get(), cgFont.get()))
507             return false;
508     }
509
510     addResult.iterator->value = true;
511     return true;
512 }
513
514 } // namespace WebCore