Remove unused custom vertical text alignment in CanvasSkia.

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/utf_string_conversions.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_render_params_linux.h"
 #include "ui/gfx/platform_font_pango.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_util.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gdk/gdk.h>
 #endif
 
+namespace gfx {
+
 namespace {
 
 // Marker for accelerators in the text.
 const gunichar kAcceleratorChar = '&';
 
 // Multiply by the text height to determine how much text should be faded
 // when elliding.
 const double kFadeWidthFactor = 1.5;
 
 // End state of the elliding fade.
 const double kFadeFinalAlpha = 0.15;
 
 // Return |cairo_font_options|. If needed, allocate and update 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 gfx::FontRenderParams& params = gfx::GetDefaultFontRenderParams();
-  gfx::FontRenderParams::SubpixelRendering subpixel = params.subpixel_rendering;
+  const FontRenderParams& params = GetDefaultFontRenderParams();
+  FontRenderParams::SubpixelRendering subpixel = params.subpixel_rendering;
   if (!params.antialiasing) {
     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_NONE);
-  } else if (subpixel == gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE) {
+  } else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_NONE) {
     cairo_font_options_set_antialias(cairo_font_options, CAIRO_ANTIALIAS_GRAY);
   } else {
     cairo_font_options_set_antialias(cairo_font_options,
                                      CAIRO_ANTIALIAS_SUBPIXEL);
     cairo_subpixel_order_t cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
-    if (subpixel == gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB)
+    if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_RGB)
       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_RGB;
-    else if (subpixel == gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR)
+    else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_BGR)
       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_BGR;
-    else if (subpixel == gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB)
+    else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VRGB)
       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VRGB;
-    else if (subpixel == gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR)
+    else if (subpixel == FontRenderParams::SUBPIXEL_RENDERING_VBGR)
       cairo_subpixel_order = CAIRO_SUBPIXEL_ORDER_VBGR;
     else
       NOTREACHED() << "Unhandled subpixel rendering type " << subpixel;
     cairo_font_options_set_subpixel_order(cairo_font_options,
                                           cairo_subpixel_order);
   }
 
-  if (params.hinting == gfx::FontRenderParams::HINTING_NONE ||
+  if (params.hinting == FontRenderParams::HINTING_NONE ||
       params.subpixel_positioning) {
     cairo_font_options_set_hint_style(cairo_font_options,
                                       CAIRO_HINT_STYLE_NONE);
     cairo_font_options_set_hint_metrics(cairo_font_options,
                                         CAIRO_HINT_METRICS_OFF);
   } else {
     cairo_hint_style_t cairo_hint_style = CAIRO_HINT_STYLE_DEFAULT;
-    if (params.hinting == gfx::FontRenderParams::HINTING_SLIGHT)
+    if (params.hinting == FontRenderParams::HINTING_SLIGHT)
       cairo_hint_style = CAIRO_HINT_STYLE_SLIGHT;
-    else if (params.hinting == gfx::FontRenderParams::HINTING_MEDIUM)
+    else if (params.hinting == FontRenderParams::HINTING_MEDIUM)
       cairo_hint_style = CAIRO_HINT_STYLE_MEDIUM;
-    else if (params.hinting == gfx::FontRenderParams::HINTING_FULL)
+    else if (params.hinting == FontRenderParams::HINTING_FULL)
       cairo_hint_style = CAIRO_HINT_STYLE_FULL;
     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 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 = gfx::GetPangoResolution();
+    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
 
-namespace gfx {
-
 PangoContext* GetPangoContext() {
 #if defined(USE_AURA)
   PangoFontMap* font_map = pango_cairo_font_map_get_default();
   return pango_font_map_create_context(font_map);
 #else
   return gdk_pango_context_get();
 #endif
 }
 
 double GetPangoResolution() {
@@ skipping 11 matching lines @@
 void DrawTextOntoCairoSurface(cairo_t* cr,
                               const string16& text,
                               const gfx::Font& font,
                               const gfx::Rect& bounds,
                               const gfx::Rect& clip,
                               SkColor text_color,
                               int flags) {
   PangoLayout* layout = pango_cairo_create_layout(cr);
   base::i18n::TextDirection text_direction =
       base::i18n::GetFirstStrongCharacterDirection(text);
-  Rect text_rect(bounds.x(), bounds.y(), 0, 0);
   DCHECK(!bounds.IsEmpty());
 
   gfx::SetupPangoLayout(
       layout, text, font, bounds.width(), text_direction, flags);
 
   pango_layout_set_height(layout, bounds.height() * PANGO_SCALE);
 
   cairo_save(cr);
   cairo_rectangle(cr, clip.x(), clip.y(), clip.width(), clip.height());
   cairo_clip(cr);
 
-  AdjustTextRectBasedOnLayout(layout, bounds, flags, &text_rect);
+  int width = 0, height = 0;
+  pango_layout_get_pixel_size(layout, &width, &height);
+  Rect text_rect(bounds.x(), bounds.y(), width, height);
+  // Vertically center |text_rect| in |bounds|.
+  text_rect.Offset(0, (bounds.height() - text_rect.height()) / 2);
 
   DrawPangoLayout(cr, layout, font, bounds, text_rect,
                   text_color, text_direction, flags);
 
   cairo_restore(cr);
   g_object_unref(layout);
 }
 
 // Pass a width greater than 0 to force wrapping and eliding.
 static void SetupPangoLayoutWithoutFont(
@@ skipping 115 matching lines @@
     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());
 }
 
-void AdjustTextRectBasedOnLayout(PangoLayout* layout,
-                                 const gfx::Rect& bounds,
-                                 int flags,
-                                 gfx::Rect* text_rect) {
-  int text_width, text_height;
-  pango_layout_get_pixel_size(layout, &text_width, &text_height);
-  text_rect->set_width(text_width);
-  text_rect->set_height(text_height);
-
-  if (flags & gfx::Canvas::TEXT_VALIGN_TOP) {
-    // Cairo should draw from the top left corner already.
-  } else if (flags & gfx::Canvas::TEXT_VALIGN_BOTTOM) {
-    text_rect->set_y(text_rect->y() + bounds.height() - text_rect->height());
-  } else {
-    // Vertically centered.
-    text_rect->set_y(text_rect->y() +
-                     ((bounds.height() - text_rect->height()) / 2));
-  }
-}
-
 void DrawPangoLayout(cairo_t* cr,
                      PangoLayout* layout,
                      const Font& font,
                      const gfx::Rect& bounds,
                      const gfx::Rect& text_rect,
                      SkColor text_color,
                      base::i18n::TextDirection text_direction,
                      int flags) {
   double r = SkColorGetR(text_color) / 255.0,
          g = SkColorGetG(text_color) / 255.0,
@@ skipping 90 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