[DirectWrite] Add support for font-stretch suffixes

Source/platform/fonts/win/FontCacheSkiaWin.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Computer, Inc.
  * Copyright (c) 2006, 2007, 2008, 2009, 2012 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.
@@ skipping 186 matching lines @@
     if (!matchesRequestedFamily) {
         SkString familyName;
         tf->getFamilyName(&familyName);
         if (equalIgnoringCase(family, familyName))
             matchesRequestedFamily = true;
     }
 
     return matchesRequestedFamily;
 }
 
-
-static bool typefacesHasVariantSuffix(const AtomicString& family,
+static bool typefacesHasWeightSuffix(const AtomicString& family,
     AtomicString& adjustedName, FontWeight& variantWeight)
 {
-    struct FamilyVariantSuffix {
+    struct FamilyWeightSuffix {
         const wchar_t* suffix;
         size_t length;
         FontWeight weight;
     };
     // Mapping from suffix to weight from the DirectWrite documentation.
-    // http://msdn.microsoft.com/en-us/library/windows/desktop/dd368082(v=vs.85).aspx
-    const static FamilyVariantSuffix variantForSuffix[] = {
+    // http://msdn.microsoft.com/en-us/library/windows/desktop/dd368082.aspx
+    const static FamilyWeightSuffix variantForSuffix[] = {
         { L" thin", 5,  FontWeight100 },
         { L" extralight", 11,  FontWeight200 },
         { L" ultralight", 11,  FontWeight200 },
         { L" light", 6,  FontWeight300 },
         { L" medium", 7,  FontWeight500 },
         { L" demibold", 9,  FontWeight600 },
         { L" semibold", 9,  FontWeight600 },
         { L" extrabold", 10,  FontWeight800 },
         { L" ultrabold", 10,  FontWeight800 },
         { L" black", 6,  FontWeight900 },
         { L" heavy", 6,  FontWeight900 }
     };
     size_t numVariants = WTF_ARRAY_LENGTH(variantForSuffix);
     bool caseSensitive = false;
     for (size_t i = 0; i < numVariants; i++) {
-        const FamilyVariantSuffix& entry = variantForSuffix[i];
+        const FamilyWeightSuffix& entry = variantForSuffix[i];
         if (family.endsWith(entry.suffix, caseSensitive)) {
             String familyName = family.string();
             familyName.truncate(family.length() - entry.length);
             adjustedName = AtomicString(familyName);
             variantWeight = entry.weight;
             return true;
         }
     }
 
     return false;
 }
 
+static bool typefacesHasStretchSuffix(const AtomicString& family,
+    AtomicString& adjustedName, FontStretch& variantStretch)
+{
+    struct FamilyStretchSuffix {
+        const wchar_t* suffix;
+        size_t length;
+        FontStretch stretch;
+    };
+    // Mapping from suffix to stretch value from the DirectWrite documentation.
+    // http://msdn.microsoft.com/en-us/library/windows/desktop/dd368078.aspx
+    // Also includes Narrow as a synonym for Condensed to to support Arial
+    // Narrow and other fonts following the same naming scheme.
+    const static FamilyStretchSuffix variantForSuffix[] = {
+        { L" ultracondensed", 15,  FontStretchUltraCondensed },
+        { L" extracondensed", 15,  FontStretchExtraCondensed },
+        { L" condensed", 10,  FontStretchCondensed },
+        { L" narrow", 7,  FontStretchCondensed },
+        { L" semicondensed", 14,  FontStretchSemiCondensed },
+        { L" semiexpanded", 13,  FontStretchSemiExpanded },
+        { L" expanded", 9,  FontStretchExpanded },
+        { L" extraexpanded", 14,  FontStretchExtraExpanded },
+        { L" ultraexpanded", 14,  FontStretchUltraExpanded }
+    };
+    size_t numVariants = WTF_ARRAY_LENGTH(variantForSuffix);
+    bool caseSensitive = false;
+    for (size_t i = 0; i < numVariants; i++) {
+        const FamilyStretchSuffix& entry = variantForSuffix[i];
+        if (family.endsWith(entry.suffix, caseSensitive)) {
+            String familyName = family.string();
+            familyName.truncate(family.length() - entry.length);
+            adjustedName = AtomicString(familyName);
+            variantStretch = entry.stretch;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
 {
     ASSERT(creationParams.creationType() == CreateFontByFamily);
 
     CString name;
     RefPtr<SkTypeface> tf = createTypeface(fontDescription, creationParams, name);
     // Windows will always give us a valid pointer here, even if the face name
     // is non-existent. We have to double-check and see if the family name was
     // really used.
     if (!tf || !typefacesMatchesFamily(tf.get(), creationParams.family())) {
         AtomicString adjustedName;
         FontWeight variantWeight;
-        if (typefacesHasVariantSuffix(creationParams.family(), adjustedName,
+        FontStretch variantStretch;
+
+        if (typefacesHasWeightSuffix(creationParams.family(), adjustedName,
             variantWeight)) {
             FontFaceCreationParams adjustedParams(adjustedName);
             FontDescription adjustedFontDescription = fontDescription;
             adjustedFontDescription.setWeight(variantWeight);
             tf = createTypeface(adjustedFontDescription, adjustedParams, name);
             if (!tf || !typefacesMatchesFamily(tf.get(), adjustedName))
                 return 0;
+
+        } else if (typefacesHasStretchSuffix(creationParams.family(),
+            adjustedName, variantStretch)) {
+            FontFaceCreationParams adjustedParams(adjustedName);
+            FontDescription adjustedFontDescription = fontDescription;
+            adjustedFontDescription.setStretch(variantStretch);
+            tf = createTypeface(adjustedFontDescription, adjustedParams, name);
+            if (!tf || !typefacesMatchesFamily(tf.get(), adjustedName))
+                return 0;
+
         } else {
             return 0;
         }
     }
 
     FontPlatformData* result = new FontPlatformData(tf,
         name.data(),
         fontSize,
         fontDescription.weight() >= FontWeight600 && !tf->isBold() || fontDescription.isSyntheticBold(),
         fontDescription.style() == FontStyleItalic && !tf->isItalic() || fontDescription.isSyntheticItalic(),
@@ skipping 43 matching lines @@
         if (typefacesMatchesFamily(tf.get(), family)) {
             result->setMinSizeForSubpixel(minSizeForSubpixelForFont);
             break;
         }
     }
 
     return result;
 }
 
 } // namespace blink