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 67 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 36 matching lines @@
     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
   } 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());
+  pango_cairo_context_set_resolution(pango_layout_get_context(layout), 96.0);

[ananta, 2014/10/17 00:49:06]

Is hardcoding to 96 here and below the right thing to do?. GetPangoDPI() would
also return the scale from the delegate.

[scottmg, 2014/10/17 23:18:42]

I'm not sure. The behaviour I'm seeing without making this 96 is that the fonts
end up scaled twice. i.e. when the desktop is 2x, the fonts are 4x.

AFAICT, this is because the device/display is 2x, so we don't also want to take
it into account here and scale the fonts a second time. (I'm a little confused
how it all fits together on Linux though.)

 
   // 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 22 matching lines @@
   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;
 
   // Otherwise, we need to convert from points.
-  return static_cast<int>(GetPixelsInPoint() *
+  return static_cast<int>((96.0 / 72.0) *

[ananta, 2014/10/17 00:49:06]

ditto

[oshima, 2014/10/22 19:48:07]

can you define const for these values with description?

       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