[vr] Bail on unhandled code points.

chrome/browser/android/vr_shell/font_fallback.cc

 // Copyright 2017 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 "chrome/browser/android/vr_shell/font_fallback.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 67 matching lines @@
 
   void SetLocale(const std::string& locale) {
     // Store font list for one locale at a time.
     if (locale != locale_) {
       font_ids_.clear();
       unknown_chars_.clear();
       locale_ = locale;
     }
   }
 
-  std::string GetFallbackFontNameForChar(UChar32 c) {
+  bool GetFallbackFontNameForChar(UChar32 c, std::string* font_name) {
     if (unknown_chars_.find(c) != unknown_chars_.end())
-      return "";
+      return false;
+
     for (SkFontID font_id : font_ids_) {
       std::unique_ptr<CachedFont>& font = g_fonts.Get()[font_id];
-      if (font->HasGlyphForCharacter(c))
-        return font->GetFontName();
+      if (font->HasGlyphForCharacter(c)) {
+        *font_name = font->GetFontName();
+        return true;
+      }
     }
     sk_sp<SkFontMgr> font_mgr(SkFontMgr::RefDefault());
     const char* bcp47_locales[] = {locale_.c_str()};
     sk_sp<SkTypeface> tf(font_mgr->matchFamilyStyleCharacter(
         nullptr, SkFontStyle(), locale_.empty() ? nullptr : bcp47_locales,
         locale_.empty() ? 0 : 1, c));
     if (tf) {
       SkFontID font_id = tf->uniqueID();
       font_ids_.push_back(font_id);
       std::unique_ptr<CachedFont>& cached_font = g_fonts.Get()[font_id];
       if (!cached_font)
         cached_font = CachedFont::CreateForTypeface(tf);
-      return cached_font->GetFontName();
+      *font_name = cached_font->GetFontName();
+      return true;
     }
     unknown_chars_.insert(c);
-    return std::string();
+    return false;
   }
 
  private:
   std::string locale_;
   std::vector<SkFontID> font_ids_;
   std::set<UChar32> unknown_chars_;
 
   DISALLOW_COPY_AND_ASSIGN(CachedFontSet);
 };
 
 base::LazyInstance<CachedFontSet>::Leaky g_cached_font_set =
     LAZY_INSTANCE_INITIALIZER;
 
 bool FontSupportsChar(const gfx::Font& font, UChar32 c) {
   sk_sp<SkTypeface> typeface =
       static_cast<gfx::PlatformFontLinux*>(font.platform_font())->typeface();
   std::unique_ptr<CachedFont>& cached_font =
       g_fonts.Get()[typeface->uniqueID()];
   if (!cached_font)
     cached_font = CachedFont::CreateForTypeface(std::move(typeface));
   return cached_font->HasGlyphForCharacter(c);
 }
 
 }  // namespace
 
-std::string GetFallbackFontNameForChar(const gfx::Font& default_font,
-                                       UChar32 c,
-                                       const std::string& locale) {
-  if (FontSupportsChar(default_font, c))
-    return std::string();
+bool GetFallbackFontNameForChar(const gfx::Font& default_font,
+                                UChar32 c,
+                                const std::string& locale,
+                                std::string* font_name) {
+  if (FontSupportsChar(default_font, c)) {
+    *font_name = std::string();
+    return true;
+  }
   CachedFontSet& cached_font_set = g_cached_font_set.Get();
   cached_font_set.SetLocale(locale);
-  return cached_font_set.GetFallbackFontNameForChar(c);
+  return cached_font_set.GetFallbackFontNameForChar(c, font_name);
 }
 
 }  // namespace vr_shell