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* const segment = &lines[i].segments[j];

[Alexei Svitkine (slow), 2013/08/27 15:40:38]

Nit: I don't think we usually put const after the *. Please remove, here and on
the line below.

[ckocagil, 2013/08/28 19:16:26]

The const after the * makes the pointer itself const. There is already other
code in this file that declares const pointers. Should I remove all these
instances or keep them?

[Alexei Svitkine (slow), 2013/08/28 21:27:46]

The other ones only seem to do it for arrays of const char* strings, rather than
const pointers to an actual class instance. I'd keep those other ones, since
there's precedent (in this file and elsewhere in the codebase) for those, but
remove these ones (the const keywords after the * only).

[ckocagil, 2013/08/30 16:53:36]

Done.

+      internal::TextRun* const 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(base::StringPrintf(
+            "current x_range: [%" PRIuS ", %" PRIuS ")",

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

nit: printing ui::Range ints with PRIuS (unsigned size) is wrong here and below.

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

Is it? ui::Range::start() and end() both return size_t. Is there a variadic arg
default conversion I'm overlooking? Anyway, I'll just use ui::Range::ToString
here since it's simpler.

[msw, 2013/08/30 00:42:28]

Hmm, I mistakenly thought they were ints; glad you improved it anyway.

+            segment->x_range.start(), segment->x_range.end()));
+        SCOPED_TRACE(base::StringPrintf(
+            "previous x_range: [%" PRIuS ", %" PRIuS ")",
+            previous_segment->x_range.start(),
+            previous_segment->x_range.end()));
+
+        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)
+          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) {
+  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);

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

Is it sufficient to EnsureLayout instead of calling Draw here and below?

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

Without Draw() we won't hit the DrawVisualText() DCHECKs. I'm not sure whether
EnsureLayout is good enough.

+    CheckLineIntegrity(render_text->lines_, render_text->runs_);
+  }
+}
+
+TEST_F(RenderTextTest, Multiline_NormalWidth) {
+  const struct {
+    wchar_t* text;
+    ui::Range first_line;
+    ui::Range second_line;
+  } kTestStrings[] = {
+    { L"abc defg hijkl mnop qrstuv wxyz", ui::Range(0, 15), ui::Range(15, 31) },

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

nit: these test cases could be covered with 50px width and half-length strings.

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

Done.

+    { L"qwertyuiopasdfghjklzxcvbnm", ui::Range(0, 17), ui::Range(17, 26) },
+    { L"\x0647\x0646\x0627\x0643 \x0627\x0644\x062A\x0641\x0627\x062D \x0648"
+      L"\x0627\x0644\x0628\x0637\x0627\x0637\x0627 \x0641\x064A",
+      ui::Range(0, 21), ui::Range(21, 23) }
+  };
+
+  scoped_ptr<RenderTextWin> render_text(
+      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+  render_text->SetDisplayRect(Rect(Point(), Size(100, 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