diff --git a/core/fxge/android/cfpf_skiafontmgr.cpp b/core/fxge/android/cfpf_skiafontmgr.cpp
index 0da444d..7c88f48 100644
--- a/core/fxge/android/cfpf_skiafontmgr.cpp
+++ b/core/fxge/android/cfpf_skiafontmgr.cpp
@@ -24,17 +24,17 @@
 
 namespace {
 
-constexpr int FPF_SKIAMATCHWEIGHT_NAME1 = 62;
-constexpr int FPF_SKIAMATCHWEIGHT_NAME2 = 60;
-constexpr int FPF_SKIAMATCHWEIGHT_1 = 16;
-constexpr int FPF_SKIAMATCHWEIGHT_2 = 8;
+constexpr int kSkiaMatchNameWeight = 62;
+constexpr int kSkiaMatchSystemNameWeight = 60;
+constexpr int kSkiaMatchSerifStyleWeight = 16;
+constexpr int kSkiaMatchScriptStyleWeight = 8;
 
-struct FPF_SKIAFONTMAP {
-  uint32_t dwFamily;
-  uint32_t dwSubSt;
+struct SkiaFontMap {
+  uint32_t family;
+  uint32_t subst;
 };
 
-const FPF_SKIAFONTMAP kSkiaFontmap[] = {
+const SkiaFontMap kSkiaFontmap[] = {
     {0x58c5083, 0xc8d2e345},  {0x5dfade2, 0xe1633081},
     {0x684317d, 0xe1633081},  {0x14ee2d13, 0xc8d2e345},
     {0x3918fe2d, 0xbbeeec72}, {0x3b98b31c, 0xe1633081},
@@ -48,133 +48,136 @@
     {0xfb4ce0de, 0xe1633081},
 };
 
-const FPF_SKIAFONTMAP kSkiaSansFontMap[] = {
+const SkiaFontMap kSkiaSansFontMap[] = {
     {0x58c5083, 0xd5b8d10f},  {0x14ee2d13, 0xd5b8d10f},
     {0x779ce19d, 0xd5b8d10f}, {0xcb7a04c8, 0xd5b8d10f},
     {0xfb4ce0de, 0xd5b8d10f},
 };
 
-uint32_t FPF_SkiaGetSubstFont(uint32_t dwHash,
-                              pdfium::span<const FPF_SKIAFONTMAP> skFontMap) {
-  const FPF_SKIAFONTMAP* pFontMap =
-      std::lower_bound(skFontMap.begin(), skFontMap.end(), dwHash,
-                       [](const FPF_SKIAFONTMAP& item, uint32_t hash) {
-                         return item.dwFamily < hash;
+uint32_t SkiaGetSubstFont(uint32_t hash,
+                          pdfium::span<const SkiaFontMap> font_map) {
+  const SkiaFontMap* it =
+      std::lower_bound(font_map.begin(), font_map.end(), hash,
+                       [](const SkiaFontMap& item, uint32_t hash) {
+                         return item.family < hash;
                        });
-  if (pFontMap != skFontMap.end() && pFontMap->dwFamily == dwHash) {
-    return pFontMap->dwSubSt;
+  if (it != font_map.end() && it->family == hash) {
+    return it->subst;
   }
   return 0;
 }
 
-enum FPF_SKIACHARSET {
-  FPF_SKIACHARSET_Ansi = 1 << 0,
-  FPF_SKIACHARSET_Default = 1 << 1,
-  FPF_SKIACHARSET_Symbol = 1 << 2,
-  FPF_SKIACHARSET_ShiftJIS = 1 << 3,
-  FPF_SKIACHARSET_Korean = 1 << 4,
-  FPF_SKIACHARSET_Johab = 1 << 5,
-  FPF_SKIACHARSET_GB2312 = 1 << 6,
-  FPF_SKIACHARSET_BIG5 = 1 << 7,
-  FPF_SKIACHARSET_Greek = 1 << 8,
-  FPF_SKIACHARSET_Turkish = 1 << 9,
-  FPF_SKIACHARSET_Vietnamese = 1 << 10,
-  FPF_SKIACHARSET_Hebrew = 1 << 11,
-  FPF_SKIACHARSET_Arabic = 1 << 12,
-  FPF_SKIACHARSET_Baltic = 1 << 13,
-  FPF_SKIACHARSET_Cyrillic = 1 << 14,
-  FPF_SKIACHARSET_Thai = 1 << 15,
-  FPF_SKIACHARSET_EeasternEuropean = 1 << 16,
-  FPF_SKIACHARSET_PC = 1 << 17,
-  FPF_SKIACHARSET_OEM = 1 << 18,
+enum SKIACHARSET {
+  SKIACHARSET_Ansi = 1 << 0,
+  SKIACHARSET_Default = 1 << 1,
+  SKIACHARSET_Symbol = 1 << 2,
+  SKIACHARSET_ShiftJIS = 1 << 3,
+  SKIACHARSET_Korean = 1 << 4,
+  SKIACHARSET_Johab = 1 << 5,
+  SKIACHARSET_GB2312 = 1 << 6,
+  SKIACHARSET_BIG5 = 1 << 7,
+  SKIACHARSET_Greek = 1 << 8,
+  SKIACHARSET_Turkish = 1 << 9,
+  SKIACHARSET_Vietnamese = 1 << 10,
+  SKIACHARSET_Hebrew = 1 << 11,
+  SKIACHARSET_Arabic = 1 << 12,
+  SKIACHARSET_Baltic = 1 << 13,
+  SKIACHARSET_Cyrillic = 1 << 14,
+  SKIACHARSET_Thai = 1 << 15,
+  SKIACHARSET_EeasternEuropean = 1 << 16,
+  SKIACHARSET_PC = 1 << 17,
+  SKIACHARSET_OEM = 1 << 18,
 };
 
-uint32_t FPF_SkiaGetCharset(FX_Charset uCharset) {
-  switch (uCharset) {
+uint32_t SkiaGetCharset(FX_Charset charset) {
+  switch (charset) {
     case FX_Charset::kANSI:
-      return FPF_SKIACHARSET_Ansi;
+      return SKIACHARSET_Ansi;
     case FX_Charset::kDefault:
-      return FPF_SKIACHARSET_Default;
+      return SKIACHARSET_Default;
     case FX_Charset::kSymbol:
-      return FPF_SKIACHARSET_Symbol;
+      return SKIACHARSET_Symbol;
     case FX_Charset::kShiftJIS:
-      return FPF_SKIACHARSET_ShiftJIS;
+      return SKIACHARSET_ShiftJIS;
     case FX_Charset::kHangul:
-      return FPF_SKIACHARSET_Korean;
+      return SKIACHARSET_Korean;
     case FX_Charset::kChineseSimplified:
-      return FPF_SKIACHARSET_GB2312;
+      return SKIACHARSET_GB2312;
     case FX_Charset::kChineseTraditional:
-      return FPF_SKIACHARSET_BIG5;
+      return SKIACHARSET_BIG5;
     case FX_Charset::kMSWin_Greek:
-      return FPF_SKIACHARSET_Greek;
+      return SKIACHARSET_Greek;
     case FX_Charset::kMSWin_Turkish:
-      return FPF_SKIACHARSET_Turkish;
+      return SKIACHARSET_Turkish;
     case FX_Charset::kMSWin_Hebrew:
-      return FPF_SKIACHARSET_Hebrew;
+      return SKIACHARSET_Hebrew;
     case FX_Charset::kMSWin_Arabic:
-      return FPF_SKIACHARSET_Arabic;
+      return SKIACHARSET_Arabic;
     case FX_Charset::kMSWin_Baltic:
-      return FPF_SKIACHARSET_Baltic;
+      return SKIACHARSET_Baltic;
     case FX_Charset::kMSWin_Cyrillic:
-      return FPF_SKIACHARSET_Cyrillic;
+      return SKIACHARSET_Cyrillic;
     case FX_Charset::kThai:
-      return FPF_SKIACHARSET_Thai;
+      return SKIACHARSET_Thai;
     case FX_Charset::kMSWin_EasternEuropean:
-      return FPF_SKIACHARSET_EeasternEuropean;
+      return SKIACHARSET_EeasternEuropean;
     default:
-      return FPF_SKIACHARSET_Default;
+      return SKIACHARSET_Default;
   }
 }
 
-uint32_t FPF_SKIANormalizeFontName(ByteStringView bsFamily) {
-  uint32_t uHashCode = 0;
-  for (unsigned char ch : bsFamily) {
+uint32_t SkiaNormalizeFontName(ByteStringView family) {
+  uint32_t hash_code = 0;
+  for (unsigned char ch : family) {
     if (ch == ' ' || ch == '-' || ch == ',')
       continue;
-    uHashCode = 31 * uHashCode + tolower(ch);
+    hash_code = 31 * hash_code + tolower(ch);
   }
-  return uHashCode;
+  return hash_code;
 }
 
-uint32_t FPF_SKIAGetFamilyHash(ByteStringView bsFamily,
-                               uint32_t dwStyle,
-                               FX_Charset uCharset) {
-  ByteString bsFont(bsFamily);
-  if (FontStyleIsForceBold(dwStyle))
-    bsFont += "Bold";
-  if (FontStyleIsItalic(dwStyle))
-    bsFont += "Italic";
-  if (FontStyleIsSerif(dwStyle))
-    bsFont += "Serif";
-  bsFont += static_cast<uint8_t>(uCharset);
-  return FX_HashCode_GetA(bsFont.AsStringView());
+uint32_t GetFamilyHash(ByteStringView family,
+                       uint32_t style,
+                       FX_Charset charset) {
+  ByteString font(family);
+  if (FontStyleIsForceBold(style)) {
+    font += "Bold";
+  }
+  if (FontStyleIsItalic(style)) {
+    font += "Italic";
+  }
+  if (FontStyleIsSerif(style)) {
+    font += "Serif";
+  }
+  font += static_cast<uint8_t>(charset);
+  return FX_HashCode_GetA(font.AsStringView());
 }
 
-bool FPF_SkiaIsCJK(FX_Charset uCharset) {
-  return FX_CharSetIsCJK(uCharset);
+bool SkiaIsCJK(FX_Charset charset) {
+  return FX_CharSetIsCJK(charset);
 }
 
-bool FPF_SkiaMaybeSymbol(ByteStringView bsFacename) {
-  ByteString bsName(bsFacename);
-  bsName.MakeLower();
-  return bsName.Contains("symbol");
+bool SkiaMaybeSymbol(ByteStringView facename) {
+  ByteString name(facename);
+  name.MakeLower();
+  return name.Contains("symbol");
 }
 
-bool FPF_SkiaMaybeArabic(ByteStringView bsFacename) {
-  ByteString bsName(bsFacename);
-  bsName.MakeLower();
-  return bsName.Contains("arabic");
+bool SkiaMaybeArabic(ByteStringView facename) {
+  ByteString name(facename);
+  name.MakeLower();
+  return name.Contains("arabic");
 }
 
 constexpr auto kFPFSkiaFontCharsets = fxcrt::ToArray<const uint32_t>({
-    FPF_SKIACHARSET_Ansi,
-    FPF_SKIACHARSET_EeasternEuropean,
-    FPF_SKIACHARSET_Cyrillic,
-    FPF_SKIACHARSET_Greek,
-    FPF_SKIACHARSET_Turkish,
-    FPF_SKIACHARSET_Hebrew,
-    FPF_SKIACHARSET_Arabic,
-    FPF_SKIACHARSET_Baltic,
+    SKIACHARSET_Ansi,
+    SKIACHARSET_EeasternEuropean,
+    SKIACHARSET_Cyrillic,
+    SKIACHARSET_Greek,
+    SKIACHARSET_Turkish,
+    SKIACHARSET_Hebrew,
+    SKIACHARSET_Arabic,
+    SKIACHARSET_Baltic,
     0,
     0,
     0,
@@ -183,12 +186,12 @@
     0,
     0,
     0,
-    FPF_SKIACHARSET_Thai,
-    FPF_SKIACHARSET_ShiftJIS,
-    FPF_SKIACHARSET_GB2312,
-    FPF_SKIACHARSET_Korean,
-    FPF_SKIACHARSET_BIG5,
-    FPF_SKIACHARSET_Johab,
+    SKIACHARSET_Thai,
+    SKIACHARSET_ShiftJIS,
+    SKIACHARSET_GB2312,
+    SKIACHARSET_Korean,
+    SKIACHARSET_BIG5,
+    SKIACHARSET_Johab,
     0,
     0,
     0,
@@ -197,11 +200,11 @@
     0,
     0,
     0,
-    FPF_SKIACHARSET_OEM,
-    FPF_SKIACHARSET_Symbol,
+    SKIACHARSET_OEM,
+    SKIACHARSET_Symbol,
 });
 
-uint32_t FPF_SkiaGetFaceCharset(uint32_t code_range) {
+uint32_t SkiaGetFaceCharset(uint32_t code_range) {
   uint32_t charset = 0;
   for (int32_t i = 0; i < 32; i++) {
     if (code_range & (1 << i)) {
@@ -215,123 +218,134 @@
 
 CFPF_SkiaFontMgr::CFPF_SkiaFontMgr() = default;
 
-CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr() {
-  m_FamilyFonts.clear();
-  m_FontFaces.clear();
-}
+CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr() = default;
 
 bool CFPF_SkiaFontMgr::InitFTLibrary() {
-  if (m_FTLibrary)
+  if (ft_library_) {
     return true;
+  }
 
-  FXFT_LibraryRec* pLibrary = nullptr;
-  FT_Init_FreeType(&pLibrary);
-  if (!pLibrary)
+  FXFT_LibraryRec* library = nullptr;
+  FT_Init_FreeType(&library);
+  if (!library) {
     return false;
+  }
 
-  m_FTLibrary.reset(pLibrary);
+  ft_library_.reset(library);
   return true;
 }
 
 void CFPF_SkiaFontMgr::LoadSystemFonts() {
-  if (m_bLoaded)
+  if (loaded_system_fonts_) {
     return;
+  }
   ScanPath("/system/fonts");
-  m_bLoaded = true;
+  loaded_system_fonts_ = true;
 }
 
-CFPF_SkiaFont* CFPF_SkiaFontMgr::CreateFont(ByteStringView bsFamilyname,
-                                            FX_Charset uCharset,
-                                            uint32_t dwStyle) {
-  uint32_t dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
-  auto family_iter = m_FamilyFonts.find(dwHash);
-  if (family_iter != m_FamilyFonts.end())
+CFPF_SkiaFont* CFPF_SkiaFontMgr::CreateFont(ByteStringView family_name,
+                                            FX_Charset charset,
+                                            uint32_t style) {
+  const uint32_t hash = GetFamilyHash(family_name, style, charset);
+  auto family_iter = family_font_map_.find(hash);
+  if (family_iter != family_font_map_.end()) {
     return family_iter->second.get();
-
-  uint32_t dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
-  uint32_t dwSubst = FPF_SkiaGetSubstFont(dwFaceName, kSkiaFontmap);
-  uint32_t dwSubstSans = FPF_SkiaGetSubstFont(dwFaceName, kSkiaSansFontMap);
-  bool bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
-  if (uCharset != FX_Charset::kMSWin_Arabic &&
-      FPF_SkiaMaybeArabic(bsFamilyname)) {
-    uCharset = FX_Charset::kMSWin_Arabic;
-  } else if (uCharset == FX_Charset::kANSI) {
-    uCharset = FX_Charset::kDefault;
   }
-  int32_t nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 +
-                       FPF_SKIAMATCHWEIGHT_2 * 2;
-  const CFPF_SkiaPathFont* pBestFont = nullptr;
-  int32_t nMax = -1;
-  int32_t nGlyphNum = 0;
+
+  const uint32_t face_name_hash = SkiaNormalizeFontName(family_name);
+  const uint32_t subst_hash = SkiaGetSubstFont(face_name_hash, kSkiaFontmap);
+  const uint32_t subst_sans_hash =
+      SkiaGetSubstFont(face_name_hash, kSkiaSansFontMap);
+  const bool maybe_symbol = SkiaMaybeSymbol(family_name);
+  if (charset != FX_Charset::kMSWin_Arabic && SkiaMaybeArabic(family_name)) {
+    charset = FX_Charset::kMSWin_Arabic;
+  } else if (charset == FX_Charset::kANSI) {
+    charset = FX_Charset::kDefault;
+  }
+  int32_t expected_score = kSkiaMatchNameWeight +
+                           kSkiaMatchSerifStyleWeight * 3 +
+                           kSkiaMatchScriptStyleWeight * 2;
+  const CFPF_SkiaPathFont* best_font = nullptr;
+  int32_t best_score = -1;
+  int32_t best_glyph_num = 0;
   for (const std::unique_ptr<CFPF_SkiaPathFont>& font :
-       pdfium::Reversed(m_FontFaces)) {
-    if (!(font->charsets() & FPF_SkiaGetCharset(uCharset)))
+       pdfium::Reversed(font_faces_)) {
+    if (!(font->charsets() & SkiaGetCharset(charset))) {
       continue;
-    int32_t nFind = 0;
-    uint32_t dwSysFontName = FPF_SKIANormalizeFontName(font->family());
-    if (dwFaceName == dwSysFontName)
-      nFind += FPF_SKIAMATCHWEIGHT_NAME1;
-    bool bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
-    if (FontStyleIsForceBold(dwStyle) == FontStyleIsForceBold(font->style()))
-      nFind += FPF_SKIAMATCHWEIGHT_1;
-    if (FontStyleIsItalic(dwStyle) == FontStyleIsItalic(font->style()))
-      nFind += FPF_SKIAMATCHWEIGHT_1;
-    if (FontStyleIsFixedPitch(dwStyle) ==
-        FontStyleIsFixedPitch(font->style())) {
-      nFind += FPF_SKIAMATCHWEIGHT_2;
     }
-    if (FontStyleIsSerif(dwStyle) == FontStyleIsSerif(font->style()))
-      nFind += FPF_SKIAMATCHWEIGHT_1;
-    if (FontStyleIsScript(dwStyle) == FontStyleIsScript(font->style()))
-      nFind += FPF_SKIAMATCHWEIGHT_2;
-    if (dwSubst == dwSysFontName || dwSubstSans == dwSysFontName) {
-      nFind += FPF_SKIAMATCHWEIGHT_NAME2;
-      bMatchedName = true;
+    int32_t score = 0;
+    const uint32_t sys_font_name_hash = SkiaNormalizeFontName(font->family());
+    if (face_name_hash == sys_font_name_hash) {
+      score += kSkiaMatchNameWeight;
     }
-    if (uCharset == FX_Charset::kDefault || bMaybeSymbol) {
-      if (nFind > nMax && bMatchedName) {
-        nMax = nFind;
-        pBestFont = font.get();
+    bool matches_name = (score == kSkiaMatchNameWeight);
+    if (FontStyleIsForceBold(style) == FontStyleIsForceBold(font->style())) {
+      score += kSkiaMatchSerifStyleWeight;
+    }
+    if (FontStyleIsItalic(style) == FontStyleIsItalic(font->style())) {
+      score += kSkiaMatchSerifStyleWeight;
+    }
+    if (FontStyleIsFixedPitch(style) == FontStyleIsFixedPitch(font->style())) {
+      score += kSkiaMatchScriptStyleWeight;
+    }
+    if (FontStyleIsSerif(style) == FontStyleIsSerif(font->style())) {
+      score += kSkiaMatchSerifStyleWeight;
+    }
+    if (FontStyleIsScript(style) == FontStyleIsScript(font->style())) {
+      score += kSkiaMatchScriptStyleWeight;
+    }
+    if (subst_hash == sys_font_name_hash ||
+        subst_sans_hash == sys_font_name_hash) {
+      score += kSkiaMatchSystemNameWeight;
+      matches_name = true;
+    }
+    if (charset == FX_Charset::kDefault || maybe_symbol) {
+      if (score > best_score && matches_name) {
+        best_score = score;
+        best_font = font.get();
       }
-    } else if (FPF_SkiaIsCJK(uCharset)) {
-      if (bMatchedName || font->glyph_num() > nGlyphNum) {
-        pBestFont = font.get();
-        nGlyphNum = font->glyph_num();
+    } else if (SkiaIsCJK(charset)) {
+      if (matches_name || font->glyph_num() > best_glyph_num) {
+        best_font = font.get();
+        best_glyph_num = font->glyph_num();
       }
-    } else if (nFind > nMax) {
-      nMax = nFind;
-      pBestFont = font.get();
+    } else if (score > best_score) {
+      best_score = score;
+      best_font = font.get();
     }
-    if (nExpectVal <= nFind) {
-      pBestFont = font.get();
+    if (score >= expected_score) {
+      best_font = font.get();
       break;
     }
   }
-  if (!pBestFont)
+  if (!best_font) {
     return nullptr;
+  }
 
-  auto font = std::make_unique<CFPF_SkiaFont>(this, pBestFont, uCharset);
+  auto font = std::make_unique<CFPF_SkiaFont>(this, best_font, charset);
   if (!font->IsValid())
     return nullptr;
 
   CFPF_SkiaFont* ret = font.get();
-  m_FamilyFonts[dwHash] = std::move(font);
+  family_font_map_[hash] = std::move(font);
   return ret;
 }
 
-RetainPtr<CFX_Face> CFPF_SkiaFontMgr::GetFontFace(ByteStringView bsFile,
-                                                  int32_t iFaceIndex) {
-  if (bsFile.IsEmpty())
+RetainPtr<CFX_Face> CFPF_SkiaFontMgr::GetFontFace(ByteStringView path,
+                                                  int32_t face_index) {
+  if (path.IsEmpty()) {
     return nullptr;
+  }
 
-  if (iFaceIndex < 0)
+  if (face_index < 0) {
     return nullptr;
+  }
 
   FT_Open_Args args;
   args.flags = FT_OPEN_PATHNAME;
-  args.pathname = const_cast<FT_String*>(bsFile.unterminated_c_str());
+  args.pathname = const_cast<FT_String*>(path.unterminated_c_str());
   RetainPtr<CFX_Face> face =
-      CFX_Face::Open(m_FTLibrary.get(), &args, iFaceIndex);
+      CFX_Face::Open(ft_library_.get(), &args, face_index);
   if (!face)
     return nullptr;
 
@@ -345,9 +359,9 @@
     return;
 
   ByteString filename;
-  bool bFolder = false;
-  while (handle->GetNextFile(&filename, &bFolder)) {
-    if (bFolder) {
+  bool is_folder = false;
+  while (handle->GetNextFile(&filename, &is_folder)) {
+    if (is_folder) {
       if (filename == "." || filename == "..")
         continue;
     } else {
@@ -359,10 +373,11 @@
     ByteString fullpath(path);
     fullpath += "/";
     fullpath += filename;
-    if (bFolder)
+    if (is_folder) {
       ScanPath(fullpath);
-    else
+    } else {
       ScanFile(fullpath);
+    }
   }
 }
 
@@ -371,42 +386,42 @@
   if (!face)
     return;
 
-  m_FontFaces.push_back(ReportFace(face, file));
+  font_faces_.push_back(ReportFace(face, file));
 }
 
 std::unique_ptr<CFPF_SkiaPathFont> CFPF_SkiaFontMgr::ReportFace(
     RetainPtr<CFX_Face> face,
     const ByteString& file) {
-  uint32_t dwStyle = 0;
+  uint32_t style = 0;
   if (face->IsBold()) {
-    dwStyle |= FXFONT_FORCE_BOLD;
+    style |= FXFONT_FORCE_BOLD;
   }
   if (face->IsItalic()) {
-    dwStyle |= FXFONT_ITALIC;
+    style |= FXFONT_ITALIC;
   }
   if (face->IsFixedWidth()) {
-    dwStyle |= FXFONT_FIXED_PITCH;
+    style |= FXFONT_FIXED_PITCH;
   }
 
-  uint32_t charset = FPF_SKIACHARSET_Default;
+  uint32_t charset = SKIACHARSET_Default;
   std::optional<std::array<uint32_t, 2>> code_page_range =
       face->GetOs2CodePageRange();
   if (code_page_range.has_value()) {
     if (code_page_range.value()[0] & (1 << 31)) {
-      dwStyle |= FXFONT_SYMBOLIC;
+      style |= FXFONT_SYMBOLIC;
     }
-    charset |= FPF_SkiaGetFaceCharset(code_page_range.value()[0]);
+    charset |= SkiaGetFaceCharset(code_page_range.value()[0]);
   }
 
   std::optional<std::array<uint8_t, 2>> panose = face->GetOs2Panose();
   if (panose.has_value() && panose.value()[0] == 2) {
     uint8_t serif = panose.value()[1];
     if ((serif > 1 && serif < 10) || serif > 13) {
-      dwStyle |= FXFONT_SERIF;
+      style |= FXFONT_SERIF;
     }
   }
 
-  return std::make_unique<CFPF_SkiaPathFont>(
-      file, face->GetFamilyName(), dwStyle, face->GetRec()->face_index, charset,
-      face->GetGlyphCount());
+  return std::make_unique<CFPF_SkiaPathFont>(file, face->GetFamilyName(), style,
+                                             face->GetRec()->face_index,
+                                             charset, face->GetGlyphCount());
 }
diff --git a/core/fxge/android/cfpf_skiafontmgr.h b/core/fxge/android/cfpf_skiafontmgr.h
index 0095854..53ea58b 100644
--- a/core/fxge/android/cfpf_skiafontmgr.h
+++ b/core/fxge/android/cfpf_skiafontmgr.h
@@ -26,12 +26,12 @@
   ~CFPF_SkiaFontMgr();
 
   void LoadSystemFonts();
-  CFPF_SkiaFont* CreateFont(ByteStringView bsFamilyname,
-                            FX_Charset uCharset,
-                            uint32_t dwStyle);
+  CFPF_SkiaFont* CreateFont(ByteStringView family_name,
+                            FX_Charset charset,
+                            uint32_t style);
 
   bool InitFTLibrary();
-  RetainPtr<CFX_Face> GetFontFace(ByteStringView bsFile, int32_t iFaceIndex);
+  RetainPtr<CFX_Face> GetFontFace(ByteStringView filename, int32_t face_index);
 
  private:
   void ScanPath(const ByteString& path);
@@ -39,10 +39,11 @@
   std::unique_ptr<CFPF_SkiaPathFont> ReportFace(RetainPtr<CFX_Face> face,
                                                 const ByteString& file);
 
-  bool m_bLoaded = false;
-  ScopedFXFTLibraryRec m_FTLibrary;
-  std::vector<std::unique_ptr<CFPF_SkiaPathFont>> m_FontFaces;
-  std::map<uint32_t, std::unique_ptr<CFPF_SkiaFont>> m_FamilyFonts;
+  bool loaded_system_fonts_ = false;
+  ScopedFXFTLibraryRec ft_library_;
+  std::vector<std::unique_ptr<CFPF_SkiaPathFont>> font_faces_;
+  // Key is a hash based on CreateFont() parameters.
+  std::map<uint32_t, std::unique_ptr<CFPF_SkiaFont>> family_font_map_;
 };
 
 #endif  // CORE_FXGE_ANDROID_CFPF_SKIAFONTMGR_H_