Prepare to enable RenderTextHarfBuzz by default

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"
@@ skipping 806 matching lines @@
   EXPECT_EQ(4U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
   EXPECT_EQ(2U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
   EXPECT_EQ(0U, render_text->cursor_position());
 }
 #endif
 
+// TODO(ckocagil): Fix the behavior and re-enable. http://crbug.com/383265
+#if 0

[msw, 2014/07/25 08:00:10]

Leave these tests running with CreateNativeInstance + TODOs.

[ckocagil, 2014/07/26 01:55:04]

Done.

 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
   // (code point) has unique bounds, so mid-glyph cursoring should be possible.
   render_text->SetFontList(FontList("Meiryo UI, 12px"));
   render_text->SetText(WideToUTF16(L"ff ffi"));
   EXPECT_EQ(0U, render_text->cursor_position());
   for (size_t i = 0; i < render_text->text().length(); ++i) {
     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
     EXPECT_EQ(i + 1, render_text->cursor_position());
   }
   EXPECT_EQ(6U, render_text->cursor_position());
 }
+#endif
 
 TEST_F(RenderTextTest, GraphemePositions) {
   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
   const base::string16 kText1 =
       WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
 
   // LTR ab, LTR 2-character grapheme, LTR cd.
   const base::string16 kText2 = WideToUTF16(L"ab" L"\x0915\x093f" L"cd");
 
   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
@@ skipping 386 matching lines @@
   EXPECT_EQ(3U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(5U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(6U, render_text->cursor_position());
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(6U, render_text->cursor_position());
 }
 #endif
 
-#if defined(OS_WIN)
+// TODO(ckocagil): Remove when RenderTextWin goes away.
+#if 0
 TEST_F(RenderTextTest, Win_LogicalClusters) {
   scoped_ptr<RenderTextWin> render_text(
       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
 
   const base::string16 test_string =
       WideToUTF16(L"\x0930\x0930\x0930\x0930\x0930");
   render_text->SetText(test_string);
   render_text->EnsureLayout();
   ASSERT_EQ(1U, render_text->runs_.size());
   WORD* logical_clusters = render_text->runs_[0]->logical_clusters.get();
   for (size_t i = 0; i < test_string.length(); ++i)
     EXPECT_EQ(i, logical_clusters[i]);
 }
-#endif  // defined(OS_WIN)
+#endif
 
 TEST_F(RenderTextTest, StringSizeSanity) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(UTF8ToUTF16("Hello World"));
   const Size string_size = render_text->GetStringSize();
   EXPECT_GT(string_size.width(), 0);
   EXPECT_GT(string_size.height(), 0);
 }
 
 TEST_F(RenderTextTest, StringSizeLongStrings) {
@@ skipping 296 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(large_content_cases); i++) {
     render_text->SetHorizontalAlignment(large_content_cases[i].alignment);
     render_text->SetDisplayOffset(large_content_cases[i].offset);
     EXPECT_EQ(large_content_cases[i].expected_offset,
               render_text->GetUpdatedDisplayOffset().x());
   }
 }
 
+// TODO(ckocagil): Fix the behavior and re-enable. http://crbug.com/396776
+#if 0
 TEST_F(RenderTextTest, SameFontForParentheses) {
   struct {
     const base::char16 left_char;
     const base::char16 right_char;
   } punctuation_pairs[] = {
     { '(', ')' },
     { '{', '}' },
     { '<', '>' },
   };
   struct {
@@ skipping 54 matching lines @@
       ASSERT_NE(-1, end_paren_span_index);
 
       const Font& start_font = spans[start_paren_span_index].first;
       const Font& end_font = spans[end_paren_span_index].first;
       EXPECT_EQ(start_font.GetFontName(), end_font.GetFontName());
       EXPECT_EQ(start_font.GetFontSize(), end_font.GetFontSize());
       EXPECT_EQ(start_font.GetStyle(), end_font.GetStyle());
     }
   }
 }
+#endif
 
 // Make sure the caret width is always >=1 so that the correct
 // caret is drawn at high DPI. crbug.com/164100.
 TEST_F(RenderTextTest, CaretWidth) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("abcdefg"));
   EXPECT_GE(render_text->GetUpdatedCursorBounds().width(), 1);
 }
 
 TEST_F(RenderTextTest, SelectWord) {
@@ skipping 202 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));
   }
 }
 
-#if defined(OS_WIN)
+// TODO(ckocagil): Enable after implementing RenderTextHarfBuzz multiline mode.
+#if 0
 // 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 };
 
   scoped_ptr<RenderTextWin> render_text(
       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
   render_text->SetDisplayRect(Rect(1, 1000));
   render_text->SetMultiline(true);
   Canvas canvas;
@@ skipping 97 matching lines @@
     EXPECT_EQ(L'\n', kTestStrings[i].text[newline_segment.char_range.start()]);
 
     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())
       EXPECT_EQ(second_expected_range,
                 render_text->lines_[1].segments[0].char_range);
   }
 }
+#endif
 
-TEST_F(RenderTextTest, Win_BreakRunsByUnicodeBlocks) {
+// TODO(ckocagil): Remove when RenderTextWin goes away.

[msw, 2014/07/25 08:00:10]

Does RenderTextHarfBuzz not suffer from the http://crbug.com/278913 defect?

[ckocagil, 2014/07/26 01:55:04]

No, and there's a HarfBuzz version of this test, namely
HarfBuzz_BreakRunsByUnicodeBlocks.

+#if 0
+TEST_F(RenderTextTest, BreakRunsByUnicodeBlocks) {
   scoped_ptr<RenderTextWin> render_text(
       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
 
   // The '\x25B6' "play character" should break runs. http://crbug.com/278913
   render_text->SetText(WideToUTF16(L"x\x25B6y"));
   render_text->EnsureLayout();
   ASSERT_EQ(3U, render_text->runs_.size());
   EXPECT_EQ(Range(0, 1), render_text->runs_[0]->range);
   EXPECT_EQ(Range(1, 2), render_text->runs_[1]->range);
   EXPECT_EQ(Range(2, 3), render_text->runs_[2]->range);
 
   render_text->SetText(WideToUTF16(L"x \x25B6 y"));
   render_text->EnsureLayout();
   ASSERT_EQ(3U, render_text->runs_.size());
   EXPECT_EQ(Range(0, 2), render_text->runs_[0]->range);
   EXPECT_EQ(Range(2, 3), render_text->runs_[1]->range);
   EXPECT_EQ(Range(3, 5), render_text->runs_[2]->range);
 }
-#endif  // defined(OS_WIN)
+#endif
 
 TEST_F(RenderTextTest, HarfBuzz_CharToGlyph) {
   struct {
     uint32 glyph_to_char[4];
     size_t char_to_glyph_expected[4];
     Range char_range_to_glyph_range_expected[4];
     bool is_rtl;
   } cases[] = {
     { // From string "A B C D" to glyphs "a b c d".
       { 0, 1, 2, 3 },
@@ skipping 98 matching lines @@
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     render_text->SetText(WideToUTF16(kTestStrings[i]));
     render_text->EnsureLayout();
 
     for (size_t j = 0; j < render_text->text().length(); ++j)
       EXPECT_FALSE(render_text->GetGlyphBounds(j).is_empty());
   }
 }
 
 }  // namespace gfx