marguerite · February 15, 2025 03:07 · marguerite · Feb 15, 2025 · marguerite · Feb 15, 2025
diff --git a/blink_font_stack_debug.patch b/blink_font_stack_debug.patch
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/core/css/css_font_selector.cc blink/renderer/core/css/css_font_selector.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/core/css/css_font_selector.cc	2025-02-15 09:43:10.732938782 +0800
 +++ blink/renderer/core/css/css_font_selector.cc	2025-02-15 09:50:27.682932708 +0800
 @@ -140,6 +140,7 @@
                                       .GetFrame()
                                       ->GetSettings()
                                       ->GetGenericFontFamilySettings();
 +  DVLOG(0) << "[CSSFontSelector::CSSFontSelector] call CSSFontSelector(&treescope) constructor";
   FontCache::Get().AddClient(this);
   if (tree_scope.RootNode().IsDocumentNode()) {
     font_face_cache_ = MakeGarbageCollected<FontFaceCache>();
 @@ -275,6 +276,10 @@
     return nullptr;
   }
 
 +  DVLOG(0) << "[CSSFontSelector::GetFontData] family_name: " << family_name;
 +  DVLOG(0) << "[CSSFontSelector::GetFontData] settings_family_name: " << settings_family_name;
 +  DVLOG(0) << "[CSSFontSelector::GetFontData] generic family: " << FontDescription::ToString(request_description.GenericFamily());
 +
   ReportFontFamilyLookupByGenericFamily(
       family_name, request_description.GetScript(),
       request_description.GenericFamily(), settings_family_name);
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/core/css/resolver/font_builder.cc blink/renderer/core/css/resolver/font_builder.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/core/css/resolver/font_builder.cc	2025-02-15 09:43:18.102826325 +0800
 +++ blink/renderer/core/css/resolver/font_builder.cc	2025-02-15 10:55:54.576872731 +0800
 @@ -35,6 +35,8 @@
 #include "third_party/blink/renderer/platform/font_family_names.h"
 #include "third_party/blink/renderer/platform/fonts/font_description.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 FontBuilder::FontBuilder(Document* document) : document_(document) {
 @@ -520,12 +522,16 @@
          tree_scope->GetDocument().IsSVGDocument());
   // TODO(crbug.com/336876): Font selector should be based on tree_scope for
   // tree-scoped references.
 +  Element* body_element = reinterpret_cast<Element*>(tree_scope->GetDocument().body());
 +  DVLOG(0) << "[FontBuilder::FontSelectorFromTreeScope] tree_scope outerHTML " << body_element->outerHTML();
 +  DVLOG(0) << "[FontBuilder::FontSelectorFromTreeScope] tree_scope innerHTML " << body_element->innerHTML();
   return document_->GetStyleEngine().GetFontSelector();
 }
 
 FontSelector* FontBuilder::ComputeFontSelector(
     const ComputedStyleBuilder& builder) {
   if (IsSet(PropertySetFlag::kFamily)) {
 +    DVLOG(0) << "[FontBuilder::ComputeFontSelector] FontSelectorFromTreeScope";
     return FontSelectorFromTreeScope(family_tree_scope_);
   } else {
     return builder.GetFont().GetFontSelector();
 @@ -550,6 +556,8 @@
   UpdateSpecifiedSize(description, parent_description);
   UpdateComputedSize(description, builder);
 
 +  DVLOG(0) << "[FontBuilder::CreateFont] FontDescription{family: " << description.Family().ToString() << ", computedsize: " << description.ComputedSize() << "}";
 +
   FontSelector* font_selector = ComputeFontSelector(builder);
   UpdateAdjustedSize(description, font_selector);
 
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_cache.cc blink/renderer/platform/fonts/font_cache.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_cache.cc	2025-02-15 09:45:37.880693566 +0800
 +++ blink/renderer/platform/fonts/font_cache.cc	2025-02-15 09:51:12.992228698 +0800
 @@ -62,6 +62,8 @@
 #include "third_party/skia/include/ports/SkTypeface_win.h"
 #endif
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 const char kColorEmojiLocale[] = "und-Zsye";
 @@ -83,6 +85,7 @@
 #endif  // BUILDFLAG(IS_WIN)
 
 FontCache& FontCache::Get() {
 +  DVLOG(0) << "running FontCache::Get()";
   return FontGlobalContext::GetFontCache();
 }
 
 @@ -129,6 +132,22 @@
 }
 #endif
 
 +const char* AlternateFontNameToString(AlternateFontName font_name_) {
 +  switch(font_name_) {
 +    case AlternateFontName::kAllowAlternate : return "kAllowAlternate";
 +    case AlternateFontName::kNoAlternate : return "kNoAlternate";
 +    case AlternateFontName::kLocalUniqueFace : return "kLocalUniqueFace";
 +    case AlternateFontName::kLastResort : return "kLastResort";
 +  }
 +}
 +
 +const char* FontFaceCreationTypeToString(FontFaceCreationType creation_type) {
 +  switch(creation_type) {
 +    case FontFaceCreationType::kCreateFontByFamily: return "kCreateFontByFamily";
 +    case FontFaceCreationType::kCreateFontByFciIdAndTtcIndex: return "kCreateFontByFciIdAndTtcIndex";
 +  }
 +}
 +
 FontPlatformData* FontCache::GetFontPlatformData(
     const FontDescription& font_description,
     const FontFaceCreationParams& creation_params,
 @@ -146,7 +165,17 @@
     return SystemFontPlatformData(font_description);
   }
 #endif
 -
 +  DVLOG(0) << "running FontCache::GetFontPlatformData()";
 +  DVLOG(0) << "[FontCache::GetFontPlatformData] font_description" << font_description.Family().ToString();
 +  DVLOG(0) << "[FontCache::GetFontPlatformData] creation_params creation_type " << FontFaceCreationTypeToString(creation_params.CreationType());
 +  if (creation_params.CreationType() == kCreateFontByFamily)
 +    DVLOG(0) << "[FontCache::GetFontPlatformData] creation_params family " << creation_params.Family();
 +  if (creation_params.CreationType() == kCreateFontByFciIdAndTtcIndex) {
 +    DVLOG(0) << "[FontCache::GetFontPlatformData] creation_params filename " << creation_params.Filename(); 
 +    DVLOG(0) << "[FontCache::GetFontPlatformData] creation_params FontconfigInterfaceId " << creation_params.FontconfigInterfaceId(); 
 +    DVLOG(0) << "[FontCache::GetFontPlatformData] creation_params TtcIndex " << creation_params.TtcIndex();
 +  }
 +  DVLOG(0) << "[FontCache::GetFontPlatformData] alternative_font_name " << AlternateFontNameToString(alternate_font_name);
   return font_platform_data_cache_->GetOrCreateFontPlatformData(
       this, font_description, creation_params, alternate_font_name);
 }
 @@ -212,6 +241,7 @@
     const AtomicString& family,
     AlternateFontName altername_font_name,
     ShouldRetain should_retain) {
 +  DVLOG(0) << "[FontCache::GetFontData] family " << family;
   if (FontPlatformData* platform_data = GetFontPlatformData(
           font_description,
           FontFaceCreationParams(
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_cache.h blink/renderer/platform/fonts/font_cache.h
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_cache.h	2025-02-15 09:45:41.570637260 +0800
 +++ blink/renderer/platform/fonts/font_cache.h	2025-02-15 09:51:16.475507895 +0800
 @@ -88,6 +88,8 @@
   kLastResort
 };
 
 +const char* AlternateFontNameToString(AlternateFontName);
 +
 typedef HashMap<FallbackListCompositeKey,
                 std::unique_ptr<NGShapeCache>,
                 FallbackListCompositeKeyTraits>
 @@ -106,6 +108,8 @@
 extern const char kNotoColorEmojiCompat[];
 #endif
 
 +const char* FontFaceCreationTypeToString(FontFaceCreationType creation_type);
 +
 class PLATFORM_EXPORT FontCache final {
   friend class FontCachePurgePreventer;
 
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font.cc blink/renderer/platform/fonts/font.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font.cc	2025-02-15 09:45:45.473911033 +0800
 +++ blink/renderer/platform/fonts/font.cc	2025-02-15 09:51:09.072289603 +0800
 @@ -46,6 +46,8 @@
 #include "third_party/skia/include/core/SkTextBlob.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 namespace {
 @@ -59,6 +61,9 @@
 scoped_refptr<FontFallbackList> GetOrCreateFontFallbackList(
     const FontDescription& font_description,
     FontSelector* font_selector) {
 +  DVLOG(0) << "running GetOrCreateFontFallbackList";
 +  DVLOG(0) << "calling GetFontFallbackMap(font_selector).Get(font_description)";
 +  DVLOG(0) << "[GetOrCreateFontFallbackList] font_description " << font_description.Family().ToString();
   return GetFontFallbackMap(font_selector).Get(font_description);
 }
 
 @@ -73,7 +78,10 @@
       font_fallback_list_(
           font_selector
               ? GetOrCreateFontFallbackList(font_description, font_selector)
 -              : nullptr) {}
 +              : nullptr) {
 +  if (font_selector)
 +    DVLOG(0) << "[Font(font_description, font_selector)] Font constructor called with font_selector " << &font_selector;
 +}
 
 Font::Font(const Font& other) = default;
 
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_iterator.cc blink/renderer/platform/fonts/font_fallback_iterator.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_iterator.cc	2025-02-15 09:45:54.160445151 +0800
 +++ blink/renderer/platform/fonts/font_fallback_iterator.cc	2025-02-15 09:51:40.825129531 +0800
 @@ -10,6 +10,9 @@
 #include "third_party/blink/renderer/platform/fonts/segmented_font_data.h"
 #include "third_party/blink/renderer/platform/fonts/simple_font_data.h"
 
 +#include "base/logging.h"
 +#include "unicode/unistr.h"
 +
 namespace blink {
 
 FontFallbackIterator::FontFallbackIterator(
 @@ -23,6 +26,18 @@
       fallback_stage_(kFontGroupFonts),
       font_fallback_priority_(font_fallback_priority) {}
 
 +const char* FallbackStageToString(FontFallbackIterator::FallbackStage font_fallback_stage) {
 +  switch(font_fallback_stage) {
 +    case FontFallbackIterator::FallbackStage::kFallbackPriorityFonts: return "kFallbackPriorityFonts";
 +    case FontFallbackIterator::FallbackStage::kFontGroupFonts: return "kFontGroupFonts";
 +    case FontFallbackIterator::FallbackStage::kSegmentedFace: return "kSegmentedFace";
 +    case FontFallbackIterator::FallbackStage::kPreferencesFonts: return "kPreferencesFonts";
 +    case FontFallbackIterator::FallbackStage::kSystemFonts: return "kSystemFonts";
 +    case FontFallbackIterator::FallbackStage::kFirstCandidateForNotdefGlyph: return "kFirstCandidateForNotdefGlyph";
 +    case FontFallbackIterator::FallbackStage::kOutOfLuck: return "kOutOfLuck"; 
 +  }
 +}
 +
 bool FontFallbackIterator::AlreadyLoadingRangeForHintChar(UChar32 hint_char) {
   for (auto* it = tracked_loading_range_sets_.begin();
        it != tracked_loading_range_sets_.end(); ++it) {
 @@ -106,12 +121,18 @@
 
 scoped_refptr<FontDataForRangeSet> FontFallbackIterator::Next(
     const Vector<UChar32>& hint_list) {
 +
 +  // our dlog test
 +  DVLOG(0) << "[FontFallbackIterator::Next] fallball_stage_: " << FallbackStageToString(fallback_stage_);
 +
   if (fallback_stage_ == kOutOfLuck)
     return base::AdoptRef(new FontDataForRangeSet());
 
   if (fallback_stage_ == kFallbackPriorityFonts) {
     // Only try one fallback priority font,
     // then proceed to regular system fallback.
 +
 +    DVLOG(0) << "[FontFallbackIterator::Next] FallbackPriorityFont";
     fallback_stage_ = kSystemFonts;
     scoped_refptr<FontDataForRangeSet> fallback_priority_font_range =
         base::AdoptRef(
 @@ -123,6 +144,12 @@
 
   if (fallback_stage_ == kSystemFonts) {
     // We've reached pref + system fallback.
 +
 +    DVLOG(0) << "[FontFallbackIterator::Next] UniqueSystemFontForHintList";
 +    std::string ustr;
 +    icu_72::UnicodeString::fromUTF32(reinterpret_cast<UChar32*>(hint_list[0]), hint_list.size()).toUTF8String(ustr);
 +    DVLOG(0) << "[FontFallbackIterator::Next] hint_list \"" << ustr << "\"";
 +
     scoped_refptr<SimpleFontData> system_font = UniqueSystemFontForHintList(hint_list);
     if (system_font) {
       // Fallback fonts are not retained in the FontDataCache.
 @@ -135,6 +162,10 @@
     // 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
     // LastResort font, not just Times or Arial.
 +
 +    DVLOG(0) << "[FontFallbackIterator::Next] GetLastResortFallbackFont";
 +    DVLOG(0) << "[FontFallbackIterator::Next] font_description_" << font_description_.Family().ToString();
 +
     FontCache& font_cache = FontCache::Get();
     fallback_stage_ = kFirstCandidateForNotdefGlyph;
     scoped_refptr<SimpleFontData> last_resort =
 @@ -152,6 +183,8 @@
   }
 
   if (fallback_stage_ == kFirstCandidateForNotdefGlyph) {
 +    DVLOG(0) << "[FontFallbackIterator::Next] kOutOfLuck";
 +    DVLOG(0) << "[FontFallbackIterator::Next] font_description_ " << font_description_.Family().ToString();
     fallback_stage_ = kOutOfLuck;
     if (!first_candidate_)
       FontCache::CrashWithFontInfo(&font_description_);
 @@ -160,6 +193,9 @@
 
   DCHECK(fallback_stage_ == kFontGroupFonts ||
          fallback_stage_ == kSegmentedFace);
 +  DVLOG(0) << "[FontFallbackIterator::Next] Running font_fallback_list_->FontDataAt";
 +  DVLOG(0) << "[FontFallbackIterator::Next] font_description_ " << font_description_.Family().ToString();
 +  DVLOG(0) << "[FontFallbackIterator::Next] current_font_data_index_(realized_font_index) " << current_font_data_index_;
   const FontData* font_data = font_fallback_list_->FontDataAt(
       font_description_, current_font_data_index_);
 
 @@ -176,6 +212,7 @@
   // Otherwise we've received a fontData from the font-family: set of fonts,
   // and a non-segmented one in this case.
   if (!font_data->IsSegmented()) {
 +    DVLOG(0) << "[FontFallbackIterator::Next] font_data is not segmented ";
     // Skip forward to the next font family for the next call to next().
     current_font_data_index_++;
     if (!font_data->IsLoading()) {
 @@ -191,6 +228,7 @@
   }
 
   // Iterate over ranges of a segmented font below.
 +  DVLOG(0) << "[FontFallbackIterator::Next] continue with segmented font processing";
 
   const auto* segmented = To<SegmentedFontData>(font_data);
   if (fallback_stage_ != kSegmentedFace) {
 @@ -226,6 +264,13 @@
 
 scoped_refptr<SimpleFontData> FontFallbackIterator::FallbackPriorityFont(
     UChar32 hint) {
 +  std::string ustr;
 +  icu_72::UnicodeString(hint).toUTF8String(ustr);
 +  DVLOG(0) << "[FontFallbackIterator::FallbackPriorityFont] FontCache::Get().FallbackFontForCharacter";
 +  DVLOG(0) << "[FontFallbackIterator::FallbackPriorityFont] font_description_ " << font_description_.Family().ToString();
 +  DVLOG(0) << "[FontFallbackIterator::FallbackPriorityFont] hint " << ustr;
 +  DVLOG(0) << "[FontFallbackIterator::FallbackPriorityFont] fallback_priority_ " << FontFallbackPriorityToString(font_fallback_priority_);
 +  DVLOG(0) << "[FontFallbackIterator::FallbackPriorityFont] font_fallback_list_->PrimarySimpleFontData(font_description_)" << font_fallback_list_->PrimarySimpleFontData(font_description_)->PlatformData().FontFamilyName();
   scoped_refptr<SimpleFontData> font_data =
       FontCache::Get().FallbackFontForCharacter(
           font_description_, hint,
 @@ -267,6 +312,10 @@
   if (!hint_list.size())
     return nullptr;
 
 +  std::string ustr;
 +  icu_72::UnicodeString::fromUTF32(reinterpret_cast<UChar32*>(hint_list[0]), hint_list.size()).toUTF8String(ustr);
 +  DVLOG(0) << "[FontFallbackIterator::UniqueSystemFontForHintList] FallbackFontForCharacter " << ustr;
 +
   FontCache& font_cache = FontCache::Get();
   UChar32 hint = hint_list[ChooseHintIndex(hint_list)];
 
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_iterator.h blink/renderer/platform/fonts/font_fallback_iterator.h
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_iterator.h	2025-02-15 09:46:04.606952416 +0800
 +++ blink/renderer/platform/fonts/font_fallback_iterator.h	2025-02-15 09:51:40.825129531 +0800
 @@ -45,6 +45,16 @@
   // fonts without passing in characters.
   scoped_refptr<FontDataForRangeSet> Next(const Vector<UChar32>& hint_list);
 
 +  enum FallbackStage {
 +    kFallbackPriorityFonts,
 +    kFontGroupFonts,
 +    kSegmentedFace,
 +    kPreferencesFonts,
 +    kSystemFonts,
 +    kFirstCandidateForNotdefGlyph,
 +    kOutOfLuck
 +  };
 +
  private:
   bool RangeSetContributesForHint(const Vector<UChar32>& hint_list,
                                   const FontDataForRangeSet*);
 @@ -64,16 +74,6 @@
   int current_font_data_index_;
   unsigned segmented_face_index_;
 
 -  enum FallbackStage {
 -    kFallbackPriorityFonts,
 -    kFontGroupFonts,
 -    kSegmentedFace,
 -    kPreferencesFonts,
 -    kSystemFonts,
 -    kFirstCandidateForNotdefGlyph,
 -    kOutOfLuck
 -  };
 -
   FallbackStage fallback_stage_;
   HashSet<UChar32> previously_asked_for_hint_;
   // FontFallbackIterator is meant for single use by HarfBuzzShaper,
 @@ -89,6 +89,7 @@
   FontFallbackPriority font_fallback_priority_;
 };
 
 +const char* FallbackStageToString(FontFallbackIterator::FallbackStage);
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_FONT_FALLBACK_ITERATOR_H_
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_list.cc blink/renderer/platform/fonts/font_fallback_list.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_list.cc	2025-02-15 09:45:59.590362297 +0800
 +++ blink/renderer/platform/fonts/font_fallback_list.cc	2025-02-15 09:51:45.328392881 +0800
 @@ -40,6 +40,8 @@
 #include "third_party/blink/renderer/platform/fonts/segmented_font_data.h"
 #include "third_party/blink/renderer/platform/wtf/text/character_names.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 FontFallbackList::FontFallbackList(FontFallbackMap& font_fallback_map)
 @@ -111,15 +113,20 @@
     if (!font_data) {
       // All fonts are custom fonts and are loading. Return the first FontData.
       font_data = FontDataAt(font_description, 0);
 -      if (font_data)
 +      if (font_data) {
 +				DVLOG(0) << "[FontFallbackList::DeterminePrimarySimpleFontDataCore] FontDataForCharacter " << const_cast<SimpleFontData*>(To<SimpleFontData>(font_data))->PlatformData().FontFamilyName();
         return font_data->FontDataForCharacter(kSpaceCharacter);
 +      }
 
       FontCache& font_cache = FontCache::Get();
       SimpleFontData* last_resort_fallback =
           font_cache.GetLastResortFallbackFont(font_description).get();
       DCHECK(last_resort_fallback);
 +			DVLOG(0) << "[FontFallbackList::DeterminePrimarySimpleFontDataCore] GetLastResortFallbackFont " << last_resort_fallback->PlatformData().FontFamilyName();
       return last_resort_fallback;
     }
 +		
 +		DVLOG(0) << "[FontFallbackList::DeterminePrimarySimpleFontDataCore] SegmentedFontData processing";
 
     const auto* segmented = DynamicTo<SegmentedFontData>(font_data);
     if (segmented && !segmented->ContainsCharacter(kSpaceCharacter))
 @@ -132,15 +139,19 @@
     // When a custom font is loading, we should use the correct fallback font to
     // layout the text.  Here skip the temporary font for the loading custom
     // font which may not act as the correct fallback font.
 -    if (!font_data_for_space->IsLoadingFallback())
 +    if (!font_data_for_space->IsLoadingFallback()) {
 +      DVLOG(0) << "[FontFallbackList::DeterminePrimarySimpleFontDataCore] font_data_for_space " << font_data_for_space->PlatformData().FontFamilyName();
       return font_data_for_space;
 +    }
 
     if (segmented) {
       for (unsigned i = 0; i < segmented->NumFaces(); i++) {
         const SimpleFontData* range_font_data =
             segmented->FaceAt(i)->FontData();
 -        if (!range_font_data->IsLoadingFallback())
 +        if (!range_font_data->IsLoadingFallback()) {
 +          DVLOG(0) << "[FontFallbackList::DeterminePrimarySimpleFontDataCore] segmented->FaceAt(" << i << ")->FontData() " << range_font_data->PlatformData().FontFamilyName();
           return range_font_data;
 +        }
       }
       if (font_data->IsLoading())
         should_load_custom_font = false;
 @@ -161,10 +172,13 @@
     curr_family = curr_family->Next();
 
   for (; curr_family; curr_family = curr_family->Next()) {
 +    DVLOG(0) << "[FontFallbackList::GetFontData] curr_family " << curr_family->FamilyName();
     family_index_++;
     if (!GetFontSelector()) {
 +      DVLOG(0) << "[FontFallbackList::GetFontData] GetFontSelector returns non-nullptr";
       // Don't query system fonts for empty font family name.
       if (!curr_family->FamilyName().empty()) {
 +        DVLOG(0) << "[FontFallbackList::GetFontData] running FontCache::Get().GetFontData(), font_description" << font_description.Family().ToString() << ", family_name" << curr_family->FamilyName();
         if (auto result = FontCache::Get().GetFontData(
                 font_description, curr_family->FamilyName())) {
           return result;
 @@ -173,10 +187,12 @@
       continue;
     }
 
 +    DVLOG(0) << "[FontFallbackList::GetFontData] running font_selector_.GetFontData(), font_description" << font_description.Family().ToString() << ", family_name" << curr_family->FamilyName();
     scoped_refptr<FontData> result =
         GetFontSelector()->GetFontData(font_description, *curr_family);
     // Don't query system fonts for empty font family name.
     if (!result && !curr_family->FamilyName().empty()) {
 +      DVLOG(0) << "[FontFallbackList::GetFontData] running FontCache::Get().GetFontData(), font_description" << font_description.Family().ToString() << ", family_name" << curr_family->FamilyName();
       result = FontCache::Get().GetFontData(font_description,
                                             curr_family->FamilyName());
       GetFontSelector()->ReportFontLookupByUniqueOrFamilyName(
 @@ -195,6 +211,7 @@
 
   if (GetFontSelector()) {
     // Try the user's preferred standard font.
 +    DVLOG(0) << "[FontFallbackList::GetFontData] try the user's preferred standard font";
     FontFamily font_family;
     font_family.SetFamily(font_family_names::kWebkitStandard,
                           FontFamily::Type::kGenericFamily);
 @@ -204,6 +221,7 @@
   }
 
   // Still no result. Hand back our last resort fallback font.
 +  DVLOG(0) << "[FontFallbackList::GetFontData] FontCache::Get().GetLastResortFallbackFont, font_description" << font_description.Family().ToString();
   auto last_resort =
       FontCache::Get().GetLastResortFallbackFont(font_description);
   if (GetFontSelector()) {
 @@ -251,8 +269,12 @@
     const FontDescription& font_description,
     unsigned realized_font_index) {
   // This fallback font is already in our list.
 -  if (realized_font_index < font_list_.size())
 +  if (realized_font_index < font_list_.size()) {
 +    DVLOG(0) << "[FontFallbackList::FontDataAt] This fallback font is already in our list: ";
 +    DVLOG(0) << "[FontFallbackList::FontDataAt] realized_font_index of font_list_ size (" << realized_font_index << "/" << font_list_.size() << ")";
 +    DVLOG(0) << "[FontFallbackList::FontDataAt] the result FontData: " << const_cast<SimpleFontData*>(To<SimpleFontData>(font_list_[realized_font_index].get()))->PlatformData().FontFamilyName();
     return font_list_[realized_font_index].get();
 +  }
 
   // Make sure we're not passing in some crazy value here.
   DCHECK_EQ(realized_font_index, font_list_.size());
 @@ -266,13 +288,19 @@
   // the same spot in the list twice.  GetFontData will adjust our
   // |family_index_| as it scans for the right font to make.
   DCHECK_EQ(FontCache::Get().Generation(), generation_);
 +  DVLOG(0) << "[FontFallbackList::FontDataAt] Running GetFontData, font_description" << font_description.Family().ToString() << ", realized_font_index " << realized_font_index;
   scoped_refptr<FontData> result = GetFontData(font_description);
   if (result) {
 +    DVLOG(0) << "[FontFallbackList::FontDataAt] Got result";
     font_list_.push_back(result);
 -    if (result->IsLoadingFallback())
 +    if (result->IsLoadingFallback()) {
 +      DVLOG(0) << "[FontFallbackList::FontDataAt] result->IsLoadingFallback is true";
       has_loading_fallback_ = true;
 -    if (result->IsCustomFont())
 +    }
 +    if (result->IsCustomFont()) {
 +      DVLOG(0) << "[FontFallbackList::FontDataAt] result->IsCustomFont is true";
       has_custom_font_ = true;
 +    }
   }
   return result.get();
 }
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_map.cc blink/renderer/platform/fonts/font_fallback_map.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_map.cc	2025-02-15 09:46:08.493559777 +0800
 +++ blink/renderer/platform/fonts/font_fallback_map.cc	2025-02-15 09:51:57.578202518 +0800
 @@ -6,6 +6,8 @@
 
 #include "third_party/blink/renderer/platform/fonts/font_selector.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 void FontFallbackMap::Trace(Visitor* visitor) const {
 @@ -23,8 +25,10 @@
   auto iter = fallback_list_for_description_.find(font_description);
   if (iter != fallback_list_for_description_.end()) {
     DCHECK(iter->value->IsValid());
 +    DVLOG(0) << "[FontFallbackMap::Get] found existing FontFallbacklist in fallback_list_for_description_";
     return iter->value;
   }
 +  DVLOG(0) << "[FontFallbackMap::Get] running FontFallbacklist::Create(*this fontfallbackmap)";
   auto add_result = fallback_list_for_description_.insert(
       font_description, FontFallbackList::Create(*this));
   return add_result.stored_value->value;
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_priority.cc blink/renderer/platform/fonts/font_fallback_priority.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_priority.cc	2025-02-15 09:46:12.900159205 +0800
 +++ blink/renderer/platform/fonts/font_fallback_priority.cc	2025-02-15 09:52:01.294811430 +0800
 @@ -11,4 +11,13 @@
          fallback_priority == FontFallbackPriority::kEmojiEmoji;
 }
 
 +const char* FontFallbackPriorityToString(FontFallbackPriority fallback_priority) {
 +  switch(fallback_priority) {
 +    case FontFallbackPriority::kText: return "kText";
 +    case FontFallbackPriority::kEmojiText: return "kEmojiText";
 +    case FontFallbackPriority::kEmojiEmoji: return "kEmojiEmoji";
 +    case FontFallbackPriority::kInvalid: return "kInvalid";
 +  }
 +}
 +
 }  // namespace blink
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_priority.h blink/renderer/platform/fonts/font_fallback_priority.h
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_fallback_priority.h	2025-02-15 09:46:17.406757105 +0800
 +++ blink/renderer/platform/fonts/font_fallback_priority.h	2025-02-15 09:52:01.294811430 +0800
 @@ -22,6 +22,8 @@
   kInvalid
 };
 
 +const char* FontFallbackPriorityToString(FontFallbackPriority);
 +
 bool IsNonTextFallbackPriority(FontFallbackPriority);
 
 }  // namespace blink
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_platform_data_cache.cc blink/renderer/platform/fonts/font_platform_data_cache.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/font_platform_data_cache.cc	2025-02-15 09:46:21.400029505 +0800
 +++ blink/renderer/platform/fonts/font_platform_data_cache.cc	2025-02-15 09:52:14.317942383 +0800
 @@ -36,6 +36,8 @@
 #include "third_party/blink/renderer/platform/fonts/font_cache.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 namespace {
 @@ -70,6 +72,8 @@
                                                is_generic_family);
   DCHECK(!key.IsHashTableDeletedValue());
 
 +  DVLOG(0) << "[FontPlatformDataCache::GetOrCreateFontPlatformData] FontCacheKey hash " << key.GetHash();
 +
   if (no_size_in_key_) {
     // Clear font size from they key. Size is not required in the primary key
     // because per-size FontPlatformData are held in a nested map.
 @@ -81,6 +85,9 @@
 
   const unsigned rounded_size = size * FontCacheKey::PrecisionMultiplier();
 
 +  DVLOG(0) << "[FontPlatformDataCache::GetOrCreateFontPlatformData] font-size " << size;
 +  DVLOG(0) << "[FontPlatformDataCache::GetOrCreateFontPlatformData] rounded_size " << rounded_size;
 +
   // Assert that the computed hash map key rounded_size value does not hit
   // the empty (max()) or deleted (max()-1) sentinel values of the hash map,
   // compare IntWithZeroKeyHashTraits() in hash_traits.h.
 @@ -186,6 +193,7 @@
     return found->get();
 
   if (!another_size) {
 +		DVLOG(0) << "[FontPlatformDataCache::SizedFontPlatformDataSet::GetOrCreateFontPlatformData] running font_cache->CreateFontPlatformData";
     *found = font_cache->CreateFontPlatformData(
         font_description, creation_params, size, alternate_font_name);
     return found->get();
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/linux/font_cache_linux.cc blink/renderer/platform/fonts/linux/font_cache_linux.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/linux/font_cache_linux.cc	2025-02-15 09:47:34.008921611 +0800
 +++ blink/renderer/platform/fonts/linux/font_cache_linux.cc	2025-02-15 09:52:25.051108908 +0800
 @@ -31,6 +31,8 @@
 #include "third_party/blink/renderer/platform/fonts/simple_font_data.h"
 #include "ui/gfx/font_fallback_linux.h"
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 static AtomicString& MutableSystemFontFamily() {
 @@ -76,8 +78,11 @@
   if (font_manager_) {
     AtomicString family_name = GetFamilyNameForCharacter(
         font_manager_.get(), c, font_description, nullptr, fallback_priority);
 -    if (family_name.empty())
 +    DVLOG(0) << "[FontCache::PlatformFallbackFontForCharacter] GetFamilyNameForCharacter " << family_name;
 +    if (family_name.empty()) {
 +      DVLOG(0) << "[FontCache::PlatformFallbackFontForCharacter] GetLastResortFallbackFont";
       return GetLastResortFallbackFont(font_description, kDoNotRetain);
 +    }
     return FontDataFromFontPlatformData(
         GetFontPlatformData(font_description,
                             FontFaceCreationParams(family_name)),
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/shaping/harfbuzz_shaper.cc blink/renderer/platform/fonts/shaping/harfbuzz_shaper.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/shaping/harfbuzz_shaper.cc	2025-02-15 09:47:55.731923482 +0800
 +++ blink/renderer/platform/fonts/shaping/harfbuzz_shaper.cc	2025-02-15 09:52:35.587611886 +0800
 @@ -33,6 +33,7 @@
 
 #include <hb.h>
 #include <unicode/uchar.h>
 +#include <unicode/unistr.h>
 #include <unicode/uscript.h>
 #include <algorithm>
 #include <hb-cplusplus.hh>
 @@ -749,6 +750,10 @@
       font_description.VariantCaps() != FontDescription::kCapsNormal;
   OpenTypeCapsSupport caps_support;
 
 +  // our dvlog test
 +  DVLOG(0) << "[HarfBuzzShaper::ShapeSegment] font_description: " << font_description.Family().ToString();
 +  DVLOG(0) << "[HarfBuzzShaper::ShapeSegment] font_fallback_priority: " << FontFallbackPriorityToString(segment.font_fallback_priority);
 +
   FontFallbackIterator fallback_iterator(
       font->CreateFontFallbackIterator(segment.font_fallback_priority));
 
 @@ -779,6 +784,11 @@
         break;
       }
 
 +      // our dvlog test
 +      std::string ustr;
 +      icu_72::UnicodeString::fromUTF32(reinterpret_cast<UChar32*>(&fallback_chars_hint[0]), fallback_chars_hint.size()).toUTF8String(ustr);
 +      DVLOG(0) << "[HarfbuzzShaper::ShapeSegment] fallback_chars_hint: \"" << ustr << "\"";
 +
       current_font_data_for_range_set =
           fallback_iterator.Next(fallback_chars_hint);
       if (!current_font_data_for_range_set->FontData()) {
 diff -urN blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/skia/font_cache_skia.cc blink/renderer/platform/fonts/skia/font_cache_skia.cc
 --- blink-ada7d6231602a093e52abc3340cc697674c9fae9.orig/renderer/platform/fonts/skia/font_cache_skia.cc	2025-02-15 09:47:43.525443067 +0800
 +++ blink/renderer/platform/fonts/skia/font_cache_skia.cc	2025-02-15 09:52:45.147463359 +0800
 @@ -58,6 +58,8 @@
 #error This file should not be used by MacOS.
 #endif
 
 +#include "base/logging.h"
 +
 namespace blink {
 
 AtomicString ToAtomicString(const SkString& str) {
 @@ -120,9 +122,26 @@
   return nullptr;
 }
 
 +/*
 +const char* GenericFallbackFontFamilyToString(inline const AtomicString& family_) {
 +  switch(family_) {
 +    case FontDescription::kSansSerifFamily: return "kSansSerif";
 +    case FontDescription::kSerifFamily: return "kSerif";
 +    case FontDescription::kMonospaceFamily: return "kMonospace";
 +    case FontDescription::kCursiveFamily: return "kCursive";
 +    case FontDescription::kFantasyFamily: return "kFantasy";
 +    default: return "g_empty_atom(System Defaul)";
 +  }  
 +}
 +*/
 +
 scoped_refptr<SimpleFontData> FontCache::GetLastResortFallbackFont(
     const FontDescription& description,
     ShouldRetain should_retain) {
 +
 +  DVLOG(0) << "[FontCache::GetLastResortFallbackFont] description " << description.Family().ToString();
 +
 +  DVLOG(0) << "[FontCache::GetLastResortFallbackFont] GetFallbackFontFamily(description)" <<  GetFallbackFontFamily(description);
   const FontFaceCreationParams fallback_creation_params(
       GetFallbackFontFamily(description));
   const FontPlatformData* font_platform_data = GetFontPlatformData(
 @@ -131,6 +150,7 @@
   // We should at least have Sans or Arial which is the last resort fallback of
   // SkFontHost ports.
   if (!font_platform_data) {
 +    DVLOG(0) << "[FontCache::GetLastResortFallbackFont] Testing Sans";
     DEFINE_THREAD_SAFE_STATIC_LOCAL(const FontFaceCreationParams,
                                     sans_creation_params,
                                     (font_family_names::kSans));
 @@ -138,6 +158,7 @@
                                              AlternateFontName::kLastResort);
   }
   if (!font_platform_data) {
 +    DVLOG(0) << "[FontCache::GetLastResortFallbackFont] Testing Arial";
     DEFINE_THREAD_SAFE_STATIC_LOCAL(const FontFaceCreationParams,
                                     arial_creation_params,
                                     (font_family_names::kArial));
 @@ -206,6 +227,7 @@
   // TODO(fuchsia): Revisit this and other font code for Fuchsia.
 
   if (creation_params.CreationType() == kCreateFontByFciIdAndTtcIndex) {
 +		DVLOG(0) << "[FontCache::CreateTypeface] creation_params.CreationType() is kCreateFontByFciIdAndTtcIndex";
     if (Platform::Current()->GetSandboxSupport()) {
       return SkTypeface_Factory::FromFontConfigInterfaceIdAndTtcIndex(
           creation_params.FontconfigInterfaceId(), creation_params.TtcIndex());
 @@ -232,7 +254,16 @@
 
   // TODO(https://crbug.com/1425390: Assign FontCache::font_manager_ in the
   // ctor.
 +	if (font_manager_) {
 +		DVLOG(0) << "[FontCache::CreateTypeface] existing font_manager_";
 +  } else {
 +  	DVLOG(0) << "[FontCache::CreateTypeface] initializing new SkFontMgr::RefDefault()";
 +  }
   auto font_manager = font_manager_ ? font_manager_ : SkFontMgr::RefDefault();
 +	DVLOG(0) << "[FontCache::CreateTypeface] font_manager->matchFamilyStyle";
 +	if (!name.empty())
 +		DVLOG(0) << "[FontCache::CreateTypeface] name.c_str() " << name.c_str();
 +  DVLOG(0) << "[FontCache::CreateTypeface] font_description.SkiaFontStyle(width: " << font_description.SkiaFontStyle().width() << ", weight: " << font_description.SkiaFontStyle().weight() << ", slant: " << font_description.SkiaFontStyle().slant() << ")";
   return sk_sp<SkTypeface>(font_manager->matchFamilyStyle(
       name.empty() ? nullptr : name.c_str(), font_description.SkiaFontStyle()));
 }
 @@ -264,14 +295,28 @@
        noto_color_emoji_from_gmscore)) {
     typeface = CreateTypefaceFromUniqueName(creation_params);
   } else {
 +    DVLOG(0) << "[FontCache::CreateFontPlatformData] CreateTypeface(font_description, creation_params, name)";
 +		DVLOG(0) << "[FontCache::CreateFontPlatformData] font_description " << font_description.Family().ToString();
 +    DVLOG(0) << "[FontCache::CreateFontPlatformData] creation_params creation_type " << FontFaceCreationTypeToString(creation_params.CreationType());
 +    if (creation_params.CreationType() == kCreateFontByFamily)
 +      DVLOG(0) << "[FontCache::CreateFontPlatformData] creation_params family " << creation_params.Family();
 +    if (creation_params.CreationType() == kCreateFontByFciIdAndTtcIndex) {
 +      DVLOG(0) << "[FontCache::CreateFontPlatformData] creation_params filename " << creation_params.Filename(); 
 +      DVLOG(0) << "[FontCache::CreateFontPlatformData] creation_params FontconfigInterfaceId " << creation_params.FontconfigInterfaceId(); 
 +      DVLOG(0) << "[FontCache::CreateFontPlatformData] creation_params TtcIndex " << creation_params.TtcIndex();
 +    }
 +		if (!name.empty())
 +			DVLOG(0) << "[FontCache::CreateFontPlatformData] name " << name;
     typeface = CreateTypeface(font_description, creation_params, name);
   }
 #else
   typeface = CreateTypeface(font_description, creation_params, name);
 #endif
 
 -  if (!typeface)
 +  if (!typeface) {
 +    DVLOG(0) << "[FontCache::CreateFontPlatformData] NULL typeface " << name;
     return nullptr;
 +  }
 
   bool synthetic_bold =
       (font_description.Weight() >
 @@ -293,6 +338,17 @@
                 ->GetResolvedFontFeatures()
           : ResolvedFontFeatures();
 
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] std::make_unique<FontPlatformData> name " << name;
 +  SkString typeface_family_name_;
 +  typeface->getFamilyName(&typeface_family_name_);
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] typeface getFamilyName() " << typeface_family_name_.c_str();
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] font_size " << font_size;
 +  int is_synthetic_bold = synthetic_bold ? 1 : 0;
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] synthetic_bold " << is_synthetic_bold;
 +  int is_synthetic_italic = synthetic_italic ? 1 : 0;
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] synthetic_italic " << is_synthetic_italic;
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] text_rendering " << ToString(font_description.TextRendering());
 +
   std::unique_ptr<FontPlatformData> font_platform_data =
       std::make_unique<FontPlatformData>(
           typeface, name, font_size, synthetic_bold, synthetic_italic,
 @@ -302,6 +358,7 @@
   font_platform_data->SetAvoidEmbeddedBitmaps(
       BitmapGlyphsBlockList::ShouldAvoidEmbeddedBitmapsForTypeface(*typeface));
 
 +  DVLOG(0) << "[FontCache::CreateFontPlatformData] font_platform_data.FontFamilyName() " << font_platform_data->FontFamilyName();
   return font_platform_data;
 }
 #endif  // !BUILDFLAG(IS_WIN)