Move allow_character_break property to 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/i18n/break_iterator.h"
@@ skipping 2058 matching lines @@
 }
 
 // Ensure strings wrap onto multiple lines for a small available width.
 TEST_F(RenderTextTest, Multiline_MinWidth) {
   const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
                                     kRtlLtr, kRtlLtrRtl };
 
   RenderTextHarfBuzz render_text;
   render_text.SetDisplayRect(Rect(1, 1000));
   render_text.SetMultiline(true);
+  render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
   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);
   }
 }
 
@@ skipping 13 matching lines @@
     { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9"
       L"\x05DA\x05DB\x05DD", Range(0, 4), Range(4, 12), false }
   };
 
   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);
+  render_text.SetWordWrapBehavior(WRAP_LONG_WORDS);
   render_text.SetHorizontalAlignment(ALIGN_TO_HEAD);
 
   Canvas canvas;
   TestSkiaTextRenderer renderer(&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.EnsureLayout();
     render_text.DrawVisualTextInternal(&renderer);
@@ skipping 166 matching lines @@
       std::vector<base::string16> lines;
       base::SplitString(base::WideToUTF16(kTestStrings[i].text), '\n', &lines);
       ASSERT_EQ(2u, lines.size());
       int difference = (lines[0].length() - lines[1].length()) * kGlyphSize;
       EXPECT_EQ(render_text.GetAlignmentOffset(0).x() + difference,
                 render_text.GetAlignmentOffset(1).x());
     }
   }
 }
 
+TEST_F(RenderTextTest, Multiline_WordWrapBehavior) {
+  const int kGlyphSize = 5;
+  const struct {
+    const WordWrapBehavior behavior;
+    const size_t num_lines;
+    const Range char_ranges[4];
+  } kTestScenarios[] = {
+    { IGNORE_LONG_WORDS, 3u,
+      { Range(0, 4), Range(4, 11), Range(11, 14), Range::InvalidRange() } },
+    { TRUNCATE_LONG_WORDS, 3u,
+      { Range(0, 4), Range(4, 8), Range(11, 14), Range::InvalidRange() } },
+    { WRAP_LONG_WORDS, 4u,
+      { Range(0, 4), Range(4, 8), Range(8, 11), Range(11, 14) } },
+    // TODO(mukai): implement ELIDE_LONG_WORDS. It's not used right now.
+  };
+  RenderTextHarfBuzz render_text;
+  render_text.SetMultiline(true);
+  render_text.SetText(ASCIIToUTF16("foo fooooo foo"));
+  render_text.set_glyph_width_for_test(kGlyphSize);
+  render_text.SetDisplayRect(Rect(0, 0, kGlyphSize * 4, 0));
+
+  Canvas canvas;
+
+  for (size_t i = 0; i < arraysize(kTestScenarios); ++i) {
+    SCOPED_TRACE(base::StringPrintf(
+        "kTestScenarios[%" PRIuS "] %d", i, kTestScenarios[i].behavior));
+    render_text.SetWordWrapBehavior(kTestScenarios[i].behavior);
+    render_text.Draw(&canvas);
+
+    ASSERT_EQ(kTestScenarios[i].num_lines, render_text.lines().size());
+    for (size_t j = 0; j < render_text.lines().size(); ++j) {
+      SCOPED_TRACE(base::StringPrintf("%" PRIuS "-th line", j));
+      EXPECT_EQ(kTestScenarios[i].char_ranges[j],
+                render_text.lines()[j].segments[0].char_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) {
@@ skipping 564 matching lines @@
   string_size.set_width(string_size.width() / 2);
   render_text.SetDisplayRect(gfx::Rect(string_size));
   render_text.EnsureLayout();
   CFIndex glyph_count = CTLineGetGlyphCount(render_text.line_);
   EXPECT_GT(text.size(), static_cast<size_t>(glyph_count));
   EXPECT_NE(0, glyph_count);
 }
 #endif
 
 }  // namespace gfx