Attempt 4 at fixing font size on linux. I think I finally got...

app/gfx/font_skia.cc

 // Copyright (c) 2006-2008 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 "app/gfx/font.h"
 
+#include <gdk/gdk.h>
+#include <pango/pango.h>
+
 #include "app/gfx/canvas.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "base/sys_string_conversions.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
 // 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";
 
+// Pango scales font sizes. This returns the scale factor. See
+// pango_cairo_context_set_resolution for details.
+// NOTE: this isn't entirely accurate, in that Pango also consults the
+// FC_PIXEL_SIZE first (see get_font_size in pangocairo-fcfont), but this
+// seems to give us the same sizes as used by Pango for all our fonts in both
+// English and Thia.
+static double GetPangoScaleFactor() {
+  static float scale_factor = 0;
+  static bool determined_scale = false;
+  if (!determined_scale) {
+    PangoContext* context = gdk_pango_context_get();
+    scale_factor = pango_cairo_context_get_resolution(context);
+    g_object_unref(context);
+    if (scale_factor <= 0)
+      scale_factor = 1;
+    else
+      scale_factor /= 72.0;
+  }
+  return scale_factor;
+}
+
 }  // namespace
 
 namespace gfx {
 
 Font::Font(const Font& other) {
   CopyFont(other);
 }
 
 Font& Font::operator=(const Font& other) {
   CopyFont(other);
@@ skipping 11 matching lines @@
   calculateMetrics();
 }
 
 void Font::calculateMetrics() {
   SkPaint paint;
   SkPaint::FontMetrics metrics;
 
   PaintSetup(&paint);
   paint.getFontMetrics(&metrics);
 
-  // NOTE: we don't use the ascent/descent as it doesn't match with how pango
-  // ends up drawing the text, in particular if we clip to the ascent/descent
-  // the text is clipped. This algorithm doesn't give us an exact match with
-  // the numbers returned from pango (we are off by 1 in some cases), but it
-  // is close enough that you won't notice clipping.
-  //
-  // NOTE2: I tried converting this to use Pango exclusively for measuring the
-  // text but it causes a startup regression. The best I could get it was
-  // ~10% slow down. Slow down appeared to be entirely in libfontconfig.
-  ascent_ = SkScalarCeil(-metrics.fTop);
-  height_ = SkScalarCeil(-metrics.fTop) + SkScalarCeil(metrics.fBottom) +
-            SkScalarCeil(metrics.fLeading);
+  ascent_ = SkScalarCeil(-metrics.fAscent);
+  height_ = ascent_ + SkScalarCeil(metrics.fDescent);
 
   if (metrics.fAvgCharWidth) {
     avg_width_ = SkScalarRound(metrics.fAvgCharWidth);
   } else {
     static const char x_char = 'x';
     paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
     SkScalar width = paint.measureText(&x_char, 1);
 
     avg_width_ = static_cast<int>(ceilf(SkScalarToFloat(width)));
   }
@@ skipping 67 matching lines @@
       base::SysWideToUTF8(font_family_).c_str(),
       static_cast<SkTypeface::Style>(skstyle));
   SkAutoUnref tf_helper(tf);
 
   return Font(tf, font_family_, font_size_ + size_delta, skstyle);
 }
 
 void Font::PaintSetup(SkPaint* paint) const {
   paint->setAntiAlias(false);
   paint->setSubpixelText(false);
-  paint->setTextSize(SkFloatToScalar(font_size_));
+  paint->setTextSize(SkFloatToScalar(font_size_ * GetPangoScaleFactor()));
   paint->setTypeface(typeface_);
   paint->setFakeBoldText((BOLD & style_) && !typeface_->isBold());
   paint->setTextSkewX((ITALIC & style_) && !typeface_->isItalic() ?
                       -SK_Scalar1/4 : 0);
 }
 
 int Font::GetStringWidth(const std::wstring& text) const {
   int width = 0, height = 0;
 
   Canvas::SizeStringInt(text, *this, &width, &height, 0);
@@ skipping 15 matching lines @@
 
 int Font::FontSize() {
   return font_size_;
 }
 
 NativeFont Font::nativeFont() const {
   return typeface_;
 }
 
 }  // namespace gfx