Revert of Replace SkTypeface::Style with SkFontStyle.

src/ports/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDataTable.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
@@ skipping 355 matching lines @@
         { SkTFixed<SkFS::kExtraExpanded_Width>::value,  SkTFixed<FC_WIDTH_EXTRAEXPANDED>::value },
         { SkTFixed<SkFS::kUltaExpanded_Width>::value,   SkTFixed<FC_WIDTH_ULTRAEXPANDED>::value },
     };
     int width = map_ranges(style.width(), widthRanges, SK_ARRAY_COUNT(widthRanges));
 
     FcPatternAddInteger(pattern, FC_WEIGHT, weight);
     FcPatternAddInteger(pattern, FC_WIDTH, width);
     FcPatternAddInteger(pattern, FC_SLANT, style.isItalic() ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
 }
 
+static SkTypeface::Style sktypefacestyle_from_fcpattern(FcPattern* pattern) {
+    int fcweight = get_int(pattern, FC_WEIGHT, FC_WEIGHT_REGULAR);
+    int fcslant = get_int(pattern, FC_SLANT, FC_SLANT_ROMAN);
+    return (SkTypeface::Style)((fcweight >= FC_WEIGHT_BOLD ? SkTypeface::kBold : 0) |
+                                (fcslant > FC_SLANT_ROMAN ? SkTypeface::kItalic : 0));
+}
+
 class SkTypeface_stream : public SkTypeface_FreeType {
 public:
     /** @param stream does not take ownership of the reference, does take ownership of the stream.*/
-    SkTypeface_stream(const SkFontStyle& style, bool fixedWidth, int index, SkStreamAsset* stream)
+    SkTypeface_stream(SkTypeface::Style style, bool fixedWidth, int ttcIndex, SkStreamAsset* stream)
         : INHERITED(style, SkTypefaceCache::NewFontID(), fixedWidth)
         , fStream(SkRef(stream))
-        , fIndex(index)
+        , fIndex(ttcIndex)
     { };
 
     virtual void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
         familyName->reset();
     }
 
     virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
         desc->setFontIndex(fIndex);
         *serialize = true;
     }
@@ skipping 40 matching lines @@
 
     virtual ~SkTypeface_fontconfig() {
         // Hold the lock while unrefing the pattern.
         FCLocker lock;
         fPattern.reset();
     }
 
 private:
     /** @param pattern takes ownership of the reference. */
     SkTypeface_fontconfig(FcPattern* pattern)
-        : INHERITED(skfontstyle_from_fcpattern(pattern),
+        : INHERITED(sktypefacestyle_from_fcpattern(pattern),
                     SkTypefaceCache::NewFontID(),
                     FC_PROPORTIONAL != get_int(pattern, FC_SPACING, FC_PROPORTIONAL))
         , fPattern(pattern)
     { };
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 class SkFontMgr_fontconfig : public SkFontMgr {
     mutable SkAutoFcConfig fFC;
@@ skipping 103 matching lines @@
                         *sizes.append() = strlen(familyName) + 1;
                     }
                 }
             }
         }
 
         return SkDataTable::NewCopyArrays((void const *const *)names.begin(),
                                           sizes.begin(), names.count());
     }
 
-    static bool FindByFcPattern(SkTypeface* cached, const SkFontStyle&, void* ctx) {
+    static bool FindByFcPattern(SkTypeface* cached, SkTypeface::Style, void* ctx) {
         SkTypeface_fontconfig* cshFace = static_cast<SkTypeface_fontconfig*>(cached);
         FcPattern* ctxPattern = static_cast<FcPattern*>(ctx);
         return FcTrue == FcPatternEqual(cshFace->fPattern, ctxPattern);
     }
 
     mutable SkMutex fTFCacheMutex;
     mutable SkTypefaceCache fTFCache;
     /** Creates a typeface using a typeface cache.
      *  @param pattern a complete pattern from FcFontRenderPrepare.
      */
     SkTypeface* createTypefaceFromFcPattern(FcPattern* pattern) const {
         FCLocker::AssertHeld();
         SkAutoMutexAcquire ama(fTFCacheMutex);
         SkTypeface* face = fTFCache.findByProcAndRef(FindByFcPattern, pattern);
         if (NULL == face) {
             FcPatternReference(pattern);
             face = SkTypeface_fontconfig::Create(pattern);
             if (face) {
-                fTFCache.add(face, SkFontStyle(), true);
+                fTFCache.add(face, SkTypeface::kNormal, true);
             }
         }
         return face;
     }
 
 public:
     SkFontMgr_fontconfig()
         : fFC(FcInitLoadConfigAndFonts())
         , fFamilyNames(GetFamilyNames(fFC)) { }
 
@@ skipping 207 matching lines @@
         return this->matchFamilyStyle(get_string(fcTypeface->fPattern, FC_FAMILY), style);
     }
 
     /** @param stream does not take ownership of the reference. */
     virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE {
         const size_t length = stream->getLength();
         if (length <= 0 || (1u << 30) < length) {
             return NULL;
         }
 
-        SkFontStyle style;
+        SkTypeface::Style style = SkTypeface::kNormal;
         bool isFixedWidth = false;
         if (!SkTypeface_FreeType::ScanFont(stream, ttcIndex, NULL, &style, &isFixedWidth)) {
             return NULL;
         }
 
         return SkNEW_ARGS(SkTypeface_stream, (style, isFixedWidth, ttcIndex,
                                               static_cast<SkStreamAsset*>(stream)));
     }
 
     virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
@@ skipping 20 matching lines @@
             return typeface.detach();
         }
 
         return this->matchFamilyStyle(NULL, style);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_fontconfig);
 }