chrome/browser/font_family_cache.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/font_family_cache.h"
   6
   7 #include <map>
   8
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/common/pref_font_webkit_names.h"
  15 #include "chrome/common/pref_names.h"
  16 #include "content/public/browser/notification_source.h"
  17
  18 // Identifies the user data on the profile.
  19 const char kFontFamilyCacheKey[] = "FontFamilyCacheKey";
  20
  21 FontFamilyCache::FontFamilyCache(Profile* profile)
  22     : prefs_(profile->GetPrefs()) {
  23   profile_pref_registrar_.Init(profile->GetPrefs());
  24   notification_registrar_.Add(this,
  25                               chrome::NOTIFICATION_PROFILE_DESTROYED,
  26                               content::Source<Profile>(profile));
  27 }
  28
  29 FontFamilyCache::~FontFamilyCache() {
  30 }
  31
  32 void FontFamilyCache::FillFontFamilyMap(Profile* profile,
  33                                         const char* map_name,
  34                                         content::ScriptFontFamilyMap* map) {
  35   FontFamilyCache* cache =
  36       static_cast<FontFamilyCache*>(profile->GetUserData(&kFontFamilyCacheKey));
  37   if (!cache) {
  38     cache = new FontFamilyCache(profile);
  39     // The profile takes ownership of |cache|.
  40     profile->SetUserData(&kFontFamilyCacheKey, cache);
  41   }
  42
  43   cache->FillFontFamilyMap(map_name, map);
  44 }
  45
  46 void FontFamilyCache::FillFontFamilyMap(const char* map_name,
  47                                         content::ScriptFontFamilyMap* map) {
  48   // TODO(falken): Get rid of the brute-force scan over possible
  49   // (font family / script) combinations - see http://crbug.com/308095.
  50   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
  51     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
  52     base::string16 result = FetchAndCacheFont(script, map_name);
  53     if (!result.empty())
  54       (*map)[script] = result;
  55   }
  56 }
  57
  58 base::string16 FontFamilyCache::FetchFont(const char* script,
  59                                           const char* map_name) {
  60   std::string pref_name = base::StringPrintf("%s.%s", map_name, script);
  61   std::string font = prefs_->GetString(pref_name.c_str());
  62   base::string16 font16 = base::UTF8ToUTF16(font);
  63
  64   // Lazily constructs the map if it doesn't already exist.
  65   ScriptFontMap& map = font_family_map_[map_name];
  66   map[script] = font16;
  67
  68   // Register for profile preference changes.
  69   profile_pref_registrar_.Add(
  70       pref_name.c_str(),
  71       base::Bind(&FontFamilyCache::OnPrefsChanged, base::Unretained(this)));
  72   return font16;
  73 }
  74
  75 base::string16 FontFamilyCache::FetchAndCacheFont(const char* script,
  76                                                   const char* map_name) {
  77   FontFamilyMap::const_iterator it = font_family_map_.find(map_name);
  78   if (it != font_family_map_.end()) {
  79     ScriptFontMap::const_iterator it2 = it->second.find(script);
  80     if (it2 != it->second.end())
  81       return it2->second;
  82   }
  83
  84   return FetchFont(script, map_name);
  85 }
  86
  87 // There are ~1000 entries in the cache. Avoid unnecessary object construction,
  88 // including std::string.
  89 void FontFamilyCache::OnPrefsChanged(const std::string& pref_name) {
  90   const size_t delimiter_length = 1;
  91   const char delimiter = '.';
  92   for (FontFamilyMap::iterator it = font_family_map_.begin();
  93        it != font_family_map_.end();
  94        ++it) {
  95     const char* map_name = it->first;
  96     size_t map_name_length = strlen(map_name);
  97
  98     // If the map name doesn't match, move on.
  99     if (pref_name.compare(0, map_name_length, map_name) != 0)
 100       continue;
 101
 102     ScriptFontMap& map = it->second;
 103     for (ScriptFontMap::iterator it2 = map.begin(); it2 != map.end(); ++it2) {
 104       const char* script = it2->first;
 105       size_t script_length = strlen(script);
 106
 107       // If the length doesn't match, move on.
 108       if (pref_name.size() !=
 109           map_name_length + script_length + delimiter_length)
 110         continue;
 111
 112       // If the script doesn't match, move on.
 113       if (pref_name.compare(
 114               map_name_length + delimiter_length, script_length, script) != 0)
 115         continue;
 116
 117       // If the delimiter doesn't match, move on.
 118       if (pref_name[map_name_length] != delimiter)
 119         continue;
 120
 121       // Clear the cache and the observer.
 122       map.erase(it2);
 123       profile_pref_registrar_.Remove(pref_name.c_str());
 124       break;
 125     }
 126   }
 127 }
 128
 129 void FontFamilyCache::Observe(int type,
 130                               const content::NotificationSource& source,
 131                               const content::NotificationDetails& details) {
 132   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
 133   profile_pref_registrar_.RemoveAll();
 134 }