Delete RenderTextWin and RenderTextPango.

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/i18n/break_iterator.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/render_text_harfbuzz.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/gfx/platform_font_win.h"
-#include "ui/gfx/render_text_win.h"
-#endif
-
-#if defined(OS_LINUX) && !defined(USE_OZONE)
-#include "ui/gfx/render_text_pango.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 using base::WideToUTF8;
 
 namespace gfx {
 
 namespace {
 
 // Various weak, LTR, RTL, and Bidi string cases with three characters each.
 const wchar_t kWeak[] =      L" . ";
 const wchar_t kLtr[] =       L"abc";
 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
-#if !defined(OS_MACOSX)
 const wchar_t kLtrRtl[] =    L"a" L"\x5d0\x5d1";
 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
 const wchar_t kRtlLtr[] =    L"\x5d0\x5d1" L"a";
 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
-#endif
 
 // Checks whether |range| contains |index|. This is not the same as calling
 // range.Contains(Range(index)), which returns true if |index| == |range.end()|.
 bool IndexInRange(const Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
 base::string16 GetSelectedText(RenderText* render_text) {
   return render_text->text().substr(render_text->selection().GetMin(),
                                     render_text->selection().length());
@@ skipping 138 matching lines @@
   render_text->ApplyStyle(UNDERLINE, true, Range(2, 5));
   std::vector<std::pair<size_t, bool> > expected_underline;
   expected_underline.push_back(std::pair<size_t, bool>(0, false));
   expected_underline.push_back(std::pair<size_t, bool>(1, true));
   expected_underline.push_back(std::pair<size_t, bool>(6, false));
   EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsForTesting(
       expected_underline));
 #endif  // OS_MACOSX
 }
 
-#if defined(OS_LINUX) && !defined(USE_OZONE)
-TEST_F(RenderTextTest, PangoAttributes) {
-  scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
-  render_text->SetText(ASCIIToUTF16("012345678"));
-
-  // Apply ranged BOLD/ITALIC styles and check the resulting Pango attributes.
-  render_text->ApplyStyle(BOLD, true, Range(2, 4));
-  render_text->ApplyStyle(ITALIC, true, Range(1, 3));
-
-  struct {
-    int start;
-    int end;
-    bool bold;
-    bool italic;
-  } cases[] = {
-    { 0, 1,       false, false },
-    { 1, 2,       false, true  },
-    { 2, 3,       true,  true  },
-    { 3, 4,       true,  false },
-    { 4, INT_MAX, false, false },
-  };
-
-  int start = 0, end = 0;
-  RenderTextPango* rt_linux = static_cast<RenderTextPango*>(render_text.get());
-  rt_linux->EnsureLayout();
-  PangoAttrList* attributes = pango_layout_get_attributes(rt_linux->layout_);
-  PangoAttrIterator* iter = pango_attr_list_get_iterator(attributes);
-  for (size_t i = 0; i < arraysize(cases); ++i) {
-    pango_attr_iterator_range(iter, &start, &end);
-    EXPECT_EQ(cases[i].start, start);
-    EXPECT_EQ(cases[i].end, end);
-    PangoFontDescription* font = pango_font_description_new();
-    pango_attr_iterator_get_font(iter, font, NULL, NULL);
-    char* description_string = pango_font_description_to_string(font);
-    const base::string16 desc = ASCIIToUTF16(description_string);
-    const bool bold = desc.find(ASCIIToUTF16("Bold")) != std::string::npos;
-    EXPECT_EQ(cases[i].bold, bold);
-    const bool italic = desc.find(ASCIIToUTF16("Italic")) != std::string::npos;
-    EXPECT_EQ(cases[i].italic, italic);
-    pango_attr_iterator_next(iter);
-    pango_font_description_free(font);
-    g_free(description_string);
-  }
-  EXPECT_FALSE(pango_attr_iterator_next(iter));
-  pango_attr_iterator_destroy(iter);
-}
-#endif
-
 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
 //                  does not implement this yet. http://crbug.com/131618
 #if !defined(OS_MACOSX)
 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
                                            const base::string16& text,
                                            bool select) {
   ASSERT_TRUE(render_text->obscured());
   render_text->SetText(text);
   int len = text.length();
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
@@ skipping 574 matching lines @@
   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
+#if defined(OS_MACOSX)
 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
-  scoped_ptr<RenderText> render_text(RenderText::CreateNativeInstance());
+  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  // defined(OS_MACOSX)
 
 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 422 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::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]);
