Replace SkTypeface::Style with SkFontStyle.

src/ports/SkFontHost_linux.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontHost.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkFontDescriptor.h"
@@ skipping 12 matching lines @@
 
 #ifndef SK_FONT_FILE_PREFIX
 #    define SK_FONT_FILE_PREFIX "/usr/share/fonts/truetype/"
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /** The base SkTypeface implementation for the custom font manager. */
 class SkTypeface_Custom : public SkTypeface_FreeType {
 public:
-    SkTypeface_Custom(Style style, bool isFixedPitch,
+    SkTypeface_Custom(const SkFontStyle& style, bool isFixedPitch,
                       bool sysFont, const SkString familyName, int index)
         : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
         , fIsSysFont(sysFont), fFamilyName(familyName), fIndex(index)
     { }
 
     bool isSysFont() const { return fIsSysFont; }
 
     virtual const char* getUniqueString() const = 0;
 
 protected:
@@ skipping 16 matching lines @@
     const int fIndex;
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 /** The empty SkTypeface implementation for the custom font manager.
  *  Used as the last resort fallback typeface.
  */
 class SkTypeface_Empty : public SkTypeface_Custom {
 public:
-    SkTypeface_Empty() : INHERITED(SkTypeface::kNormal, false, true, SkString(), 0) {}
+    SkTypeface_Empty() : INHERITED(SkFontStyle(), false, true, SkString(), 0) {}
 
     virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
 
 protected:
     virtual SkStream* onOpenStream(int*) const SK_OVERRIDE { return NULL; }
 
 private:
     typedef SkTypeface_Custom INHERITED;
 };
 
 /** The stream SkTypeface implementation for the custom font manager. */
 class SkTypeface_Stream : public SkTypeface_Custom {
 public:
-    SkTypeface_Stream(Style style, bool isFixedPitch, bool sysFont, const SkString familyName,
-                      SkStream* stream, int ttcIndex)
-        : INHERITED(style, isFixedPitch, sysFont, familyName, ttcIndex)
+    SkTypeface_Stream(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
+                      const SkString familyName, SkStream* stream, int index)
+        : INHERITED(style, isFixedPitch, sysFont, familyName, index)
         , fStream(SkRef(stream))
     { }
 
     virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
 
 protected:
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
         *ttcIndex = this->getIndex();
         return fStream->duplicate();
     }
 
 private:
     const SkAutoTUnref<const SkStream> fStream;
 
     typedef SkTypeface_Custom INHERITED;
 };
 
 /** The file SkTypeface implementation for the custom font manager. */
 class SkTypeface_File : public SkTypeface_Custom {
 public:
-    SkTypeface_File(Style style, bool isFixedPitch, bool sysFont, const SkString familyName,
-                    const char path[], int index)
+    SkTypeface_File(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
+                    const SkString familyName, const char path[], int index)
         : INHERITED(style, isFixedPitch, sysFont, familyName, index)
         , fPath(path)
     { }
 
     virtual const char* getUniqueString() const SK_OVERRIDE {
         const char* str = strrchr(fPath.c_str(), '/');
         if (str) {
             str += 1;   // skip the '/'
         }
         return str;
@@ skipping 147 matching lines @@
         return this->createFromStream(stream, ttcIndex);
     }
 
     virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE {
         if (NULL == stream || stream->getLength() <= 0) {
             SkDELETE(stream);
             return NULL;
         }
 
         bool isFixedPitch;
-        SkTypeface::Style style;
+        SkFontStyle style;
         SkString name;
         if (SkTypeface_FreeType::ScanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
             return SkNEW_ARGS(SkTypeface_Stream, (style, isFixedPitch, false, name,
                                                   stream, ttcIndex));
         } else {
             return NULL;
         }
     }
 
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
@@ skipping 21 matching lines @@
         if (NULL == tf) {
             tf = gDefaultFamily->matchStyle(style);
         }
 
         return SkSafeRef(tf);
     }
 
 private:
 
     static bool get_name_and_style(const char path[], SkString* name,
-                                   SkTypeface::Style* style, bool* isFixedPitch) {
+                                   SkFontStyle* style, bool* isFixedPitch) {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         if (stream.get()) {
             return SkTypeface_FreeType::ScanFont(stream, 0, name, style, isFixedPitch);
         } else {
             SkDebugf("---- failed to open <%s> as a font\n", path);
             return false;
         }
     }
 
     void load_directory_fonts(const SkString& directory) {
         SkOSFile::Iter iter(directory.c_str(), ".ttf");
         SkString name;
 
         while (iter.next(&name, false)) {
             SkString filename(
                 SkOSPath::Join(directory.c_str(), name.c_str()));
 
             bool isFixedPitch;
             SkString realname;
-            SkTypeface::Style style = SkTypeface::kNormal; // avoid uninitialized warning
-
+            SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
             if (!get_name_and_style(filename.c_str(), &realname, &style, &isFixedPitch)) {
                 SkDebugf("------ can't load <%s> as a font\n", filename.c_str());
                 continue;
             }
 
             SkTypeface_Custom* tf = SkNEW_ARGS(SkTypeface_File, (
                                                 style,
                                                 isFixedPitch,
                                                 true,  // system-font (cannot delete)
                                                 realname,
@@ skipping 55 matching lines @@
     }
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Custom>, true> fFamilies;
     SkFontStyleSet_Custom* gDefaultFamily;
     SkTypeface* gDefaultNormal;
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return new SkFontMgr_Custom(SK_FONT_FILE_PREFIX);
 }