Vertically center multi-line RenderTextHarfBuzz that uses SetMinLineHeight().

ui/gfx/render_text.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/render_text.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
@@ skipping 48 matching lines @@
 const SkScalar kUnderlineOffset = (SK_Scalar1 / 9);
 // Fraction of the text size to use for a strike through or under-line.
 const SkScalar kLineThickness = (SK_Scalar1 / 18);
 // Fraction of the text size to use for a top margin of a diagonal strike.
 const SkScalar kDiagonalStrikeMarginOffset = (SK_Scalar1 / 4);
 
 // Invalid value of baseline.  Assigning this value to |baseline_| causes
 // re-calculation of baseline.
 const int kInvalidBaseline = INT_MAX;
 
-// Returns the baseline, with which the text best appears vertically centered.
-int DetermineBaselineCenteringText(const Rect& display_rect,
-                                   const FontList& font_list) {
-  const int display_height = display_rect.height();
-  const int font_height = font_list.GetHeight();
-  // Lower and upper bound of baseline shift as we try to show as much area of
-  // text as possible.  In particular case of |display_height| == |font_height|,
-  // we do not want to shift the baseline.
-  const int min_shift = std::min(0, display_height - font_height);
-  const int max_shift = std::abs(display_height - font_height);
-  const int baseline = font_list.GetBaseline();
-  const int cap_height = font_list.GetCapHeight();
-  const int internal_leading = baseline - cap_height;
-  // Some platforms don't support getting the cap height, and simply return
-  // the entire font ascent from GetCapHeight().  Centering the ascent makes
-  // the font look too low, so if GetCapHeight() returns the ascent, center
-  // the entire font height instead.
-  const int space =
-      display_height - ((internal_leading != 0) ? cap_height : font_height);
-  const int baseline_shift = space / 2 - internal_leading;
-  return baseline + std::max(min_shift, std::min(max_shift, baseline_shift));
-}
-
 int round(float value) {
   return static_cast<int>(floor(value + 0.5f));
 }
 
 // Given |font| and |display_width|, returns the width of the fade gradient.
 int CalculateFadeGradientWidth(const FontList& font_list, int display_width) {
   // Fade in/out about 3 characters of the beginning/end of the string.
   // Use a 1/3 of the display width if the display width is very short.
   const int narrow_width = font_list.GetExpectedTextWidth(3);
   const int gradient_width = std::min(narrow_width, round(display_width / 3.f));
@@ skipping 729 matching lines @@
   const float string_size = GetStringSizeF().width();
   // The cursor is drawn one pixel beyond the int-enclosed text bounds.
   return cursor_enabled_ ? std::ceil(string_size) + 1 : string_size;
 }
 
 int RenderText::GetContentWidth() {
   return ToCeiledInt(GetContentWidthF());
 }
 
 int RenderText::GetBaseline() {
-  if (baseline_ == kInvalidBaseline)
-    baseline_ = DetermineBaselineCenteringText(display_rect(), font_list());
+  if (baseline_ == kInvalidBaseline) {
+    baseline_ =
+        DetermineBaselineCenteringText(display_rect().height(), font_list());
+  }
   DCHECK_NE(kInvalidBaseline, baseline_);
   return baseline_;
 }
 
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
   if (clip_to_display_rect()) {
     Rect clip_rect(display_rect());
     clip_rect.Inset(ShadowValue::GetMargin(shadows_));
@@ skipping 540 matching lines @@
 // static
 bool RenderText::RangeContainsCaret(const Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
       caret_pos - 1 : caret_pos + 1;
   return range.Contains(Range(caret_pos, adjacent));
 }
 
+// static
+int RenderText::DetermineBaselineCenteringText(const int display_height,
+                                               const FontList& font_list) {
+  const int font_height = font_list.GetHeight();
+  // Lower and upper bound of baseline shift as we try to show as much area of
+  // text as possible.  In particular case of |display_height| == |font_height|,
+  // we do not want to shift the baseline.
+  const int min_shift = std::min(0, display_height - font_height);
+  const int max_shift = std::abs(display_height - font_height);
+  const int baseline = font_list.GetBaseline();
+  const int cap_height = font_list.GetCapHeight();
+  const int internal_leading = baseline - cap_height;
+  // Some platforms don't support getting the cap height, and simply return
+  // the entire font ascent from GetCapHeight().  Centering the ascent makes
+  // the font look too low, so if GetCapHeight() returns the ascent, center
+  // the entire font height instead.
+  const int space =
+      display_height - ((internal_leading != 0) ? cap_height : font_height);
+  const int baseline_shift = space / 2 - internal_leading;
+  return baseline + std::max(min_shift, std::min(max_shift, baseline_shift));
+}
+
 void RenderText::MoveCursorTo(size_t position, bool select) {
   size_t cursor = std::min(position, text().length());
   if (IsValidCursorIndex(cursor))
     SetSelectionModel(SelectionModel(
         Range(select ? selection().start() : cursor, cursor),
         (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
 }
 
 void RenderText::OnTextAttributeChanged() {
   layout_text_.clear();
@@ skipping 282 matching lines @@
 
   for (; range_max < length; ++range_max)
     if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
       break;
 
   return range.is_reversed() ? Range(range_max, range_min)
                              : Range(range_min, range_max);
 }
 
 }  // namespace gfx