-}
-#endif  // defined(OS_WIN)
-
 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) {
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
@@ skipping 592 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 for RenderTextHarfBuzz after implementing multiline.
 // Ensure strings wrap onto multiple lines for a small available width.
-TEST_F(RenderTextTest, Multiline_MinWidth) {
+TEST_F(RenderTextTest, DISABLED_Multiline_MinWidth) {
   const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
                                     kRtlLtr, kRtlLtrRtl };
 
-  scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   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) {
+TEST_F(RenderTextTest, DISABLED_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::CreateNativeInstance()));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(50, 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].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) {
+TEST_F(RenderTextTest, DISABLED_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::CreateNativeInstance()));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   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) {
+TEST_F(RenderTextTest, DISABLED_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::CreateNativeInstance()));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(200, 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].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);
   }
 }
 
-// TODO(ckocagil): Remove when RenderTextWin goes away.
-TEST_F(RenderTextTest, BreakRunsByUnicodeBlocks) {
-  scoped_ptr<RenderTextWin> render_text(
-      static_cast<RenderTextWin*>(RenderText::CreateNativeInstance()));
-
-  // The '\x25B6' "play character" should break runs. http://crbug.com/278913
-  render_text->SetText(WideToUTF16(L"x\x25B6y"));

[msw, 2015/02/02 22:52:55]

I wonder if we could preserve a similar test for HarfBuzz...
(ensure that characters of unusual code blocks are drawn correctly)

[Daniel Erat, 2015/02/02 23:10:31]

it's collapsed, but it looks like we already have an identical harfbuzz-specific
test: see HarfBuzz_BreakRunsByUnicodeBlocks on line 2139.

-  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)
-
 // Test TextRunHarfBuzz's cluster finding logic.
 TEST_F(RenderTextTest, HarfBuzz_Clusters) {
   struct {
     uint32 glyph_to_char[4];
     Range chars[4];
     Range glyphs[4];
     bool is_rtl;
   } cases[] = {
     { // From string "A B C D" to glyphs "a b c d".
       { 0, 1, 2, 3 },
@@ skipping 170 matching lines @@
   render_text.SetText(UTF8ToUTF16("x\xF0\x9F\x98\x81y\xE2\x9C\xA8"));
   render_text.EnsureLayout();
   ASSERT_EQ(4U, render_text.runs_.size());
   EXPECT_EQ(Range(0, 1), render_text.runs_[0]->range);
   // The length is 2 since U+1F601 is represented as a surrogate pair in UTF16.
   EXPECT_EQ(Range(1, 3), render_text.runs_[1]->range);
   EXPECT_EQ(Range(3, 4), render_text.runs_[2]->range);
   EXPECT_EQ(Range(4, 5), render_text.runs_[3]->range);
 }
 
-// Disabled on Mac because RenderTextMac doesn't implement GetGlyphBounds.
-#if !defined(OS_MACOSX)
 TEST_F(RenderTextTest, GlyphBounds) {
   const wchar_t* kTestStrings[] = {
       L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
   };
-  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-
-  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());
-  }
-}
-#endif
-
-// Remove this after making RTHB default in favor of RenderTextTest.GlyphBounds.
-TEST_F(RenderTextTest, HarfBuzz_GlyphBounds) {
-  const wchar_t* kTestStrings[] = {
-      L"asdf 1234 qwer", L"\x0647\x0654", L"\x0645\x0631\x062D\x0628\x0627"
-  };
   scoped_ptr<RenderText> render_text(new RenderTextHarfBuzz);
 
   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());
   }
 }
@@ skipping 155 matching lines @@
             base::StringToLowerASCII(fonts[0].GetActualFontNameForTesting()));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetDisplayRect(Rect(0, 0, 25, 25));
   render_text->SetFontList(font_list);
   EXPECT_GT(render_text->GetBaseline(), font_list.GetBaseline());
 }
 #endif
 
 }  // namespace gfx