Add FontRenderParamsQuery.

Add a new struct that encapsulates the parameters used to
initialize FontRenderParams.

Also remove all the existing FontRenderParams functions in
favor of a single GetFontRenderParams() function that takes
a FontRenderParamsQuery.

BUG=395313,396659
TBR=boliu@chromium.org

Review URL: https://codereview.chromium.org/413003002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@285425 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 147 insertions, 173 deletions

diff --git a/android_webview/native/aw_settings.cc b/android_webview/native/aw_settings.cc
index 55b449b..0a4f8d9 100644
--- a/android_webview/native/aw_settings.cc
+++ b/android_webview/native/aw_settings.cc
@@ -9,6 +9,7 @@
 #include "android_webview/native/aw_contents.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
+#include "base/macros.h"
 #include "base/supports_user_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
@@ -74,7 +75,8 @@ void PopulateFixedRendererPreferences(RendererPreferences* prefs) {
       content::TAP_MULTIPLE_TARGETS_STRATEGY_NONE;
 
   // TODO(boliu): Deduplicate with chrome/ code.
-  const gfx::FontRenderParams& params = gfx::GetDefaultWebKitFontRenderParams();
+  CR_DEFINE_STATIC_LOCAL(const gfx::FontRenderParams, params,
+      (gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(true), NULL)));
   prefs->should_antialias_text = params.antialiasing;
   prefs->use_subpixel_positioning = params.subpixel_positioning;
   prefs->hinting = GetRendererPreferencesHintingEnum(params.hinting);
diff --git a/chrome/browser/renderer_preferences_util.cc b/chrome/browser/renderer_preferences_util.cc
index 82a3779..45ab1b3 100644
--- a/chrome/browser/renderer_preferences_util.cc
+++ b/chrome/browser/renderer_preferences_util.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/renderer_preferences_util.h"
 
+#include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
@@ -131,7 +132,8 @@ void UpdateFromSystemSettings(
 #endif
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
-  const gfx::FontRenderParams& params = gfx::GetDefaultWebKitFontRenderParams();
+  CR_DEFINE_STATIC_LOCAL(const gfx::FontRenderParams, params,
+      (gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(true), NULL)));
   prefs->should_antialias_text = params.antialiasing;
   prefs->use_subpixel_positioning = params.subpixel_positioning;
   prefs->hinting = GetRendererPreferencesHintingEnum(params.hinting);
diff --git a/content/browser/renderer_host/sandbox_ipc_linux.cc b/content/browser/renderer_host/sandbox_ipc_linux.cc
index 8459b5c..3e3cc03 100644
--- a/content/browser/renderer_host/sandbox_ipc_linux.cc
+++ b/content/browser/renderer_host/sandbox_ipc_linux.cc
@@ -12,6 +12,7 @@
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/linux_util.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/posix/eintr_wrapper.h"
@@ -41,8 +42,9 @@ SandboxIPCHandler::SandboxIPCHandler(int lifeline_fd, int browser_socket)
     : lifeline_fd_(lifeline_fd), browser_socket_(browser_socket) {
   // FontConfig doesn't provide a standard property to control subpixel
   // positioning, so we pass the current setting through to WebKit.
-  WebFontInfo::setSubpixelPositioning(
-      gfx::GetDefaultWebKitFontRenderParams().subpixel_positioning);
+  CR_DEFINE_STATIC_LOCAL(const gfx::FontRenderParams, params,
+      (gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(true), NULL)));
+  WebFontInfo::setSubpixelPositioning(params.subpixel_positioning);
 }
 
 void SandboxIPCHandler::Run() {
diff --git a/ui/gfx/font_render_params.cc b/ui/gfx/font_render_params.cc
index 5d8c22e..0166ba8 100644
--- a/ui/gfx/font_render_params.cc
+++ b/ui/gfx/font_render_params.cc
@@ -17,4 +17,13 @@ FontRenderParams::FontRenderParams()
 
 FontRenderParams::~FontRenderParams() {}
 
+FontRenderParamsQuery::FontRenderParamsQuery(bool for_web_contents)
+    : for_web_contents(for_web_contents),
+      pixel_size(0),
+      point_size(0),
+      style(-1) {
+}
+
+FontRenderParamsQuery::~FontRenderParamsQuery() {}
+
 }  // namespace gfx
diff --git a/ui/gfx/font_render_params.h b/ui/gfx/font_render_params.h
index 1b49e04..fb28700 100644
--- a/ui/gfx/font_render_params.h
+++ b/ui/gfx/font_render_params.h
@@ -40,6 +40,8 @@ struct GFX_EXPORT FontRenderParams {
 
   // Should subpixel positioning (i.e. fractional X positions for glyphs) be
   // used?
+  // TODO(derat): Remove this; we don't set it in the browser and mostly ignore
+  // it in Blink: http://crbug.com/396659
   bool subpixel_positioning;
 
   // Should FreeType's autohinter be used (as opposed to Freetype's bytecode
@@ -57,23 +59,36 @@ struct GFX_EXPORT FontRenderParams {
   SubpixelRendering subpixel_rendering;
 };
 
-// Returns the system's default parameters for font rendering.
-GFX_EXPORT const FontRenderParams& GetDefaultFontRenderParams();
-
-// Returns the system's default parameters for WebKit font rendering.
-// TODO(derat): Rename to GetDefaultFontRenderParamsForWebContents().
-GFX_EXPORT const FontRenderParams& GetDefaultWebKitFontRenderParams();
-
-// Returns the appropriate parameters for rendering the font described by the
-// passed-in-arguments, any of which may be NULL. If |family_out| is non-NULL,
-// it will be updated to contain the recommended font family from |family_list|.
-// |style| optionally points to a bit field of Font::FontStyle values.
-GFX_EXPORT FontRenderParams GetCustomFontRenderParams(
-    bool for_web_contents,
-    const std::vector<std::string>* family_list,
-    const int* pixel_size,
-    const int* point_size,
-    const int* style,
+// A query used to determine the appropriate FontRenderParams.
+struct GFX_EXPORT FontRenderParamsQuery {
+  explicit FontRenderParamsQuery(bool for_web_contents);
+  ~FontRenderParamsQuery();
+
+  bool is_empty() const {
+    return families.empty() && pixel_size <= 0 && point_size <= 0 && style < 0;
+  }
+
+  // True if rendering text for the web.
+  // TODO(derat): Remove this once FontRenderParams::subpixel_positioning is
+  // gone: http://crbug.com/396659
+  bool for_web_contents;
+
+  // Requested font families, or empty if unset.
+  std::vector<std::string> families;
+
+  // Font size in pixels or points, or 0 if unset.
+  int pixel_size;
+  int point_size;
+
+  // gfx::Font::FontStyle bit field, or -1 if unset.
+  int style;
+};
+
+// Returns the appropriate parameters for rendering the font described by
+// |query|. If |family_out| is non-NULL, it will be updated to contain the
+// recommended font family from |query.families|.
+GFX_EXPORT FontRenderParams GetFontRenderParams(
+    const FontRenderParamsQuery& query,
     std::string* family_out);
 
 }  // namespace gfx
diff --git a/ui/gfx/font_render_params_android.cc b/ui/gfx/font_render_params_android.cc
index b67ea18..c5b17b0 100644
--- a/ui/gfx/font_render_params_android.cc
+++ b/ui/gfx/font_render_params_android.cc
@@ -5,6 +5,7 @@
 #include "ui/gfx/font_render_params.h"
 
 #include "base/logging.h"
+#include "base/macros.h"
 
 namespace gfx {
 
@@ -29,24 +30,14 @@ FontRenderParams LoadDefaults() {
 
 }  // namespace
 
-const FontRenderParams& GetDefaultFontRenderParams() {
-  static FontRenderParams default_params = LoadDefaults();
-  return default_params;
-}
-
-const FontRenderParams& GetDefaultWebKitFontRenderParams() {
-  return GetDefaultFontRenderParams();
-}
-
-FontRenderParams GetCustomFontRenderParams(
-    bool for_web_contents,
-    const std::vector<std::string>* family_list,
-    const int* pixel_size,
-    const int* point_size,
-    const int* style,
-    std::string* family_out) {
-  NOTIMPLEMENTED();
-  return GetDefaultFontRenderParams();
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  // Customized font rendering settings are not supported, only defaults.
+  if (!query.is_empty() || family_out)
+    NOTIMPLEMENTED();
+  CR_DEFINE_STATIC_LOCAL(
+      const gfx::FontRenderParams, params, (LoadDefaults()));
+  return params;
 }
 
 }  // namespace gfx
diff --git a/ui/gfx/font_render_params_linux.cc b/ui/gfx/font_render_params_linux.cc
index bba66d4..e8e60e3 100644
--- a/ui/gfx/font_render_params_linux.cc
+++ b/ui/gfx/font_render_params_linux.cc
@@ -38,12 +38,8 @@ FontRenderParams::SubpixelRendering ConvertFontconfigRgba(int rgba) {
 }
 
 // Queries Fontconfig for rendering settings and updates |params_out| and
-// |family_out| (if non-NULL). Returns false on failure. See
-// GetCustomFontRenderParams() for descriptions of arguments.
-bool QueryFontconfig(const std::vector<std::string>* family_list,
-                     const int* pixel_size,
-                     const int* point_size,
-                     const int* style,
+// |family_out| (if non-NULL). Returns false on failure.
+bool QueryFontconfig(const FontRenderParamsQuery& query,
                      FontRenderParams* params_out,
                      std::string* family_out) {
   FcPattern* pattern = FcPatternCreate();
@@ -51,22 +47,20 @@ bool QueryFontconfig(const std::vector<std::string>* family_list,
 
   FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 
-  if (family_list) {
-    for (std::vector<std::string>::const_iterator it = family_list->begin();
-         it != family_list->end(); ++it) {
-      FcPatternAddString(
-          pattern, FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
-    }
+  for (std::vector<std::string>::const_iterator it = query.families.begin();
+       it != query.families.end(); ++it) {
+    FcPatternAddString(
+        pattern, FC_FAMILY, reinterpret_cast<const FcChar8*>(it->c_str()));
   }
-  if (pixel_size)
-    FcPatternAddDouble(pattern, FC_PIXEL_SIZE, *pixel_size);
-  if (point_size)
-    FcPatternAddInteger(pattern, FC_SIZE, *point_size);
-  if (style) {
+  if (query.pixel_size > 0)
+    FcPatternAddDouble(pattern, FC_PIXEL_SIZE, query.pixel_size);
+  if (query.point_size > 0)
+    FcPatternAddInteger(pattern, FC_SIZE, query.point_size);
+  if (query.style >= 0) {
     FcPatternAddInteger(pattern, FC_SLANT,
-        (*style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
+        (query.style & Font::ITALIC) ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
     FcPatternAddInteger(pattern, FC_WEIGHT,
-        (*style & Font::BOLD) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL);
+        (query.style & Font::BOLD) ? FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL);
   }
 
   FcConfigSubstitute(NULL, pattern, FcMatchPattern);
@@ -120,31 +114,10 @@ bool QueryFontconfig(const std::vector<std::string>* family_list,
   return true;
 }
 
-// Returns the system's default settings.
-FontRenderParams LoadDefaults(bool for_web_contents) {
-  return GetCustomFontRenderParams(
-      for_web_contents, NULL, NULL, NULL, NULL, NULL);
-}
-
 }  // namespace
 
-const FontRenderParams& GetDefaultFontRenderParams() {
-  static FontRenderParams default_params = LoadDefaults(false);
-  return default_params;
-}
-
-const FontRenderParams& GetDefaultWebKitFontRenderParams() {
-  static FontRenderParams default_params = LoadDefaults(true);
-  return default_params;
-}
-
-FontRenderParams GetCustomFontRenderParams(
-    bool for_web_contents,
-    const std::vector<std::string>* family_list,
-    const int* pixel_size,
-    const int* point_size,
-    const int* style,
-    std::string* family_out) {
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
   if (family_out)
     family_out->clear();
 
@@ -153,12 +126,11 @@ FontRenderParams GetCustomFontRenderParams(
   const LinuxFontDelegate* delegate = LinuxFontDelegate::instance();
   if (delegate)
     params = delegate->GetDefaultFontRenderParams();
-  QueryFontconfig(
-      family_list, pixel_size, point_size, style, &params, family_out);
+  QueryFontconfig(query, &params, family_out);
 
   // Fontconfig doesn't support configuring subpixel positioning; check a flag.
   params.subpixel_positioning = CommandLine::ForCurrentProcess()->HasSwitch(
-      for_web_contents ?
+      query.for_web_contents ?
       switches::kEnableWebkitTextSubpixelPositioning :
       switches::kEnableBrowserTextSubpixelPositioning);
 
@@ -167,9 +139,8 @@ FontRenderParams GetCustomFontRenderParams(
     params.hinting = FontRenderParams::HINTING_NONE;
 
   // Use the first family from the list if Fontconfig didn't suggest a family.
-  if (family_out && family_out->empty() &&
-      family_list && !family_list->empty())
-    *family_out = (*family_list)[0];
+  if (family_out && family_out->empty() && !query.families.empty())
+    *family_out = query.families[0];
 
   return params;
 }
diff --git a/ui/gfx/font_render_params_linux_unittest.cc b/ui/gfx/font_render_params_linux_unittest.cc
index 1844320..a792483 100644
--- a/ui/gfx/font_render_params_linux_unittest.cc
+++ b/ui/gfx/font_render_params_linux_unittest.cc
@@ -98,7 +98,8 @@ TEST_F(FontRenderParamsTest, Default) {
       kFontconfigMatchFooter +
       kFontconfigFileFooter));
 
-  FontRenderParams params = GetDefaultFontRenderParams();
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(true), NULL);
   EXPECT_TRUE(params.antialiasing);
   EXPECT_FALSE(params.autohinter);
   EXPECT_TRUE(params.use_bitmaps);
@@ -131,25 +132,24 @@ TEST_F(FontRenderParamsTest, Size) {
 
   // The defaults should be used when the supplied size isn't matched by the
   // second or third blocks.
-  int pixel_size = 12;
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, NULL, &pixel_size, NULL, NULL, NULL);
+  FontRenderParamsQuery query(false);
+  query.pixel_size = 12;
+  FontRenderParams params = GetFontRenderParams(query, NULL);
   EXPECT_TRUE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
   EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
             params.subpixel_rendering);
 
-  pixel_size = 10;
-  params = GetCustomFontRenderParams(
-      false, NULL, &pixel_size, NULL, NULL, NULL);
+  query.pixel_size = 10;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_FALSE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
   EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_NONE,
             params.subpixel_rendering);
 
-  int point_size = 20;
-  params = GetCustomFontRenderParams(
-      false, NULL, NULL, &point_size, NULL, NULL);
+  query.pixel_size = 0;
+  query.point_size = 20;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_TRUE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_SLIGHT, params.hinting);
   EXPECT_EQ(FontRenderParams::SUBPIXEL_RENDERING_RGB,
@@ -177,27 +177,24 @@ TEST_F(FontRenderParamsTest, Style) {
       kFontconfigMatchFooter +
       kFontconfigFileFooter));
 
-  int style = Font::NORMAL;
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, &style, NULL);
+  FontRenderParamsQuery query(false);
+  query.style = Font::NORMAL;
+  FontRenderParams params = GetFontRenderParams(query, NULL);
   EXPECT_TRUE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
 
-  style = Font::BOLD;
-  params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, &style, NULL);
+  query.style = Font::BOLD;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_FALSE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_FULL, params.hinting);
 
-  style = Font::ITALIC;
-  params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, &style, NULL);
+  query.style = Font::ITALIC;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_TRUE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_NONE, params.hinting);
 
-  style = Font::BOLD | Font::ITALIC;
-  params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, &style, NULL);
+  query.style = Font::BOLD | Font::ITALIC;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_FALSE(params.antialiasing);
   EXPECT_EQ(FontRenderParams::HINTING_NONE, params.hinting);
 }
@@ -217,8 +214,8 @@ TEST_F(FontRenderParamsTest, Scalable) {
       kFontconfigFileFooter));
 
   // Check that we specifically ask how scalable fonts should be rendered.
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, NULL, NULL);
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(false), NULL);
   EXPECT_TRUE(params.antialiasing);
 }
 
@@ -236,13 +233,12 @@ TEST_F(FontRenderParamsTest, UseBitmaps) {
       kFontconfigMatchFooter +
       kFontconfigFileFooter));
 
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, NULL, NULL);
+  FontRenderParamsQuery query(false);
+  FontRenderParams params = GetFontRenderParams(query, NULL);
   EXPECT_FALSE(params.use_bitmaps);
 
-  const int pixel_size = 5;
-  params = GetCustomFontRenderParams(
-      false, NULL, &pixel_size, NULL, NULL, NULL);
+  query.pixel_size = 5;
+  params = GetFontRenderParams(query, NULL);
   EXPECT_TRUE(params.use_bitmaps);
 }
 
@@ -264,8 +260,8 @@ TEST_F(FontRenderParamsTest, OnlySetConfiguredValues) {
       kFontconfigFileFooter));
 
   // The subpixel rendering setting from the delegate should make it through.
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, NULL, NULL, NULL, NULL, NULL);
+  FontRenderParams params = GetFontRenderParams(
+      FontRenderParamsQuery(false), NULL);
   EXPECT_EQ(system_params.subpixel_rendering, params.subpixel_rendering);
 }
 
@@ -277,19 +273,18 @@ TEST_F(FontRenderParamsTest, NoFontconfigMatch) {
   system_params.subpixel_rendering = FontRenderParams::SUBPIXEL_RENDERING_RGB;
   test_font_delegate_.set_params(system_params);
 
-  std::vector<std::string> families;
-  families.push_back("Arial");
-  families.push_back("Times New Roman");
-  const int pixel_size = 10;
+  FontRenderParamsQuery query(false);
+  query.families.push_back("Arial");
+  query.families.push_back("Times New Roman");
+  query.pixel_size = 10;
   std::string suggested_family;
-  FontRenderParams params = GetCustomFontRenderParams(
-      false, &families, &pixel_size, NULL, NULL, &suggested_family);
+  FontRenderParams params = GetFontRenderParams(query, &suggested_family);
 
   // The system params and the first requested family should be returned.
   EXPECT_EQ(system_params.antialiasing, params.antialiasing);
   EXPECT_EQ(system_params.hinting, params.hinting);
   EXPECT_EQ(system_params.subpixel_rendering, params.subpixel_rendering);
-  EXPECT_EQ("Arial", suggested_family);
+  EXPECT_EQ(query.families[0], suggested_family);
 }
 
 }  // namespace gfx
