[RenderText] Adding vertical alignment options

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 <climits>
 
 #include "base/command_line.h"
@@ skipping 466 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;
   const int font_style = font_list.GetFontStyle();
   SetStyle(BOLD, (font_style & gfx::Font::BOLD) != 0);
   SetStyle(ITALIC, (font_style & gfx::Font::ITALIC) != 0);
   SetStyle(UNDERLINE, (font_style & gfx::Font::UNDERLINE) != 0);
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   OnLayoutTextAttributeChanged(false);
 }
@@ skipping 458 matching lines @@
   if (!multiline())
     offset.Add(GetUpdatedDisplayOffset());
   else
     offset.Add(Vector2d(0, lines_[line_number].preceding_heights));
   offset.Add(GetAlignmentOffset(line_number));
   return offset;
 }
 
 RenderText::RenderText()
     : horizontal_alignment_(base::i18n::IsRTL() ? ALIGN_RIGHT : ALIGN_LEFT),
+      vertical_alignment_(VALIGN_MIDDLE),
       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 181 matching lines @@
     const int width = multiline_ ?
         std::ceil(lines_[line_number].size.width()) +
         (cursor_enabled_ ? 1 : 0) :
         GetContentWidth();
     offset.set_x(display_rect().width() - width);
     // Put any extra margin pixel on the left to match legacy behavior.
     if (horizontal_alignment == ALIGN_CENTER)
       offset.set_x((offset.x() + 1) / 2);
   }
 
-  // Vertically center the text.
+  // Vertically align the text.
   if (multiline_) {
     const int text_height = lines_.back().preceding_heights +
-        lines_.back().size.height();
-    offset.set_y((display_rect_.height() - text_height) / 2);
+                            std::ceil(lines_.back().size.height());
+    if (vertical_alignment_ == VALIGN_TOP) {
+      offset.set_y(0);
+    } else if (vertical_alignment_ == VALIGN_BOTTOM) {
+      offset.set_y(display_rect_.height() - text_height);
+    } else {
+      DCHECK_EQ(VALIGN_MIDDLE, vertical_alignment_);
+      offset.set_y((display_rect_.height() - text_height) / 2);
+    }
   } else {
-    offset.set_y(GetBaseline() - GetDisplayTextBaseline());
+    if (vertical_alignment_ == VALIGN_TOP) {
+      offset.set_y(0);
+    } else if (vertical_alignment_ == VALIGN_BOTTOM) {
+      offset.set_y(display_rect_.height() - font_list_.GetHeight());
+    } else {
+      DCHECK_EQ(VALIGN_MIDDLE, vertical_alignment_);
+      offset.set_y(GetBaseline() - GetDisplayTextBaseline());
+    }
   }
-
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
   const int width = display_rect().width();
   if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
     return;
 
   const int gradient_width = CalculateFadeGradientWidth(font_list(), width);
   if (gradient_width == 0)
     return;
 
   HorizontalAlignment horizontal_alignment = GetCurrentHorizontalAlignment();
   Rect solid_part = display_rect();
   Rect left_part;
   Rect right_part;
   if (horizontal_alignment != ALIGN_LEFT) {
     left_part = solid_part;
     left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
     solid_part.Inset(gradient_width, 0, 0, 0);
   }
   if (horizontal_alignment != ALIGN_RIGHT) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
-  text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
+  text_rect.Inset(GetAlignmentOffset(0).x(), GetAlignmentOffset(0).y(), 0, 0);

[msw, 2015/04/01 15:07:17]

nit: cache the alignment offset instead of calling this twice.

 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
   skia::RefPtr<SkShader> shader = CreateFadeShader(
       text_rect, left_part, right_part, colors_.breaks().front().second);
   if (shader)
     renderer->SetShader(shader.get());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(shadows_);
@@ skipping 301 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx