Font variations.

src/core/SkFontDescriptor.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFontDescriptor_DEFINED
 #define SkFontDescriptor_DEFINED
 
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTypeface.h"
 
+class SkFontParameters {

[bungeman-skia, 2015/03/23 21:59:05]

So this class is pragmatic, but also represents the odd rift (which FontConfig
ignores) between font request properties (properties of a font request like
name, style, characters, language), and extended font properties (information in
addition to the font data which is needed to define the font like index, axis,
extra scale, extra matrix, synthetic attributes).

The SkFontDescriptor wants to be able to represent both, so it almost seems like
it wants to be two parts. The SkTypeface base class knows everything about the
font request, but it's up to the subclasses to know about font parameters. The
font paramaters would also always need to ride with the data, so maybe this
should also have the data on it and the 'openStream' return one of these as a
whole package.

The implementation of this is also currently an ugly hack, just to get things
working. Needs to be cleaned up.

+public:
+    SkFontParameters() : fIndex(0) { }
+    int fIndex;
+    SkAutoSTArray<4, SkFixed> fAxis;
+};
+
 class SkFontDescriptor {
 public:
     SkFontDescriptor(SkTypeface::Style = SkTypeface::kNormal);
     // Does not affect ownership of SkStream.
     SkFontDescriptor(SkStream*);
 
     void serialize(SkWStream*);
 
     SkTypeface::Style getStyle() { return fStyle; }
     void setStyle(SkTypeface::Style style) { fStyle = style; }
 
     const char* getFamilyName() const { return fFamilyName.c_str(); }
     const char* getFullName() const { return fFullName.c_str(); }
     const char* getPostscriptName() const { return fPostscriptName.c_str(); }
     const char* getFontFileName() const { return fFontFileName.c_str(); }
     bool hasFontData() const { return fFontData.get() != NULL; }
     // Transfers ownership to the caller.
     SkStreamAsset* transferFontData() { return fFontData.detach(); }
-    int getFontIndex() const { return fFontIndex; }
+    SkFontParameters& getFontParameters() { return fFontParameters; }
 
     void setFamilyName(const char* name) { fFamilyName.set(name); }
     void setFullName(const char* name) { fFullName.set(name); }
     void setPostscriptName(const char* name) { fPostscriptName.set(name); }
     void setFontFileName(const char* name) { fFontFileName.set(name); }
     /** Set the font data only if it is necessary for serialization.
      *  This method takes ownership of the stream (both reference and cursor).
      */
     void setFontData(SkStreamAsset* stream) { fFontData.reset(stream); }
-    void setFontIndex(int index) { fFontIndex = index; }
 
 private:
     SkString fFamilyName;
     SkString fFullName;
     SkString fPostscriptName;
     SkString fFontFileName;
     SkAutoTDelete<SkStreamAsset> fFontData;
-    int fFontIndex;
+    SkFontParameters fFontParameters;
 
     SkTypeface::Style fStyle;
 };
 
 #endif // SkFontDescriptor_DEFINED