Replace SkTypeface::Style with SkFontStyle.

src/ports/SkFontConfigTypeface.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkStream.h"
 #include "SkTypefaceCache.h"
 
 class SkFontDescriptor;
 
 class FontConfigTypeface : public SkTypeface_FreeType {
     SkFontConfigInterface::FontIdentity fIdentity;
     SkString fFamilyName;
     SkStream* fLocalStream;
 
 public:
-    static FontConfigTypeface* Create(Style style,
+    static FontConfigTypeface* Create(SkFontStyle style,

[reed1, 2014/10/17 18:50:31]

why not "const SkFontStyle&" everywhere, since its a class and (may) get
bigger/more complex in the future?

[bungeman-skia, 2014/10/17 19:56:48]

Done. I didn't do it now since I'm replacing a value, and SkFontStyle is rather
small. However, you're right, in some cases this could get rather large with
lots of overriding preferences attached.

                                       const SkFontConfigInterface::FontIdentity& fi,
                                       const SkString& familyName) {
         return SkNEW_ARGS(FontConfigTypeface, (style, fi, familyName));
     }
 
-    static FontConfigTypeface* Create(Style style, bool fixedWidth, SkStream* localStream) {
+    static FontConfigTypeface* Create(SkFontStyle style, bool fixedWidth, SkStream* localStream) {
         return SkNEW_ARGS(FontConfigTypeface, (style, fixedWidth, localStream));
     }
 
     virtual ~FontConfigTypeface() {
         SkSafeUnref(fLocalStream);
     }
 
     const SkFontConfigInterface::FontIdentity& getIdentity() const {
         return fIdentity;
     }
 
     const char* getFamilyName() const { return fFamilyName.c_str(); }
     SkStream*   getLocalStream() const { return fLocalStream; }
 
     bool isFamilyName(const char* name) const {
         return fFamilyName.equals(name);
     }
 
     static SkTypeface* LegacyCreateTypeface(const SkTypeface* family,
                                             const char familyName[],
                                             SkTypeface::Style);
 
 protected:
     friend class SkFontHost;    // hack until we can make public versions
 
-    FontConfigTypeface(Style style,
+    FontConfigTypeface(SkFontStyle style,
                        const SkFontConfigInterface::FontIdentity& fi,
                        const SkString& familyName)
             : INHERITED(style, SkTypefaceCache::NewFontID(), false)
             , fIdentity(fi)
             , fFamilyName(familyName)
             , fLocalStream(NULL) {}
 
-    FontConfigTypeface(Style style, bool fixedWidth, SkStream* localStream)
+    FontConfigTypeface(SkFontStyle style, bool fixedWidth, SkStream* localStream)
             : INHERITED(style, SkTypefaceCache::NewFontID(), fixedWidth) {
         // we default to empty fFamilyName and fIdentity
         fLocalStream = localStream;
         SkSafeRef(localStream);
     }
 
     virtual void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
     virtual void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
 
 private:
     typedef SkTypeface_FreeType INHERITED;
 };