Switch non-gdi windows font path to use new SkFontMgr

Source/core/platform/graphics/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 92 matching lines @@
     ASSERT(fontPlatformData);
     return getFontResourceData(fontPlatformData, shouldRetain);
 }
 
 void FontCache::getTraitsInFamily(const AtomicString& familyName,
                                   Vector<unsigned>& traitsMasks)
 {
     notImplemented();
 }
 
-SkTypeface* FontCache::createTypeface(const FontDescription& fontDescription, const AtomicString& family, CString& name)
+void FontCache::getFontNameIncludingFallback(const FontDescription& fontDescription, const AtomicString& family, CString& name)

[bungeman-chromium, 2013/08/31 02:57:24]

I really liked the createTypeface abstraction, it seems like a much cleaner
separation of concerns (and less duplicated code). It seems the only reason for
this change of name/behavior is that the FontConfig port isn't implementing the
FontMgr interface well. If that's all that's motivating this change, let's fix
it, I'd hate to see this get too messy to support just because we haven't
implemented something which really needs to be implemented anyway.

[eae, 2013/09/03 21:04:14]

I agree, I'll add the windows-specific code in here under an ifdef until we have
FontMgr for other platforms. How does that sounds?

 {
     name = "";
 
     // 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-")) {
         static const struct {
             FontDescription::GenericFamilyType mType;
             const char* mName;
         } fontDescriptions[] = {
             { FontDescription::SerifFamily, "serif" },
             { FontDescription::SansSerifFamily, "sans-serif" },
             { FontDescription::MonospaceFamily, "monospace" },
             { FontDescription::CursiveFamily, "cursive" },
             { FontDescription::FantasyFamily, "fantasy" }
         };
 
         FontDescription::GenericFamilyType type = fontDescription.genericFamily();
         for (unsigned i = 0; i < SK_ARRAY_COUNT(fontDescriptions); i++) {
             if (type == fontDescriptions[i].mType) {
                 name = fontDescriptions[i].mName;
                 break;
             }
         }
     } else {
         // convert the name to utf8
         name = family.string().utf8();
     }
+}
+
+#if !OS(WINDOWS)
+FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
+{
+    CString name;
+    getFontNameIncludingFallback(fontDescription, family, name);
 
     int style = SkTypeface::kNormal;
     if (fontDescription.weight() >= FontWeightBold)
         style |= SkTypeface::kBold;
     if (fontDescription.italic())
         style |= SkTypeface::kItalic;
 
-    return SkTypeface::CreateFromName(name.data(), static_cast<SkTypeface::Style>(style));
-}
-
-#if !OS(WINDOWS)
-FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
-{
-    CString name;
-    SkTypeface* tf = createTypeface(fontDescription, family, name);
+    SkTypeface* tf = SkTypeface::CreateFromName(name.data(), static_cast<SkTypeface::Style>(style));
     if (!tf)
         return 0;
 
     FontPlatformData* result = new FontPlatformData(tf,
         name.data(),
         fontDescription.computedSize(),
         fontDescription.weight() >= FontWeightBold && !tf->isBold(),
         fontDescription.italic() && !tf->isItalic(),
         fontDescription.orientation());
     tf->unref();
     return result;
 }
 #endif // !OS(WINDOWNS)
 
 } // namespace WebCore