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

ui/gfx/render_text.h

 // 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.
 
 #ifndef UI_GFX_RENDER_TEXT_H_
 #define UI_GFX_RENDER_TEXT_H_
 
 #include <algorithm>
 #include <cstring>
 #include <string>
@@ skipping 149 matching lines @@
   static RenderText* CreateInstance();
 
   const base::string16& text() const { return text_; }
   void SetText(const base::string16& text);
 
   HorizontalAlignment horizontal_alignment() const {
     return horizontal_alignment_;
   }
   void SetHorizontalAlignment(HorizontalAlignment alignment);
 
-  VerticalAlignment vertical_alignment() const {
-    return vertical_alignment_;
-  }
-  void SetVerticalAlignment(VerticalAlignment alignment);
-
   const FontList& font_list() const { return font_list_; }
   void SetFontList(const FontList& font_list);
   void SetFont(const Font& font);
 
   // Set the font size to |size| in pixels.
   void SetFontSize(int size);
 
   // Get the first font in |font_list_|.
   const Font& GetPrimaryFont() const;
 
@@ skipping 146 matching lines @@
   // The default implementation is same as GetStringSize. Certain platforms that
   // compute the text size as floating-point values, like Mac, will override
   // this method.
   // See comment in Canvas::GetStringWidthF for its usage.
   virtual SizeF GetStringSizeF();
 
   // Returns the width of the content (which is the wrapped width in multiline
   // mode). Reserves room for the cursor if |cursor_enabled_| is true.
   int GetContentWidth();
 
-  // Returns the common baseline of the text. The returned value is the vertical
-  // offset from the top of |display_rect| to the text baseline, in pixels.
-  virtual int GetBaseline() = 0;
+  // Returns the common baseline of the text. The return value is the vertical
+  // offset from the top of |display_rect_| to the text baseline, in pixels.
+  // The baseline is determined from the font list and display rect, and does
+  // not depend on the text.
+  int GetBaseline();
 
   void Draw(Canvas* canvas);
 
   // Draws a cursor at |position|.
   void DrawCursor(Canvas* canvas, const SelectionModel& position);
 
   // Draw the selected text without a cursor or selection highlight. Subpixel
   // antialiasing is disabled and foreground color is forced to black.
   void DrawSelectedTextForDrag(Canvas* canvas);
 
@@ skipping 37 matching lines @@
 
  protected:
   RenderText();
 
   const BreakList<SkColor>& colors() const { return colors_; }
   const std::vector<BreakList<bool> >& styles() const { return styles_; }
 
   const std::vector<internal::Line>& lines() const { return lines_; }
   void set_lines(std::vector<internal::Line>* lines) { lines_.swap(*lines); }
 
+  // Returns the baseline of the current text.  The return value depends on
+  // the text and its layout while the return value of GetBaseline() doesn't.
+  // GetAlignmentOffset() takes into account the difference between them.
+  //
+  // We'd like a RenderText to show the text always on the same baseline
+  // regardless of the text, so the text does not jump up or down depending
+  // on the text.  However, underlying layout engines return different baselines
+  // depending on the text.  In general, layout engines determine the minimum
+  // bounding box for the text and return the baseline from the top of the
+  // bounding box.  So the baseline changes depending on font metrics used to
+  // layout the text.
+  //
+  // For example, suppose there are FontA and FontB and the baseline of FontA
+  // is smaller than the one of FontB.  If the text is laid out only with FontA,
+  // then the baseline of FontA may be returned.  If the text includes some
+  // characters which are laid out with FontB, then the baseline of FontB may
+  // be returned.
+  //
+  // GetBaseline() returns the fixed baseline regardless of the text.
+  // GetLayoutTextBaseline() returns the baseline determined by the underlying
+  // layout engine, and it changes depending on the text.  GetAlignmentOffset()
+  // returns the difference between them.
+  virtual int GetLayoutTextBaseline() = 0;
+
   const Vector2d& GetUpdatedDisplayOffset();
 
   void set_cached_bounds_and_offset_valid(bool valid) {
     cached_bounds_and_offset_valid_ = valid;
   }
 
   // Get the selection model that visually neighbors |position| by |break_type|.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel GetAdjacentSelectionModel(const SelectionModel& current,
                                            BreakType break_type,
@@ skipping 124 matching lines @@
   // Draw the selection.
   void DrawSelection(Canvas* canvas);
 
   // Logical UTF-16 string data to be drawn.
   base::string16 text_;
 
   // Horizontal alignment of the text with respect to |display_rect_|.  The
   // default is to align left if the application UI is LTR and right if RTL.
   HorizontalAlignment horizontal_alignment_;
 
-  // Vertical alignment of the text with respect to |display_rect_|.  The
-  // default is to align vertically centered.
-  VerticalAlignment vertical_alignment_;
-
   // The text directionality mode, defaults to DIRECTIONALITY_FROM_TEXT.
   DirectionalityMode directionality_mode_;
 
   // The cached text direction, potentially computed from the text or UI locale.
   // Use GetTextDirection(), do not use this potentially invalid value directly!
   base::i18n::TextDirection text_direction_;
 
   // A list of fonts used to render |text_|.
   FontList font_list_;
 
@@ skipping 65 matching lines @@
   // Flag to work around a Skia bug with the PDF path (http://crbug.com/133548)
   // that results in incorrect clipping when drawing to the document margins.
   // This field allows disabling clipping to work around the issue.
   // TODO(asvitkine): Remove this when the underlying Skia bug is fixed.
   bool clip_to_display_rect_;
 
   // The offset for the text to be drawn, relative to the display area.
   // Get this point with GetUpdatedDisplayOffset (or risk using a stale value).
   Vector2d display_offset_;
 
+  // The baseline of the text.  This is determined from the height of the
+  // display area and the cap height of the font list so the text is vertically
+  // centered.
+  int baseline_;
+
   // The cached bounds and offset are invalidated by changes to the cursor,
   // selection, font, and other operations that adjust the visible text bounds.
   bool cached_bounds_and_offset_valid_;
 
   // Text shadows to be drawn.
   ShadowValues text_shadows_;
 
   // A list of valid layout text line break positions.
   BreakList<size_t> line_breaks_;
 
   // Lines computed by EnsureLayout. These should be invalidated with
   // ResetLayout and on |display_rect_| changes.
   std::vector<internal::Line> lines_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_