diff --git a/ui/gfx/font_render_params_win.cc b/ui/gfx/font_render_params_win.cc
index c7d5d33..2ad1b5b 100644
--- a/ui/gfx/font_render_params_win.cc
+++ b/ui/gfx/font_render_params_win.cc
@@ -72,23 +72,12 @@ class CachedFontRenderParams : public gfx::SingletonHwnd::Observer {
 
 }  // namespace
 
-const FontRenderParams& GetDefaultFontRenderParams() {
+FontRenderParams GetFontRenderParams(const FontRenderParamsQuery& query,
+                                     std::string* family_out) {
+  // Customized font rendering settings are not supported, only defaults.
+  if (!query.is_empty() || family_out)
+    NOTIMPLEMENTED();
   return CachedFontRenderParams::GetInstance()->GetParams();
 }
 
-const FontRenderParams& GetDefaultWebKitFontRenderParams() {
-  return GetDefaultFontRenderParams();
-}
-
-FontRenderParams GetCustomFontRenderParams(
-    bool for_web_contents,
-    const std::vector<std::string>* family_list,
-    const int* pixel_size,
-    const int* point_size,
-    const int* style,
-    std::string* family_out) {
-  NOTIMPLEMENTED();
-  return GetDefaultFontRenderParams();
-}
-
 }  // namespace gfx
diff --git a/ui/gfx/platform_font_pango.cc b/ui/gfx/platform_font_pango.cc
index 39f0bb8..403b836 100644
--- a/ui/gfx/platform_font_pango.cc
+++ b/ui/gfx/platform_font_pango.cc
@@ -94,43 +94,40 @@ PlatformFontPango::PlatformFontPango() {
 }
 
 PlatformFontPango::PlatformFontPango(NativeFont native_font) {
-  std::string font_family;
-  std::vector<std::string> family_names;
+  FontRenderParamsQuery query(false);
   base::SplitString(pango_font_description_get_family(native_font), ',',
-                    &family_names);
+                    &query.families);
 
   const int pango_size =
       pango_font_description_get_size(native_font) / PANGO_SCALE;
