Enable hidpi on Linux, refactor a bit on Windows to share

ui/gfx/pango_util.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 "ui/gfx/pango_util.h"
 
 #include <cairo/cairo.h>
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
 #include <string>
@@ skipping 10 matching lines @@
 #include "ui/gfx/platform_font_pango.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
 namespace {
 
 // Marker for accelerators in the text.
 const gunichar kAcceleratorChar = '&';
 
+const double kStandardDPI = 96.0;
+const double kPointsPerInch = 72.0;
+
 // Creates and returns a PangoContext. The caller owns the context.
 PangoContext* GetPangoContext() {
   PangoFontMap* font_map = pango_cairo_font_map_get_default();
   return pango_font_map_create_context(font_map);
 }
 
 // Creates a new cairo_font_options_t based on |params|.
 cairo_font_options_t* CreateCairoFontOptions(const FontRenderParams& params) {
   cairo_font_options_t* cairo_font_options = cairo_font_options_create();
 
@@ skipping 37 matching lines @@
     else
       NOTREACHED() << "Unhandled hinting style " << params.hinting;
     cairo_font_options_set_hint_style(cairo_font_options, cairo_hint_style);
     cairo_font_options_set_hint_metrics(cairo_font_options,
                                         CAIRO_HINT_METRICS_ON);
   }
 
   return cairo_font_options;
 }
 
-// Returns the DPI that should be used by Pango.
-double GetPangoDPI() {
-  static double dpi = -1.0;
-  if (dpi < 0.0) {
-    const gfx::LinuxFontDelegate* delegate = gfx::LinuxFontDelegate::instance();
-    if (delegate)
-      dpi = delegate->GetFontDPI();
-    if (dpi <= 0.0)
-      dpi = 96.0;
-  }
-  return dpi;
-}
-
-// Returns the number of pixels in a point.
-// - multiply a point size by this to get pixels ("device units")
-// - divide a pixel size by this to get points
-double GetPixelsInPoint() {
-  static double pixels_in_point = GetPangoDPI() / 72.0;  // 72 points in an inch
-  return pixels_in_point;
-}
-
 }  // namespace
 
 void SetUpPangoLayout(
     PangoLayout* layout,
     const base::string16& text,
     const FontList& font_list,
     base::i18n::TextDirection text_direction,
     int flags) {
   cairo_font_options_t* cairo_font_options = CreateCairoFontOptions(
       font_list.GetPrimaryFont().GetFontRenderParams());
@@ skipping 37 matching lines @@
   } else {
     // Fading the text will be handled in the draw operation.
     // Ensure that the text is only on one line.
     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
     pango_layout_set_width(layout, -1);
   }
 
   // Set the layout's resolution to match the resolution used to convert from
   // points to pixels.
   pango_cairo_context_set_resolution(pango_layout_get_context(layout),
-                                     GetPangoDPI());
+                                     kStandardDPI);
 
   // Set text and accelerator character if needed.
   if (flags & Canvas::SHOW_PREFIX) {
     // Escape the text string to be used as markup.
     std::string utf8 = base::UTF16ToUTF8(text);
     gchar* escaped_text = g_markup_escape_text(utf8.c_str(), utf8.size());
     pango_layout_set_markup_with_accel(layout,
                                        escaped_text,
                                        strlen(escaped_text),
                                        kAcceleratorChar, NULL);
@@ skipping 21 matching lines @@
       font_list.GetFontDescriptionString().c_str()));
   pango_layout_set_font_description(layout, desc.get());
 }
 
 int GetPangoFontSizeInPixels(PangoFontDescription* pango_font) {
   // If the size is absolute, then it's in Pango units rather than points. There
   // are PANGO_SCALE Pango units in a device unit (pixel).
   if (pango_font_description_get_size_is_absolute(pango_font))
     return pango_font_description_get_size(pango_font) / PANGO_SCALE;
 
+  const double scale = kStandardDPI / kPointsPerInch;
   // Otherwise, we need to convert from points.
-  return static_cast<int>(GetPixelsInPoint() *
-      pango_font_description_get_size(pango_font) / PANGO_SCALE + 0.5);
+  return static_cast<int>(
+      scale * pango_font_description_get_size(pango_font) / PANGO_SCALE + 0.5);
 }
 
 PangoFontMetrics* GetPangoFontMetrics(PangoFontDescription* desc) {
   static std::map<int, PangoFontMetrics*>* desc_to_metrics = NULL;
   static PangoContext* context = NULL;
 
   if (!context) {
     context = GetPangoContext();
     pango_context_set_language(context, pango_language_get_default());
   }
 
   if (!desc_to_metrics)
     desc_to_metrics = new std::map<int, PangoFontMetrics*>();
 
   const int desc_hash = pango_font_description_hash(desc);
   std::map<int, PangoFontMetrics*>::iterator i =
       desc_to_metrics->find(desc_hash);
 
   if (i == desc_to_metrics->end()) {
     PangoFontMetrics* metrics = pango_context_get_metrics(context, desc, NULL);
     desc_to_metrics->insert(std::make_pair(desc_hash, metrics));
     return metrics;
   }
   return i->second;
 }
 
 }  // namespace gfx