Improve fallback for Burmese with leading punctuation + spacing mark

third_party/WebKit/Source/platform/fonts/FontFallbackIterator.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/FontFallbackIterator.h"
 
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontFallbackList.h"
 #include "platform/fonts/SegmentedFontData.h"
@@ skipping 81 matching lines @@
     m_fallbackStage = SystemFonts;
     RefPtr<FontDataForRangeSet> fallbackPriorityFontRange =
         adoptRef(new FontDataForRangeSet(fallbackPriorityFont(hintList[0])));
     if (fallbackPriorityFontRange->hasFontData())
       return uniqueOrNext(fallbackPriorityFontRange.release(), hintList);
     return next(hintList);
   }
 
   if (m_fallbackStage == SystemFonts) {
     // We've reached pref + system fallback.
-    ASSERT(hintList.size());
-    RefPtr<SimpleFontData> systemFont = uniqueSystemFontForHint(hintList[0]);
+    RefPtr<SimpleFontData> systemFont = uniqueSystemFontForHintList(hintList);
     if (systemFont) {
       // Fallback fonts are not retained in the FontDataCache.
       return uniqueOrNext(adoptRef(new FontDataForRangeSet(systemFont)),
                           hintList);
     }
 
     // If we don't have options from the system fallback anymore or had
     // previously returned them, we only have the last resort font left.
     // TODO: crbug.com/42217 Improve this by doing the last run with a last
     // resort font that has glyphs for everything, for example the Unicode
@@ skipping 72 matching lines @@
 }
 
 PassRefPtr<SimpleFontData> FontFallbackIterator::fallbackPriorityFont(
     UChar32 hint) {
   return FontCache::fontCache()->fallbackFontForCharacter(
       m_fontDescription, hint,
       m_fontFallbackList->primarySimpleFontData(m_fontDescription),
       m_fontFallbackPriority);
 }
 
-PassRefPtr<SimpleFontData> FontFallbackIterator::uniqueSystemFontForHint(
-    UChar32 hint) {
+static inline unsigned chooseHintIndex(const Vector<UChar32>& hintList) {
+  // crbug.com/618178 has a test case where no Myanmar font is ever found,
+  // because the run starts with a punctuation character with a script value of
+  // common. Our current font fallback code does not find a very meaningful
+  // result for this.
+  // TODO crbug.com/668706 - Improve this situation.
+  // So if we have multiple hint characters (which indicates that a
+  // multi-character grapheme or more failed to shape, then we can try to be
+  // smarter and select the first character that has an actual script value.
+  DCHECK(hintList.size());
+  if (hintList.size() <= 1)
+    return 0;
+
+  UErrorCode err = U_ZERO_ERROR;
+  UScriptCode hintCharScript = uscript_getScript(hintList[0], &err);
+  if (!U_SUCCESS(err) || hintCharScript > USCRIPT_INHERITED)
+    return 0;
+
+  for (size_t i = 1; i < hintList.size(); ++i) {
+    UScriptCode newHintScript = uscript_getScript(hintList[i], &err);
+    if (!U_SUCCESS(err))
+      return 0;
+    if (newHintScript > USCRIPT_INHERITED)
+      return i;
+  }
+  return 0;
+}
+
+PassRefPtr<SimpleFontData> FontFallbackIterator::uniqueSystemFontForHintList(
+    const Vector<UChar32>& hintList) {
   // When we're asked for a fallback for the same characters again, we give up
   // because the shaper must have previously tried shaping with the font
   // already.
-  if (!hint || m_previouslyAskedForHint.contains(hint))
+  if (!hintList.size())
     return nullptr;
 
   FontCache* fontCache = FontCache::fontCache();
+  UChar32 hint = hintList[chooseHintIndex(hintList)];
+
+  if (!hint || m_previouslyAskedForHint.contains(hint))
+    return nullptr;
   m_previouslyAskedForHint.add(hint);
   return fontCache->fallbackFontForCharacter(
       m_fontDescription, hint,
       m_fontFallbackList->primarySimpleFontData(m_fontDescription));
 }
 
 }  // namespace blink