Change string16 to std::string in the gfx::Font() interface.

ui/gfx/platform_font_pango.cc

 // Copyright (c) 2011 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/platform_font_pango.h"
 
 #include <algorithm>
 #include <fontconfig/fontconfig.h>
 #include <map>
 #include <pango/pango.h>
@@ skipping 73 matching lines @@
 // Find the best match font for |family_name| in the same way as Skia
 // to make sure CreateFont() successfully creates a default font.  In
 // Skia, it only checks the best match font.  If it failed to find
 // one, SkTypeface will be NULL for that font family.  It eventually
 // causes a segfault.  For example, family_name = "Sans" and system
 // may have various fonts.  The first font family in FcPattern will be
 // "DejaVu Sans" but a font family returned by FcFontMatch will be "VL
 // PGothic".  In this case, SkTypeface for "Sans" returns NULL even if
 // the system has a font for "Sans" font family.  See FontMatch() in
 // skia/ports/SkFontHost_fontconfig.cpp for more detail.
-string16 FindBestMatchFontFamilyName(const char* family_name) {
+std::string FindBestMatchFontFamilyName(const char* family_name) {
   FcPattern* pattern = FcPatternCreate();
   FcValue fcvalue;
   fcvalue.type = FcTypeString;
   char* family_name_copy = strdup(family_name);
   fcvalue.u.s = reinterpret_cast<FcChar8*>(family_name_copy);
   FcPatternAdd(pattern, FC_FAMILY, fcvalue, 0);
   FcConfigSubstitute(0, pattern, FcMatchPattern);
   FcDefaultSubstitute(pattern);
   FcResult result;
   FcPattern* match = FcFontMatch(0, pattern, &result);
   DCHECK(match) << "Could not find font: " << family_name;
   FcChar8* match_family;
   FcPatternGetString(match, FC_FAMILY, 0, &match_family);
 
-  string16 font_family = UTF8ToUTF16(reinterpret_cast<char*>(match_family));
+  std::string font_family(reinterpret_cast<char*>(match_family));
   FcPatternDestroy(match);
   FcPatternDestroy(pattern);
   free(family_name_copy);
   return font_family;
 }
 
 std::string GetDefaultFont() {
 #if defined(USE_WAYLAND) || !defined(TOOLKIT_USES_GTK)
   return "sans 10";
 #else
@@ skipping 53 matching lines @@
   } else {
     // Otherwise, we need to convert from points.
     size_in_pixels =
         pango_font_description_get_size(native_font) * GetPixelsInPoint() /
         PANGO_SCALE;
   }
 
   // Find best match font for |family_name| to make sure we can get
   // a SkTypeface for the default font.
   // TODO(agl): remove this.
-  string16 font_family = FindBestMatchFontFamilyName(family_name);
+  std::string font_family = FindBestMatchFontFamilyName(family_name);
 
   InitWithNameAndSize(font_family, size_in_pixels);
   int style = 0;
   if (pango_font_description_get_weight(native_font) == PANGO_WEIGHT_BOLD) {
     // TODO(davemoore) What should we do about other weights? We currently
     // only support BOLD.
     style |= gfx::Font::BOLD;
   }
   if (pango_font_description_get_style(native_font) == PANGO_STYLE_ITALIC) {
     // TODO(davemoore) What about PANGO_STYLE_OBLIQUE?
     style |= gfx::Font::ITALIC;
   }
   if (style != 0)
     style_ = style;
 }
 
