Font variations.

src/ports/SkFontMgr_android.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 "SkFontConfigParser_android.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
@@ skipping 10 matching lines @@
 #include <limits>
 
 // For test only.
 static const char* gTestFontsXml = NULL;
 static const char* gTestFallbackFontsXml = NULL;
 static const char* gTestBasePath = NULL;
 
 class SkTypeface_Android : public SkTypeface_FreeType {
 public:
     SkTypeface_Android(int index,
+                       const SkTArray<SkFixed, true>& axes,
                        const SkFontStyle& style,
                        bool isFixedPitch,
                        const SkString& familyName)
         : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
         , fIndex(index)
         , fFamilyName(familyName) { }
 
 protected:
     void onGetFamilyName(SkString* familyName) const override {
         *familyName = fFamilyName;
     }
 
     int fIndex;
     SkString fFamilyName;
+    const SkTArray<SkFixed, true> fAxes;
 
 private:
     typedef SkTypeface_FreeType INHERITED;
 };
 
 class SkTypeface_AndroidSystem : public SkTypeface_Android {
 public:
     SkTypeface_AndroidSystem(const SkString& pathName,
                              int index,
+                             const SkTArray<SkFixed, true>& axes,
                              const SkFontStyle& style,
                              bool isFixedPitch,
                              const SkString& familyName,
                              const SkLanguage& lang,
                              FontVariant variantStyle)
-        : INHERITED(index, style, isFixedPitch, familyName)
+        : INHERITED(index, axes, style, isFixedPitch, familyName)
         , fPathName(pathName)
         , fLang(lang)
         , fVariantStyle(variantStyle) { }
 
     virtual void onGetFontDescriptor(SkFontDescriptor* desc,
                                      bool* serialize) const override {
         SkASSERT(desc);
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
-        desc->setFontFileName(fPathName.c_str());
-        desc->setFontIndex(fIndex);
         *serialize = false;
     }
     SkStreamAsset* onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fIndex;
         return SkStream::NewFromFile(fPathName.c_str());
     }
+    SkFontData* onCreateFontData() const SK_OVERRIDE {
+        return new SkFontData(SkStream::NewFromFile(fPathName.c_str()), fIndex,
+                              fAxes.count(), fAxes.begin());
+    }
 
     const SkString fPathName;
     const SkLanguage fLang;
     const FontVariant fVariantStyle;
 
     typedef SkTypeface_Android INHERITED;
 };
 
 class SkTypeface_AndroidStream : public SkTypeface_Android {
 public:
     SkTypeface_AndroidStream(SkStreamAsset* stream,
                              int index,
+                             const SkTArray<SkFixed, true>& axes,
                              const SkFontStyle& style,
                              bool isFixedPitch,
                              const SkString& familyName)
-        : INHERITED(index, style, isFixedPitch, familyName)
+        : INHERITED(index, axes, style, isFixedPitch, familyName)
         , fStream(stream) { }
 
     virtual void onGetFontDescriptor(SkFontDescriptor* desc,
                                      bool* serialize) const override {
         SkASSERT(desc);
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
-        desc->setFontFileName(NULL);
         *serialize = true;
     }
 
     SkStreamAsset* onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fIndex;
         return fStream->duplicate();
     }
 
+    SkFontData* onCreateFontData() const SK_OVERRIDE {
+        return new SkFontData(fStream->duplicate(), fIndex, fAxes.count(), fAxes.begin());
+    }
+
 private:
     SkAutoTDelete<SkStreamAsset> fStream;
 
     typedef SkTypeface_Android INHERITED;
 };
 
 class SkFontStyleSet_Android : public SkFontStyleSet {
 public:
     explicit SkFontStyleSet_Android(const FontFamily& family,
                                     const SkTypeface_FreeType::Scanner& scanner)
@@ skipping 37 matching lines @@
             }
 
             // The first specified family name overrides the family name found in the font.
             // TODO: SkTypeface_AndroidSystem::onCreateFamilyNameIterator should return
             // all of the specified family names in addition to the names found in the font.
             if (cannonicalFamilyName != NULL) {
                 familyName = *cannonicalFamilyName;
             }
 
             fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
-                                                 (pathName, ttcIndex,
+                                                 (pathName, ttcIndex, fontFile.fAxes,
                                                   style, isFixedWidth, familyName,
                                                   lang, variant)));
         }
     }
 
     int count() override {
         return fStyles.count();
     }
     void getStyle(int index, SkFontStyle* style, SkString* name) override {
         if (index < 0 || fStyles.count() <= index) {
@@ skipping 226 matching lines @@
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(bareStream);
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         if (!fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
             return NULL;
         }
-        return SkNEW_ARGS(SkTypeface_AndroidStream, (stream.detach(), ttcIndex,
+        return SkNEW_ARGS(SkTypeface_AndroidStream, (stream.detach(), ttcIndex, SkTArray<SkFixed, true>(),
                                                      style, isFixedPitch, name));
     }
 
+    SkTypeface* onCreateFromFontData(SkFontData* data) const SK_OVERRIDE {
+        SkAutoTDelete<SkStreamAsset> stream(data->transferStream());
+        bool isFixedPitch;
+        SkFontStyle style;
+        SkString name;
+        if (!fScanner.scanFont(stream, data->getIndex(), &name, &style, &isFixedPitch)) {
+            return NULL;
+        }
+        return SkNEW_ARGS(SkTypeface_AndroidStream, (stream.detach(), data->getIndex(),
+                                                     SkTArray<SkFixed, true>(data->getAxis(), data->getAxisCount()),
+                                                     style, isFixedPitch, name));
+    }
+
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) const override {
         SkFontStyle style = SkFontStyle(styleBits);
 
         if (familyName) {
             // On Android, we must return NULL when we can't find the requested
             // named typeface so that the system/app can provide their own recovery
             // mechanism. On other platforms we'd provide a typeface from the
             // default family instead.
@@ skipping 113 matching lines @@
 {
     gTestFontsXml = fontsXml;
     gTestFallbackFontsXml = fallbackFontsXml;
     gTestBasePath = basePath;
     SkASSERT(gTestFontsXml);
     SkASSERT(gTestFallbackFontsXml);
     SkASSERT(gTestBasePath);
     SkDEBUGF(("Test BasePath: %s Fonts: %s FallbackFonts: %s\n",
               gTestBasePath, gTestFontsXml, gTestFallbackFontsXml));
 }