Add multiline support to RenderTextHarfBuzz.

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/i18n/break_iterator.h"
@@ skipping 62 matching lines @@
     render_text->MoveCursor(CHARACTER_BREAK, direction, false);
   }
   // Check that cursoring is clamped at the line edge.
   EXPECT_EQ(expected.back(), render_text->selection_model());
   // Check that it is the line edge.
   render_text->MoveCursor(LINE_BREAK, direction, false);
   EXPECT_EQ(expected.back(), render_text->selection_model());
 }
 #endif  // !defined(OS_MACOSX)
 
+// Test utility for Multiline_Newline test case. Empty |expected_range| means
+// the blank line which has no segments. Otherwise |segments| should contain
+// exactly one line segment whose range equals to |expected_range|.
+void VerifyLineSegments(const Range& expected_range,
+                        const std::vector<internal::LineSegment>& segments) {
+  EXPECT_EQ(expected_range.is_empty() ? 0ul : 1ul, segments.size());
+  if (!expected_range.is_empty())
+    EXPECT_EQ(expected_range, segments[0].char_range);
+}
+
 }  // namespace
 
 class RenderTextTest : public testing::Test {
 };
 
 TEST_F(RenderTextTest, DefaultStyle) {
   // Check the default styles applied to new instances and adjusted text.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   EXPECT_TRUE(render_text->text().empty());
   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
@@ skipping 1763 matching lines @@
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     const int expected_width = render_text->GetStringSize().width();
     render_text->MoveCursorTo(SelectionModel(Range(0, 1), CURSOR_FORWARD));
     EXPECT_EQ(expected_width, render_text->GetStringSize().width());
     // Drawing the text should not DCHECK or crash; see http://crbug.com/262119
     render_text->Draw(&canvas);
     render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
   }
 }
 
-// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings wrap onto multiple lines for a small available width.
-TEST_F(RenderTextTest, DISABLED_Multiline_MinWidth) {
+TEST_F(RenderTextTest, Multiline_MinWidth) {
   const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
                                     kRtlLtr, kRtlLtrRtl };
 
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-  render_text->SetDisplayRect(Rect(1, 1000));
-  render_text->SetMultiline(true);
+  RenderTextHarfBuzz render_text;
+  render_text.SetDisplayRect(Rect(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);
+    render_text.SetText(WideToUTF16(kTestStrings[i]));
+    render_text.Draw(&canvas);
+    EXPECT_GT(render_text.lines_.size(), 1U);
   }
 }
 
-// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings wrap onto multiple lines for a normal available width.
-TEST_F(RenderTextTest, DISABLED_Multiline_NormalWidth) {
+TEST_F(RenderTextTest, Multiline_NormalWidth) {
   const struct {
     const wchar_t* const text;
     const Range first_line_char_range;
     const Range second_line_char_range;
   } kTestStrings[] = {
     { L"abc defg hijkl", Range(0, 9), Range(9, 14) },
-    { L"qwertyzxcvbn", Range(0, 8), Range(8, 12) },
-    { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9\x05DD",
-          Range(4, 10), Range(0, 4) }
+    { L"qwertyzxcvbn", Range(0, 10), Range(10, 12) },
+    { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9"
+      L"\x05DA\x05DB\x05DD", Range(4, 12), Range(0, 4) }
   };
 
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-  render_text->SetDisplayRect(Rect(50, 1000));
-  render_text->SetMultiline(true);
+  RenderTextHarfBuzz render_text;
+  // Specify the fixed width for characters to suppress the possible variations
+  // of linebreak results.
+  render_text.set_glyph_width_for_test(5);
+  render_text.SetDisplayRect(Rect(50, 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].text));
-    render_text->Draw(&canvas);
-    ASSERT_EQ(2U, render_text->lines_.size());
-    ASSERT_EQ(1U, render_text->lines_[0].segments.size());
+    render_text.SetText(WideToUTF16(kTestStrings[i].text));
+    render_text.Draw(&canvas);
+    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());
+              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);
+              render_text.lines_[1].segments[0].char_range);
   }
 }
 
-// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings don't wrap onto multiple lines for a sufficient available
 // width.
-TEST_F(RenderTextTest, DISABLED_Multiline_SufficientWidth) {
+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<RenderText> render_text(RenderText::CreateInstance());
-  render_text->SetDisplayRect(Rect(30, 1000));
-  render_text->SetMultiline(true);
+  RenderTextHarfBuzz render_text;
+  render_text.SetDisplayRect(Rect(1000, 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());
+    render_text.SetText(WideToUTF16(kTestStrings[i]));
+    render_text.Draw(&canvas);
+    EXPECT_EQ(1U, render_text.lines_.size());
   }
 }
 
-// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
-TEST_F(RenderTextTest, DISABLED_Multiline_Newline) {
+TEST_F(RenderTextTest, Multiline_Newline) {
   const struct {
     const wchar_t* const text;
+    const size_t lines_count;
     // Ranges of the characters on each line preceding the newline.
-    const Range first_line_char_range;
-    const Range second_line_char_range;
+    const Range line_char_ranges[3];
   } kTestStrings[] = {
-    { L"abc\ndef", Range(0, 3), Range(4, 7) },
-    { L"a \n b ", Range(0, 2), Range(3, 6) },
-    { L"\n" , Range::InvalidRange(), Range::InvalidRange() }
+    {L"abc\ndef", 2ul, { Range(0, 3), Range(4, 7), Range::InvalidRange() } },
+    {L"a \n b ", 2ul, { Range(0, 2), Range(3, 6), Range::InvalidRange() } },
+    {L"ab\n", 2ul, { Range(0, 2), Range(), Range::InvalidRange() } },
+    {L"a\n\nb", 3ul, { Range(0, 1), Range(), Range(3, 4) } },
+    {L"\nab", 2ul, { Range(), Range(1, 3), Range::InvalidRange() } },
+    {L"\n", 2ul, { Range(), Range(), Range::InvalidRange() } },
   };
 
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-  render_text->SetDisplayRect(Rect(200, 1000));
-  render_text->SetMultiline(true);
+  RenderTextHarfBuzz render_text;
+  render_text.SetDisplayRect(Rect(200, 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].text));
-    render_text->Draw(&canvas);
+    render_text.SetText(WideToUTF16(kTestStrings[i].text));
+    render_text.Draw(&canvas);
+    EXPECT_EQ(kTestStrings[i].lines_count, render_text.lines_.size());
+    if (kTestStrings[i].lines_count != render_text.lines_.size())
+      continue;
 
-    ASSERT_EQ(2U, render_text->lines_.size());
-
-    const Range first_expected_range = kTestStrings[i].first_line_char_range;
-    ASSERT_EQ(first_expected_range.IsValid() ? 2U : 1U,
-              render_text->lines_[0].segments.size());
-    if (first_expected_range.IsValid())
-      EXPECT_EQ(first_expected_range,
-                render_text->lines_[0].segments[0].char_range);
-
-    const internal::LineSegment& newline_segment =
-        render_text->lines_[0].segments[first_expected_range.IsValid() ? 1 : 0];
-    ASSERT_EQ(1U, newline_segment.char_range.length());
-    EXPECT_EQ(L'\n', kTestStrings[i].text[newline_segment.char_range.start()]);
-
-    const Range second_expected_range = kTestStrings[i].second_line_char_range;
-    ASSERT_EQ(second_expected_range.IsValid() ? 1U : 0U,
-              render_text->lines_[1].segments.size());
-    if (second_expected_range.IsValid())
-      EXPECT_EQ(second_expected_range,
-                render_text->lines_[1].segments[0].char_range);
+    for (size_t j = 0; j < kTestStrings[i].lines_count; ++j) {
+      SCOPED_TRACE(base::StringPrintf("Line %" PRIuS "", j));
+      VerifyLineSegments(kTestStrings[i].line_char_ranges[j],
+                         render_text.lines_[j].segments);
+    }
   }
 }
 
+TEST_F(RenderTextTest, NewlineWithoutMultilineFlag) {
+  const wchar_t* kTestStrings[] = {
+    L"abc\ndef", L"a \n b ", L"ab\n", L"a\n\nb", L"\nab", L"\n",
+  };
+
+  RenderTextHarfBuzz render_text;
+  render_text.SetDisplayRect(Rect(200, 1000));
+  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());
+  }
+}
+
 // Test TextRunHarfBuzz's cluster finding logic.
 TEST_F(RenderTextTest, HarfBuzz_Clusters) {
   struct {
     uint32 glyph_to_char[4];
     Range chars[4];
     Range glyphs[4];
     bool is_rtl;
   } cases[] = {
     { // From string "A B C D" to glyphs "a b c d".
       { 0, 1, 2, 3 },
@@ skipping 349 matching lines @@
             base::StringToLowerASCII(fonts[0].GetActualFontNameForTesting()));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(0, 0, 25, 25));
   render_text->SetFontList(font_list);
   EXPECT_GT(render_text->GetBaseline(), font_list.GetBaseline());
 }
 #endif
 
 }  // namespace gfx