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/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/gfx/render_text_win.h"
@@ skipping 53 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());
 }
 
+// For segments in the same run, checks the continuity and order of |x_range|
+// and |char_range| fields.
+#if defined(OS_WIN)
+void CheckLineIntegrity(const std::vector<internal::Line>& lines,
+                        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) {
+    SCOPED_TRACE(base::StringPrintf("line %" PRIuS, i));
+    for (size_t j = 0; j < lines[i].segments.size(); ++j) {
+      SCOPED_TRACE(base::StringPrintf("segment %" PRIuS, j));
+      const internal::LineSegment* segment = &lines[i].segments[j];
+      internal::TextRun* run = runs[segment->run];
+
+      if (!previous_segment) {
+        previous_segment = segment;
+      } else if (runs[previous_segment->run] != run) {
+        previous_segment = NULL;
+      } else {
+        SCOPED_TRACE(run->script_analysis.fRTL ? "RTL" : "LTR");
+        SCOPED_TRACE(std::string("current x_range: ") +
+            segment->x_range.ToString());
+        SCOPED_TRACE(std::string("previous x_range: ") +
+            previous_segment->x_range.ToString());
+
+        EXPECT_EQ(previous_segment->char_range.end(),
+                  segment->char_range.start());
+        if (!run->script_analysis.fRTL)
+          EXPECT_EQ(previous_segment->x_range.end(), segment->x_range.start());
+        else if (i != previous_segment_line)

[msw, 2013/09/06 23:47:45]

I realize that we shouldn't break a run into separate segments, except to split
the run onto different lines, but I don't think this check on the else is
necessary. Shouldn't the text-space start/end x-coordinates of the segments
match, regardless of the line that the consecutive segments are placed on?

[ckocagil, 2013/09/11 14:59:49]

It doesn't seem necessary to me either. Done.

+          EXPECT_EQ(segment->x_range.end(), previous_segment->x_range.start());
+
+        previous_segment = segment;
+        previous_segment_line = i;
+      }
+    }
+  }
+}
+#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_MinWidth) {

[msw, 2013/09/06 23:47:45]

I'm looking forward to many more tests. Can you add this one now?
Add a Multiline_SufficientWidth or similar to test trivial behavior:
SetMultiline(true) but use strings (LTR, RTL, spaces, no spaces) that fit on one
line and don't wrap with the sufficiently wide display rect width.

[ckocagil, 2013/09/11 14:59:49]

Done.

+  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(Point(), Size(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);
+    CheckLineIntegrity(render_text->lines_, render_text->runs_);

[msw, 2013/09/06 23:47:45]

Can you EXPECT_GT(render_text->lines_.size(), 1U) here?

[ckocagil, 2013/09/11 14:59:49]

Done.

+  }
+}
+
+TEST_F(RenderTextTest, Multiline_NormalWidth) {
+  const struct {
+    wchar_t* text;

[msw, 2013/09/06 23:47:45]

nit: make all these members const.

[ckocagil, 2013/09/11 14:59:49]

Done.

+    ui::Range first_line;

[msw, 2013/09/06 23:47:45]

nit: |first_line_char_range| and |second_line_char_range|

[ckocagil, 2013/09/11 14:59:49]

Done.

+    ui::Range second_line;
+  } kTestStrings[] = {
+    { L"abc defg hijkl", ui::Range(0, 9), ui::Range(9, 14) },
+    { L"qwertyuiop", ui::Range(0, 8), ui::Range(8, 10) },

[msw, 2013/09/06 23:47:45]

nit: indent the ui::Range entries to match, even on line 1724.

[ckocagil, 2013/09/11 14:59:49]

Done.

+    { L"\x0647\x0630\x0627 \x0647\x0648 \x0627\x0644\x0628\x0627\x0628",
+      ui::Range(0, 7), ui::Range(7, 12) }
+  };
+
+  scoped_ptr<RenderTextWin> render_text(
+      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+  render_text->SetDisplayRect(Rect(Point(), Size(50, 1000)));
+  render_text->SetMultiline(true);
+  Canvas canvas;
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestStrings); ++i) {
+    SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
+    render_text->SetText(WideToUTF16(kTestStrings[i].text));
+    render_text->Draw(&canvas);
+    CheckLineIntegrity(render_text->lines_, render_text->runs_);
+    ASSERT_EQ(2U, render_text->lines_.size());
+    ASSERT_EQ(1U, render_text->lines_[0].segments.size());
+    EXPECT_EQ(kTestStrings[i].first_line,
+              render_text->lines_[0].segments[0].char_range);
+    ASSERT_EQ(1U, render_text->lines_[1].segments.size());
+    EXPECT_EQ(kTestStrings[i].second_line,
+              render_text->lines_[1].segments[0].char_range);
+  }
+}
+#endif  // defined(OS_WIN)
+
 }  // namespace gfx