aura: Make 'ui' buildable without gtk.

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_gtk.h"
+#include "ui/gfx/platform_font_pango.h"
 
 #include <algorithm>
 #include <fontconfig/fontconfig.h>
 #include <map>
 #include <pango/pango.h>
 #include <string>
 
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/linux_util.h"
 
-#if !defined(USE_WAYLAND)
+#if !defined(USE_WAYLAND) && defined(TOOLKIT_USES_GTK)
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 #endif
 
 namespace {
 
 // The font family name which is used when a user's application font for
 // GNOME/KDE is a non-scalable one. The name should be listed in the
 // IsFallbackFontAllowed function in skia/ext/SkFontHost_fontconfig_direct.cpp.
 const char* kFallbackFontFamilyName = "sans";
@@ skipping 74 matching lines @@
   FcPatternGetString(match, FC_FAMILY, 0, &match_family);
 
   string16 font_family = UTF8ToUTF16(reinterpret_cast<char*>(match_family));
   FcPatternDestroy(match);
   FcPatternDestroy(pattern);
   free(family_name_copy);
   return font_family;
 }
 
 std::string GetDefaultFont() {
-#if defined(USE_WAYLAND) || defined(USE_AURA)
+#if defined(USE_WAYLAND) || !defined(TOOLKIT_USES_GTK)
   return "sans 10";
 #else
   GtkSettings* settings = gtk_settings_get_default();
 
   gchar* font_name = NULL;
   g_object_get(settings, "gtk-font-name", &font_name, NULL);
 
   // Temporary CHECK for helping track down
   // http://code.google.com/p/chromium/issues/detail?id=12530
   CHECK(font_name) << " Unable to get gtk-font-name for default font.";
 
   std::string default_font = std::string(font_name);
   g_free(font_name);
   return default_font;
 #endif
 }
 
 }  // namespace
 
 namespace gfx {
 
-Font* PlatformFontGtk::default_font_ = NULL;
+Font* PlatformFontPango::default_font_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
-// PlatformFontGtk, public:
+// PlatformFontPango, public:
 
-PlatformFontGtk::PlatformFontGtk() {
+PlatformFontPango::PlatformFontPango() {
   if (default_font_ == NULL) {
     std::string font_name = GetDefaultFont();
 
     PangoFontDescription* desc =
         pango_font_description_from_string(font_name.c_str());
     default_font_ = new Font(desc);
     pango_font_description_free(desc);
 
     DCHECK(default_font_);
   }
 
   InitFromPlatformFont(
-      static_cast<PlatformFontGtk*>(default_font_->platform_font()));
+      static_cast<PlatformFontPango*>(default_font_->platform_font()));
 }
 
-PlatformFontGtk::PlatformFontGtk(const Font& other) {
+PlatformFontPango::PlatformFontPango(const Font& other) {
   InitFromPlatformFont(
-      static_cast<PlatformFontGtk*>(other.platform_font()));
+      static_cast<PlatformFontPango*>(other.platform_font()));
 }
 
-PlatformFontGtk::PlatformFontGtk(NativeFont native_font) {
+PlatformFontPango::PlatformFontPango(NativeFont native_font) {
   const char* family_name = pango_font_description_get_family(native_font);
 
   gint size_in_pixels = 0;
   if (pango_font_description_get_size_is_absolute(native_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_font_description_get_size(native_font) / PANGO_SCALE;
   } else {
     // Otherwise, we need to convert from points.
     size_in_pixels =
@@ skipping 14 matching lines @@
     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 string16& font_name,
-                                 int font_size) {
+PlatformFontPango::PlatformFontPango(const string16& font_name,
+                                     int font_size) {
   InitWithNameAndSize(font_name, font_size);
 }
 
-double PlatformFontGtk::underline_position() const {
-  const_cast<PlatformFontGtk*>(this)->InitPangoMetrics();
+double PlatformFontPango::underline_position() const {
+  const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return underline_position_pixels_;
 }
 
-double PlatformFontGtk::underline_thickness() const {
-  const_cast<PlatformFontGtk*>(this)->InitPangoMetrics();
+double PlatformFontPango::underline_thickness() const {
+  const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return underline_thickness_pixels_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// PlatformFontGtk, PlatformFont implementation:
+// PlatformFontPango, PlatformFont implementation:
 
 // static
-void PlatformFontGtk::ReloadDefaultFont() {
+void PlatformFontPango::ReloadDefaultFont() {
   delete default_font_;
   default_font_ = NULL;
 }
 
-Font PlatformFontGtk::DeriveFont(int size_delta, int style) const {
+Font PlatformFontPango::DeriveFont(int size_delta, int style) const {
   // If the delta is negative, if must not push the size below 1
   if (size_delta < 0)
     DCHECK_LT(-size_delta, font_size_pixels_);
 
   if (style == style_) {
     // Fast path, we just use the same typeface at a different size
-    return Font(new PlatformFontGtk(typeface_,
-                                    font_family_,
-                                    font_size_pixels_ + size_delta,
-                                    style_));
+    return Font(new PlatformFontPango(typeface_,
+                                      font_family_,
+                                      font_size_pixels_ + size_delta,
+                                      style_));
   }
 
   // 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(),
       static_cast<SkTypeface::Style>(skstyle));
   SkAutoUnref tf_helper(typeface);
 
-  return Font(new PlatformFontGtk(typeface,
-                                  font_family_,
-                                  font_size_pixels_ + size_delta,
-                                  style));
+  return Font(new PlatformFontPango(typeface,
+                                    font_family_,
+                                    font_size_pixels_ + size_delta,
+                                    style));
 }
 
-int PlatformFontGtk::GetHeight() const {
+int PlatformFontPango::GetHeight() const {
   return height_pixels_;
 }
 
-int PlatformFontGtk::GetBaseline() const {
+int PlatformFontPango::GetBaseline() const {
   return ascent_pixels_;
 }
 
-int PlatformFontGtk::GetAverageCharacterWidth() const {
+int PlatformFontPango::GetAverageCharacterWidth() const {
   return SkScalarRound(average_width_pixels_);
 }
 
-int PlatformFontGtk::GetStringWidth(const string16& text) const {
+int PlatformFontPango::GetStringWidth(const string16& text) const {
   int width = 0, height = 0;
-  CanvasSkia::SizeStringInt(text, Font(const_cast<PlatformFontGtk*>(this)),
+  CanvasSkia::SizeStringInt(text, Font(const_cast<PlatformFontPango*>(this)),
                             &width, &height, gfx::Canvas::NO_ELLIPSIS);
   return width;
 }
 
-int PlatformFontGtk::GetExpectedTextWidth(int length) const {
-  double char_width = const_cast<PlatformFontGtk*>(this)->GetAverageWidth();
+int PlatformFontPango::GetExpectedTextWidth(int length) const {
+  double char_width = const_cast<PlatformFontPango*>(this)->GetAverageWidth();
   return round(static_cast<float>(length) * char_width);
 }
 
-int PlatformFontGtk::GetStyle() const {
+int PlatformFontPango::GetStyle() const {
   return style_;
 }
 
-string16 PlatformFontGtk::GetFontName() const {
+string16 PlatformFontPango::GetFontName() const {
   return font_family_;
 }
 
-int PlatformFontGtk::GetFontSize() const {
+int PlatformFontPango::GetFontSize() const {
   return font_size_pixels_;
 }
 
-NativeFont PlatformFontGtk::GetNativeFont() const {
+NativeFont PlatformFontPango::GetNativeFont() const {
   PangoFontDescription* pfd = pango_font_description_new();
   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() 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.
       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:
+// PlatformFontPango, private:
 
-PlatformFontGtk::PlatformFontGtk(SkTypeface* typeface,
-                                 const string16& name,
-                                 int size,
-                                 int style) {
+PlatformFontPango::PlatformFontPango(SkTypeface* typeface,
+                                     const string16& name,
+                                     int size,
+                                     int style) {
   InitWithTypefaceNameSizeAndStyle(typeface, name, size, style);
 }
 
-PlatformFontGtk::~PlatformFontGtk() {}
+PlatformFontPango::~PlatformFontPango() {}
 
-void PlatformFontGtk::InitWithNameAndSize(const string16& font_name,
-                                          int font_size) {
+void PlatformFontPango::InitWithNameAndSize(const string16& font_name,
+                                            int font_size) {
   DCHECK_GT(font_size, 0);
   string16 fallback;
 
   SkTypeface* typeface = SkTypeface::CreateFromName(
       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: "
                     << UTF16ToUTF8(font_name)
                     << ", " << kFallbackFontFamilyName;
     fallback = UTF8ToUTF16(kFallbackFontFamilyName);
   }
   SkAutoUnref typeface_helper(typeface);
 
   InitWithTypefaceNameSizeAndStyle(typeface,
                                    fallback.empty() ? font_name : fallback,
                                    font_size,
                                    gfx::Font::NORMAL);
 }
 
-void PlatformFontGtk::InitWithTypefaceNameSizeAndStyle(
+void PlatformFontPango::InitWithTypefaceNameSizeAndStyle(
     SkTypeface* typeface,
     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_pixels_ = font_size;
   style_ = style;
   pango_metrics_inited_ = false;
   average_width_pixels_ = 0.0f;
   underline_position_pixels_ = 0.0f;
   underline_thickness_pixels_ = 0.0f;
 
   SkPaint paint;
   SkPaint::FontMetrics metrics;
   PaintSetup(&paint);
   paint.getFontMetrics(&metrics);
 
   ascent_pixels_ = SkScalarCeil(-metrics.fAscent);
   height_pixels_ = ascent_pixels_ + SkScalarCeil(metrics.fDescent);
 }
 
-void PlatformFontGtk::InitFromPlatformFont(const PlatformFontGtk* other) {
+void PlatformFontPango::InitFromPlatformFont(const PlatformFontPango* other) {
   typeface_helper_.reset(new SkAutoUnref(other->typeface_));
   typeface_ = other->typeface_;
   typeface_->ref();
   font_family_ = other->font_family_;
   font_size_pixels_ = other->font_size_pixels_;
   style_ = other->style_;
   height_pixels_ = other->height_pixels_;
   ascent_pixels_ = other->ascent_pixels_;
   pango_metrics_inited_ = other->pango_metrics_inited_;
   average_width_pixels_ = other->average_width_pixels_;
   underline_position_pixels_ = other->underline_position_pixels_;
   underline_thickness_pixels_ = other->underline_thickness_pixels_;
 }
 
-void PlatformFontGtk::PaintSetup(SkPaint* paint) const {
+void PlatformFontPango::PaintSetup(SkPaint* paint) const {
   paint->setAntiAlias(false);
   paint->setSubpixelText(false);
   paint->setTextSize(font_size_pixels_);
   paint->setTypeface(typeface_);
   paint->setFakeBoldText((gfx::Font::BOLD & style_) && !typeface_->isBold());
   paint->setTextSkewX((gfx::Font::ITALIC & style_) && !typeface_->isItalic() ?
                       -SK_Scalar1/4 : 0);
 }
 
-void PlatformFontGtk::InitPangoMetrics() {
+void PlatformFontPango::InitPangoMetrics() {
   if (!pango_metrics_inited_) {
     pango_metrics_inited_ = true;
     PangoFontDescription* pango_desc = GetNativeFont();
     PangoFontMetrics* pango_metrics = GetPangoFontMetrics(pango_desc);
 
     underline_position_pixels_ =
         pango_font_metrics_get_underline_position(pango_metrics) /
         PANGO_SCALE;
 
     // TODO(davemoore): Come up with a better solution.
@@ skipping 14 matching lines @@
     // conversions.
     int text_width_pixels = GetStringWidth(
         ASCIIToUTF16("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     double dialog_units_pixels = (text_width_pixels / 26 + 1) / 2;
     average_width_pixels_ = std::min(pango_width_pixels, dialog_units_pixels);
     pango_font_description_free(pango_desc);
   }
 }
 
 
-double PlatformFontGtk::GetAverageWidth() const {
-  const_cast<PlatformFontGtk*>(this)->InitPangoMetrics();
+double PlatformFontPango::GetAverageWidth() const {
+  const_cast<PlatformFontPango*>(this)->InitPangoMetrics();
   return average_width_pixels_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFont, public:
 
 // static
 PlatformFont* PlatformFont::CreateDefault() {
-  return new PlatformFontGtk;
+  return new PlatformFontPango;
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromFont(const Font& other) {
-  return new PlatformFontGtk(other);
+  return new PlatformFontPango(other);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
-  return new PlatformFontGtk(native_font);
+  return new PlatformFontPango(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const string16& font_name,
                                                   int font_size) {
-  return new PlatformFontGtk(font_name, font_size);
+  return new PlatformFontPango(font_name, font_size);
 }
 
 }  // namespace gfx