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): Enable for RenderTextHarfBuzz. http://crbug.com/383265
 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
   // 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());
@@ skipping 397 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
 
+// TODO(ckocagil): Remove when RenderTextWin goes away.
 #if defined(OS_WIN)
 TEST_F(RenderTextTest, Win_LogicalClusters) {
   scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
 
   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]);
 }
@@ skipping 307 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): Enable for RenderTextHarfBuzz. http://crbug.com/396776
 TEST_F(RenderTextTest, SameFontForParentheses) {
   struct {
     const base::char16 left_char;
     const base::char16 right_char;
   } punctuation_pairs[] = {
     { '(', ')' },
     { '{', '}' },
     { '<', '>' },
   };
   struct {
@@ skipping 19 matching lines @@
     { WideToUTF16(L"Hello World(\x0915\x093f)Hello World") },
 
     // Hebrew(English)
     { WideToUTF16(L"\x05e0\x05b8(a)") },
     // Hebrew(English)Hebrew
     { WideToUTF16(L"\x05e0\x05b8(a)\x05e0\x05b8") },
     // English(Hebrew)English
     { WideToUTF16(L"Hello World(\x05e0\x05b8)Hello World") },
   };
 
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::string16 text = cases[i].text;
     const size_t start_paren_char_index = text.find('(');
     ASSERT_NE(base::string16::npos, start_paren_char_index);
     const size_t end_paren_char_index = text.find(')');
     ASSERT_NE(base::string16::npos, end_paren_char_index);
 
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(punctuation_pairs); ++j) {
       text[start_paren_char_index] = punctuation_pairs[j].left_char;
       text[end_paren_char_index] = punctuation_pairs[j].right_char;
@@ skipping 237 matching lines @@
     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 for RenderTextHarfBuzz after implementing multiline.
 // 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()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
   render_text->SetDisplayRect(Rect(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);
     EXPECT_GT(render_text->lines_.size(), 1U);
   }
 }
 
+// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings wrap onto multiple lines for a normal available width.
 TEST_F(RenderTextTest, Multiline_NormalWidth) {
   const struct {
     const wchar_t* const text;
     const Range first_line_char_range;
     const Range second_line_char_range;
   } kTestStrings[] = {
     { L"abc defg hijkl", Range(0, 9), Range(9, 14) },
     { L"qwertyzxcvbn", Range(0, 8), Range(8, 12) },
     { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9\x05DD",
           Range(4, 10), Range(0, 4) }
   };
 
   scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
   render_text->SetDisplayRect(Rect(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);
     ASSERT_EQ(2U, render_text->lines_.size());
     ASSERT_EQ(1U, render_text->lines_[0].segments.size());
     EXPECT_EQ(kTestStrings[i].first_line_char_range,
               render_text->lines_[0].segments[0].char_range);
     ASSERT_EQ(1U, render_text->lines_[1].segments.size());
     EXPECT_EQ(kTestStrings[i].second_line_char_range,
               render_text->lines_[1].segments[0].char_range);
   }
 }
 
+// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings don't wrap onto multiple lines for a sufficient available
 // width.
 TEST_F(RenderTextTest, Multiline_SufficientWidth) {
   const wchar_t* kTestStrings[] = { L"", L" ", L".", L" . ", L"abc", L"a b c",
                                     L"\x62E\x628\x632", L"\x62E \x628 \x632" };
 
   scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
   render_text->SetDisplayRect(Rect(30, 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);
     EXPECT_EQ(1U, render_text->lines_.size());
   }
 }
 
+// TODO(ckocagil): Enable for RenderTextHarfBuzz after implementing multiline.
 TEST_F(RenderTextTest, Multiline_Newline) {
   const struct {
     const wchar_t* const text;
     // Ranges of the characters on each line preceding the newline.
     const Range first_line_char_range;
     const Range second_line_char_range;
   } kTestStrings[] = {
     { L"abc\ndef", Range(0, 3), Range(4, 7) },
     { L"a \n b ", Range(0, 2), Range(3, 6) },
     { L"\n" , Range::InvalidRange(), Range::InvalidRange() }
   };
 
   scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
   render_text->SetDisplayRect(Rect(200, 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);
 
     ASSERT_EQ(2U, render_text->lines_.size());
@@ skipping 12 matching lines @@
 
     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);
   }
 }
 
-TEST_F(RenderTextTest, Win_BreakRunsByUnicodeBlocks) {
+// TODO(ckocagil): Remove when RenderTextWin goes away.
+TEST_F(RenderTextTest, BreakRunsByUnicodeBlocks) {
   scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateInstance()));
+      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
 
   // 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"));
@@ skipping 115 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