-PlatformFontPango::PlatformFontPango(const string16& font_name,
+PlatformFontPango::PlatformFontPango(const std::string& font_name,
                                      int font_size) {
   InitWithNameAndSize(font_name, font_size);
 }
 
 double PlatformFontPango::underline_position() const {
   const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return underline_position_pixels_;
 }
 
 double PlatformFontPango::underline_thickness() const {
@@ skipping 24 matching lines @@
   }
 
   // If the style has changed we may need to load a new face
   int skstyle = SkTypeface::kNormal;
   if (gfx::Font::BOLD & style)
     skstyle |= SkTypeface::kBold;
   if (gfx::Font::ITALIC & style)
     skstyle |= SkTypeface::kItalic;
 
   SkTypeface* typeface = SkTypeface::CreateFromName(
-      UTF16ToUTF8(font_family_).c_str(),
+      font_family_.c_str(),
       static_cast<SkTypeface::Style>(skstyle));
   SkAutoUnref tf_helper(typeface);
 
   return Font(new PlatformFontPango(typeface,
                                     font_family_,
                                     font_size_pixels_ + size_delta,
                                     style));
 }
 
 int PlatformFontPango::GetHeight() const {
@@ skipping 18 matching lines @@
 
 int PlatformFontPango::GetExpectedTextWidth(int length) const {
   double char_width = const_cast<PlatformFontPango*>(this)->GetAverageWidth();
   return round(static_cast<float>(length) * char_width);
 }
 
 int PlatformFontPango::GetStyle() const {
   return style_;
 }
 
-string16 PlatformFontPango::GetFontName() const {
+std::string PlatformFontPango::GetFontName() const {
   return font_family_;
 }
 
 int PlatformFontPango::GetFontSize() const {
   return font_size_pixels_;
 }
 
 NativeFont PlatformFontPango::GetNativeFont() const {
   PangoFontDescription* pfd = pango_font_description_new();
-  pango_font_description_set_family(pfd, UTF16ToUTF8(GetFontName()).c_str());
+  pango_font_description_set_family(pfd, GetFontName().c_str());
   // Set the absolute size to avoid overflowing UI elements.
   // pango_font_description_set_absolute_size() takes a size in Pango units.
   // There are PANGO_SCALE Pango units in one device unit.  Screen output
   // devices use pixels as their device units.
   pango_font_description_set_absolute_size(
       pfd, font_size_pixels_ * PANGO_SCALE);
 
   switch (GetStyle()) {
     case gfx::Font::NORMAL:
       // Nothing to do, should already be PANGO_STYLE_NORMAL.
@@ skipping 10 matching lines @@
       break;
   }
 
   return pfd;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontPango, private:
 
 PlatformFontPango::PlatformFontPango(SkTypeface* typeface,
-                                     const string16& name,
+                                     const std::string& name,
                                      int size,
                                      int style) {
   InitWithTypefaceNameSizeAndStyle(typeface, name, size, style);
 }
 
 PlatformFontPango::~PlatformFontPango() {}
 
-void PlatformFontPango::InitWithNameAndSize(const string16& font_name,
+void PlatformFontPango::InitWithNameAndSize(const std::string& font_name,
                                             int font_size) {
   DCHECK_GT(font_size, 0);
-  string16 fallback;
+  std::string fallback;
 
   SkTypeface* typeface = SkTypeface::CreateFromName(
-      UTF16ToUTF8(font_name).c_str(), SkTypeface::kNormal);
+      font_name.c_str(), SkTypeface::kNormal);
   if (!typeface) {
     // A non-scalable font such as .pcf is specified. Falls back to a default
     // scalable font.
     typeface = SkTypeface::CreateFromName(
         kFallbackFontFamilyName, SkTypeface::kNormal);
     CHECK(typeface) << "Could not find any font: "
-                    << UTF16ToUTF8(font_name)
+                    << font_name
                     << ", " << kFallbackFontFamilyName;
-    fallback = UTF8ToUTF16(kFallbackFontFamilyName);
+    fallback = kFallbackFontFamilyName;
   }
   SkAutoUnref typeface_helper(typeface);
 
   InitWithTypefaceNameSizeAndStyle(typeface,
                                    fallback.empty() ? font_name : fallback,
                                    font_size,
                                    gfx::Font::NORMAL);
 }
 
 void PlatformFontPango::InitWithTypefaceNameSizeAndStyle(
     SkTypeface* typeface,
-    const string16& font_family,
+    const std::string& font_family,
     int font_size,
     int style) {
   typeface_helper_.reset(new SkAutoUnref(typeface));
   typeface_ = typeface;
   typeface_->ref();
   font_family_ = font_family;
   font_size_pixels_ = font_size;
   style_ = style;
   pango_metrics_inited_ = false;
   average_width_pixels_ = 0.0f;
@@ skipping 86 matching lines @@
 PlatformFont* PlatformFont::CreateFromFont(const Font& other) {
   return new PlatformFontPango(other);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
   return new PlatformFontPango(native_font);
 }
 
 // static
-PlatformFont* PlatformFont::CreateFromNameAndSize(const string16& font_name,
+PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontPango(font_name, font_size);
 }
 
 }  // namespace gfx