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 1845 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 third_line_char_range;
   } 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;
+
+#define COMPARE_RANGE(r1, segments, message)                           \

[msw, 2015/02/05 21:59:27]

Please write this as a function instead of a preprocessor directive.

[Jun Mukai, 2015/02/05 23:28:00]

Done.

+  EXPECT_EQ(r1.length() == 0 ? 0ul : 1ul, segments.size()) << message; \
+  if (r1.length() != 0)                                                \
+    EXPECT_EQ(r1, segments[0].char_range) << message
+
+  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);
+    EXPECT_EQ(kTestStrings[i].lines_count, render_text.lines_.size());
+    if (kTestStrings[i].lines_count != render_text.lines_.size())
+      continue;
+
+    COMPARE_RANGE(kTestStrings[i].first_line_char_range,
+                  render_text.lines_[0].segments, "first line");
+    COMPARE_RANGE(kTestStrings[i].second_line_char_range,
+                  render_text.lines_[1].segments, "second line");
+    if (kTestStrings[i].lines_count > 2)
+      COMPARE_RANGE(kTestStrings[i].third_line_char_range,
+                    render_text.lines_[2].segments, "third line");
+  }
+#undef COMPARE_RANGE
+}
+
+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].text));
-    render_text->Draw(&canvas);
+    render_text.SetText(WideToUTF16(kTestStrings[i]));
+    render_text.Draw(&canvas);
 
-    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);
+    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;
@@ skipping 352 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