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

ui/gfx/render_text_unittest.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/format_macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 1121 matching lines @@
 }
 
 // TODO(asvitkine): This test fails because PlatformFontMac uses point font
 //                  sizes instead of pixel sizes like other implementations.
 #if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, StringSizeEmptyString) {
   // Ascent and descent of Arial and Symbol are different on most platforms.
   const FontList font_list("Arial,Symbol, 16px");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(font_list);
+  render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
 
   // The empty string respects FontList metrics for non-zero height
   // and baseline.
   render_text->SetText(base::string16());
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(0, render_text->GetStringSize().width());
   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 
   render_text->SetText(UTF8ToUTF16(" "));
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
@@ skipping 21 matching lines @@
       symbol_font.GetBaseline() < arial_font.GetBaseline()) {
     std::swap(smaller_font, larger_font);
     std::swap(smaller_font_text, larger_font_text);
   }
   ASSERT_LT(smaller_font.GetHeight(), larger_font.GetHeight());
   ASSERT_LT(smaller_font.GetBaseline(), larger_font.GetBaseline());
 
   // Check |smaller_font_text| is rendered with the smaller font.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(UTF8ToUTF16(smaller_font_text));
-  render_text->SetFont(smaller_font);
+  render_text->SetFontList(FontList(smaller_font));
+  render_text->SetDisplayRect(Rect(0, 0, 0,
+                                   render_text->font_list().GetHeight()));
   EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
 
   // Layout the same text with mixed fonts.  The text should be rendered with
   // the smaller font, but the height and baseline are determined with the
   // metrics of the font list, which is equal to the larger font.
   std::vector<Font> fonts;
   fonts.push_back(smaller_font);  // The primary font is the smaller font.
   fonts.push_back(larger_font);
   const FontList font_list(fonts);
   render_text->SetFontList(font_list);
+  render_text->SetDisplayRect(Rect(0, 0, 0,
+                                   render_text->font_list().GetHeight()));
   EXPECT_LT(smaller_font.GetHeight(), render_text->GetStringSize().height());
   EXPECT_LT(smaller_font.GetBaseline(), render_text->GetBaseline());
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 }
 
 TEST_F(RenderTextTest, SetFont) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFont(Font("Arial", 12));
   EXPECT_EQ("Arial", render_text->GetPrimaryFont().GetFontName());
@@ skipping 81 matching lines @@
   // when the RenderText object is created.  This test will check the default in
   // LTR mode, and the next test will check the RTL default.
   const bool was_rtl = base::i18n::IsRTL();
   SetRTL(false);
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("abcdefg"));
   render_text->SetFontList(FontList("Arial, 13px"));
 
   // Set display area's size equal to the font size.
   const Size font_size(render_text->GetContentWidth(),
-                       render_text->GetStringSize().height());
+                       render_text->font_list().GetHeight());
   Rect display_rect(font_size);
   render_text->SetDisplayRect(display_rect);
 
   Vector2d offset = render_text->GetLineOffset(0);
   EXPECT_TRUE(offset.IsZero());
 
-  // Set display area's size greater than font size.
-  const int kEnlargement = 2;
-  display_rect.Inset(0, 0, -kEnlargement, -kEnlargement);
+  const int kEnlargementX = 2;
+  display_rect.Inset(0, 0, -kEnlargementX, 0);
   render_text->SetDisplayRect(display_rect);
 
-  // Check the default horizontal and vertical alignment.
+  // Check the default horizontal alignment.
   offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(kEnlargement / 2, offset.y());
   EXPECT_EQ(0, offset.x());
 
   // Check explicitly setting the horizontal alignment.
   render_text->SetHorizontalAlignment(ALIGN_LEFT);
   offset = render_text->GetLineOffset(0);
   EXPECT_EQ(0, offset.x());
   render_text->SetHorizontalAlignment(ALIGN_CENTER);
   offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(kEnlargement / 2, offset.x());
+  EXPECT_EQ(kEnlargementX / 2, offset.x());
   render_text->SetHorizontalAlignment(ALIGN_RIGHT);
   offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(kEnlargement, offset.x());
+  EXPECT_EQ(kEnlargementX, offset.x());
 
-  // Check explicitly setting the vertical alignment.
-  render_text->SetVerticalAlignment(ALIGN_TOP);
+  // Check that text is vertically centered within taller display rects.
+  const int kEnlargementY = display_rect.height();
+  display_rect.Inset(0, 0, 0, -kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
+  const Vector2d prev_offset = render_text->GetLineOffset(0);
+  display_rect.Inset(0, 0, 0, -2 * kEnlargementY);
+  render_text->SetDisplayRect(display_rect);
   offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(0, offset.y());
-  render_text->SetVerticalAlignment(ALIGN_VCENTER);
-  offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(kEnlargement / 2, offset.y());
-  render_text->SetVerticalAlignment(ALIGN_BOTTOM);
-  offset = render_text->GetLineOffset(0);
-  EXPECT_EQ(kEnlargement, offset.y());
+  EXPECT_EQ(prev_offset.y() + kEnlargementY, offset.y());
 
   SetRTL(was_rtl);
 }
 
 TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
   // This only checks the default horizontal alignment in RTL mode; all other
   // GetLineOffset(0) attributes are checked by the test above.
   const bool was_rtl = base::i18n::IsRTL();
   SetRTL(true);
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
@@ skipping 378 matching lines @@
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     render_text->Draw(&canvas);
     EXPECT_EQ(1U, render_text->lines_.size());
   }
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace gfx