Revert "Revert "Reland 2: mac: Use a placeholder string for the family name of the system font." Br…

Source/platform/fonts/mac/FontFamilyMatcherMac.mm

  /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 18 matching lines @@
 
 #import "config.h"
 #import "platform/fonts/mac/FontFamilyMatcherMac.h"
 
 #import <AppKit/AppKit.h>
 #import <Foundation/Foundation.h>
 #import <math.h>
 #import <wtf/HashSet.h>
 #import <wtf/text/AtomicStringHash.h>
 
+#include "platform/fonts/FontTraits.h"
+#include "platform/LayoutTestSupport.h"
+#include "platform/mac/VersionUtilMac.h"
+
+ @interface NSFont (YosemiteAdditions)
+ + (NSFont*)systemFontOfSize:(CGFloat)size weight:(CGFloat)weight;
+ @end
+
+ namespace {
+
+ static CGFloat toYosemiteFontWeight(blink::FontWeight fontWeight)
+ {
+     static uint64_t nsFontWeights[] = {
+         0xbfe99999a0000000, // NSFontWeightUltraLight
+         0xbfe3333340000000, // NSFontWeightThin
+         0xbfd99999a0000000, // NSFontWeightLight
+         0x0000000000000000, // NSFontWeightRegular
+         0x3fcd70a3e0000000, // NSFontWeightMedium
+         0x3fd3333340000000, // NSFontWeightSemibold
+         0x3fd99999a0000000, // NSFontWeightBold
+         0x3fe1eb8520000000, // NSFontWeightHeavy
+         0x3fe3d70a40000000, // NSFontWeightBlack
+     };
+     ASSERT(fontWeight >= 0 && fontWeight <= 8);
+     CGFloat* weight = reinterpret_cast<CGFloat*>(&nsFontWeights[fontWeight]);
+     return *weight;
+ }
+ }
+
 namespace blink {
 
 const NSFontTraitMask SYNTHESIZED_FONT_TRAITS = (NSBoldFontMask | NSItalicFontMask);
 
 const NSFontTraitMask IMPORTANT_FONT_TRAITS = (NSCompressedFontMask
     | NSCondensedFontMask
     | NSExpandedFontMask
     | NSItalicFontMask
     | NSNarrowFontMask
     | NSPosterFontMask
@@ skipping 45 matching lines @@
     if (chosenWeightDeltaMagnitude == candidateWeightDeltaMagnitude)
         return abs(candidateWeight - 6) > abs(chosenWeight - 6);
 
     // Otherwise, prefer the one closer to the desired weight.
     return candidateWeightDeltaMagnitude < chosenWeightDeltaMagnitude;
 }
 
 // Family name is somewhat of a misnomer here.  We first attempt to find an exact match
 // comparing the desiredFamily to the PostScript name of the installed fonts.  If that fails
 // we then do a search based on the family names of the installed fonts.
-NSFont* MatchNSFontFamily(NSString* desiredFamily, NSFontTraitMask desiredTraits, int desiredWeight, float size)
+NSFont* MatchNSFontFamily(NSString* desiredFamily, NSFontTraitMask desiredTraits, FontWeight desiredWeight, float size)
 {
+    if ([desiredFamily isEqualToString:@"BlinkMacSystemFont"]) {
+        // On OSX 10.9, the default system font depends on the SDK version. When
+        // compiled against the OSX 10.10 SDK, the font is .LucidaGrandeUI. When
+        // compiled against the OSX 10.6 SDK, the font is Lucida Grande. Layout
+        // tests don't support different expectations based on the SDK version,
+        // so force layout tests to use "Lucida Grande". Once the 10.10 SDK
+        // switch is made, this should be changed to return .LucidaGrandeUI and
+        // the Layout Expectations should be updated. http://crbug.com/515836.
+        if (LayoutTestSupport::isRunningLayoutTest() && IsOSMavericks()) {
+            if (desiredWeight >= blink::FontWeightBold)
+                return [NSFont fontWithName:@"Lucida Grande Bold" size:size];
+            else
+                return [NSFont fontWithName:@"Lucida Grande" size:size];
+        }
+
+        NSFont* font = nil;
+        if (IsOSMavericksOrEarlier()) {
+            // On older OSX versions, only bold and regular are available.
+            if (desiredWeight >= blink::FontWeightBold)
+                font = [NSFont boldSystemFontOfSize:size];
+            else
+                font = [NSFont systemFontOfSize:size];
+        }
+        else {
+            // On OSX 10.10+, the default system font has more weights.
+            font = [NSFont systemFontOfSize:size weight:toYosemiteFontWeight(desiredWeight)];
+        }
+
+        if (desiredTraits & IMPORTANT_FONT_TRAITS)
+            font = [[NSFontManager sharedFontManager] convertFont:font toHaveTrait:desiredTraits];
+        return font;
+    }
+
     NSFontManager *fontManager = [NSFontManager sharedFontManager];
 
     // Do a simple case insensitive search for a matching font family.
     // NSFontManager requires exact name matches.
     // This addresses the problem of matching arial to Arial, etc., but perhaps not all the issues.
     NSEnumerator *e = [[fontManager availableFontFamilies] objectEnumerator];
     NSString *availableFamily;
     while ((availableFamily = [e nextObject])) {
         if ([desiredFamily caseInsensitiveCompare:availableFamily] == NSOrderedSame)
             break;
     }
 
+    int appKitFontWeight = toAppKitFontWeight(desiredWeight);
     if (!availableFamily) {
         // Match by PostScript name.
         NSEnumerator *availableFonts = [[fontManager availableFonts] objectEnumerator];
         NSString *availableFont;
         NSFont *nameMatchedFont = nil;
-        NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (desiredWeight >= 7 ? NSBoldFontMask : 0);
+        NSFontTraitMask desiredTraitsForNameMatch = desiredTraits | (appKitFontWeight >= 7 ? NSBoldFontMask : 0);
         while ((availableFont = [availableFonts nextObject])) {
             if ([desiredFamily caseInsensitiveCompare:availableFont] == NSOrderedSame) {
                 nameMatchedFont = [NSFont fontWithName:availableFont size:size];
 
                 // Special case Osaka-Mono.  According to <rdar://problem/3999467>, we need to
                 // treat Osaka-Mono as fixed pitch.
                 if ([desiredFamily caseInsensitiveCompare:@"Osaka-Mono"] == NSOrderedSame && desiredTraitsForNameMatch == 0)
                     return nameMatchedFont;
 
                 NSFontTraitMask traits = [fontManager traitsOfFont:nameMatchedFont];
@@ skipping 21 matching lines @@
         // Array indices must be hard coded because of lame AppKit API.
         NSString *fontFullName = [fontInfo objectAtIndex:0];
         NSInteger fontWeight = [[fontInfo objectAtIndex:2] intValue];
 
         NSFontTraitMask fontTraits = [[fontInfo objectAtIndex:3] unsignedIntValue];
 
         BOOL newWinner;
         if (!choseFont)
             newWinner = acceptableChoice(desiredTraits, fontTraits);
         else
-            newWinner = betterChoice(desiredTraits, desiredWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
+            newWinner = betterChoice(desiredTraits, appKitFontWeight, chosenTraits, chosenWeight, fontTraits, fontWeight);
 
         if (newWinner) {
             choseFont = YES;
             chosenWeight = fontWeight;
             chosenTraits = fontTraits;
             chosenFullName = fontFullName;
 
-            if (chosenWeight == desiredWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
+            if (chosenWeight == appKitFontWeight && (chosenTraits & IMPORTANT_FONT_TRAITS) == (desiredTraits & IMPORTANT_FONT_TRAITS))
                 break;
         }
     }
 
     if (!choseFont)
         return nil;
 
     NSFont *font = [NSFont fontWithName:chosenFullName size:size];
 
     if (!font)
         return nil;
 
     NSFontTraitMask actualTraits = 0;
     if (desiredTraits & NSFontItalicTrait)
         actualTraits = [fontManager traitsOfFont:font];
     int actualWeight = [fontManager weightOfFont:font];
 
-    bool syntheticBold = desiredWeight >= 7 && actualWeight < 7;
+    bool syntheticBold = appKitFontWeight >= 7 && actualWeight < 7;
     bool syntheticItalic = (desiredTraits & NSFontItalicTrait) && !(actualTraits & NSFontItalicTrait);
 
     // There are some malformed fonts that will be correctly returned by -fontWithFamily:traits:weight:size: as a match for a particular trait,
     // though -[NSFontManager traitsOfFont:] incorrectly claims the font does not have the specified trait. This could result in applying
     // synthetic bold on top of an already-bold font, as reported in <http://bugs.webkit.org/show_bug.cgi?id=6146>. To work around this
     // problem, if we got an apparent exact match, but the requested traits aren't present in the matched font, we'll try to get a font from
     // the same family without those traits (to apply the synthetic traits to later).
     NSFontTraitMask nonSyntheticTraits = desiredTraits;
 
     if (syntheticBold)
         nonSyntheticTraits &= ~NSBoldFontMask;
 
     if (syntheticItalic)
         nonSyntheticTraits &= ~NSItalicFontMask;
 
     if (nonSyntheticTraits != desiredTraits) {
         NSFont *fontWithoutSyntheticTraits = [fontManager fontWithFamily:availableFamily traits:nonSyntheticTraits weight:chosenWeight size:size];
         if (fontWithoutSyntheticTraits)
             font = fontWithoutSyntheticTraits;
     }
 
     return font;
 }
 
+int toAppKitFontWeight(FontWeight fontWeight)
+{
+    static int appKitFontWeights[] = {
+        2, // FontWeight100
+        3, // FontWeight200
+        4, // FontWeight300
+        5, // FontWeight400
+        6, // FontWeight500
+        8, // FontWeight600
+        9, // FontWeight700
+        10, // FontWeight800
+        12, // FontWeight900
+    };
+    return appKitFontWeights[fontWeight];
+}
+
 } // namespace blink