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 15 matching lines @@
 #ifndef SK_DEBUG_FONTS
     #define SK_DEBUG_FONTS 0
 #endif
 
 #if SK_DEBUG_FONTS
 #    define DEBUG_FONT(args) SkDebugf args
 #else
 #    define DEBUG_FONT(args)
 #endif
 
+//SkTypeface* SkAndroidNextLogicalTypeface(SkFontID, SkFontID, SkPaintOptionsAndroid const&) {

[djsollen, 2014/07/31 14:51:37]

drop this

[bungeman-skia, 2014/07/31 22:15:53]

As soon as https://codereview.chromium.org/434623002/ lands. Until then I need
this around for testing and to remind me that this can't be committed yet
(either the other change must land first or I'll have to come up with another
fix).

+//    return NULL;
+//}
+
 class SkTypeface_Android : public SkTypeface_FreeType {
 public:
     SkTypeface_Android(int index,
                        Style style,
                        bool isFixedPitch,
                        const SkString familyName)
         : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
         , fIndex(index)
         , fFamilyName(familyName) { }
 
     const SkString& name() const { return fFamilyName; }
 
 protected:
     int fIndex;
     SkString fFamilyName;
 
 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)
         : INHERITED(index, style, isFixedPitch, familyName)
-        , fPathName(pathName) { }
+        , fPathName(pathName)
+        , fLang(lang) { }
 
     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;
 
+    friend class SkFontMgr_Android;

[djsollen, 2014/07/31 14:51:37]

why!!  A simple get function makes it clear that you should only be querying
fLang

[bungeman-skia, 2014/07/31 22:15:53]

As discussed since this is all hidden away in the cpp file, just made the things
public since they're const.

     typedef SkTypeface_Android INHERITED;
 };
 
 class SkTypeface_AndroidStream : public SkTypeface_Android {
 public:
     SkTypeface_AndroidStream(SkStream* stream,
                              int index,
                              Style style,
                              bool isFixedPitch,
                              const SkString familyName)
@@ skipping 21 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* cannonicalName = NULL;
+        if (family.fNames.count() > 0) {
+            cannonicalName = &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;
+            const int ttcIndex = family.fFontFiles[i].fIndex;
             SkString fontName;
             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()));
+                DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, pathName.c_str()));
                 continue;
             }
 
+            const SkLanguage& lang = family.fFontFiles[i].fPaintOptions.getLanguage();
+
+            if (cannonicalName != NULL) {
+                fontName = *cannonicalName;

[djsollen, 2014/07/31 14:51:37]

what is the benefit of passing the same name for each font in the family?

[bungeman-skia, 2014/07/31 22:15:53]

The name is the family name as specified by the FontFamily. Basically, we need
to ensure getFamilyName on the typeface will return a string which can be looked
up to find the typeface again. I'll try to clarify this in the naming.

+            }
+
             fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
                                                  (pathName, ttcIndex,
-                                                  style, isFixedWidth, fontName)));
+                                                  style, isFixedWidth, fontName, lang)));
         }
     }
 
     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.
  *  SkTDict<> doesn't let us do index-based lookup, so we write our own mapping.
  */
 struct NameToFamily {
     SkString name;
     SkFontStyleSet_Android* styleSet;
 };
 
 class SkFontMgr_Android : public SkFontMgr {
 public:
     SkFontMgr_Android() {
         SkTDArray<FontFamily*> fontFamilies;
-        SkFontConfigParser::GetFontFamilies(fontFamilies);
+        SkFontConfigParser::GetFontFamilies(fontFamilies,
+                                            SkPaintOptionsAndroid::kCompact_Variant);

[djsollen, 2014/07/31 14:51:37]

document why we ignore the compact variant for fallbacks!

[bungeman-skia, 2014/07/31 22:15:53]

Eck, I don't think we want to. Now that I've done this and you've written this
and I tried to document it, it turns out that 'variant' is just like 'width' or
'stretch' except vertical, and is a style against which we should be matching.
In other words, if we're doing fallback for a 'compact' font, then we'd prefer
'compact' matches.

         this->buildNameToFamilyMap(fontFamilies);
         this->findDefaultFont();
     }
 
 protected:
     /** Returns not how many families we have, but how many unique names
      *  exist among the families.
      */
     virtual int onCountFamilies() const SK_OVERRIDE {
         return fNameToFamilyMap.count();
@@ skipping 17 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
+    {
+        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;
+                }
+
+                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));
+        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);
 }