Simplify PangoLayout configuration.

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 <fontconfig/fontconfig.h>
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
 #include <string>
 
 #include <algorithm>
 #include <map>
-#include <vector>
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
 #include "ui/gfx/font_render_params_linux.h"
-#include "ui/gfx/platform_font_pango.h"
-#include "ui/gfx/rect.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
 namespace {
 
 // Marker for accelerators in the text.
 const gunichar kAcceleratorChar = '&';
 
-// Return |cairo_font_options|. If needed, allocate and update it.
+// 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);
+}
+
+// Returns a static cairo_font_options_t. If needed, allocates and updates it.
 // TODO(derat): Return font-specific options: http://crbug.com/125235
 cairo_font_options_t* GetCairoFontOptions() {
   // Font settings that we initialize once and then use when drawing text.
   static cairo_font_options_t* cairo_font_options = NULL;
   if (cairo_font_options)
     return cairo_font_options;
 
   cairo_font_options = cairo_font_options_create();
 
   const FontRenderParams& params = GetDefaultFontRenderParams();
@@ 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 resolution (DPI) used by pango. A negative value means the
+// resolution hasn't been set.
+double GetPangoResolution() {
+  static double resolution;
+  static bool determined_resolution = false;
+  if (!determined_resolution) {
+    determined_resolution = true;
+    PangoContext* default_context = GetPangoContext();
+    resolution = pango_cairo_context_get_resolution(default_context);
+    g_object_unref(default_context);
+  }
+  return resolution;
+}
+
 // 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
 float GetPixelsInPoint() {
   static float pixels_in_point = 1.0;
   static bool determined_value = false;
 
   if (!determined_value) {
     // http://goo.gl/UIh5m: "This is a scale factor between points specified in
     // a PangoFontDescription and Cairo units.  The default value is 96, meaning
     // that a 10 point font will be 13 units high. (10 * 96. / 72. = 13.3)."
     double pango_dpi = GetPangoResolution();
     if (pango_dpi <= 0)
       pango_dpi = 96.0;
     pixels_in_point = pango_dpi / 72.0;  // 72 points in an inch
     determined_value = true;
   }
 
   return pixels_in_point;
 }
 
 }  // namespace
 
-PangoContext* GetPangoContext() {
-  PangoFontMap* font_map = pango_cairo_font_map_get_default();
-  return pango_font_map_create_context(font_map);
-}
-
-double GetPangoResolution() {
-  static double resolution;
-  static bool determined_resolution = false;
-  if (!determined_resolution) {
-    determined_resolution = true;
-    PangoContext* default_context = GetPangoContext();
-    resolution = pango_cairo_context_get_resolution(default_context);
-    g_object_unref(default_context);
-  }
-  return resolution;
-}
-
-// Pass a width greater than 0 to force wrapping and eliding.
-static void SetupPangoLayoutWithoutFont(
+void SetUpPangoLayout(
     PangoLayout* layout,
     const base::string16& text,
-    int width,
+    const FontList& font_list,
     base::i18n::TextDirection text_direction,
     int flags) {
+  // TODO(derat): Use rendering parameters from |font_list| instead of defaults.
   cairo_font_options_t* cairo_font_options = GetCairoFontOptions();
 
   // If we got an explicit request to turn off subpixel rendering, disable it on
   // a copy of the static font options object.
   bool copied_cairo_font_options = false;
   if ((flags & Canvas::NO_SUBPIXEL_RENDERING) &&
       (cairo_font_options_get_antialias(cairo_font_options) ==
        CAIRO_ANTIALIAS_SUBPIXEL)) {
     cairo_font_options = cairo_font_options_copy(cairo_font_options);
     copied_cairo_font_options = true;
     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY);
   }
 
   // This needs to be done early on; it has no effect when called just before
   // pango_cairo_show_layout().
   pango_cairo_context_set_font_options(
       pango_layout_get_context(layout), cairo_font_options);
 
   if (copied_cairo_font_options) {
     cairo_font_options_destroy(cairo_font_options);
     cairo_font_options = NULL;
   }
 
   // Set Pango's base text direction explicitly from |text_direction|.
   pango_layout_set_auto_dir(layout, FALSE);
   pango_context_set_base_dir(pango_layout_get_context(layout),
       (text_direction == base::i18n::RIGHT_TO_LEFT ?
        PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR));
 
-  if (width > 0)
-    pango_layout_set_width(layout, width * PANGO_SCALE);
-
   if (flags & Canvas::TEXT_ALIGN_CENTER) {
     // We don't support center aligned w/ eliding.
     DCHECK(gfx::Canvas::NO_ELLIPSIS);
     pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
   } else if (flags & Canvas::TEXT_ALIGN_RIGHT) {
     pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
   }
 
   if (flags & Canvas::NO_ELLIPSIS) {
     pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
@@ skipping 41 matching lines @@
           RemoveAcceleratorChar(text,
                                 static_cast<base::char16>(kAcceleratorChar),
                                 NULL, NULL);
       utf8 = base::UTF16ToUTF8(accelerator_removed);
     } else {
       utf8 = base::UTF16ToUTF8(text);
     }
 
     pango_layout_set_text(layout, utf8.data(), utf8.size());
   }
-}
 
-void SetupPangoLayout(PangoLayout* layout,
-                      const base::string16& text,
-                      const Font& font,
-                      int width,
-                      base::i18n::TextDirection text_direction,
-                      int flags) {
-  SetupPangoLayoutWithoutFont(layout, text, width, text_direction, flags);
-
-  ScopedPangoFontDescription desc(font.GetNativeFont());
+  ScopedPangoFontDescription desc(pango_font_description_from_string(
+      font_list.GetFontDescriptionString().c_str()));
   pango_layout_set_font_description(layout, desc.get());
 }
 
-void SetupPangoLayoutWithFontDescription(
-    PangoLayout* layout,
-    const base::string16& text,
-    const std::string& font_description,
-    int width,
-    base::i18n::TextDirection text_direction,
-    int flags) {
-  SetupPangoLayoutWithoutFont(layout, text, width, text_direction, flags);
-
-  ScopedPangoFontDescription desc(
-      pango_font_description_from_string(font_description.c_str()));
-  pango_layout_set_font_description(layout, desc.get());
-}
-
 size_t GetPangoFontSizeInPixels(PangoFontDescription* pango_font) {
   size_t size_in_pixels = pango_font_description_get_size(pango_font);
   if (pango_font_description_get_size_is_absolute(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).
     size_in_pixels /= PANGO_SCALE;
   } else {
     // Otherwise, we need to convert from points.
     size_in_pixels = size_in_pixels * GetPixelsInPoint() / PANGO_SCALE;
   }
@@ skipping 18 matching lines @@
 
   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