Windows implementation of multiline RenderText

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"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/gfx/render_text_win.h"
@@ skipping 1117 matching lines @@
   const FontList font_list("Arial,Symbol, 16px");
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(font_list);
 
   // 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(" "));

[msw, 2013/09/11 17:32:37]

Why did you remove this?

[ckocagil, 2013/09/11 20:31:16]

Added back. See my comment above LineBreaker in render_text_win.cc.

-  EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
-  EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 }
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
   // Check that Arial and Symbol have different font metrics.
   Font arial_font("Arial", 16);
   Font symbol_font("Symbol", 16);
   EXPECT_NE(arial_font.GetHeight(), symbol_font.GetHeight());
   EXPECT_NE(arial_font.GetBaseline(), symbol_font.GetBaseline());
   // "a" should be rendered with Arial, not with Symbol.
@@ skipping 15 matching lines @@
   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);
   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.
+  // the smaller font, and the height and baseline are determined with the
+  // metrics of the smaller font.

[msw, 2013/09/11 17:32:37]

Why has this changed? I think it was correct before, so RenderText
heights/baselines won't change if text changes wind up using other fonts in the
list. Perhaps that's not needed if RenderText users adjust the placement to
account for font list metrics, but that's not the case right now, afaik, and
this change will probably break some omnibox/textfield alignment. Can you
restore the previous behavior?

[ckocagil, 2013/09/11 20:31:16]

Reverted the changes to existing tests. See my comment above LineBreaker in
render_text_win.cc.

   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);
-  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());
+  EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
+  EXPECT_EQ(smaller_font.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());
   EXPECT_EQ(12, render_text->GetPrimaryFont().GetFontSize());
 }
 
 TEST_F(RenderTextTest, SetFontList) {
@@ skipping 81 matching lines @@
   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());
   Rect display_rect(font_size);
   render_text->SetDisplayRect(display_rect);
 
-  Vector2d offset = render_text->GetTextOffset();
+  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);
   render_text->SetDisplayRect(display_rect);
 
   // Check the default horizontal and vertical alignment.
-  offset = render_text->GetTextOffset();
+  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->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(0, offset.x());
   render_text->SetHorizontalAlignment(ALIGN_CENTER);
-  offset = render_text->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(kEnlargement / 2, offset.x());
   render_text->SetHorizontalAlignment(ALIGN_RIGHT);
-  offset = render_text->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(kEnlargement, offset.x());
 
   // Check explicitly setting the vertical alignment.
   render_text->SetVerticalAlignment(ALIGN_TOP);
-  offset = render_text->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(0, offset.y());
   render_text->SetVerticalAlignment(ALIGN_VCENTER);
-  offset = render_text->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(kEnlargement / 2, offset.y());
   render_text->SetVerticalAlignment(ALIGN_BOTTOM);
-  offset = render_text->GetTextOffset();
+  offset = render_text->GetLineOffset(0);
   EXPECT_EQ(kEnlargement, offset.y());
 
   SetRTL(was_rtl);
 }
 
 TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
   // This only checks the default horizontal alignment in RTL mode; all other
-  // GetTextOffset() attributes are checked by the test above.
+  // 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());
   render_text->SetText(ASCIIToUTF16("abcdefg"));
   render_text->SetFontList(FontList("Arial, 13px"));
   const int kEnlargement = 2;
   const Size font_size(render_text->GetContentWidth() + kEnlargement,
                        render_text->GetStringSize().height());
   Rect display_rect(font_size);
   render_text->SetDisplayRect(display_rect);
-  Vector2d offset = render_text->GetTextOffset();
+  Vector2d offset = render_text->GetLineOffset(0);
   EXPECT_EQ(kEnlargement, offset.x());
   SetRTL(was_rtl);
 }
 
 TEST_F(RenderTextTest, SameFontForParentheses) {
   struct {
     const char16 left_char;
     const char16 right_char;
   } punctuation_pairs[] = {
     { '(', ')' },
@@ skipping 285 matching lines @@
     const int expected_width = render_text->GetStringSize().width();
     render_text->MoveCursorTo(SelectionModel(ui::Range(0, 1), CURSOR_FORWARD));
     EXPECT_EQ(expected_width, render_text->GetStringSize().width());
     // Draw the text. It shouldn't hit any DCHECKs or crash.
     // See http://crbug.com/214150
     render_text->Draw(&canvas);
     render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
   }
 }
 
+#if defined(OS_WIN)
+TEST_F(RenderTextTest, Multiline_MinWidth) {

[msw, 2013/09/11 17:32:37]

nit: Add high-level comments explaining what each test does, like:
// Ensure strings wrap onto multiple lines for a small available width.

[ckocagil, 2013/09/11 20:31:16]

Done.

+  const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
+                                    kRtlLtr, kRtlLtrRtl };
+
+  scoped_ptr<RenderTextWin> render_text(
+      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+  render_text->SetDisplayRect(Rect(Point(), Size(1, 1000)));
+  render_text->SetMultiline(true);
+  Canvas canvas;
+
+  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_GT(render_text->lines_.size(), 1U);
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_NormalWidth) {
+  const struct {
+    const wchar_t* const text;
+    const ui::Range first_line_char_range;
+    const ui::Range second_line_char_range;
+  } kTestStrings[] = {
+    { L"abc defg hijkl", ui::Range(0, 9), ui::Range(9, 14) },
+    { L"qwertyuiop",     ui::Range(0, 8), ui::Range(8, 10) },
+    { L"\x0647\x0630\x0627 \x0647\x0648 \x0627\x0644\x0628\x0627\x0628",
+                         ui::Range(0, 7), ui::Range(7, 12) }
+  };
+
+  scoped_ptr<RenderTextWin> render_text(
+      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+  render_text->SetDisplayRect(Rect(Point(), Size(50, 1000)));
+  render_text->SetMultiline(true);
+  Canvas canvas;
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(WideToUTF16(kTestStrings[i].text));
+    render_text->Draw(&canvas);
+    CheckLineIntegrity(render_text->lines_, render_text->runs_);

[msw, 2013/09/11 17:32:37]

You shouldn't need to call this explicitly here, it happens all the time.

[ckocagil, 2013/09/11 20:31:16]

Done.

+    ASSERT_EQ(2U, render_text->lines_.size());
+    ASSERT_EQ(1U, render_text->lines_[0].segments.size());
+    EXPECT_EQ(kTestStrings[i].first_line_char_range,
+              render_text->lines_[0].segments[0].char_range);
+    ASSERT_EQ(1U, render_text->lines_[1].segments.size());
+    EXPECT_EQ(kTestStrings[i].second_line_char_range,
+              render_text->lines_[1].segments[0].char_range);
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_SufficientWidth) {
+  const wchar_t* kTestStrings[] = { L"", L" ",
+                                    L".", L" . ",
+                                    L"abc", L"a b c",
+                                    L"\x62E\x628\x632", L"\x62E \x628 \x632" };
+
+  scoped_ptr<RenderTextWin> render_text(
+      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+  render_text->SetDisplayRect(Rect(Point(), Size(30, 1000)));
+  render_text->SetMultiline(true);
+  Canvas canvas;
+
+  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