Update typeface serialization style.

src/utils/SkWhitelistTypefaces.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkFontDescriptor.h"
 #include "SkStream.h"
@@ skipping 65 matching lines @@
     if (!length) {
         return 0;
     }
     data.setCount((int) length);
     if (!fontStream->peek(data.begin(), length)) {
         return 0;
     }
     return SkChecksum::Murmur3(data.begin(), length);
 }
 
-static void serialize_sub(const char* fontName, SkTypeface::Style style, SkWStream* wstream) {
-    SkFontDescriptor desc(style);
+static void serialize_sub(const char* fontName, SkFontStyle style, SkWStream* wstream) {
+    SkFontDescriptor desc;
     SkString subName(SUBNAME_PREFIX);
     subName.append(fontName);
     const char* familyName = subName.c_str();
     desc.setFamilyName(familyName);
+    desc.setStyle(style);
     desc.serialize(wstream);
 #if WHITELIST_DEBUG
     for (int i = 0; i < whitelistCount; ++i) {
         if (!strcmp(fontName, whitelist[i].fFontName)) {
             if (!whitelist[i].fSerializedSub) {
                 whitelist[i].fSerializedSub = true;
                 SkDebugf("%s %s\n", __FUNCTION__, familyName);
             }
             break;
         }
     }
 #endif
 }
 
 static bool is_local(const SkTypeface* tf) {
     bool isLocal = false;
-    SkFontDescriptor desc(tf->style());
+    SkFontDescriptor desc;
     tf->getFontDescriptor(&desc, &isLocal);
     return isLocal;
 }
 
 static void serialize_full(const SkTypeface* tf, SkWStream* wstream) {
     bool isLocal = false;
-    SkFontDescriptor desc(tf->style());
+    SkFontDescriptor desc;
     tf->getFontDescriptor(&desc, &isLocal);
 
     // Embed font data if it's a local font.
     if (isLocal && !desc.hasFontData()) {
         desc.setFontData(tf->createFontData());
     }
     desc.serialize(wstream);
 }
 
 static void serialize_name_only(const SkTypeface* tf, SkWStream* wstream) {
     bool isLocal = false;
-    SkFontDescriptor desc(tf->style());
+    SkFontDescriptor desc;
     tf->getFontDescriptor(&desc, &isLocal);
     SkASSERT(!isLocal);
 #if WHITELIST_DEBUG
     const char* familyName = desc.getFamilyName();
     if (familyName) {
         if (!strcmp(familyName, "Times New Roman")) {
             if (!timesNewRomanSerializedNameOnly) {
                 timesNewRomanSerializedNameOnly = true;
                 SkDebugf("%s %s\n", __FUNCTION__, familyName);
             }
@@ skipping 35 matching lines @@
     if (whitelist[whitelistIndex].fChecksum != checksum) {
 #if WHITELIST_DEBUG
         if (whitelist[whitelistIndex].fChecksum) {
             SkDebugf("!!! checksum changed !!!\n");
         }
         SkDebugf("checksum updated\n");
         SkDebugf("    { \"%s\", 0x%08x },\n", fontName, checksum);
 #endif
         whitelist[whitelistIndex].fChecksum = checksum;
     }
-    serialize_sub(fontName, tf->style(), wstream);
+    serialize_sub(fontName, tf->fontStyle(), wstream);
 }
 
 sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* stream) {
     SkFontDescriptor desc;
     if (!SkFontDescriptor::Deserialize(stream, &desc)) {
         return nullptr;
     }
 
     SkFontData* data = desc.detachFontData();
     if (data) {
         sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
         if (typeface) {
             return typeface;
         }
     }
     const char* familyName = desc.getFamilyName();
     if (!strncmp(SUBNAME_PREFIX, familyName, sizeof(SUBNAME_PREFIX) - 1)) {
         familyName += sizeof(SUBNAME_PREFIX) - 1;
     }
-    return SkTypeface::MakeFromName(familyName, SkFontStyle::FromOldStyle(desc.getStyle()));
+    return SkTypeface::MakeFromName(familyName, desc.getStyle());
 }
 
 bool CheckChecksums() {
     for (int i = 0; i < whitelistCount; ++i) {
         const char* fontName = whitelist[i].fFontName;
         sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkFontStyle()));
         uint32_t checksum = compute_checksum(tf.get());
         if (whitelist[i].fChecksum != checksum) {
             return false;
         }
@@ skipping 49 matching lines @@
         const char* fontName = whitelist[i].fFontName;
         sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkFontStyle()));
         uint32_t checksum = compute_checksum(tf.get());
         line.printf(checksumEntry, fontName, checksum);
         sk_fwrite(line.c_str(), line.size(), file);
     }
     sk_fwrite(checksumTrailer, sizeof(checksumTrailer) - 1, file);
     sk_fclose(file);
     return true;
 }