Allow the default generic font family settings to find the first available font

chrome/browser/ui/webui/options/font_settings_handler.cc

 // Copyright (c) 2012 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/ui/webui/options/font_settings_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 20 matching lines @@
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_urls.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
-#if defined(OS_WIN)
-#include "ui/gfx/font.h"
-#include "ui/gfx/platform_font_win.h"
-#endif
-
 namespace {
 
-// Returns the localized name of a font so that settings can find it within the
-// list of system fonts. On Windows, the list of system fonts has names only
-// for the system locale, but the pref value may be in the English name.
-std::string MaybeGetLocalizedFontName(const std::string& font_name) {
-#if defined(OS_WIN)
-  gfx::Font font(font_name, 12);  // dummy font size
-  return static_cast<gfx::PlatformFontWin*>(font.platform_font())->
-      GetLocalizedFontName();
-#else
-  return font_name;
-#endif
-}
-
 const char kAdvancedFontSettingsExtensionId[] =
     "caclkomlalccbpcdllchkeecicepbmbm";
 
 }  // namespace
 
 
 namespace options {
 
 FontSettingsHandler::FontSettingsHandler()
     : extension_registry_observer_(this),
@@ skipping 132 matching lines @@
     bool has_font = list->GetList(i, &font);
     DCHECK(has_font);
     base::string16 value;
     bool has_value = font->GetString(1, &value);
     DCHECK(has_value);
     bool has_rtl_chars = base::i18n::StringContainsStrongRTLChars(value);
     font->AppendString(has_rtl_chars ? "rtl" : "ltr");
   }
 
   base::ListValue selected_values;
+  selected_values.AppendString(FontSettingsUtilities::MaybeGetLocalizedFontName(
+      standard_font_.GetValue()));
   selected_values.AppendString(
-      MaybeGetLocalizedFontName(standard_font_.GetValue()));
+      FontSettingsUtilities::MaybeGetLocalizedFontName(serif_font_.GetValue()));
+  selected_values.AppendString(FontSettingsUtilities::MaybeGetLocalizedFontName(
+      sans_serif_font_.GetValue()));
   selected_values.AppendString(
-      MaybeGetLocalizedFontName(serif_font_.GetValue()));
-  selected_values.AppendString(
-      MaybeGetLocalizedFontName(sans_serif_font_.GetValue()));
-  selected_values.AppendString(
-      MaybeGetLocalizedFontName(fixed_font_.GetValue()));
+      FontSettingsUtilities::MaybeGetLocalizedFontName(fixed_font_.GetValue()));
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "FontSettings.setFontsData", *list.get(), selected_values);
 }
 
 void FontSettingsHandler::SetUpStandardFontSample() {
-  base::StringValue font_value(standard_font_.GetValue());
+  base::StringValue font_value(
+      FontSettingsUtilities::ResolveFontList(standard_font_.GetValue()));
   base::FundamentalValue size_value(default_font_size_.GetValue());
   web_ui()->CallJavascriptFunctionUnsafe("FontSettings.setUpStandardFontSample",
                                          font_value, size_value);
 }
 
 void FontSettingsHandler::SetUpSerifFontSample() {
-  base::StringValue font_value(serif_font_.GetValue());
+  base::StringValue font_value(
+      FontSettingsUtilities::ResolveFontList(serif_font_.GetValue()));
   base::FundamentalValue size_value(default_font_size_.GetValue());
   web_ui()->CallJavascriptFunctionUnsafe("FontSettings.setUpSerifFontSample",
                                          font_value, size_value);
 }
 
 void FontSettingsHandler::SetUpSansSerifFontSample() {
-  base::StringValue font_value(sans_serif_font_.GetValue());
+  base::StringValue font_value(
+      FontSettingsUtilities::ResolveFontList(sans_serif_font_.GetValue()));
   base::FundamentalValue size_value(default_font_size_.GetValue());
   web_ui()->CallJavascriptFunctionUnsafe(
       "FontSettings.setUpSansSerifFontSample", font_value, size_value);
 }
 
 void FontSettingsHandler::SetUpFixedFontSample() {
-  base::StringValue font_value(fixed_font_.GetValue());
+  base::StringValue font_value(
+      FontSettingsUtilities::ResolveFontList(fixed_font_.GetValue()));
   base::FundamentalValue size_value(default_fixed_font_size_.GetValue());
   web_ui()->CallJavascriptFunctionUnsafe("FontSettings.setUpFixedFontSample",
                                          font_value, size_value);
 }
 
 void FontSettingsHandler::SetUpMinimumFontSample() {
   base::FundamentalValue size_value(minimum_font_size_.GetValue());
   web_ui()->CallJavascriptFunctionUnsafe("FontSettings.setUpMinimumFontSample",
                                          size_value);
 }
@@ skipping 23 matching lines @@
       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents()));
 }
 
 void FontSettingsHandler::OnWebKitDefaultFontSizeChanged() {
   SetUpStandardFontSample();
   SetUpSerifFontSample();
   SetUpSansSerifFontSample();
 }
 
 }  // namespace options