Always aligns text at vertically center (Textfield, Label).

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 <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 330 matching lines @@
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
-void RenderText::SetVerticalAlignment(VerticalAlignment alignment) {
-  if (vertical_alignment_ != alignment) {
-    vertical_alignment_ = alignment;
-    display_offset_ = Vector2d();
-    cached_bounds_and_offset_valid_ = false;
-  }
-}
-
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
   cached_bounds_and_offset_valid_ = false;
   ResetLayout();
 }
 
 void RenderText::SetFont(const Font& font) {
   SetFontList(FontList(font));
 }
 
@@ skipping 277 matching lines @@
 
 SizeF RenderText::GetStringSizeF() {
   const Size size = GetStringSize();
   return SizeF(size.width(), size.height());
 }
 
 int RenderText::GetContentWidth() {
   return GetStringSize().width() + (cursor_enabled_ ? 1 : 0);
 }
 
+int RenderText::GetBaseline() {
+  UpdateCachedBoundsAndOffset();
+  return baseline_;
+}
+
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
   if (clip_to_display_rect()) {
     Rect clip_rect(display_rect());
     clip_rect.Inset(ShadowValue::GetMargin(text_shadows_));
 
     canvas->Save();
     canvas->ClipRect(clip_rect);
   }
@@ skipping 111 matching lines @@
   return SelectionModel(sel.start(),
                         sel.is_reversed() ? CURSOR_BACKWARD : CURSOR_FORWARD);
 }
 
 void RenderText::SetTextShadows(const ShadowValues& shadows) {
   text_shadows_ = shadows;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
-      vertical_alignment_(ALIGN_VCENTER),
       directionality_mode_(DIRECTIONALITY_FROM_TEXT),
       text_direction_(base::i18n::UNKNOWN_DIRECTION),
       cursor_enabled_(true),
       cursor_visible_(false),
       insert_mode_(true),
       cursor_color_(kDefaultColor),
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
@@ skipping 164 matching lines @@
 #if defined(OS_WIN)
     const int width = lines_[line_number].size.width() +
         (cursor_enabled_ ? 1 : 0);
 #else
     const int width = GetContentWidth();
 #endif
     offset.set_x(display_rect().width() - width);
     if (horizontal_alignment_ == ALIGN_CENTER)
       offset.set_x(offset.x() / 2);
   }
-  if (vertical_alignment_ != ALIGN_TOP) {
-    offset.set_y(display_rect().height() - GetStringSize().height());
-    if (vertical_alignment_ == ALIGN_VCENTER)
-      offset.set_y(offset.y() / 2);
-  }
+  offset.set_y(baseline_ - GetBaselineOfTextLayout());
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   if (multiline() || (!fade_head() && !fade_tail()))
     return;
 
   const int display_width = display_rect().width();
 
   // If the text fits as-is, no need to fade.
@@ skipping 136 matching lines @@
     const int negate_rtl = horizontal_alignment_ == ALIGN_RIGHT ? -1 : 1;
     const int offset = negate_rtl * display_offset_.x();
     if (display_width > (content_width + offset)) {
       delta_x = negate_rtl * (display_width - (content_width + offset));
     }
   }
 
   Vector2d delta_offset(delta_x, 0);
   display_offset_ += delta_offset;
   cursor_bounds_ += delta_offset;
+
+  // Determine the baseline so the text is placed at vertically center.
+  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.
+  int min_shift;
+  int max_shift;
+  if (display_height < font_height) {
+    min_shift = display_height - font_height;
+    max_shift = font_height - display_height;
+  } else {
+    min_shift = 0;
+    max_shift = display_height - font_height;
+  }
+  const int baseline_shift =
+      std::max(min_shift, std::min(max_shift,
+          (display_height - font_list().GetCapHeight()) / 2));
+  baseline_ = font_list().GetBaseline() + baseline_shift;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx