Implement SkFontMgr_Android::onMatchFamilyStyleCharacter.

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 41 matching lines @@
 private:
     typedef SkTypeface_FreeType INHERITED;
 };
 
 class SkTypeface_AndroidSystem : public SkTypeface_Android {
 public:
     SkTypeface_AndroidSystem(const SkString pathName,
                              int index,
                              Style style,
                              bool isFixedPitch,
-                             const SkString familyName)
+                             const SkString familyName,
+                             const SkLanguage& lang,
+                             SkPaintOptionsAndroid::FontVariant variant)
         : INHERITED(index, style, isFixedPitch, familyName)
-        , fPathName(pathName) { }
+        , fPathName(pathName)
+        , fLang(lang)
+        , fVariant(variant) { }
 
     virtual void onGetFontDescriptor(SkFontDescriptor* desc,
                                      bool* serialize) const SK_OVERRIDE {
         SkASSERT(desc);
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
         desc->setFontFileName(fPathName.c_str());
         *serialize = false;
     }
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
         *ttcIndex = fIndex;
         return SkStream::NewFromFile(fPathName.c_str());
     }
 
-private:
-    SkString fPathName;
+    const SkString fPathName;
+    const SkLanguage fLang;
+    const SkPaintOptionsAndroid::FontVariant fVariant;
 
     typedef SkTypeface_Android INHERITED;
 };
 
 class SkTypeface_AndroidStream : public SkTypeface_Android {
 public:
     SkTypeface_AndroidStream(SkStream* stream,
                              int index,
                              Style style,
                              bool isFixedPitch,
@@ skipping 22 matching lines @@
 };
 
 void get_path_for_sys_fonts(SkString* full, const SkString& name) {
     full->set(getenv("ANDROID_ROOT"));
     full->append(SK_FONT_FILE_PREFIX);
     full->append(name);
 }
 
 class SkFontStyleSet_Android : public SkFontStyleSet {
 public:
-    explicit SkFontStyleSet_Android(FontFamily* family) {
+    explicit SkFontStyleSet_Android(const FontFamily& family) {
+        const SkString* cannonicalFamilyName = NULL;
+        if (family.fNames.count() > 0) {
+            cannonicalFamilyName = &family.fNames[0];
+        }
         // TODO? make this lazy
-        for (int i = 0; i < family->fFontFiles.count(); ++i) {
-            const SkString& fileName = family->fFontFiles[i].fFileName;
+        for (int i = 0; i < family.fFontFiles.count(); ++i) {
+            const FontFileInfo& fontFile = family.fFontFiles[i];
 
             SkString pathName;
-            get_path_for_sys_fonts(&pathName, fileName);
+            get_path_for_sys_fonts(&pathName, fontFile.fFileName);
 
             SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
             if (!stream.get()) {
-                DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, fileName.c_str()));
+                DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, pathName.c_str()));
                 continue;
             }
 
-            const int ttcIndex = family->fFontFiles[i].fIndex;
-            SkString fontName;
+            const int ttcIndex = fontFile.fIndex;
+            SkString familyName;
             SkTypeface::Style style;
             bool isFixedWidth;
             if (!SkTypeface_FreeType::ScanFont(stream.get(), ttcIndex,
-                                               &fontName, &style, &isFixedWidth)) {
-                DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, fileName.c_str()));
+                                               &familyName, &style, &isFixedWidth)) {
+                DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, pathName.c_str()));
                 continue;
             }
 
+            const SkLanguage& lang = fontFile.fPaintOptions.getLanguage();
+            SkPaintOptionsAndroid::FontVariant variant = fontFile.fPaintOptions.getFontVariant();
+
+            // 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,
-                                                  style, isFixedWidth, fontName)));
+                                                  style, isFixedWidth, familyName,
+                                                  lang, variant)));
         }
     }
 
     virtual int count() SK_OVERRIDE {
         return fStyles.count();
     }
     virtual void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
         if (index < 0 || fStyles.count() <= index) {
             return;
         }
         if (style) {
             *style = this->style(index);
         }
         if (name) {
             name->reset();
         }
     }
-    virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
+    virtual SkTypeface_AndroidSystem* createTypeface(int index) SK_OVERRIDE {
         if (index < 0 || fStyles.count() <= index) {
             return NULL;
         }
         return SkRef(fStyles[index].get());
     }
 
     /** Find the typeface in this style set that most closely matches the given pattern.
      *  TODO: consider replacing with SkStyleSet_Indirect::matchStyle();
      *  this simpler version using match_score() passes all our tests.
      */
