Home | History | Annotate | Download | only in ports 
      1 /*
      2  * Copyright 2014 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 #include "SkDWriteNTDDI_VERSION.h"
      8 
      9 #include "SkTypes.h"
     10 #if defined(SK_BUILD_FOR_WIN)
     11 
     12 // SkTypes will include Windows.h, which will pull in all of the GDI defines.
     13 // GDI #defines GetGlyphIndices to GetGlyphIndicesA or GetGlyphIndicesW, but
     14 // IDWriteFontFace has a method called GetGlyphIndices. Since this file does
     15 // not use GDI, undefing GetGlyphIndices makes things less confusing.
     16 #undef GetGlyphIndices
     17 
     18 #include "SkDWrite.h"
     19 #include "SkDWriteFontFileStream.h"
     20 #include "SkFontDescriptor.h"
     21 #include "SkFontStream.h"
     22 #include "SkOTTable_OS_2.h"
     23 #include "SkOTTable_fvar.h"
     24 #include "SkOTTable_head.h"
     25 #include "SkOTTable_hhea.h"
     26 #include "SkOTTable_post.h"
     27 #include "SkOTUtils.h"
     28 #include "SkScalerContext.h"
     29 #include "SkScalerContext_win_dw.h"
     30 #include "SkTo.h"
     31 #include "SkTypeface_win_dw.h"
     32 #include "SkUtils.h"
     33 
     34 void DWriteFontTypeface::onGetFamilyName(SkString* familyName) const {
     35     SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
     36     HRV(fDWriteFontFamily->GetFamilyNames(&familyNames));
     37 
     38     sk_get_locale_string(familyNames.get(), nullptr/*fMgr->fLocaleName.get()*/, familyName);
     39 }
     40 
     41 void DWriteFontTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
     42                                              bool* isLocalStream) const {
     43     // Get the family name.
     44     SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
     45     HRV(fDWriteFontFamily->GetFamilyNames(&familyNames));
     46 
     47     SkString utf8FamilyName;
     48     sk_get_locale_string(familyNames.get(), nullptr/*fMgr->fLocaleName.get()*/, &utf8FamilyName);
     49 
     50     desc->setFamilyName(utf8FamilyName.c_str());
     51     desc->setStyle(this->fontStyle());
     52     *isLocalStream = SkToBool(fDWriteFontFileLoader.get());
     53 }
     54 
     55 static SkUnichar next_utf8(const void** chars) {
     56     return SkUTF8_NextUnichar((const char**)chars);
     57 }
     58 
     59 static SkUnichar next_utf16(const void** chars) {
     60     return SkUTF16_NextUnichar((const uint16_t**)chars);
     61 }
     62 
     63 static SkUnichar next_utf32(const void** chars) {
     64     const SkUnichar** uniChars = (const SkUnichar**)chars;
     65     SkUnichar uni = **uniChars;
     66     *uniChars += 1;
     67     return uni;
     68 }
     69 
     70 typedef SkUnichar (*EncodingProc)(const void**);
     71 
     72 static EncodingProc find_encoding_proc(SkTypeface::Encoding enc) {
     73     static const EncodingProc gProcs[] = {
     74         next_utf8, next_utf16, next_utf32
     75     };
     76     SkASSERT((size_t)enc < SK_ARRAY_COUNT(gProcs));
     77     return gProcs[enc];
     78 }
     79 
     80 int DWriteFontTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
     81                                         uint16_t glyphs[], int glyphCount) const
     82 {
     83     if (nullptr == glyphs) {
     84         EncodingProc next_ucs4_proc = find_encoding_proc(encoding);
     85         for (int i = 0; i < glyphCount; ++i) {
     86             const SkUnichar c = next_ucs4_proc(&chars);
     87             BOOL exists;
     88             fDWriteFont->HasCharacter(c, &exists);
     89             if (!exists) {
     90                 return i;
     91             }
     92         }
     93         return glyphCount;
     94     }
     95 
     96     switch (encoding) {
     97     case SkTypeface::kUTF8_Encoding:
     98     case SkTypeface::kUTF16_Encoding: {
     99         static const int scratchCount = 256;
    100         UINT32 scratch[scratchCount];
    101         EncodingProc next_ucs4_proc = find_encoding_proc(encoding);
    102         for (int baseGlyph = 0; baseGlyph < glyphCount; baseGlyph += scratchCount) {
    103             int glyphsLeft = glyphCount - baseGlyph;
    104             int limit = SkTMin(glyphsLeft, scratchCount);
    105             for (int i = 0; i < limit; ++i) {
    106                 scratch[i] = next_ucs4_proc(&chars);
    107             }
    108             fDWriteFontFace->GetGlyphIndices(scratch, limit, &glyphs[baseGlyph]);
    109         }
    110         break;
    111     }
    112     case SkTypeface::kUTF32_Encoding: {
    113         const UINT32* utf32 = reinterpret_cast<const UINT32*>(chars);
    114         fDWriteFontFace->GetGlyphIndices(utf32, glyphCount, glyphs);
    115         break;
    116     }
    117     default:
    118         SK_ABORT("Invalid Text Encoding");
    119     }
    120 
    121     for (int i = 0; i < glyphCount; ++i) {
    122         if (0 == glyphs[i]) {
    123             return i;
    124         }
    125     }
    126     return glyphCount;
    127 }
    128 
    129 int DWriteFontTypeface::onCountGlyphs() const {
    130     return fDWriteFontFace->GetGlyphCount();
    131 }
    132 
    133 int DWriteFontTypeface::onGetUPEM() const {
    134     DWRITE_FONT_METRICS metrics;
    135     fDWriteFontFace->GetMetrics(&metrics);
    136     return metrics.designUnitsPerEm;
    137 }
    138 
    139 class LocalizedStrings_IDWriteLocalizedStrings : public SkTypeface::LocalizedStrings {
    140 public:
    141     /** Takes ownership of the IDWriteLocalizedStrings. */
    142     explicit LocalizedStrings_IDWriteLocalizedStrings(IDWriteLocalizedStrings* strings)
    143         : fIndex(0), fStrings(strings)
    144     { }
    145 
    146     bool next(SkTypeface::LocalizedString* localizedString) override {
    147         if (fIndex >= fStrings->GetCount()) {
    148             return false;
    149         }
    150 
    151         // String
    152         UINT32 stringLen;
    153         HRBM(fStrings->GetStringLength(fIndex, &stringLen), "Could not get string length.");
    154 
    155         SkSMallocWCHAR wString(stringLen+1);
    156         HRBM(fStrings->GetString(fIndex, wString.get(), stringLen+1), "Could not get string.");
    157 
    158         HRB(sk_wchar_to_skstring(wString.get(), stringLen, &localizedString->fString));
    159 
    160         // Locale
    161         UINT32 localeLen;
    162         HRBM(fStrings->GetLocaleNameLength(fIndex, &localeLen), "Could not get locale length.");
    163 
    164         SkSMallocWCHAR wLocale(localeLen+1);
    165         HRBM(fStrings->GetLocaleName(fIndex, wLocale.get(), localeLen+1), "Could not get locale.");
    166 
    167         HRB(sk_wchar_to_skstring(wLocale.get(), localeLen, &localizedString->fLanguage));
    168 
    169         ++fIndex;
    170         return true;
    171     }
    172 
    173 private:
    174     UINT32 fIndex;
    175     SkTScopedComPtr<IDWriteLocalizedStrings> fStrings;
    176 };
    177 
    178 SkTypeface::LocalizedStrings* DWriteFontTypeface::onCreateFamilyNameIterator() const {
    179     sk_sp<SkTypeface::LocalizedStrings> nameIter =
    180         SkOTUtils::LocalizedStrings_NameTable::MakeForFamilyNames(*this);
    181     if (!nameIter) {
    182         SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
    183         HRNM(fDWriteFontFamily->GetFamilyNames(&familyNames), "Could not obtain family names.");
    184         nameIter = sk_make_sp<LocalizedStrings_IDWriteLocalizedStrings>(familyNames.release());
    185     }
    186     return nameIter.release();
    187 }
    188 
    189 int DWriteFontTypeface::onGetVariationDesignPosition(
    190     SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const
    191 {
    192 
    193 #if defined(NTDDI_WIN10_RS3) && NTDDI_VERSION >= NTDDI_WIN10_RS3
    194 
    195     SkTScopedComPtr<IDWriteFontFace5> fontFace5;
    196     if (FAILED(fDWriteFontFace->QueryInterface(&fontFace5))) {
    197         return -1;
    198     }
    199 
    200     // Return 0 if the font is not variable font.
    201     if (!fontFace5->HasVariations()) {
    202         return 0;
    203     }
    204 
    205     UINT32 fontAxisCount = fontFace5->GetFontAxisValueCount();
    206     SkTScopedComPtr<IDWriteFontResource> fontResource;
    207     HR_GENERAL(fontFace5->GetFontResource(&fontResource), nullptr, -1);
    208     int variableAxisCount = 0;
    209     for (UINT32 i = 0; i < fontAxisCount; ++i) {
    210         if (fontResource->GetFontAxisAttributes(i) & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
    211             variableAxisCount++;
    212         }
    213     }
    214 
    215     if (!coordinates || coordinateCount < variableAxisCount) {
    216         return variableAxisCount;
    217     }
    218 
    219     SkAutoSTMalloc<8, DWRITE_FONT_AXIS_VALUE> fontAxisValue(fontAxisCount);
    220     HR_GENERAL(fontFace5->GetFontAxisValues(fontAxisValue.get(), fontAxisCount), nullptr, -1);
    221     UINT32 coordIndex = 0;
    222 
    223     for (UINT32 axisIndex = 0; axisIndex < fontAxisCount; ++axisIndex) {
    224         if (fontResource->GetFontAxisAttributes(axisIndex) & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
    225             coordinates[coordIndex].axis = SkEndian_SwapBE32(fontAxisValue[axisIndex].axisTag);
    226             coordinates[coordIndex].value = fontAxisValue[axisIndex].value;
    227         }
    228     }
    229 
    230     return variableAxisCount;
    231 
    232 #endif
    233 
    234     return -1;
    235 }
    236 
    237 int DWriteFontTypeface::onGetVariationDesignParameters(
    238     SkFontParameters::Variation::Axis parameters[], int parameterCount) const
    239 {
    240 
    241 #if defined(NTDDI_WIN10_RS3) && NTDDI_VERSION >= NTDDI_WIN10_RS3
    242 
    243     SkTScopedComPtr<IDWriteFontFace5> fontFace5;
    244     if (FAILED(fDWriteFontFace->QueryInterface(&fontFace5))) {
    245         return -1;
    246     }
    247 
    248     // Return 0 if the font is not variable font.
    249     if (!fontFace5->HasVariations()) {
    250         return 0;
    251     }
    252 
    253     UINT32 fontAxisCount = fontFace5->GetFontAxisValueCount();
    254     SkTScopedComPtr<IDWriteFontResource> fontResource;
    255     HR_GENERAL(fontFace5->GetFontResource(&fontResource), nullptr, -1);
    256     int variableAxisCount = 0;
    257     for (UINT32 i = 0; i < fontAxisCount; ++i) {
    258         if (fontResource->GetFontAxisAttributes(i) & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
    259             variableAxisCount++;
    260         }
    261     }
    262 
    263     if (!parameters || parameterCount < variableAxisCount) {
    264         return variableAxisCount;
    265     }
    266 
    267     SkAutoSTMalloc<8, DWRITE_FONT_AXIS_RANGE> fontAxisRange(fontAxisCount);
    268     HR_GENERAL(fontResource->GetFontAxisRanges(fontAxisRange.get(), fontAxisCount), nullptr, -1);
    269     SkAutoSTMalloc<8, DWRITE_FONT_AXIS_VALUE> fontAxisDefaultValue(fontAxisCount);
    270     HR_GENERAL(fontResource->GetDefaultFontAxisValues(fontAxisDefaultValue.get(), fontAxisCount),
    271                nullptr, -1);
    272     UINT32 coordIndex = 0;
    273 
    274     for (UINT32 axisIndex = 0; axisIndex < fontAxisCount; ++axisIndex) {
    275         if (fontResource->GetFontAxisAttributes(axisIndex) & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE) {
    276             parameters[coordIndex].tag = SkEndian_SwapBE32(fontAxisDefaultValue[axisIndex].axisTag);
    277             parameters[coordIndex].min = fontAxisRange[axisIndex].minValue;
    278             parameters[coordIndex].def = fontAxisDefaultValue[axisIndex].value;
    279             parameters[coordIndex].max = fontAxisRange[axisIndex].maxValue;
    280             parameters[coordIndex].setHidden(fontResource->GetFontAxisAttributes(axisIndex) &
    281                                              DWRITE_FONT_AXIS_ATTRIBUTES_HIDDEN);
    282         }
    283     }
    284 
    285     return variableAxisCount;
    286 
    287 #endif
    288 
    289     return -1;
    290 }
    291 
    292 int DWriteFontTypeface::onGetTableTags(SkFontTableTag tags[]) const {
    293     DWRITE_FONT_FACE_TYPE type = fDWriteFontFace->GetType();
    294     if (type != DWRITE_FONT_FACE_TYPE_CFF &&
    295         type != DWRITE_FONT_FACE_TYPE_TRUETYPE &&
    296         type != DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION)
    297     {
    298         return 0;
    299     }
    300 
    301     int ttcIndex;
    302     std::unique_ptr<SkStream> stream(this->openStream(&ttcIndex));
    303     return stream.get() ? SkFontStream::GetTableTags(stream.get(), ttcIndex, tags) : 0;
    304 }
    305 
    306 size_t DWriteFontTypeface::onGetTableData(SkFontTableTag tag, size_t offset,
    307                                           size_t length, void* data) const
    308 {
    309     AutoDWriteTable table(fDWriteFontFace.get(), SkEndian_SwapBE32(tag));
    310     if (!table.fExists) {
    311         return 0;
    312     }
    313 
    314     if (offset > table.fSize) {
    315         return 0;
    316     }
    317     size_t size = SkTMin(length, table.fSize - offset);
    318     if (data) {
    319         memcpy(data, table.fData + offset, size);
    320     }
    321 
    322     return size;
    323 }
    324 
    325 sk_sp<SkTypeface> DWriteFontTypeface::onMakeClone(const SkFontArguments& args) const {
    326     // Skip if the current face index does not match the ttcIndex
    327     if (fDWriteFontFace->GetIndex() != SkTo<UINT32>(args.getCollectionIndex())) {
    328         return sk_ref_sp(this);
    329     }
    330 
    331 #if defined(NTDDI_WIN10_RS3) && NTDDI_VERSION >= NTDDI_WIN10_RS3
    332 
    333     SkTScopedComPtr<IDWriteFontFace5> fontFace5;
    334 
    335     if (SUCCEEDED(fDWriteFontFace->QueryInterface(&fontFace5)) && fontFace5->HasVariations()) {
    336         UINT32 fontAxisCount = fontFace5->GetFontAxisValueCount();
    337         UINT32 argsCoordCount = args.getVariationDesignPosition().coordinateCount;
    338         SkAutoSTMalloc<8, DWRITE_FONT_AXIS_VALUE> fontAxisValue(fontAxisCount);
    339         HRN(fontFace5->GetFontAxisValues(fontAxisValue.get(), fontAxisCount));
    340 
    341         for (UINT32 fontIndex = 0; fontIndex < fontAxisCount; ++fontIndex) {
    342             for (UINT32 argsIndex = 0; argsIndex < argsCoordCount; ++argsIndex) {
    343                 if (SkEndian_SwapBE32(fontAxisValue[fontIndex].axisTag) ==
    344                     args.getVariationDesignPosition().coordinates[argsIndex].axis) {
    345                     fontAxisValue[fontIndex].value =
    346                         args.getVariationDesignPosition().coordinates[argsIndex].value;
    347                 }
    348             }
    349         }
    350         SkTScopedComPtr<IDWriteFontResource> fontResource;
    351         HRN(fontFace5->GetFontResource(&fontResource));
    352         SkTScopedComPtr<IDWriteFontFace5> newFontFace5;
    353         HRN(fontResource->CreateFontFace(fDWriteFont->GetSimulations(),
    354                                          fontAxisValue.get(),
    355                                          fontAxisCount,
    356                                          &newFontFace5));
    357 
    358         SkTScopedComPtr<IDWriteFontFace> newFontFace;
    359         HRN(newFontFace5->QueryInterface(&newFontFace));
    360         return sk_sp<SkTypeface>(DWriteFontTypeface::Create(fFactory.get(),
    361                                                             newFontFace.get(),
    362                                                             fDWriteFont.get(),
    363                                                             fDWriteFontFamily.get(),
    364                                                             fDWriteFontFileLoader.get(),
    365                                                             fDWriteFontCollectionLoader.get()));
    366     }
    367 
    368 #endif
    369 
    370     return sk_ref_sp(this);
    371 }
    372 
    373 SkStreamAsset* DWriteFontTypeface::onOpenStream(int* ttcIndex) const {
    374     *ttcIndex = fDWriteFontFace->GetIndex();
    375 
    376     UINT32 numFiles;
    377     HRNM(fDWriteFontFace->GetFiles(&numFiles, nullptr),
    378          "Could not get number of font files.");
    379     if (numFiles != 1) {
    380         return nullptr;
    381     }
    382 
    383     SkTScopedComPtr<IDWriteFontFile> fontFile;
    384     HRNM(fDWriteFontFace->GetFiles(&numFiles, &fontFile), "Could not get font files.");
    385 
    386     const void* fontFileKey;
    387     UINT32 fontFileKeySize;
    388     HRNM(fontFile->GetReferenceKey(&fontFileKey, &fontFileKeySize),
    389          "Could not get font file reference key.");
    390 
    391     SkTScopedComPtr<IDWriteFontFileLoader> fontFileLoader;
    392     HRNM(fontFile->GetLoader(&fontFileLoader), "Could not get font file loader.");
    393 
    394     SkTScopedComPtr<IDWriteFontFileStream> fontFileStream;
    395     HRNM(fontFileLoader->CreateStreamFromKey(fontFileKey, fontFileKeySize,
    396                                              &fontFileStream),
    397          "Could not create font file stream.");
    398 
    399     return new SkDWriteFontFileStream(fontFileStream.get());
    400 }
    401 
    402 SkScalerContext* DWriteFontTypeface::onCreateScalerContext(const SkScalerContextEffects& effects,
    403                                                            const SkDescriptor* desc) const {
    404     return new SkScalerContext_DW(sk_ref_sp(const_cast<DWriteFontTypeface*>(this)), effects, desc);
    405 }
    406 
    407 void DWriteFontTypeface::onFilterRec(SkScalerContextRec* rec) const {
    408     if (rec->fFlags & SkScalerContext::kLCD_Vertical_Flag) {
    409         rec->fMaskFormat = SkMask::kA8_Format;
    410         rec->fFlags |= SkScalerContext::kGenA8FromLCD_Flag;
    411     }
    412 
    413     unsigned flagsWeDontSupport = SkScalerContext::kForceAutohinting_Flag |
    414                                   SkScalerContext::kEmbolden_Flag |
    415                                   SkScalerContext::kLCD_Vertical_Flag;
    416     rec->fFlags &= ~flagsWeDontSupport;
    417 
    418     SkFontHinting h = rec->getHinting();
    419     // DirectWrite2 allows for hinting to be turned off. Force everything else to normal.
    420     if (h != kNo_SkFontHinting || !fFactory2 || !fDWriteFontFace2) {
    421         h = kNormal_SkFontHinting;
    422     }
    423     rec->setHinting(h);
    424 
    425 #if defined(SK_FONT_HOST_USE_SYSTEM_SETTINGS)
    426     IDWriteFactory* factory = sk_get_dwrite_factory();
    427     if (factory != nullptr) {
    428         SkTScopedComPtr<IDWriteRenderingParams> defaultRenderingParams;
    429         if (SUCCEEDED(factory->CreateRenderingParams(&defaultRenderingParams))) {
    430             float gamma = defaultRenderingParams->GetGamma();
    431             rec->setDeviceGamma(gamma);
    432             rec->setPaintGamma(gamma);
    433 
    434             rec->setContrast(defaultRenderingParams->GetEnhancedContrast());
    435         }
    436     }
    437 #endif
    438 }
    439 
    440 ///////////////////////////////////////////////////////////////////////////////
    441 //PDF Support
    442 
    443 void DWriteFontTypeface::getGlyphToUnicodeMap(SkUnichar* glyphToUnicode) const {
    444     unsigned glyphCount = fDWriteFontFace->GetGlyphCount();
    445     sk_bzero(glyphToUnicode, sizeof(SkUnichar) * glyphCount);
    446     IDWriteFontFace* fontFace = fDWriteFontFace.get();
    447     int maxGlyph = -1;
    448     unsigned remainingGlyphCount = glyphCount;
    449     for (UINT32 c = 0; c < 0x10FFFF && remainingGlyphCount != 0; ++c) {
    450         UINT16 glyph = 0;
    451         HRVM(fontFace->GetGlyphIndices(&c, 1, &glyph), "Failed to get glyph index.");
    452         // Intermittent DW bug on Windows 10. See crbug.com/470146.
    453         if (glyph >= glyphCount) {
    454             return;
    455         }
    456         if (0 < glyph && glyphToUnicode[glyph] == 0) {
    457             maxGlyph = SkTMax(static_cast<int>(glyph), maxGlyph);
    458             glyphToUnicode[glyph] = c;  // Always use lowest-index unichar.
    459             --remainingGlyphCount;
    460         }
    461     }
    462 }
    463 
    464 std::unique_ptr<SkAdvancedTypefaceMetrics> DWriteFontTypeface::onGetAdvancedMetrics() const {
    465 
    466     std::unique_ptr<SkAdvancedTypefaceMetrics> info(nullptr);
    467 
    468     DWRITE_FONT_METRICS dwfm;
    469     fDWriteFontFace->GetMetrics(&dwfm);
    470 
    471     info.reset(new SkAdvancedTypefaceMetrics);
    472 
    473     info->fAscent = SkToS16(dwfm.ascent);
    474     info->fDescent = SkToS16(dwfm.descent);
    475     info->fCapHeight = SkToS16(dwfm.capHeight);
    476 
    477     {
    478         SkTScopedComPtr<IDWriteLocalizedStrings> postScriptNames;
    479         BOOL exists = FALSE;
    480         if (FAILED(fDWriteFont->GetInformationalStrings(
    481                         DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME,
    482                         &postScriptNames,
    483                         &exists)) ||
    484             !exists ||
    485             FAILED(sk_get_locale_string(postScriptNames.get(), nullptr, &info->fPostScriptName)))
    486         {
    487             SkDEBUGF("Unable to get postscript name for typeface %p\n", this);
    488         }
    489     }
    490 
    491     // SkAdvancedTypefaceMetrics::fFontName must actually be a family name.
    492     SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
    493     if (FAILED(fDWriteFontFamily->GetFamilyNames(&familyNames)) ||
    494         FAILED(sk_get_locale_string(familyNames.get(), nullptr, &info->fFontName)))
    495     {
    496         SkDEBUGF("Unable to get family name for typeface 0x%p\n", this);
    497     }
    498     if (info->fPostScriptName.isEmpty()) {
    499         info->fPostScriptName = info->fFontName;
    500     }
    501 
    502     DWRITE_FONT_FACE_TYPE fontType = fDWriteFontFace->GetType();
    503     if (fontType != DWRITE_FONT_FACE_TYPE_TRUETYPE &&
    504         fontType != DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION)
    505     {
    506         return info;
    507     }
    508 
    509     // Simulated fonts aren't really TrueType fonts.
    510     if (fDWriteFontFace->GetSimulations() == DWRITE_FONT_SIMULATIONS_NONE) {
    511         info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;
    512     }
    513 
    514     AutoTDWriteTable<SkOTTableHead> headTable(fDWriteFontFace.get());
    515     AutoTDWriteTable<SkOTTablePostScript> postTable(fDWriteFontFace.get());
    516     AutoTDWriteTable<SkOTTableHorizontalHeader> hheaTable(fDWriteFontFace.get());
    517     AutoTDWriteTable<SkOTTableOS2> os2Table(fDWriteFontFace.get());
    518     if (!headTable.fExists || !postTable.fExists || !hheaTable.fExists || !os2Table.fExists) {
    519         return info;
    520     }
    521 
    522     SkOTUtils::SetAdvancedTypefaceFlags(os2Table->version.v4.fsType, info.get());
    523 
    524     // There are versions of DirectWrite which support named instances for system variation fonts,
    525     // but no means to indicate that such a typeface is a variation.
    526     AutoTDWriteTable<SkOTTableFontVariations> fvarTable(fDWriteFontFace.get());
    527     if (fvarTable.fExists) {
    528         info->fFlags |= SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag;
    529     }
    530 
    531     //There exist CJK fonts which set the IsFixedPitch and Monospace bits,
    532     //but have full width, latin half-width, and half-width kana.
    533     bool fixedWidth = (postTable->isFixedPitch &&
    534                       (1 == SkEndian_SwapBE16(hheaTable->numberOfHMetrics)));
    535     //Monospace
    536     if (fixedWidth) {
    537         info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;
    538     }
    539     //Italic
    540     if (os2Table->version.v0.fsSelection.field.Italic) {
    541         info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style;
    542     }
    543     //Serif
    544     using SerifStyle = SkPanose::Data::TextAndDisplay::SerifStyle;
    545     SerifStyle serifStyle = os2Table->version.v0.panose.data.textAndDisplay.bSerifStyle;
    546     if (SkPanose::FamilyType::TextAndDisplay == os2Table->version.v0.panose.bFamilyType) {
    547         if (SerifStyle::Cove == serifStyle ||
    548             SerifStyle::ObtuseCove == serifStyle ||
    549             SerifStyle::SquareCove == serifStyle ||
    550             SerifStyle::ObtuseSquareCove == serifStyle ||
    551             SerifStyle::Square == serifStyle ||
    552             SerifStyle::Thin == serifStyle ||
    553             SerifStyle::Bone == serifStyle ||
    554             SerifStyle::Exaggerated == serifStyle ||
    555             SerifStyle::Triangle == serifStyle)
    556         {
    557             info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style;
    558         }
    559     //Script
    560     } else if (SkPanose::FamilyType::Script == os2Table->version.v0.panose.bFamilyType) {
    561         info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style;
    562     }
    563 
    564     info->fItalicAngle = SkEndian_SwapBE32(postTable->italicAngle) >> 16;
    565 
    566     info->fBBox = SkIRect::MakeLTRB((int32_t)SkEndian_SwapBE16((uint16_t)headTable->xMin),
    567                                     (int32_t)SkEndian_SwapBE16((uint16_t)headTable->yMax),
    568                                     (int32_t)SkEndian_SwapBE16((uint16_t)headTable->xMax),
    569                                     (int32_t)SkEndian_SwapBE16((uint16_t)headTable->yMin));
    570     return info;
    571 }
    572 #endif//defined(SK_BUILD_FOR_WIN)
    573