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/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 61 matching lines @@
     EXPECT_EQ(expected[i], render_text->selection_model());
     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());
 }
 
+#if defined(OS_WIN)
+bool CheckLineIntegrity(const std::vector<internal::Line>& lines,

[msw, 2013/08/21 16:46:23]

nit: add a comment about what it actually verifies.

[ckocagil, 2013/08/23 21:45:34]

Done.

+                        const ScopedVector<internal::TextRun>& runs) {
+  size_t previous_segment_line = 0;
+  const internal::LineSegment* previous_segment = NULL;
+
+  for (size_t i = 0; i < lines.size(); ++i)
+    for (size_t j = 0; j < lines[i].segments.size(); ++j) {
+      const internal::LineSegment* const segment = &lines[i].segments[j];
+      internal::TextRun* const run = runs[segment->run];
+
+      if (!previous_segment || runs[previous_segment->run] != run) {
+        previous_segment = 0;

[msw, 2013/08/21 16:46:23]

What? Use NULL. Also, won't |previous_segment| *always* be NULL, since it's only
set to something valid in the else block (which can only be reached by
|previous_segment| being not NULL)?

[ckocagil, 2013/08/23 21:45:34]

Oops. Fixed the logic here and it uses NULL now. While fixing this test I
discovered some bugs and did a little refactoring on the way. Sorry for doing it
this late in the review process.

+      } else {
+        if (!run->script_analysis.fRTL) {
+          if (previous_segment->x_pos.end() != segment->x_pos.start())
+            return false;

[msw, 2013/08/21 16:46:23]

Consider turning these into EXPECT_EQ or ASSERT_EQ and using SCOPED_TRACE to
give context to the line number and segment number, then this function can drop
the bool return value:
https://code.google.com/p/chromium/codesearch#chromium/src/testing/gtest/incl...

[ckocagil, 2013/08/23 21:45:34]

Done.

+        } else if (i != previous_segment_line) {
+          if (segment->x_pos.end() != previous_segment->x_pos.start())
+            return false;
+        }
+
+        previous_segment = segment;
+        previous_segment_line = i;
+      }
+    }
+
+  return true;
+}
+#endif  // defined(OS_WIN)
+
 }  // 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 1195 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) {

[msw, 2013/08/21 16:46:23]

Add some more tests for the approximate size and/or line count with:
1) A huge display rect and text with '\n', '\r', '\r\n', etc.
(will it respect line breaks in the text if wrapping isn't *needed*?)
2) A reasonable display rect and strings of various length.
(does wrapping work reasonably well for common strings?)
3) A reasonable display rect and strings with very long words.
(how are long words, perhaps with hyphen/punctuation, handled?)
4) A reasonable display rect and LTR/RTL/BiDi/Complex strings.
(do line breaks around LTR/RTL in each directionality work ok, etc.)
And probably more, but that seems like a good start...

[ckocagil, 2013/08/23 21:45:34]

I added some new test cases. Note that I can't add 1) yet because line break
characters aren't implemented yet. I'm trying to come up with more test cases
and other ways of testing this class.

[msw, 2013/08/27 01:30:52]

Hmm, I think base::i18n::BreakIterator should handle newline characters. Also,
you might look at break_iterator_unittest.cc or existing strings used in
multi-line labels for test ideas. I think you're off to a good start for
testing, but this definitely needs more test cases and varied expectations. My
first thought is that you need to thoroughly test multi-line cases where each
line has more than one segment. It's ok to leave some testing ideas in a TODO or
bug comment for a followup CL.

[ckocagil, 2013/08/28 18:01:45]

BreakIterator only gives positions that are suitable for breaking lines at, it
doesn't tell where the newline characters are. I was planning on adding newline
support in another CL. I'm adding a bug comment to extend the tests.

+  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());

[msw, 2013/08/21 16:46:23]

Why does this set an empty display rect? Wouldn't that be an edge case?

[ckocagil, 2013/08/23 21:45:34]

An empty (or 1-pixel wide) display rect forces RenderTextWin to put every
character in a new line. This generates the maximum number of lines, which is
hard for the class to do correctly and a good case to test.

[msw, 2013/08/27 01:30:52]

Cool, 1px makes more sense; I figure 0px should perhaps not break lines.

+  render_text->SetMultiline(true);
+  Canvas canvas;
+
+  for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
+    render_text->SetText(WideToUTF16(kTestStrings[i]));
+    render_text->Draw(&canvas);
+    EXPECT_TRUE(CheckLineIntegrity(render_text->lines_, render_text->runs_)) <<
+        "For kTestStrings[" << i << "]";

[msw, 2013/08/21 16:46:23]

Use SCOPED_TRACE here too, instead of piping output to EXPECT_TRUE, to give each
CheckLineIntegrity call its context.

[ckocagil, 2013/08/23 21:45:34]

Done.

+  }
+}
+#endif  // defined(OS_WIN)
+
 }  // namespace gfx