Sky shouldn't round font weights

sky/engine/platform/fonts/skia/FontCacheSkia.cpp

 /*
  * Copyright (c) 2006, 2007, 2008, 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 51 matching lines @@
 {
     SkAutoTUnref<SkFontConfigInterface> fci(SkFontConfigInterface::RefGlobal());
     SkFontConfigInterface::FontIdentity fontIdentity;
     fontIdentity.fID = fontconfigInterfaceId;
     return fci->openStream(fontIdentity);
 }
 #endif
 
 namespace blink {
 
+static int toSkiaWeight(FontWeight weight)
+{
+    switch (weight) {
+    case FontWeight100:
+        return SkFontStyle::kThin_Weight;
+    case FontWeight200:
+        return SkFontStyle::kExtraLight_Weight;
+    case FontWeight300:
+        return SkFontStyle::kLight_Weight;
+    case FontWeight400:
+        return SkFontStyle::kNormal_Weight;
+    case FontWeight500:
+        return SkFontStyle::kMedium_Weight;
+    case FontWeight600:
+        return SkFontStyle::kSemiBold_Weight;
+    case FontWeight700:
+        return SkFontStyle::kBold_Weight;
+    case FontWeight800:
+        return SkFontStyle::kExtraBold_Weight;
+    case FontWeight900:
+        return SkFontStyle::kBlack_Weight;
+    }
+    ASSERT_NOT_REACHED();
+    return SkFontStyle::kNormal_Weight;
+}
+
+static SkFontStyle::Slant toSkiaSlant(FontStyle style)
+{
+    switch (style) {
+    case FontStyleNormal:
+        return SkFontStyle::kUpright_Slant;
+    case FontStyleItalic:
+        return SkFontStyle::kItalic_Slant;
+    }
+    ASSERT_NOT_REACHED();
+    return SkFontStyle::kUpright_Slant;
+}
+
+static int toSkiaWidth(FontStretch stretch)
+{
+    // Numeric values matching OS/2 & Windows Metrics usWidthClass table.
+    // https://www.microsoft.com/typography/otspec/os2.htm
+    return static_cast<int>(stretch);
+}
+
+static SkFontStyle toSkiaFontStyle(const FontDescription& fontDescription)
+{
+    return SkFontStyle(toSkiaWeight(fontDescription.weight()),
+                       toSkiaWidth(fontDescription.stretch()),
+                       toSkiaSlant(fontDescription.style()));
+}
+
 void FontCache::platformInit()
 {
 }
 
 PassRefPtr<SimpleFontData> FontCache::fallbackOnStandardFontStyle(
     const FontDescription& fontDescription, UChar32 character)
 {
     FontDescription substituteDescription(fontDescription);
     substituteDescription.setStyle(FontStyleNormal);
     substituteDescription.setWeight(FontWeightNormal);
@@ skipping 101 matching lines @@
     AtomicString family = creationParams.family();
     // If we're creating a fallback font (e.g. "-webkit-monospace"), convert the name into
     // the fallback name (like "monospace") that fontconfig understands.
     if (!family.length() || family.startsWith("-webkit-")) {
         name = getFallbackFontFamily(fontDescription).string().utf8();
     } else {
         // convert the name to utf8
         name = family.utf8();
     }
 
-    int style = SkTypeface::kNormal;
+    SkFontStyle style = toSkiaFontStyle(fontDescription);
+    RefPtr<SkFontMgr> fm = adoptRef(SkFontMgr::RefDefault());
+    RefPtr<SkTypeface> typeface = adoptRef(fm->matchFamilyStyle(name.data(), style));
+    if (typeface)
+        return typeface.release();
+
+    int legacyStyle = SkTypeface::kNormal;
     if (fontDescription.weight() >= FontWeight600)
-        style |= SkTypeface::kBold;
+        legacyStyle |= SkTypeface::kBold;
     if (fontDescription.style())
-        style |= SkTypeface::kItalic;
+        legacyStyle |= SkTypeface::kItalic;
 
-    // FIXME: Use m_fontManager, SkFontStyle and matchFamilyStyle instead of
-    // CreateFromName on all platforms.
-    return adoptRef(SkTypeface::CreateFromName(name.data(), static_cast<SkTypeface::Style>(style)));
+    // FIXME: Use fm, SkFontStyle and matchFamilyStyle instead of this legacy
+    // API. To make this work, we need to understand the extra fallback behavior
+    // in CreateFromName.
+    return adoptRef(SkTypeface::CreateFromName(name.data(), static_cast<SkTypeface::Style>(legacyStyle)));
 }
 
 #if !OS(WIN)
 FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
 {
     CString name;
     RefPtr<SkTypeface> tf(createTypeface(fontDescription, creationParams, name));
     if (!tf)
         return 0;
 
     FontPlatformData* result = new FontPlatformData(tf,
         name.data(),
         fontSize,
         (fontDescription.weight() >= FontWeight600 && !tf->isBold()) || fontDescription.isSyntheticBold(),
         (fontDescription.style() && !tf->isItalic()) || fontDescription.isSyntheticItalic(),
         fontDescription.orientation(),
         fontDescription.useSubpixelPositioning());
     return result;
 }
 #endif // !OS(WIN)
 
 } // namespace blink