-  const bool pango_using_pixels =
-      pango_font_description_get_size_is_absolute(native_font);
+  if (pango_font_description_get_size_is_absolute(native_font))
+    query.pixel_size = pango_size;
+  else
+    query.point_size = pango_size;
 
-  int style = 0;
-  // TODO(davemoore) What should we do about other weights? We currently only
-  // support BOLD.
+  query.style = gfx::Font::NORMAL;
+  // TODO(davemoore): Support weights other than bold?
   if (pango_font_description_get_weight(native_font) == PANGO_WEIGHT_BOLD)
-    style |= gfx::Font::BOLD;
-  // TODO(davemoore) What about PANGO_STYLE_OBLIQUE?
+    query.style |= gfx::Font::BOLD;
+  // TODO(davemoore): What about PANGO_STYLE_OBLIQUE?
   if (pango_font_description_get_style(native_font) == PANGO_STYLE_ITALIC)
-    style |= gfx::Font::ITALIC;
-
-  const FontRenderParams params = GetCustomFontRenderParams(
-      false, &family_names,
-      pango_using_pixels ? &pango_size : NULL /* pixel_size */,
-      !pango_using_pixels ? &pango_size : NULL /* point_size */,
-      &style, &font_family);
+    query.style |= gfx::Font::ITALIC;
 
+  std::string font_family;
+  const FontRenderParams params = gfx::GetFontRenderParams(query, &font_family);
   InitFromDetails(skia::RefPtr<SkTypeface>(), font_family,
-                  gfx::GetPangoFontSizeInPixels(native_font), style, params);
+                  gfx::GetPangoFontSizeInPixels(native_font),
+                  query.style, params);
 }
 
 PlatformFontPango::PlatformFontPango(const std::string& font_name,
                                      int font_size_pixels) {
-  const std::vector<std::string> font_list(1, font_name);
-  const int style = Font::NORMAL;
-  const FontRenderParams params = GetCustomFontRenderParams(
-      false, &font_list, &font_size_pixels, NULL, &style, NULL);
+  FontRenderParamsQuery query(false);
+  query.families.push_back(font_name);
+  query.pixel_size = font_size_pixels;
+  query.style = gfx::Font::NORMAL;
   InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size_pixels,
-                  style, params);
+                  query.style, gfx::GetFontRenderParams(query, NULL));
 }
 
 double PlatformFontPango::underline_position() const {
@@ -171,15 +168,13 @@ Font PlatformFontPango::DeriveFont(int size_delta, int style) const {
   skia::RefPtr<SkTypeface> typeface =
       (style == style_) ? typeface_ : CreateSkTypeface(style, &new_family);
 
-  const std::vector<std::string> family_list(1, new_family);
-  const FontRenderParams render_params = GetCustomFontRenderParams(
-      false, &family_list, &new_size, NULL, &style, NULL);
+  FontRenderParamsQuery query(false);
+  query.families.push_back(new_family);
+  query.pixel_size = new_size;
+  query.style = style;
 
-  return Font(new PlatformFontPango(typeface,
-                                    new_family,
-                                    new_size,
-                                    style,
-                                    render_params));
+  return Font(new PlatformFontPango(typeface, new_family, new_size, style,
+                                    gfx::GetFontRenderParams(query, NULL)));
 }
 
 int PlatformFontPango::GetHeight() const {
diff --git a/ui/gfx/platform_font_win.cc b/ui/gfx/platform_font_win.cc
index 9f61db3..a4505a3b 100644
--- a/ui/gfx/platform_font_win.cc
+++ b/ui/gfx/platform_font_win.cc
@@ -11,6 +11,7 @@
 #include <string>
 
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ -193,7 +194,9 @@ int PlatformFontWin::GetFontSize() const {
 }
 
 const FontRenderParams& PlatformFontWin::GetFontRenderParams() const {
-  return GetDefaultFontRenderParams();
+  CR_DEFINE_STATIC_LOCAL(const gfx::FontRenderParams, params,
+      (gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(false), NULL)));
+  return params;
 }
 
 NativeFont PlatformFontWin::GetNativeFont() const {