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&) {
+//    return NULL;
+//}

[bungeman-skia, 2014/07/30 17:00:07]

I'll remove this block soon. I've commented out the following blocks on Clankium
and this is all that is needed to keep things linking. Once we remove the bit in
SkScalerContext.cpp which calls this, it will no longer be needed at all.

+#    [ 'OS == "android"', {
+#      'defines': [
+#        'SK_FONTHOST_DOES_NOT_USE_FONTMGR',
+#      ],
+#    }],

+#    '../third_party/skia/src/ports/SkFontConfigInterface_android.cpp',
+#    '../third_party/skia/src/ports/SkFontConfigInterface_direct.cpp',

+#    '../third_party/skia/src/fonts/SkFontMgr_fontconfig.cpp',
+#    '../third_party/skia/src/ports/SkFontHost_fontconfig.cpp',

+
 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,
+                             bool useInFallback)

[tomhudson, 2014/07/30 17:54:58]

You pass "is accepted fallback variant" to "use in fallback".
Naming not transparent; comment or rename.

[bungeman-skia, 2014/07/30 23:03:28]

Removed.

         : INHERITED(index, style, isFixedPitch, familyName)
-        , fPathName(pathName) { }
+        , fPathName(pathName)
+        , fLang(lang)
+        , fUseInFallback(useInFallback)

[bungeman-skia, 2014/07/30 17:00:07]

For the moment I'm sticking this on the typeface since that's more or less how
it was being done before. However, it appears that we should just never add
these to the fallback font families to begin with.

+    { }

[tomhudson, 2014/07/30 17:54:58]

Nit: Skia style?

[bungeman-skia, 2014/07/30 23:03:28]

Hmm, we do this in a number of other places, Skia style is a little...
something.

 
     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;
 
+public:

[djsollen, 2014/07/30 17:31:43]

seems like having 2 getters makes more sense than making these fields public

[tomhudson, 2014/07/30 17:54:58]

Acknowledged.

[bungeman-skia, 2014/07/30 23:03:28]

You Java people and your gratuitous setters and getters. Even in Java I would
just make this a final field. Heck, in Java I would have made this a static
inner class. Made private const and SkFontMgr_Android a friend for reading.

+    const SkLanguage fLang;
+    const bool fUseInFallback;
+
+private:
     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) : fFontFamily(family) {
+    explicit SkFontStyleSet_Android(FontFamily* family, SkString* name) {
         // TODO? make this lazy
         for (int i = 0; i < family->fFontFiles.count(); ++i) {
             const SkString& fileName = family->fFontFiles[i].fFileName;
 
             SkString pathName;
             get_path_for_sys_fonts(&pathName, fileName);
 
             SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
             if (!stream.get()) {
                 DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, fileName.c_str()));
                 continue;
             }
 
+            int ttcIndex = family->fFontFiles[i].fIndex;

[djsollen, 2014/07/30 17:31:43]

const int

[bungeman-skia, 2014/07/30 23:03:28]

Done.

             SkString fontName;
             SkTypeface::Style style;
             bool isFixedWidth;
-            if (!SkTypeface_FreeType::ScanFont(stream.get(), family->fFontFiles[i].fIndex,
+            if (!SkTypeface_FreeType::ScanFont(stream.get(), ttcIndex,
                                                &fontName, &style, &isFixedWidth)) {
                 DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, fileName.c_str()));
                 continue;
             }
 
+            static int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant |

[djsollen, 2014/07/30 17:31:43]

let's document why we do this.

The compact variant is the real source of the issue as they are used by the OS
in places that are space constrained and having variable ascent/descent values
are not acceptable.

So we exclude the compact variant for when building our dictionary of fonts.

[tomhudson, 2014/07/30 17:54:58]

Acknowledged.

[bungeman-skia, 2014/07/30 23:03:28]

Moved all the way over to the parser.

+                                              SkPaintOptionsAndroid::kElegant_Variant;
+            bool isAcceptedFallbackVariant = SkToBool(
+                family->fFontFiles[i].fPaintOptions.getFontVariant() & acceptedVariants);
+
+            const SkLanguage& lang = family->fFontFiles[i].fPaintOptions.getLanguage();
+
+            if (name != NULL) {
+                fontName = *name;
+            }
+
             fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
-                                                 (pathName, 0,
-                                                  style, isFixedWidth, fontName)));
+                                                 (pathName, ttcIndex,
+                                                  style, isFixedWidth, fontName,
+                                                  lang, isAcceptedFallbackVariant)));
         }
     }
 
     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 14 matching lines @@
     }
     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;
     }
 
 
-    FontFamily* fFontFamily;
-    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
+    {
+        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 (!face->fUseInFallback ||
+                   (!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 14 matching lines @@
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
                                                unsigned styleBits) const SK_OVERRIDE {
         SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
         SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
                                                  ? SkFontStyle::kBold_Weight
                                                  : SkFontStyle::kNormal_Weight,
                                         SkFontStyle::kNormal_Width,
                                         oldStyle & SkTypeface::kItalic
                                                  ? SkFontStyle::kItalic_Slant
                                                  : SkFontStyle::kUpright_Slant);
-        SkTypeface* tf = NULL;
 
         if (NULL != 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.
-            tf = this->onMatchFamilyStyle(familyName, style);
-        } else {
-            tf = fDefaultFamily->matchStyle(style);
+            return this->onMatchFamilyStyle(familyName, style);
         }
-
-        // TODO: double ref? qv matchStyle()
-        return SkSafeRef(tf);
+        return fDefaultFamily->matchStyle(style);
     }
 
 
 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();
+            if (families[i]->fIsFallbackFont) {

[djsollen, 2014/07/30 17:31:43]

in general this if/else block is very dense and hard to parse. Can we dedupe any
of this code or at least insert a few comments to help explain?

[tomhudson, 2014/07/30 17:54:58]

Acknowledged.

[bungeman-skia, 2014/07/30 23:03:28]

Made it much different now.

+                SkString fallbackName;
+                fallbackName.printf("%.2x##fallback", i);
+                NameToFamily* nextEntry = fFallbackNameToFamilyMap.append();
+                SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (fallbackName));
+                nextEntry->styleSet = fFontStyleSets.push_back().reset(
+                    SkNEW_ARGS(SkFontStyleSet_Android, (families[i], &fallbackName)));
+            } else {
+                SkString* cannonicalName = NULL;
+                if (families[i]->fNames.count() > 0) {
+                    cannonicalName = &families[i]->fNames[0];
+                }
+                SkFontStyleSet_Android* newSet = fFontStyleSets.push_back().reset(
+                    SkNEW_ARGS(SkFontStyleSet_Android, (families[i], cannonicalName)));
+                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 = 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);
 }