Remove wstring from gfx.

gfx/platform_font_gtk.cc

 // Copyright (c) 2010 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 "gfx/platform_font_gtk.h"
 
 #include <algorithm>
 #include <fontconfig/fontconfig.h>
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 #include <map>
 #include <pango/pango.h>
 
 #include "base/logging.h"
 #include "base/string_piece.h"
-#include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/font.h"
 #include "gfx/gtk_util.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/core/SkPaint.h"
 
 namespace {
 
 // The font family name which is used when a user's application font for
@@ skipping 33 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.
-std::wstring FindBestMatchFontFamilyName(const char* family_name) {
+string16 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);
 
-  std::wstring font_family = UTF8ToWide(reinterpret_cast<char*>(match_family));
+  string16 font_family = UTF8ToUTF16(reinterpret_cast<char*>(match_family));
   FcPatternDestroy(match);
   FcPatternDestroy(pattern);
   free(family_name_copy);
   return font_family;
 }
 
 }  // namespace
 
 namespace gfx {
 
@@ skipping 38 matching lines @@
   if (pango_font_description_get_size_is_absolute(native_font)) {
     // font_size_ is treated as scaled (see comment in GetPangoScaleFactor). If
     // we get here the font size is absolute though, and we need to invert the
     // scale so that when scaled in the rest of this class everything lines up.
     size /= GetPangoScaleFactor();
   }
 
   // Find best match font for |family_name| to make sure we can get
   // a SkTypeface for the default font.
   // TODO(agl): remove this.
-  std::wstring font_family = FindBestMatchFontFamilyName(family_name);
+  string16 font_family = FindBestMatchFontFamilyName(family_name);
 
   InitWithNameAndSize(font_family, size / PANGO_SCALE);
   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;
 }
 
-PlatformFontGtk::PlatformFontGtk(const std::wstring& font_name,
+PlatformFontGtk::PlatformFontGtk(const string16& font_name,
                                  int font_size) {
   InitWithNameAndSize(font_name, font_size);
 }
 
 double PlatformFontGtk::underline_position() const {
   const_cast<PlatformFontGtk*>(this)->InitPangoMetrics();
   return underline_position_;
 }
 
 double PlatformFontGtk::underline_thickness() const {
@@ skipping 18 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(
-      base::SysWideToUTF8(font_family_).c_str(),
+      UTF16ToUTF8(font_family_).c_str(),
       static_cast<SkTypeface::Style>(skstyle));
   SkAutoUnref tf_helper(typeface);
 
   return Font(new PlatformFontGtk(typeface,
                                   font_family_,
                                   font_size_ + size_delta,
                                   style));
 }
 
 int PlatformFontGtk::GetHeight() const {
@@ skipping 17 matching lines @@
 
 int PlatformFontGtk::GetExpectedTextWidth(int length) const {
   double char_width = const_cast<PlatformFontGtk*>(this)->GetAverageWidth();
   return round(static_cast<float>(length) * char_width);
 }
 
 int PlatformFontGtk::GetStyle() const {
   return style_;
 }
 
-const std::wstring& PlatformFontGtk::GetFontName() const {
+string16 PlatformFontGtk::GetFontName() const {
   return font_family_;
 }
 
 int PlatformFontGtk::GetFontSize() const {
   return font_size_;
 }
 
 NativeFont PlatformFontGtk::GetNativeFont() const {
   PangoFontDescription* pfd = pango_font_description_new();
-  pango_font_description_set_family(pfd, WideToUTF8(GetFontName()).c_str());
+  pango_font_description_set_family(pfd, UTF16ToUTF8(GetFontName()).c_str());
   // Set the absolute size to avoid overflowing UI elements.
   pango_font_description_set_absolute_size(pfd,
       GetFontSize() * PANGO_SCALE * GetPangoScaleFactor());
 
   switch (GetStyle()) {
     case gfx::Font::NORMAL:
       // Nothing to do, should already be PANGO_STYLE_NORMAL.
       break;
     case gfx::Font::BOLD:
       pango_font_description_set_weight(pfd, PANGO_WEIGHT_BOLD);
       break;
     case gfx::Font::ITALIC:
       pango_font_description_set_style(pfd, PANGO_STYLE_ITALIC);
       break;
     case gfx::Font::UNDERLINED:
       // TODO(deanm): How to do underlined?  Where do we use it?  Probably have
       // to paint it ourselves, see pango_font_metrics_get_underline_position.
       break;
   }
 
   return pfd;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontGtk, private:
 
 PlatformFontGtk::PlatformFontGtk(SkTypeface* typeface,
-                                 const std::wstring& name,
+                                 const string16& name,
                                  int size,
                                  int style) {
   InitWithTypefaceNameSizeAndStyle(typeface, name, size, style);
 }
 
 PlatformFontGtk::~PlatformFontGtk() {}
 
-void PlatformFontGtk::InitWithNameAndSize(const std::wstring& font_name,
+void PlatformFontGtk::InitWithNameAndSize(const string16& font_name,
                                           int font_size) {
   DCHECK_GT(font_size, 0);
-  std::wstring fallback;
+  string16 fallback;
 
   SkTypeface* typeface = SkTypeface::CreateFromName(
-      base::SysWideToUTF8(font_name).c_str(), SkTypeface::kNormal);
+      UTF16ToUTF8(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: "
-                    << base::SysWideToUTF8(font_name)
+                    << UTF16ToUTF8(font_name)
                     << ", " << kFallbackFontFamilyName;
-    fallback = base::SysUTF8ToWide(kFallbackFontFamilyName);
+    fallback = UTF8ToUTF16(kFallbackFontFamilyName);
   }
   SkAutoUnref typeface_helper(typeface);
 
   InitWithTypefaceNameSizeAndStyle(typeface,
                                    fallback.empty() ? font_name : fallback,
                                    font_size,
                                    gfx::Font::NORMAL);
 }
 
 void PlatformFontGtk::InitWithTypefaceNameSizeAndStyle(
     SkTypeface* typeface,
-    const std::wstring& font_family,
+    const string16& font_family,
     int font_size,
     int style) {
   typeface_helper_.reset(new SkAutoUnref(typeface));
   typeface_ = typeface;
   typeface_->ref();
   font_family_ = font_family;
   font_size_ = font_size;
   style_ = style;
   pango_metrics_inited_ = false;
   average_width_ = 0.0f;
@@ skipping 106 matching lines @@
 PlatformFont* PlatformFont::CreateFromFont(const Font& other) {
   return new PlatformFontGtk(other);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
   return new PlatformFontGtk(native_font);
 }
 
 // static
-PlatformFont* PlatformFont::CreateFromNameAndSize(const std::wstring& font_name,
+PlatformFont* PlatformFont::CreateFromNameAndSize(const string16& font_name,
                                                   int font_size) {
   return new PlatformFontGtk(font_name, font_size);
 }
 
 }  // namespace gfx