Fixes vertical alignment of RenderText.

ui/gfx/font_list.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 <stdlib.h>
+#include "ui/gfx/font_list.h"
+
+#include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "ui/gfx/font_list.h"
 
 namespace {
 
 // Parses font description into |font_names|, |font_style| and |font_size|.
 void ParseFontDescriptionString(const std::string& font_description_string,
                                 std::vector<std::string>* font_names,
                                 int* font_style,
                                 int* font_size) {
   base::SplitString(font_description_string, ',', font_names);
   DCHECK_GT(font_names->size(), 1U);
@@ skipping 40 matching lines @@
                                  int font_size) {
   std::string description = JoinString(font_names, ',');
   description += "," + FontStyleAndSizeToString(font_style, font_size);
   return description;
 }
 
 }  // namespace
 
 namespace gfx {
 
-FontList::FontList() {
+FontList::FontList() : common_height_(-1), common_baseline_(-1) {
   fonts_.push_back(Font());
 }
 
 FontList::FontList(const std::string& font_description_string)
-    : font_description_string_(font_description_string) {
+    : font_description_string_(font_description_string),
+      common_height_(-1),
+      common_baseline_(-1) {
   DCHECK(!font_description_string.empty());
   // DCHECK description string ends with "px" for size in pixel.
   DCHECK(EndsWith(font_description_string, "px", true));
 }
 
 FontList::FontList(const std::vector<Font>& fonts)
-    : fonts_(fonts) {
+    : fonts_(fonts),
+      common_height_(-1),
+      common_baseline_(-1) {
   DCHECK(!fonts.empty());
   if (DCHECK_IS_ON()) {
     int style = fonts[0].GetStyle();
     int size = fonts[0].GetFontSize();
     for (size_t i = 1; i < fonts.size(); ++i) {
       DCHECK_EQ(fonts[i].GetStyle(), style);
       DCHECK_EQ(fonts[i].GetFontSize(), size);
     }
   }
 }
 
-FontList::FontList(const Font& font) {
+FontList::FontList(const Font& font)
+    : common_height_(-1),
+      common_baseline_(-1) {
   fonts_.push_back(font);
 }
 
 FontList::~FontList() {
 }
 
 FontList FontList::DeriveFontList(int font_style) const {
   // If there is a font vector, derive from that.
   if (!fonts_.empty()) {
     std::vector<Font> fonts = fonts_;
@@ skipping 32 matching lines @@
   int font_style = 0;
   ParseFontDescriptionString(font_description_string_, &font_names,
                              &font_style, &old_size);
 
   if (old_size == size)
     return FontList(font_description_string_);
 
   return FontList(BuildFontDescription(font_names, font_style, size));
 }
 
+int FontList::GetHeight() const {
+  if (common_height_ < 0) {
+    int ascent = 0;
+    int descent = 0;
+    const std::vector<Font>& fonts = GetFonts();
+    for (std::vector<Font>::const_iterator i = fonts.begin();
+         i != fonts.end(); ++i) {
+      ascent = std::max(ascent, i->GetBaseline());
+      descent = std::max(descent, i->GetHeight() - i->GetBaseline());
+    }
+    common_height_ = ascent + descent;
+  }
+  return common_height_;
+}
+
+int FontList::GetBaseline() const {
+  if (common_baseline_ < 0) {
+    int baseline = 0;
+    const std::vector<Font>& fonts = GetFonts();
+    for (std::vector<Font>::const_iterator i = fonts.begin();
+         i != fonts.end(); ++i) {
+      baseline = std::max(baseline, i->GetBaseline());
+    }
+    common_baseline_ = baseline;
+  }
+  return common_baseline_;
+}
+
 int FontList::GetFontStyle() const {
   if (!fonts_.empty())
     return fonts_[0].GetStyle();
 
   std::vector<std::string> font_names;
   int font_style;
   int font_size;
   ParseFontDescriptionString(font_description_string_, &font_names,
                              &font_style, &font_size);
   return font_style;
@@ skipping 30 matching lines @@
       if (font_style == Font::NORMAL)
         fonts_.push_back(font);
       else
         fonts_.push_back(font.DeriveFont(0, font_style));
     }
   }
   return fonts_;
 }
 
 }  // namespace gfx