-    virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+    virtual SkTypeface_AndroidSystem* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
         if (0 == fStyles.count()) {
             return NULL;
         }
-        SkTypeface* closest = fStyles[0];
+        SkTypeface_AndroidSystem* closest = fStyles[0];
         int minScore = std::numeric_limits<int>::max();
         for (int i = 0; i < fStyles.count(); ++i) {
             SkFontStyle style = this->style(i);
             int score = match_score(pattern, style);
             if (score < minScore) {
                 closest = fStyles[i];
                 minScore = score;
             }
         }
         return SkRef(closest);
@@ skipping 13 matching lines @@
         return SkFontStyle::kUpright_Slant;
     }
     static int match_score(const SkFontStyle& pattern, const SkFontStyle& candidate) {
         int score = 0;
         score += abs((pattern.width() - candidate.width()) * 100);
         score += abs((pattern.isItalic() == candidate.isItalic()) ? 0 : 1000);
         score += abs(pattern.weight() - candidate.weight());
         return score;
     }
 
-    SkTArray<SkAutoTUnref<SkTypeface>, true> fStyles;
+    SkTArray<SkAutoTUnref<SkTypeface_AndroidSystem>, true> fStyles;
 
     friend struct NameToFamily;
     friend class SkFontMgr_Android;
 
     typedef SkFontStyleSet INHERITED;
 };
 
 /** On Android a single family can have many names, but our API assumes unique names.
  *  Map names to the back end so that all names for a given family refer to the same
  *  (non-replicated) set of typefaces.
@@ skipping 39 matching lines @@
     virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
         if (!familyName) {
             return NULL;
         }
         SkAutoAsciiToLC tolc(familyName);
         for (int i = 0; i < fNameToFamilyMap.count(); ++i) {
             if (fNameToFamilyMap[i].name.equals(tolc.lc())) {
                 return SkRef(fNameToFamilyMap[i].styleSet);
             }
         }
+        // TODO: eventually we should not need to name fallback families.
+        for (int i = 0; i < fFallbackNameToFamilyMap.count(); ++i) {
+            if (fFallbackNameToFamilyMap[i].name.equals(tolc.lc())) {
+                return SkRef(fFallbackNameToFamilyMap[i].styleSet);
+            }
+        }
         return NULL;
     }
 
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
                                            const SkFontStyle& style) const SK_OVERRIDE {
         SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
         return sset->matchStyle(style);
     }
 
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
                                          const SkFontStyle& style) const SK_OVERRIDE {
         for (int i = 0; i < fFontStyleSets.count(); ++i) {
             for (int j = 0; j < fFontStyleSets[i]->fStyles.count(); ++j) {
                 if (fFontStyleSets[i]->fStyles[j] == typeface) {
                     return fFontStyleSets[i]->matchStyle(style);
                 }
             }
         }
         return NULL;
     }
 
+    virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
+                                                    const SkFontStyle& style,
+                                                    const char bpc47[],
+                                                    uint32_t character) const SK_OVERRIDE
+    {
+        // If the familyName maps to a family, then match the style and get the variant.
+        // Otherwise "elegant" unless the family name ends in "compact".
+        bool isCompact = false;
+        if (familyName) {
+            size_t familyNameLen = strlen(familyName);
+            static const char compactLiteral[] = "compact";
+            static const size_t compactLiteralLen = SK_ARRAY_COUNT(compactLiteral);
+            if (compactLiteralLen <= familyNameLen) {

[djsollen, 2014/08/01 20:24:04]

should this be < or would a font with the name "compact" also be a compact font?

[bungeman-skia, 2014/08/04 19:24:20]

So, when I wrote this I was under the impression from the enumeration that fonts
were effectively 'elegant' or 'compact' with default sort if being a lazy out.
It actually appears that 'default' means (in some sense) both 'elegant' and
'compact'. It's 'elegant' because it hasn't been squashed, but it's 'compact'
because it doesn't draw out of the ascent/descent. As a result, this is
something which actually needs to go on the 'style' request, along with the 5000
other things which would also be nice to have on the requested style.

For the time being I will set it up so that this can be implemented easily in
the future, but will currently use the 'elegant' first approach as that's what
Blink expects.

+                const char* familyNameEnd = familyName + familyNameLen - compactLiteralLen;
+                isCompact = SkToBool(strcmp(familyNameEnd, compactLiteral));
+            }
+        }
+
+        uint32_t ignoredVariantMask = SkPaintOptionsAndroid::kCompact_Variant;
+        if (isCompact) {
+            ignoredVariantMask = ~SkPaintOptionsAndroid::kCompact_Variant;
+        }
+
+        for (int i = 0; i < 2; ++i, ignoredVariantMask = ~ignoredVariantMask) {

[djsollen, 2014/08/01 20:24:04]

document that the second time through the loop looks for the opposite of the
initial mask.

[bungeman-skia, 2014/08/04 19:24:20]

Changed the logic to make this more obvious and added a comment.

+            SkLanguage lang(bpc47);
+            do {
+                const SkString& langTag = lang.getTag();
+                for (int i = 0; i < fFallbackNameToFamilyMap.count(); ++i) {
+                    SkFontStyleSet_Android* family = fFallbackNameToFamilyMap[i].styleSet;
+                    SkAutoTUnref<SkTypeface_AndroidSystem> face(family->matchStyle(style));
+
+                    if (!langTag.isEmpty() && langTag != face->fLang.getTag()) {
+                        continue;
+                    }
+
+                    if (SkToBool(face->fVariant & ignoredVariantMask)) {
+                        continue;
+                    }
+
+                    SkPaint paint;
+                    paint.setTypeface(face);
+                    paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
+
+                    uint16_t glyphID;
+                    paint.textToGlyphs(&character, sizeof(character), &glyphID);
+                    if (glyphID != 0) {
+                        return face.detach();
+                    }
+                }
+            } while (!lang.getTag().isEmpty() && (lang = lang.getParent(), true));

[djsollen, 2014/08/01 20:24:04]

At first glance it is not clear that the last run through the loop is with an
empty langTag, so please document it.

[bungeman-skia, 2014/08/04 19:24:20]

Documented.

+        }
+        return NULL;
+    }
+
     virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(new SkMemoryStream(data));
         return this->createFromStream(stream, ttcIndex);
     }
 
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         return stream.get() ? this->createFromStream(stream, ttcIndex) : NULL;
     }
 
@@ skipping 33 matching lines @@
     }
 
 
 private:
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
     SkFontStyleSet* fDefaultFamily;
     SkTypeface* fDefaultTypeface;
 
     SkTDArray<NameToFamily> fNameToFamilyMap;
+    SkTDArray<NameToFamily> fFallbackNameToFamilyMap;
 
     void buildNameToFamilyMap(SkTDArray<FontFamily*> families) {
         for (int i = 0; i < families.count(); i++) {
-            fFontStyleSets.push_back().reset(
-                SkNEW_ARGS(SkFontStyleSet_Android, (families[i])));
-            for (int j = 0; j < families[i]->fNames.count(); j++) {
-                NameToFamily* nextEntry = fNameToFamilyMap.append();
-                SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (families[i]->fNames[j]));
-                nextEntry->styleSet = fFontStyleSets.back().get();
+            FontFamily& family = *families[i];
+
+            SkTDArray<NameToFamily>* nameToFamily = &fNameToFamilyMap;
+            if (family.fIsFallbackFont) {
+                nameToFamily = &fFallbackNameToFamilyMap;
+
+                if (0 == family.fNames.count()) {
+                    SkString& fallbackName = family.fNames.push_back();
+                    fallbackName.printf("%.2x##fallback", i);
+                }
+            }
+
+            SkFontStyleSet_Android* newSet = SkNEW_ARGS(SkFontStyleSet_Android, (family));
+            if (0 == newSet->count()) {
+                SkDELETE(newSet);
+                continue;
+            }
+            fFontStyleSets.push_back().reset(newSet);
+
+            for (int j = 0; j < family.fNames.count(); j++) {
+                NameToFamily* nextEntry = nameToFamily->append();
+                SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (family.fNames[j]));
+                nextEntry->styleSet = newSet;
             }
         }
     }
 
     void findDefaultFont() {
         SkASSERT(!fFontStyleSets.empty());
 
         static const char* gDefaultNames[] = { "sans-serif" };
         for (size_t i = 0; i < SK_ARRAY_COUNT(gDefaultNames); ++i) {
             SkFontStyleSet* set = this->onMatchFamily(gDefaultNames[i]);
@@ skipping 17 matching lines @@
     }
 
     typedef SkFontMgr INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Android);
 }