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);
+  // Specify the fixed width for characters to suppress the possible variations
+  // of linebreak results.
+  RenderTextHarfBuzz::SetGlyphWidthForTest(5);
+  RenderTextHarfBuzz render_text;
+  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);
   }
+
+  RenderTextHarfBuzz::SetGlyphWidthForTest(0);
 }
 
-// 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) {

[msw, 2015/02/05 01:09:16]

nit: add a test [case] of consecutive newline characters "a\n\nb".

[Jun Mukai, 2015/02/05 19:48:32]

Done.

   const struct {
     const wchar_t* const text;
     // Ranges of the characters on each line preceding the newline.
     const Range first_line_char_range;
     const Range second_line_char_range;
   } kTestStrings[] = {
     { L"abc\ndef", Range(0, 3), Range(4, 7) },
     { L"a \n b ", Range(0, 2), Range(3, 6) },
+    { L"ab\n", Range(0, 2), Range::InvalidRange() },

[msw, 2015/02/05 01:09:16]

Why doesn't the second line have char Range(2, 3)? (ditto below) Don't we want
segments with the newline characters? I could be persuaded otherwise...

[Jun Mukai, 2015/02/05 19:48:32]

The invalid range means the empty line, as you see below for "\n" case.
But I changed my mind, I think Range() (an empty range) represents the
empty-ness more.

+    { L"\nab", Range::InvalidRange(), Range(1, 3) },
     { L"\n" , Range::InvalidRange(), 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);
 
-    ASSERT_EQ(2U, render_text->lines_.size());
+    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())
+    ASSERT_EQ(first_expected_range.IsValid() ? 1U : 0U,
+              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()]);
+                render_text.lines_[0].segments[0].char_range);
+    }
 
     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())
+              render_text.lines_[1].segments.size());
+    if (second_expected_range.IsValid()) {
       EXPECT_EQ(second_expected_range,
-                render_text->lines_[1].segments[0].char_range);
+                render_text.lines_[1].segments[0].char_range);
+    }
   }
 }
 
+TEST_F(RenderTextTest, Multiline_NewlineWithoutMultilineFlag) {

[msw, 2015/02/05 01:09:16]

nit: I think you can drop the "Multiline_" test fixture prefix here.

[Jun Mukai, 2015/02/05 19:48:32]

Done.

+  const wchar_t* kTestStrings[] = {
+    L"abc\ndef", L"a \n b ", L"ab\n", 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