src/ui/gfx/render_text_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/render_text.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/format_macros.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "ui/gfx/break_list.h"
  16 #include "ui/gfx/canvas.h"
  17
  18 #if defined(OS_WIN)
  19 #include "base/win/windows_version.h"
  20 #include "ui/gfx/render_text_win.h"
  21 #endif
  22
  23 #if defined(OS_LINUX) && !defined(USE_OZONE)
  24 #include "ui/gfx/render_text_pango.h"
  25 #endif
  26
  27 #if defined(TOOLKIT_GTK)
  28 #include <gtk/gtk.h>
  29 #endif
  30
  31 using base::ASCIIToUTF16;
  32 using base::UTF8ToUTF16;
  33 using base::WideToUTF16;
  34
  35 namespace gfx {
  36
  37 namespace {
  38
  39 // Various weak, LTR, RTL, and Bidi string cases with three characters each.
  40 const wchar_t kWeak[] =      L" . ";
  41 const wchar_t kLtr[] =       L"abc";
  42 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
  43 #if !defined(OS_MACOSX)
  44 const wchar_t kLtrRtl[] =    L"a" L"\x5d0\x5d1";
  45 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
  46 const wchar_t kRtlLtr[] =    L"\x5d0\x5d1" L"a";
  47 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
  48 #endif
  49
  50 // Checks whether |range| contains |index|. This is not the same as calling
  51 // |range.Contains(gfx::Range(index))| - as that would return true when
  52 // |index| == |range.end()|.
  53 bool IndexInRange(const Range& range, size_t index) {
  54   return index >= range.start() && index < range.end();
  55 }
  56
  57 base::string16 GetSelectedText(RenderText* render_text) {
  58   return render_text->text().substr(render_text->selection().GetMin(),
  59                                     render_text->selection().length());
  60 }
  61
  62 // A test utility function to set the application default text direction.
  63 void SetRTL(bool rtl) {
  64   // Override the current locale/direction.
  65   base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
  66 #if defined(TOOLKIT_GTK)
  67   // Do the same for GTK, which does not rely on the ICU default locale.
  68   gtk_widget_set_default_direction(rtl ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
  69 #endif
  70   EXPECT_EQ(rtl, base::i18n::IsRTL());
  71 }
  72
  73 #if !defined(OS_MACOSX)
  74 // Ensure cursor movement in the specified |direction| yields |expected| values.
  75 void RunMoveCursorLeftRightTest(RenderText* render_text,
  76                                 const std::vector<SelectionModel>& expected,
  77                                 VisualCursorDirection direction) {
  78   for (size_t i = 0; i < expected.size(); ++i) {
  79     SCOPED_TRACE(base::StringPrintf("Going %s; expected value index %d.",
  80         direction == CURSOR_LEFT ? "left" : "right", static_cast<int>(i)));
  81     EXPECT_EQ(expected[i], render_text->selection_model());
  82     render_text->MoveCursor(CHARACTER_BREAK, direction, false);
  83   }
  84   // Check that cursoring is clamped at the line edge.
  85   EXPECT_EQ(expected.back(), render_text->selection_model());
  86   // Check that it is the line edge.
  87   render_text->MoveCursor(LINE_BREAK, direction, false);
  88   EXPECT_EQ(expected.back(), render_text->selection_model());
  89 }
  90 #endif  // !defined(OS_MACOSX)
  91
  92 }  // namespace
  93
  94 class RenderTextTest : public testing::Test {
  95 };
  96
  97 TEST_F(RenderTextTest, DefaultStyle) {
  98   // Check the default styles applied to new instances and adjusted text.
  99   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 100   EXPECT_TRUE(render_text->text().empty());
 101   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
 102   for (size_t i = 0; i < arraysize(cases); ++i) {
 103     EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLACK));
 104     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
 105       EXPECT_TRUE(render_text->styles()[style].EqualsValueForTesting(false));
 106     render_text->SetText(WideToUTF16(cases[i]));
 107   }
 108 }
 109
 110 TEST_F(RenderTextTest, SetColorAndStyle) {
 111   // Ensure custom default styles persist across setting and clearing text.
 112   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 113   const SkColor color = SK_ColorRED;
 114   render_text->SetColor(color);
 115   render_text->SetStyle(BOLD, true);
 116   render_text->SetStyle(UNDERLINE, false);
 117   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
 118   for (size_t i = 0; i < arraysize(cases); ++i) {
 119     EXPECT_TRUE(render_text->colors().EqualsValueForTesting(color));
 120     EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(true));
 121     EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsValueForTesting(false));
 122     render_text->SetText(WideToUTF16(cases[i]));
 123
 124     // Ensure custom default styles can be applied after text has been set.
 125     if (i == 1)
 126       render_text->SetStyle(STRIKE, true);
 127     if (i >= 1)
 128       EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
 129   }
 130 }
 131
 132 TEST_F(RenderTextTest, ApplyColorAndStyle) {
 133   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 134   render_text->SetText(ASCIIToUTF16("012345678"));
 135
 136   // Apply a ranged color and style and check the resulting breaks.
 137   render_text->ApplyColor(SK_ColorRED, Range(1, 4));
 138   render_text->ApplyStyle(BOLD, true, Range(2, 5));
 139   std::vector<std::pair<size_t, SkColor> > expected_color;
 140   expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
 141   expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
 142   expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
 143   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
 144   std::vector<std::pair<size_t, bool> > expected_style;
 145   expected_style.push_back(std::pair<size_t, bool>(0, false));
 146   expected_style.push_back(std::pair<size_t, bool>(2, true));
 147   expected_style.push_back(std::pair<size_t, bool>(5, false));
 148   EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style));
 149
 150   // Ensure setting a color and style overrides the ranged colors and styles.
 151   render_text->SetColor(SK_ColorBLUE);
 152   EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
 153   render_text->SetStyle(BOLD, false);
 154   EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(false));
 155
 156   // Apply a color and style over the text end and check the resulting breaks.
 157   // (INT_MAX should be used instead of the text length for the range end)
 158   const size_t text_length = render_text->text().length();
 159   render_text->ApplyColor(SK_ColorRED, Range(0, text_length));
 160   render_text->ApplyStyle(BOLD, true, Range(2, text_length));
 161   std::vector<std::pair<size_t, SkColor> > expected_color_end;
 162   expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
 163   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
 164   std::vector<std::pair<size_t, bool> > expected_style_end;
 165   expected_style_end.push_back(std::pair<size_t, bool>(0, false));
 166   expected_style_end.push_back(std::pair<size_t, bool>(2, true));
 167   EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style_end));
 168
 169   // Ensure ranged values adjust to accommodate text length changes.
 170   render_text->ApplyStyle(ITALIC, true, Range(0, 2));
 171   render_text->ApplyStyle(ITALIC, true, Range(3, 6));
 172   render_text->ApplyStyle(ITALIC, true, Range(7, text_length));
 173   std::vector<std::pair<size_t, bool> > expected_italic;
 174   expected_italic.push_back(std::pair<size_t, bool>(0, true));
 175   expected_italic.push_back(std::pair<size_t, bool>(2, false));
 176   expected_italic.push_back(std::pair<size_t, bool>(3, true));
 177   expected_italic.push_back(std::pair<size_t, bool>(6, false));
 178   expected_italic.push_back(std::pair<size_t, bool>(7, true));
 179   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 180
 181   // Truncating the text should trim any corresponding breaks.
 182   render_text->SetText(ASCIIToUTF16("0123456"));
 183   expected_italic.resize(4);
 184   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 185   render_text->SetText(ASCIIToUTF16("01234"));
 186   expected_italic.resize(3);
 187   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 188
 189   // Appending text should extend the terminal styles without changing breaks.
 190   render_text->SetText(ASCIIToUTF16("012345678"));
 191   EXPECT_TRUE(render_text->styles()[ITALIC].EqualsForTesting(expected_italic));
 192 }
 193
 194 #if defined(OS_LINUX) && !defined(USE_OZONE)
 195 TEST_F(RenderTextTest, PangoAttributes) {
 196   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 197   render_text->SetText(ASCIIToUTF16("012345678"));
 198
 199   // Apply ranged BOLD/ITALIC styles and check the resulting Pango attributes.
 200   render_text->ApplyStyle(BOLD, true, Range(2, 4));
 201   render_text->ApplyStyle(ITALIC, true, Range(1, 3));
 202
 203   struct {
 204     int start;
 205     int end;
 206     bool bold;
 207     bool italic;
 208   } cases[] = {
 209     { 0, 1,       false, false },
 210     { 1, 2,       false, true  },
 211     { 2, 3,       true,  true  },
 212     { 3, 4,       true,  false },
 213     { 4, INT_MAX, false, false },
 214   };
 215
 216   int start = 0, end = 0;
 217   RenderTextPango* rt_linux = static_cast<RenderTextPango*>(render_text.get());
 218   rt_linux->EnsureLayout();
 219   PangoAttrList* attributes = pango_layout_get_attributes(rt_linux->layout_);
 220   PangoAttrIterator* iter = pango_attr_list_get_iterator(attributes);
 221   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 222     pango_attr_iterator_range(iter, &start, &end);
 223     EXPECT_EQ(cases[i].start, start);
 224     EXPECT_EQ(cases[i].end, end);
 225     PangoFontDescription* font = pango_font_description_new();
 226     pango_attr_iterator_get_font(iter, font, NULL, NULL);
 227     char* description_string = pango_font_description_to_string(font);
 228     const base::string16 desc = ASCIIToUTF16(description_string);
 229     const bool bold = desc.find(ASCIIToUTF16("Bold")) != std::string::npos;
 230     EXPECT_EQ(cases[i].bold, bold);
 231     const bool italic = desc.find(ASCIIToUTF16("Italic")) != std::string::npos;
 232     EXPECT_EQ(cases[i].italic, italic);
 233     pango_attr_iterator_next(iter);
 234     pango_font_description_free(font);
 235     g_free(description_string);
 236   }
 237   EXPECT_FALSE(pango_attr_iterator_next(iter));
 238   pango_attr_iterator_destroy(iter);
 239 }
 240 #endif
 241
 242 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
 243 //                  does not implement this yet. http://crbug.com/131618
 244 #if !defined(OS_MACOSX)
 245 void TestVisualCursorMotionInObscuredField(RenderText* render_text,
 246                                            const base::string16& text,
 247                                            bool select) {
 248   ASSERT_TRUE(render_text->obscured());
 249   render_text->SetText(text);
 250   int len = text.length();
 251   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, select);
 252   EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
 253             render_text->selection_model());
 254   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, select);
 255   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 256   for (int j = 1; j <= len; ++j) {
 257     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, select);
 258     EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_BACKWARD),
 259               render_text->selection_model());
 260   }
 261   for (int j = len - 1; j >= 0; --j) {
 262     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, select);
 263     EXPECT_EQ(SelectionModel(Range(select ? 0 : j, j), CURSOR_FORWARD),
 264               render_text->selection_model());
 265   }
 266   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, select);
 267   EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
 268             render_text->selection_model());
 269   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, select);
 270   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 271 }
 272
 273 TEST_F(RenderTextTest, ObscuredText) {
 274   const base::string16 seuss = ASCIIToUTF16("hop on pop");
 275   const base::string16 no_seuss = ASCIIToUTF16("**********");
 276   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 277
 278   // GetLayoutText() returns asterisks when the obscured bit is set.
 279   render_text->SetText(seuss);
 280   render_text->SetObscured(true);
 281   EXPECT_EQ(seuss, render_text->text());
 282   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 283   render_text->SetObscured(false);
 284   EXPECT_EQ(seuss, render_text->text());
 285   EXPECT_EQ(seuss, render_text->GetLayoutText());
 286
 287   render_text->SetObscured(true);
 288
 289   // Surrogate pairs are counted as one code point.
 290   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
 291   render_text->SetText(invalid_surrogates);
 292   EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetLayoutText());
 293   const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
 294   render_text->SetText(valid_surrogates);
 295   EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetLayoutText());
 296   EXPECT_EQ(0U, render_text->cursor_position());
 297   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 298   EXPECT_EQ(2U, render_text->cursor_position());
 299
 300   // Test index conversion and cursor validity with a valid surrogate pair.
 301   EXPECT_EQ(0U, render_text->TextIndexToLayoutIndex(0U));
 302   EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(1U));
 303   EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(2U));
 304   EXPECT_EQ(0U, render_text->LayoutIndexToTextIndex(0U));
 305   EXPECT_EQ(2U, render_text->LayoutIndexToTextIndex(1U));
 306   EXPECT_TRUE(render_text->IsCursorablePosition(0U));
 307   EXPECT_FALSE(render_text->IsCursorablePosition(1U));
 308   EXPECT_TRUE(render_text->IsCursorablePosition(2U));
 309
 310   // FindCursorPosition() should not return positions between a surrogate pair.
 311   render_text->SetDisplayRect(Rect(0, 0, 20, 20));
 312   EXPECT_EQ(render_text->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
 313   EXPECT_EQ(render_text->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
 314   for (int x = -1; x <= 20; ++x) {
 315     SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
 316     EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
 317   }
 318
 319   // GetGlyphBounds() should yield the entire string bounds for text index 0.
 320   EXPECT_EQ(render_text->GetStringSize().width(),
 321             static_cast<int>(render_text->GetGlyphBounds(0U).length()));
 322
 323   // Cursoring is independent of underlying characters when text is obscured.
 324   const wchar_t* const texts[] = {
 325     kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl,
 326     L"hop on pop",                              // Check LTR word boundaries.
 327     L"\x05d0\x05d1 \x05d0\x05d2 \x05d1\x05d2",  // Check RTL word boundaries.
 328   };
 329   for (size_t i = 0; i < arraysize(texts); ++i) {
 330     base::string16 text = WideToUTF16(texts[i]);
 331     TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
 332     TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
 333   }
 334 }
 335
 336 TEST_F(RenderTextTest, RevealObscuredText) {
 337   const base::string16 seuss = ASCIIToUTF16("hop on pop");
 338   const base::string16 no_seuss = ASCIIToUTF16("**********");
 339   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 340
 341   render_text->SetText(seuss);
 342   render_text->SetObscured(true);
 343   EXPECT_EQ(seuss, render_text->text());
 344   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 345
 346   // Valid reveal index and new revealed index clears previous one.
 347   render_text->RenderText::SetObscuredRevealIndex(0);
 348   EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
 349   render_text->RenderText::SetObscuredRevealIndex(1);
 350   EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetLayoutText());
 351   render_text->RenderText::SetObscuredRevealIndex(2);
 352   EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetLayoutText());
 353
 354   // Invalid reveal index.
 355   render_text->RenderText::SetObscuredRevealIndex(-1);
 356   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 357   render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
 358   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 359
 360   // SetObscured clears the revealed index.
 361   render_text->RenderText::SetObscuredRevealIndex(0);
 362   EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetLayoutText());
 363   render_text->SetObscured(false);
 364   EXPECT_EQ(seuss, render_text->GetLayoutText());
 365   render_text->SetObscured(true);
 366   EXPECT_EQ(no_seuss, render_text->GetLayoutText());
 367
 368   // SetText clears the revealed index.
 369   render_text->SetText(ASCIIToUTF16("new"));
 370   EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetLayoutText());
 371   render_text->RenderText::SetObscuredRevealIndex(2);
 372   EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetLayoutText());
 373   render_text->SetText(ASCIIToUTF16("new longer"));
 374   EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetLayoutText());
 375
 376   // Text with invalid surrogates.
 377   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 'h', 'o', 'p', 0};
 378   render_text->SetText(invalid_surrogates);
 379   EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
 380   render_text->RenderText::SetObscuredRevealIndex(0);
 381   const base::char16 invalid_expect_0[] = {0xDC00, '*', '*', '*', '*', 0};
 382   EXPECT_EQ(invalid_expect_0, render_text->GetLayoutText());
 383   render_text->RenderText::SetObscuredRevealIndex(1);
 384   const base::char16 invalid_expect_1[] = {'*', 0xD800, '*', '*', '*', 0};
 385   EXPECT_EQ(invalid_expect_1, render_text->GetLayoutText());
 386   render_text->RenderText::SetObscuredRevealIndex(2);
 387   EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetLayoutText());
 388
 389   // Text with valid surrogates before and after the reveal index.
 390   const base::char16 valid_surrogates[] =
 391       {0xD800, 0xDC00, 'h', 'o', 'p', 0xD800, 0xDC00, 0};
 392   render_text->SetText(valid_surrogates);
 393   EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetLayoutText());
 394   render_text->RenderText::SetObscuredRevealIndex(0);
 395   const base::char16 valid_expect_0_and_1[] =
 396       {0xD800, 0xDC00, '*', '*', '*', '*', 0};
 397   EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
 398   render_text->RenderText::SetObscuredRevealIndex(1);
 399   EXPECT_EQ(valid_expect_0_and_1, render_text->GetLayoutText());
 400   render_text->RenderText::SetObscuredRevealIndex(2);
 401   EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetLayoutText());
 402   render_text->RenderText::SetObscuredRevealIndex(5);
 403   const base::char16 valid_expect_5_and_6[] =
 404       {'*', '*', '*', '*', 0xD800, 0xDC00, 0};
 405   EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
 406   render_text->RenderText::SetObscuredRevealIndex(6);
 407   EXPECT_EQ(valid_expect_5_and_6, render_text->GetLayoutText());
 408 }
 409
 410 TEST_F(RenderTextTest, ElidedText) {
 411   // TODO(skanuj) : Add more test cases for following
 412   // - RenderText styles.
 413   // - Cross interaction of truncate, elide and obscure.
 414   // - ElideText tests from text_elider.cc.
 415   struct {
 416     const wchar_t* text;
 417     const wchar_t* layout_text;
 418     const bool elision_expected;
 419   } cases[] = {
 420     // Strings shorter than the elision width should be laid out in full.
 421     { L"",        L""       , false },
 422     { kWeak,      kWeak     , false },
 423     { kLtr,       kLtr      , false },
 424     { kLtrRtl,    kLtrRtl   , false },
 425     { kLtrRtlLtr, kLtrRtlLtr, false },
 426     { kRtl,       kRtl      , false },
 427     { kRtlLtr,    kRtlLtr   , false },
 428     { kRtlLtrRtl, kRtlLtrRtl, false },
 429     // Strings as long as the elision width should be laid out in full.
 430     { L"012ab",   L"012ab"  , false },
 431     // Long strings should be elided with an ellipsis appended at the end.
 432     { L"012abc",              L"012a\x2026", true },
 433     { L"012ab" L"\x5d0\x5d1", L"012a\x2026", true },
 434     { L"012a" L"\x5d1" L"b",  L"012a\x2026", true },
 435     // No RLM marker added as digits (012) have weak directionality.
 436     { L"01" L"\x5d0\x5d1\x5d2", L"01\x5d0\x5d1\x2026", true },
 437     // RLM marker added as "ab" have strong LTR directionality.
 438     { L"ab" L"\x5d0\x5d1\x5d2", L"ab\x5d0\x5d1\x2026\x200f", true },
 439     // Complex script is not handled. In this example, the "\x0915\x093f" is a
 440     // compound glyph, but only half of it is elided.
 441     { L"0123\x0915\x093f", L"0123\x0915\x2026", true },
 442     // Surrogate pairs should be elided reasonably enough.
 443     { L"0\x05e9\x05bc\x05c1\x05b8",   L"0\x05e9\x05bc\x05c1\x05b8", false },
 444     { L"0\x05e9\x05bc\x05c1\x05b8",   L"0\x05e9\x05bc\x2026"      , true  },
 445     { L"01\x05e9\x05bc\x05c1\x05b8",  L"01\x05e9\x2026"           , true  },
 446     { L"012\x05e9\x05bc\x05c1\x05b8", L"012\x2026"                , true  },
 447     { L"012\xF0\x9D\x84\x9E",         L"012\xF0\x2026"            , true  },
 448   };
 449
 450   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
 451   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
 452   expected_render_text->SetDisplayRect(gfx::Rect(0, 0, 9999, 100));
 453
 454   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 455   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
 456   render_text->SetElideBehavior(gfx::ELIDE_AT_END);
 457
 458   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
 459     // Compute expected width
 460     expected_render_text->SetText(WideToUTF16(cases[i].layout_text));
 461     int expected_width = expected_render_text->GetContentWidth();
 462
 463     base::string16 input = WideToUTF16(cases[i].text);
 464     // Extend the input text to ensure that it is wider than the layout_text,
 465     // and so it will get elided.
 466     if (cases[i].elision_expected)
 467       input.append(WideToUTF16(L" MMMMMMMMMMM"));
 468
 469     render_text->SetText(input);
 470     render_text->SetDisplayRect(gfx::Rect(0, 0, expected_width, 100));
 471     EXPECT_EQ(input, render_text->text());
 472     EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
 473         << "->For case " << i << ": " << cases[i].text << "\n";
 474     expected_render_text->SetText(base::string16());
 475   }
 476 }
 477
 478 TEST_F(RenderTextTest, ElidedObscuredText) {
 479   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
 480   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
 481   expected_render_text->SetDisplayRect(gfx::Rect(0, 0, 9999, 100));
 482   expected_render_text->SetText(WideToUTF16(L"**\x2026"));
 483
 484   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 485   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
 486   render_text->SetElideBehavior(gfx::ELIDE_AT_END);
 487   render_text->SetDisplayRect(
 488       gfx::Rect(0, 0, expected_render_text->GetContentWidth(), 100));
 489   render_text->SetObscured(true);
 490   render_text->SetText(WideToUTF16(L"abcdef"));
 491   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
 492   EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
 493 }
 494
 495 TEST_F(RenderTextTest, TruncatedText) {
 496   struct {
 497     const wchar_t* text;
 498     const wchar_t* layout_text;
 499   } cases[] = {
 500     // Strings shorter than the truncation length should be laid out in full.
 501     { L"",        L""        },
 502     { kWeak,      kWeak      },
 503     { kLtr,       kLtr       },
 504     { kLtrRtl,    kLtrRtl    },
 505     { kLtrRtlLtr, kLtrRtlLtr },
 506     { kRtl,       kRtl       },
 507     { kRtlLtr,    kRtlLtr    },
 508     { kRtlLtrRtl, kRtlLtrRtl },
 509     // Strings as long as the truncation length should be laid out in full.
 510     { L"01234",   L"01234"   },
 511     // Long strings should be truncated with an ellipsis appended at the end.
 512     { L"012345",                  L"0123\x2026"     },
 513     { L"012" L" . ",              L"012 \x2026"     },
 514     { L"012" L"abc",              L"012a\x2026"     },
 515     { L"012" L"a" L"\x5d0\x5d1",  L"012a\x2026"     },
 516     { L"012" L"a" L"\x5d1" L"b",  L"012a\x2026"     },
 517     { L"012" L"\x5d0\x5d1\x5d2",  L"012\x5d0\x2026" },
 518     { L"012" L"\x5d0\x5d1" L"a",  L"012\x5d0\x2026" },
 519     { L"012" L"\x5d0" L"a" L"\x5d1",    L"012\x5d0\x2026" },
 520     // Surrogate pairs should be truncated reasonably enough.
 521     { L"0123\x0915\x093f",              L"0123\x2026"                },
 522     { L"0\x05e9\x05bc\x05c1\x05b8",     L"0\x05e9\x05bc\x05c1\x05b8" },
 523     { L"01\x05e9\x05bc\x05c1\x05b8",    L"01\x05e9\x05bc\x2026"      },
 524     { L"012\x05e9\x05bc\x05c1\x05b8",   L"012\x05e9\x2026"           },
 525     { L"0123\x05e9\x05bc\x05c1\x05b8",  L"0123\x2026"                },
 526     { L"01234\x05e9\x05bc\x05c1\x05b8", L"0123\x2026"                },
 527     { L"012\xF0\x9D\x84\x9E",           L"012\xF0\x2026"             },
 528   };
 529
 530   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 531   render_text->set_truncate_length(5);
 532   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
 533     render_text->SetText(WideToUTF16(cases[i].text));
 534     EXPECT_EQ(WideToUTF16(cases[i].text), render_text->text());
 535     EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
 536         << "For case " << i << ": " << cases[i].text;
 537   }
 538 }
 539
 540 TEST_F(RenderTextTest, TruncatedObscuredText) {
 541   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 542   render_text->set_truncate_length(3);
 543   render_text->SetObscured(true);
 544   render_text->SetText(WideToUTF16(L"abcdef"));
 545   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
 546   EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
 547 }
 548
 549 TEST_F(RenderTextTest, TruncatedCursorMovementLTR) {
 550   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 551   render_text->set_truncate_length(2);
 552   render_text->SetText(WideToUTF16(L"abcd"));
 553
 554   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 555   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
 556   EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
 557   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
 558   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 559
 560   std::vector<SelectionModel> expected;
 561   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 562   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 563   // The cursor hops over the ellipsis and elided text to the line end.
 564   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
 565   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 566   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 567
 568   expected.clear();
 569   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 570   // The cursor hops over the elided text to preceeding text.
 571   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 572   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 573   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 574   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 575 }
 576
 577 TEST_F(RenderTextTest, TruncatedCursorMovementRTL) {
 578   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 579   render_text->set_truncate_length(2);
 580   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3"));
 581
 582   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 583   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
 584   EXPECT_EQ(SelectionModel(4, CURSOR_FORWARD), render_text->selection_model());
 585   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
 586   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 587
 588   std::vector<SelectionModel> expected;
 589   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 590   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 591   // The cursor hops over the ellipsis and elided text to the line end.
 592   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
 593   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 594   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 595
 596   expected.clear();
 597   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 598   // The cursor hops over the elided text to preceeding text.
 599   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 600   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 601   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 602   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 603 }
 604
 605 TEST_F(RenderTextTest, GetTextDirection) {
 606   struct {
 607     const wchar_t* text;
 608     const base::i18n::TextDirection text_direction;
 609   } cases[] = {
 610     // Blank strings and those with no/weak directionality default to LTR.
 611     { L"",        base::i18n::LEFT_TO_RIGHT },
 612     { kWeak,      base::i18n::LEFT_TO_RIGHT },
 613     // Strings that begin with strong LTR characters.
 614     { kLtr,       base::i18n::LEFT_TO_RIGHT },
 615     { kLtrRtl,    base::i18n::LEFT_TO_RIGHT },
 616     { kLtrRtlLtr, base::i18n::LEFT_TO_RIGHT },
 617     // Strings that begin with strong RTL characters.
 618     { kRtl,       base::i18n::RIGHT_TO_LEFT },
 619     { kRtlLtr,    base::i18n::RIGHT_TO_LEFT },
 620     { kRtlLtrRtl, base::i18n::RIGHT_TO_LEFT },
 621   };
 622
 623   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 624   const bool was_rtl = base::i18n::IsRTL();
 625
 626   for (size_t i = 0; i < 2; ++i) {
 627     // Toggle the application default text direction (to try each direction).
 628     SetRTL(!base::i18n::IsRTL());
 629     const base::i18n::TextDirection ui_direction = base::i18n::IsRTL() ?
 630         base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
 631
 632     // Ensure that directionality modes yield the correct text directions.
 633     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
 634       render_text->SetText(WideToUTF16(cases[j].text));
 635       render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
 636       EXPECT_EQ(render_text->GetTextDirection(), cases[j].text_direction);
 637       render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
 638       EXPECT_EQ(render_text->GetTextDirection(), ui_direction);
 639       render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
 640       EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
 641       render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
 642       EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
 643     }
 644   }
 645
 646   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 647
 648   // Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
 649   render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
 650   render_text->SetText(WideToUTF16(kLtr));
 651   EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
 652   render_text->SetText(WideToUTF16(kRtl));
 653   EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
 654 }
 655
 656 TEST_F(RenderTextTest, MoveCursorLeftRightInLtr) {
 657   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 658
 659   // Pure LTR.
 660   render_text->SetText(ASCIIToUTF16("abc"));
 661   // |expected| saves the expected SelectionModel when moving cursor from left
 662   // to right.
 663   std::vector<SelectionModel> expected;
 664   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 665   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 666   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 667   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 668   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 669   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 670
 671   expected.clear();
 672   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 673   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 674   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 675   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 676   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 677   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 678 }
 679
 680 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtl) {
 681   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 682   // LTR-RTL
 683   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
 684   // The last one is the expected END position.
 685   std::vector<SelectionModel> expected;
 686   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 687   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 688   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 689   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 690   expected.push_back(SelectionModel(5, CURSOR_FORWARD));
 691   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 692   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 693   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
 694   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 695
 696   expected.clear();
 697   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
 698   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
 699   expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
 700   expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
 701   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 702   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 703   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 704   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 705   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 706 }
 707
 708 TEST_F(RenderTextTest, MoveCursorLeftRightInLtrRtlLtr) {
 709   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 710   // LTR-RTL-LTR.
 711   render_text->SetText(WideToUTF16(L"a" L"\x05d1" L"b"));
 712   std::vector<SelectionModel> expected;
 713   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 714   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 715   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 716   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 717   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 718   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 719
 720   expected.clear();
 721   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 722   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 723   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 724   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 725   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 726   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 727 }
 728
 729 TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
 730   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 731   // Pure RTL.
 732   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
 733   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
 734   std::vector<SelectionModel> expected;
 735
 736   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 737   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 738   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 739   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 740   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 741   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 742
 743   expected.clear();
 744
 745   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 746   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 747   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 748   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 749   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 750   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 751 }
 752
 753 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
 754   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 755   // RTL-LTR
 756   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2" L"abc"));
 757   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
 758   std::vector<SelectionModel> expected;
 759   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 760   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 761   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 762   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 763   expected.push_back(SelectionModel(5, CURSOR_FORWARD));
 764   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
 765   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 766   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
 767   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 768
 769   expected.clear();
 770   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
 771   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
 772   expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
 773   expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
 774   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 775   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 776   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 777   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 778   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 779 }
 780
 781 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
 782   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 783   // RTL-LTR-RTL.
 784   render_text->SetText(WideToUTF16(L"\x05d0" L"a" L"\x05d1"));
 785   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
 786   std::vector<SelectionModel> expected;
 787   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 788   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
 789   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
 790   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
 791   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 792   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 793
 794   expected.clear();
 795   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
 796   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
 797   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
 798   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
 799   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
 800   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 801 }
 802
 803 // TODO(xji): temporarily disable in platform Win since the complex script
 804 // characters turned into empty square due to font regression. So, not able
 805 // to test 2 characters belong to the same grapheme.
 806 #if defined(OS_LINUX)
 807 TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
 808   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 809
 810   render_text->SetText(WideToUTF16(L"\x0915\x093f\x0915\x094d\x0915"));
 811   EXPECT_EQ(0U, render_text->cursor_position());
 812   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 813   EXPECT_EQ(2U, render_text->cursor_position());
 814   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 815   EXPECT_EQ(4U, render_text->cursor_position());
 816   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 817   EXPECT_EQ(5U, render_text->cursor_position());
 818   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 819   EXPECT_EQ(5U, render_text->cursor_position());
 820
 821   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
 822   EXPECT_EQ(4U, render_text->cursor_position());
 823   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
 824   EXPECT_EQ(2U, render_text->cursor_position());
 825   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
 826   EXPECT_EQ(0U, render_text->cursor_position());
 827   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
 828   EXPECT_EQ(0U, render_text->cursor_position());
 829 }
 830 #endif
 831
 832 TEST_F(RenderTextTest, MoveCursorLeftRight_MeiryoUILigatures) {
 833   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 834   // Meiryo UI uses single-glyph ligatures for 'ff' and 'ffi', but each letter
 835   // (code point) has unique bounds, so mid-glyph cursoring should be possible.
 836   render_text->SetFontList(FontList("Meiryo UI, 12px"));
 837   render_text->SetText(WideToUTF16(L"ff ffi"));
 838   EXPECT_EQ(0U, render_text->cursor_position());
 839   for (size_t i = 0; i < render_text->text().length(); ++i) {
 840     render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
 841     EXPECT_EQ(i + 1, render_text->cursor_position());
 842   }
 843   EXPECT_EQ(6U, render_text->cursor_position());
 844 }
 845
 846 TEST_F(RenderTextTest, GraphemePositions) {
 847   // LTR 2-character grapheme, LTR abc, LTR 2-character grapheme.
 848   const base::string16 kText1 =
 849       WideToUTF16(L"\x0915\x093f" L"abc" L"\x0915\x093f");
 850
 851   // LTR ab, LTR 2-character grapheme, LTR cd.
 852   const base::string16 kText2 = WideToUTF16(L"ab" L"\x0915\x093f" L"cd");
 853
 854   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
 855   // two characters forming the surrogate pair 0x0001D11E.
 856   const std::string kSurrogate = "\xF0\x9D\x84\x9E";
 857
 858   // LTR ab, UTF16 surrogate pair, LTR cd.
 859   const base::string16 kText3 = UTF8ToUTF16("ab" + kSurrogate + "cd");
 860
 861   struct {
 862     base::string16 text;
 863     size_t index;
 864     size_t expected_previous;
 865     size_t expected_next;
 866   } cases[] = {
 867     { base::string16(), 0, 0, 0 },
 868     { base::string16(), 1, 0, 0 },
 869     { base::string16(), 50, 0, 0 },
 870     { kText1, 0, 0, 2 },
 871     { kText1, 1, 0, 2 },
 872     { kText1, 2, 0, 3 },
 873     { kText1, 3, 2, 4 },
 874     { kText1, 4, 3, 5 },
 875     { kText1, 5, 4, 7 },
 876     { kText1, 6, 5, 7 },
 877     { kText1, 7, 5, 7 },
 878     { kText1, 8, 7, 7 },
 879     { kText1, 50, 7, 7 },
 880     { kText2, 0, 0, 1 },
 881     { kText2, 1, 0, 2 },
 882     { kText2, 2, 1, 4 },
 883     { kText2, 3, 2, 4 },
 884     { kText2, 4, 2, 5 },
 885     { kText2, 5, 4, 6 },
 886     { kText2, 6, 5, 6 },
 887     { kText2, 7, 6, 6 },
 888     { kText2, 50, 6, 6 },
 889     { kText3, 0, 0, 1 },
 890     { kText3, 1, 0, 2 },
 891     { kText3, 2, 1, 4 },
 892     { kText3, 3, 2, 4 },
 893     { kText3, 4, 2, 5 },
 894     { kText3, 5, 4, 6 },
 895     { kText3, 6, 5, 6 },
 896     { kText3, 7, 6, 6 },
 897     { kText3, 50, 6, 6 },
 898   };
 899
 900   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
 901   //                  font support for some scripts - http://crbug.com/106450
 902 #if defined(OS_WIN)
 903   if (base::win::GetVersion() < base::win::VERSION_VISTA)
 904     return;
 905 #endif
 906
 907   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 908   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
 909     render_text->SetText(cases[i].text);
 910
 911     size_t next = render_text->IndexOfAdjacentGrapheme(cases[i].index,
 912                                                        CURSOR_FORWARD);
 913     EXPECT_EQ(cases[i].expected_next, next);
 914     EXPECT_TRUE(render_text->IsCursorablePosition(next));
 915
 916     size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
 917                                                            CURSOR_BACKWARD);
 918     EXPECT_EQ(cases[i].expected_previous, previous);
 919     EXPECT_TRUE(render_text->IsCursorablePosition(previous));
 920   }
 921 }
 922
 923 TEST_F(RenderTextTest, EdgeSelectionModels) {
 924   // Simple Latin text.
 925   const base::string16 kLatin = WideToUTF16(L"abc");
 926   // LTR 2-character grapheme.
 927   const base::string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
 928   // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
 929   const base::string16 kHindiLatin =
 930       WideToUTF16(L"\x0915\x093f" L"a" L"\x0915\x093f");
 931   // RTL 2-character grapheme.
 932   const base::string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
 933   // RTL 2-character grapheme, LTR a, RTL 2-character grapheme.
 934   const base::string16 kHebrewLatin =
 935       WideToUTF16(L"\x05e0\x05b8" L"a" L"\x05e0\x05b8");
 936
 937   struct {
 938     base::string16 text;
 939     base::i18n::TextDirection expected_text_direction;
 940   } cases[] = {
 941     { base::string16(), base::i18n::LEFT_TO_RIGHT },
 942     { kLatin,       base::i18n::LEFT_TO_RIGHT },
 943     { kLTRGrapheme, base::i18n::LEFT_TO_RIGHT },
 944     { kHindiLatin,  base::i18n::LEFT_TO_RIGHT },
 945     { kRTLGrapheme, base::i18n::RIGHT_TO_LEFT },
 946     { kHebrewLatin, base::i18n::RIGHT_TO_LEFT },
 947   };
 948
 949   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
 950   //                  font support for some scripts - http://crbug.com/106450
 951 #if defined(OS_WIN)
 952   if (base::win::GetVersion() < base::win::VERSION_VISTA)
 953     return;
 954 #endif
 955
 956   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 957   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
 958     render_text->SetText(cases[i].text);
 959     bool ltr = (cases[i].expected_text_direction == base::i18n::LEFT_TO_RIGHT);
 960
 961     SelectionModel start_edge =
 962         render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
 963     EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
 964
 965     SelectionModel end_edge =
 966         render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
 967     EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
 968   }
 969 }
 970
 971 TEST_F(RenderTextTest, SelectAll) {
 972   const wchar_t* const cases[] =
 973       { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
 974
 975   // Ensure that SelectAll respects the |reversed| argument regardless of
 976   // application locale and text content directionality.
 977   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
 978   const SelectionModel expected_reversed(Range(3, 0), CURSOR_FORWARD);
 979   const SelectionModel expected_forwards(Range(0, 3), CURSOR_BACKWARD);
 980   const bool was_rtl = base::i18n::IsRTL();
 981
 982   for (size_t i = 0; i < 2; ++i) {
 983     SetRTL(!base::i18n::IsRTL());
 984     // Test that an empty string produces an empty selection model.
 985     render_text->SetText(base::string16());
 986     EXPECT_EQ(render_text->selection_model(), SelectionModel());
 987
 988     // Test the weak, LTR, RTL, and Bidi string cases.
 989     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
 990       render_text->SetText(WideToUTF16(cases[j]));
 991       render_text->SelectAll(false);
 992       EXPECT_EQ(render_text->selection_model(), expected_forwards);
 993       render_text->SelectAll(true);
 994       EXPECT_EQ(render_text->selection_model(), expected_reversed);
 995     }
 996   }
 997
 998   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 999 }
1000
1001   TEST_F(RenderTextTest, MoveCursorLeftRightWithSelection) {
1002   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1003   render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
1004   // Left arrow on select ranging (6, 4).
1005   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1006   EXPECT_EQ(Range(6), render_text->selection());
1007   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1008   EXPECT_EQ(Range(4), render_text->selection());
1009   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1010   EXPECT_EQ(Range(5), render_text->selection());
1011   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1012   EXPECT_EQ(Range(6), render_text->selection());
1013   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
1014   EXPECT_EQ(Range(6, 5), render_text->selection());
1015   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, true);
1016   EXPECT_EQ(Range(6, 4), render_text->selection());
1017   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1018   EXPECT_EQ(Range(6), render_text->selection());
1019
1020   // Right arrow on select ranging (4, 6).
1021   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1022   EXPECT_EQ(Range(0), render_text->selection());
1023   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1024   EXPECT_EQ(Range(1), render_text->selection());
1025   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1026   EXPECT_EQ(Range(2), render_text->selection());
1027   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1028   EXPECT_EQ(Range(3), render_text->selection());
1029   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1030   EXPECT_EQ(Range(5), render_text->selection());
1031   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1032   EXPECT_EQ(Range(4), render_text->selection());
1033   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
1034   EXPECT_EQ(Range(4, 5), render_text->selection());
1035   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, true);
1036   EXPECT_EQ(Range(4, 6), render_text->selection());
1037   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1038   EXPECT_EQ(Range(4), render_text->selection());
1039 }
1040 #endif  // !defined(OS_MACOSX)
1041
1042 // TODO(xji): Make these work on Windows.
1043 #if defined(OS_LINUX)
1044 void MoveLeftRightByWordVerifier(RenderText* render_text,
1045                                  const wchar_t* str) {
1046   render_text->SetText(WideToUTF16(str));
1047
1048   // Test moving by word from left ro right.
1049   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1050   bool first_word = true;
1051   while (true) {
1052     // First, test moving by word from a word break position, such as from
1053     // "|abc def" to "abc| def".
1054     SelectionModel start = render_text->selection_model();
1055     render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1056     SelectionModel end = render_text->selection_model();
1057     if (end == start)  // reach the end.
1058       break;
1059
1060     // For testing simplicity, each word is a 3-character word.
1061     int num_of_character_moves = first_word ? 3 : 4;
1062     first_word = false;
1063     render_text->MoveCursorTo(start);
1064     for (int j = 0; j < num_of_character_moves; ++j)
1065       render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1066     EXPECT_EQ(end, render_text->selection_model());
1067
1068     // Then, test moving by word from positions inside the word, such as from
1069     // "a|bc def" to "abc| def", and from "ab|c def" to "abc| def".
1070     for (int j = 1; j < num_of_character_moves; ++j) {
1071       render_text->MoveCursorTo(start);
1072       for (int k = 0; k < j; ++k)
1073         render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
1074       render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1075       EXPECT_EQ(end, render_text->selection_model());
1076     }
1077   }
1078
1079   // Test moving by word from right to left.
1080   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1081   first_word = true;
1082   while (true) {
1083     SelectionModel start = render_text->selection_model();
1084     render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1085     SelectionModel end = render_text->selection_model();
1086     if (end == start)  // reach the end.
1087       break;
1088
1089     int num_of_character_moves = first_word ? 3 : 4;
1090     first_word = false;
1091     render_text->MoveCursorTo(start);
1092     for (int j = 0; j < num_of_character_moves; ++j)
1093       render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1094     EXPECT_EQ(end, render_text->selection_model());
1095
1096     for (int j = 1; j < num_of_character_moves; ++j) {
1097       render_text->MoveCursorTo(start);
1098       for (int k = 0; k < j; ++k)
1099         render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
1100       render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1101       EXPECT_EQ(end, render_text->selection_model());
1102     }
1103   }
1104 }
1105
1106 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText) {
1107   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1108
1109   // For testing simplicity, each word is a 3-character word.
1110   std::vector<const wchar_t*> test;
1111   test.push_back(L"abc");
1112   test.push_back(L"abc def");
1113   test.push_back(L"\x05E1\x05E2\x05E3");
1114   test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1115   test.push_back(L"abc \x05E1\x05E2\x05E3");
1116   test.push_back(L"abc def \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1117   test.push_back(L"abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1118                  L" \x05E7\x05E8\x05E9");
1119
1120   test.push_back(L"abc \x05E1\x05E2\x05E3 hij");
1121   test.push_back(L"abc def \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 hij opq");
1122   test.push_back(L"abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1123                  L" \x05E7\x05E8\x05E9" L" opq rst uvw");
1124
1125   test.push_back(L"\x05E1\x05E2\x05E3 abc");
1126   test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 abc def");
1127   test.push_back(L"\x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6 \x05E7\x05E8\x05E9"
1128                  L" abc def hij");
1129
1130   test.push_back(L"\x05D1\x05D2\x05D3 abc \x05E1\x05E2\x05E3");
1131   test.push_back(L"\x05D1\x05D2\x05D3 \x05D4\x05D5\x05D6 abc def"
1132                  L" \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6");
1133   test.push_back(L"\x05D1\x05D2\x05D3 \x05D4\x05D5\x05D6 \x05D7\x05D8\x05D9"
1134                  L" abc def hij \x05E1\x05E2\x05E3 \x05E4\x05E5\x05E6"
1135                  L" \x05E7\x05E8\x05E9");
1136
1137   for (size_t i = 0; i < test.size(); ++i)
1138     MoveLeftRightByWordVerifier(render_text.get(), test[i]);
1139 }
1140
1141 TEST_F(RenderTextTest, MoveLeftRightByWordInBidiText_TestEndOfText) {
1142   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1143
1144   render_text->SetText(WideToUTF16(L"ab\x05E1"));
1145   // Moving the cursor by word from "abC|" to the left should return "|abC".
1146   // But since end of text is always treated as a word break, it returns
1147   // position "ab|C".
1148   // TODO(xji): Need to make it work as expected.
1149   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1150   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1151   // EXPECT_EQ(SelectionModel(), render_text->selection_model());
1152
1153   // Moving the cursor by word from "|abC" to the right returns "abC|".
1154   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1155   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1156   EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
1157
1158   render_text->SetText(WideToUTF16(L"\x05E1\x05E2" L"a"));
1159   // For logical text "BCa", moving the cursor by word from "aCB|" to the left
1160   // returns "|aCB".
1161   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
1162   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1163   EXPECT_EQ(SelectionModel(3, CURSOR_FORWARD), render_text->selection_model());
1164
1165   // Moving the cursor by word from "|aCB" to the right should return "aCB|".
1166   // But since end of text is always treated as a word break, it returns
1167   // position "a|CB".
1168   // TODO(xji): Need to make it work as expected.
1169   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1170   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1171   // EXPECT_EQ(SelectionModel(), render_text->selection_model());
1172 }
1173
1174 TEST_F(RenderTextTest, MoveLeftRightByWordInTextWithMultiSpaces) {
1175   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1176   render_text->SetText(WideToUTF16(L"abc     def"));
1177   render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
1178   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1179   EXPECT_EQ(11U, render_text->cursor_position());
1180
1181   render_text->MoveCursorTo(SelectionModel(5, CURSOR_FORWARD));
1182   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, false);
1183   EXPECT_EQ(0U, render_text->cursor_position());
1184 }
1185
1186 TEST_F(RenderTextTest, MoveLeftRightByWordInChineseText) {
1187   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1188   render_text->SetText(WideToUTF16(L"\x6211\x4EEC\x53BB\x516C\x56ED\x73A9"));
1189   render_text->MoveCursor(LINE_BREAK, CURSOR_LEFT, false);
1190   EXPECT_EQ(0U, render_text->cursor_position());
1191   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1192   EXPECT_EQ(2U, render_text->cursor_position());
1193   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1194   EXPECT_EQ(3U, render_text->cursor_position());
1195   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1196   EXPECT_EQ(5U, render_text->cursor_position());
1197   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1198   EXPECT_EQ(6U, render_text->cursor_position());
1199   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, false);
1200   EXPECT_EQ(6U, render_text->cursor_position());
1201 }
1202 #endif
1203
1204 #if defined(OS_WIN)
1205 TEST_F(RenderTextTest, Win_LogicalClusters) {
1206   scoped_ptr<RenderTextWin> render_text(
1207       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1208
1209   const base::string16 test_string =
1210       WideToUTF16(L"\x0930\x0930\x0930\x0930\x0930");
1211   render_text->SetText(test_string);
1212   render_text->EnsureLayout();
1213   ASSERT_EQ(1U, render_text->runs_.size());
1214   WORD* logical_clusters = render_text->runs_[0]->logical_clusters.get();
1215   for (size_t i = 0; i < test_string.length(); ++i)
1216     EXPECT_EQ(i, logical_clusters[i]);
1217 }
1218 #endif  // defined(OS_WIN)
1219
1220 TEST_F(RenderTextTest, StringSizeSanity) {
1221   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1222   render_text->SetText(UTF8ToUTF16("Hello World"));
1223   const Size string_size = render_text->GetStringSize();
1224   EXPECT_GT(string_size.width(), 0);
1225   EXPECT_GT(string_size.height(), 0);
1226 }
1227
1228 // TODO(asvitkine): This test fails because PlatformFontMac uses point font
1229 //                  sizes instead of pixel sizes like other implementations.
1230 #if !defined(OS_MACOSX)
1231 TEST_F(RenderTextTest, StringSizeEmptyString) {
1232   // Ascent and descent of Arial and Symbol are different on most platforms.
1233   const FontList font_list("Arial,Symbol, 16px");
1234   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1235   render_text->SetFontList(font_list);
1236   render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
1237
1238   // The empty string respects FontList metrics for non-zero height
1239   // and baseline.
1240   render_text->SetText(base::string16());
1241   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1242   EXPECT_EQ(0, render_text->GetStringSize().width());
1243   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1244
1245   render_text->SetText(UTF8ToUTF16(" "));
1246   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1247   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1248 }
1249 #endif  // !defined(OS_MACOSX)
1250
1251 TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
1252   // Check that Arial and Symbol have different font metrics.
1253   Font arial_font("Arial", 16);
1254   ASSERT_EQ("arial",
1255             StringToLowerASCII(arial_font.GetActualFontNameForTesting()));
1256   Font symbol_font("Symbol", 16);
1257   ASSERT_EQ("symbol",
1258             StringToLowerASCII(symbol_font.GetActualFontNameForTesting()));
1259   EXPECT_NE(arial_font.GetHeight(), symbol_font.GetHeight());
1260   EXPECT_NE(arial_font.GetBaseline(), symbol_font.GetBaseline());
1261   // "a" should be rendered with Arial, not with Symbol.
1262   const char* arial_font_text = "a";
1263   // "®" (registered trademark symbol) should be rendered with Symbol,
1264   // not with Arial.
1265   const char* symbol_font_text = "\xC2\xAE";
1266
1267   Font smaller_font = arial_font;
1268   Font larger_font = symbol_font;
1269   const char* smaller_font_text = arial_font_text;
1270   const char* larger_font_text = symbol_font_text;
1271   if (symbol_font.GetHeight() < arial_font.GetHeight() &&
1272       symbol_font.GetBaseline() < arial_font.GetBaseline()) {
1273     std::swap(smaller_font, larger_font);
1274     std::swap(smaller_font_text, larger_font_text);
1275   }
1276   ASSERT_LT(smaller_font.GetHeight(), larger_font.GetHeight());
1277   ASSERT_LT(smaller_font.GetBaseline(), larger_font.GetBaseline());
1278
1279   // Check |smaller_font_text| is rendered with the smaller font.
1280   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1281   render_text->SetText(UTF8ToUTF16(smaller_font_text));
1282   render_text->SetFontList(FontList(smaller_font));
1283   render_text->SetDisplayRect(Rect(0, 0, 0,
1284                                    render_text->font_list().GetHeight()));
1285   EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
1286   EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
1287
1288   // Layout the same text with mixed fonts.  The text should be rendered with
1289   // the smaller font, but the height and baseline are determined with the
1290   // metrics of the font list, which is equal to the larger font.
1291   std::vector<Font> fonts;
1292   fonts.push_back(smaller_font);  // The primary font is the smaller font.
1293   fonts.push_back(larger_font);
1294   const FontList font_list(fonts);
1295   render_text->SetFontList(font_list);
1296   render_text->SetDisplayRect(Rect(0, 0, 0,
1297                                    render_text->font_list().GetHeight()));
1298   EXPECT_LT(smaller_font.GetHeight(), render_text->GetStringSize().height());
1299   EXPECT_LT(smaller_font.GetBaseline(), render_text->GetBaseline());
1300   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
1301   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
1302 }
1303
1304 TEST_F(RenderTextTest, SetFontList) {
1305   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1306   render_text->SetFontList(FontList("Arial,Symbol, 13px"));
1307   const std::vector<Font>& fonts = render_text->font_list().GetFonts();
1308   ASSERT_EQ(2U, fonts.size());
1309   EXPECT_EQ("Arial", fonts[0].GetFontName());
1310   EXPECT_EQ("Symbol", fonts[1].GetFontName());
1311   EXPECT_EQ(13, render_text->font_list().GetFontSize());
1312 }
1313
1314 TEST_F(RenderTextTest, StringSizeBoldWidth) {
1315   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1316   render_text->SetText(UTF8ToUTF16("Hello World"));
1317
1318   const int plain_width = render_text->GetStringSize().width();
1319   EXPECT_GT(plain_width, 0);
1320
1321   // Apply a bold style and check that the new width is greater.
1322   render_text->SetStyle(BOLD, true);
1323   const int bold_width = render_text->GetStringSize().width();
1324   EXPECT_GT(bold_width, plain_width);
1325
1326   // Now, apply a plain style over the first word only.
1327   render_text->ApplyStyle(BOLD, false, Range(0, 5));
1328   const int plain_bold_width = render_text->GetStringSize().width();
1329   EXPECT_GT(plain_bold_width, plain_width);
1330   EXPECT_LT(plain_bold_width, bold_width);
1331 }
1332
1333 TEST_F(RenderTextTest, StringSizeHeight) {
1334   base::string16 cases[] = {
1335     WideToUTF16(L"Hello World!"),  // English
1336     WideToUTF16(L"\x6328\x62f6"),  // Japanese
1337     WideToUTF16(L"\x0915\x093f"),  // Hindi
1338     WideToUTF16(L"\x05e0\x05b8"),  // Hebrew
1339   };
1340
1341   const FontList default_font_list;
1342   const FontList& larger_font_list = default_font_list.DeriveWithSizeDelta(24);
1343   EXPECT_GT(larger_font_list.GetHeight(), default_font_list.GetHeight());
1344
1345   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
1346     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1347     render_text->SetFontList(default_font_list);
1348     render_text->SetText(cases[i]);
1349
1350     const int height1 = render_text->GetStringSize().height();
1351     EXPECT_GT(height1, 0);
1352
1353     // Check that setting the larger font increases the height.
1354     render_text->SetFontList(larger_font_list);
1355     const int height2 = render_text->GetStringSize().height();
1356     EXPECT_GT(height2, height1);
1357   }
1358 }
1359
1360 TEST_F(RenderTextTest, GetBaselineSanity) {
1361   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1362   render_text->SetText(UTF8ToUTF16("Hello World"));
1363   const int baseline = render_text->GetBaseline();
1364   EXPECT_GT(baseline, 0);
1365 }
1366
1367 TEST_F(RenderTextTest, CursorBoundsInReplacementMode) {
1368   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1369   render_text->SetText(ASCIIToUTF16("abcdefg"));
1370   render_text->SetDisplayRect(Rect(100, 17));
1371   SelectionModel sel_b(1, CURSOR_FORWARD);
1372   SelectionModel sel_c(2, CURSOR_FORWARD);
1373   Rect cursor_around_b = render_text->GetCursorBounds(sel_b, false);
1374   Rect cursor_before_b = render_text->GetCursorBounds(sel_b, true);
1375   Rect cursor_before_c = render_text->GetCursorBounds(sel_c, true);
1376   EXPECT_EQ(cursor_around_b.x(), cursor_before_b.x());
1377   EXPECT_EQ(cursor_around_b.right(), cursor_before_c.x());
1378 }
1379
1380 TEST_F(RenderTextTest, GetTextOffset) {
1381   // The default horizontal text offset differs for LTR and RTL, and is only set
1382   // when the RenderText object is created.  This test will check the default in
1383   // LTR mode, and the next test will check the RTL default.
1384   const bool was_rtl = base::i18n::IsRTL();
1385   SetRTL(false);
1386   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1387   render_text->SetText(ASCIIToUTF16("abcdefg"));
1388   render_text->SetFontList(FontList("Arial, 13px"));
1389
1390   // Set display area's size equal to the font size.
1391   const Size font_size(render_text->GetContentWidth(),
1392                        render_text->font_list().GetHeight());
1393   Rect display_rect(font_size);
1394   render_text->SetDisplayRect(display_rect);
1395
1396   Vector2d offset = render_text->GetLineOffset(0);
1397   EXPECT_TRUE(offset.IsZero());
1398
1399   const int kEnlargementX = 2;
1400   display_rect.Inset(0, 0, -kEnlargementX, 0);
1401   render_text->SetDisplayRect(display_rect);
1402
1403   // Check the default horizontal alignment.
1404   offset = render_text->GetLineOffset(0);
1405   EXPECT_EQ(0, offset.x());
1406
1407   // Check explicitly setting the horizontal alignment.
1408   render_text->SetHorizontalAlignment(ALIGN_LEFT);
1409   offset = render_text->GetLineOffset(0);
1410   EXPECT_EQ(0, offset.x());
1411   render_text->SetHorizontalAlignment(ALIGN_CENTER);
1412   offset = render_text->GetLineOffset(0);
1413   EXPECT_EQ(kEnlargementX / 2, offset.x());
1414   render_text->SetHorizontalAlignment(ALIGN_RIGHT);
1415   offset = render_text->GetLineOffset(0);
1416   EXPECT_EQ(kEnlargementX, offset.x());
1417
1418   // Check that text is vertically centered within taller display rects.
1419   const int kEnlargementY = display_rect.height();
1420   display_rect.Inset(0, 0, 0, -kEnlargementY);
1421   render_text->SetDisplayRect(display_rect);
1422   const Vector2d prev_offset = render_text->GetLineOffset(0);
1423   display_rect.Inset(0, 0, 0, -2 * kEnlargementY);
1424   render_text->SetDisplayRect(display_rect);
1425   offset = render_text->GetLineOffset(0);
1426   EXPECT_EQ(prev_offset.y() + kEnlargementY, offset.y());
1427
1428   SetRTL(was_rtl);
1429 }
1430
1431 TEST_F(RenderTextTest, GetTextOffsetHorizontalDefaultInRTL) {
1432   // This only checks the default horizontal alignment in RTL mode; all other
1433   // GetLineOffset(0) attributes are checked by the test above.
1434   const bool was_rtl = base::i18n::IsRTL();
1435   SetRTL(true);
1436   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1437   render_text->SetText(ASCIIToUTF16("abcdefg"));
1438   render_text->SetFontList(FontList("Arial, 13px"));
1439   const int kEnlargement = 2;
1440   const Size font_size(render_text->GetContentWidth() + kEnlargement,
1441                        render_text->GetStringSize().height());
1442   Rect display_rect(font_size);
1443   render_text->SetDisplayRect(display_rect);
1444   Vector2d offset = render_text->GetLineOffset(0);
1445   EXPECT_EQ(kEnlargement, offset.x());
1446   SetRTL(was_rtl);
1447 }
1448
1449 TEST_F(RenderTextTest, SameFontForParentheses) {
1450   struct {
1451     const base::char16 left_char;
1452     const base::char16 right_char;
1453   } punctuation_pairs[] = {
1454     { '(', ')' },
1455     { '{', '}' },
1456     { '<', '>' },
1457   };
1458   struct {
1459     base::string16 text;
1460   } cases[] = {
1461     // English(English)
1462     { WideToUTF16(L"Hello World(a)") },
1463     // English(English)English
1464     { WideToUTF16(L"Hello World(a)Hello World") },
1465
1466     // Japanese(English)
1467     { WideToUTF16(L"\x6328\x62f6(a)") },
1468     // Japanese(English)Japanese
1469     { WideToUTF16(L"\x6328\x62f6(a)\x6328\x62f6") },
1470     // English(Japanese)English
1471     { WideToUTF16(L"Hello World(\x6328\x62f6)Hello World") },
1472
1473     // Hindi(English)
1474     { WideToUTF16(L"\x0915\x093f(a)") },
1475     // Hindi(English)Hindi
1476     { WideToUTF16(L"\x0915\x093f(a)\x0915\x093f") },
1477     // English(Hindi)English
1478     { WideToUTF16(L"Hello World(\x0915\x093f)Hello World") },
1479
1480     // Hebrew(English)
1481     { WideToUTF16(L"\x05e0\x05b8(a)") },
1482     // Hebrew(English)Hebrew
1483     { WideToUTF16(L"\x05e0\x05b8(a)\x05e0\x05b8") },
1484     // English(Hebrew)English
1485     { WideToUTF16(L"Hello World(\x05e0\x05b8)Hello World") },
1486   };
1487
1488   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1489   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
1490     base::string16 text = cases[i].text;
1491     const size_t start_paren_char_index = text.find('(');
1492     ASSERT_NE(base::string16::npos, start_paren_char_index);
1493     const size_t end_paren_char_index = text.find(')');
1494     ASSERT_NE(base::string16::npos, end_paren_char_index);
1495
1496     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(punctuation_pairs); ++j) {
1497       text[start_paren_char_index] = punctuation_pairs[j].left_char;
1498       text[end_paren_char_index] = punctuation_pairs[j].right_char;
1499       render_text->SetText(text);
1500
1501       const std::vector<RenderText::FontSpan> spans =
1502           render_text->GetFontSpansForTesting();
1503
1504       int start_paren_span_index = -1;
1505       int end_paren_span_index = -1;
1506       for (size_t k = 0; k < spans.size(); ++k) {
1507         if (IndexInRange(spans[k].second, start_paren_char_index))
1508           start_paren_span_index = k;
1509         if (IndexInRange(spans[k].second, end_paren_char_index))
1510           end_paren_span_index = k;
1511       }
1512       ASSERT_NE(-1, start_paren_span_index);
1513       ASSERT_NE(-1, end_paren_span_index);
1514
1515       const Font& start_font = spans[start_paren_span_index].first;
1516       const Font& end_font = spans[end_paren_span_index].first;
1517       EXPECT_EQ(start_font.GetFontName(), end_font.GetFontName());
1518       EXPECT_EQ(start_font.GetFontSize(), end_font.GetFontSize());
1519       EXPECT_EQ(start_font.GetStyle(), end_font.GetStyle());
1520     }
1521   }
1522 }
1523
1524 // Make sure the caret width is always >=1 so that the correct
1525 // caret is drawn at high DPI. crbug.com/164100.
1526 TEST_F(RenderTextTest, CaretWidth) {
1527   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1528   render_text->SetText(ASCIIToUTF16("abcdefg"));
1529   EXPECT_GE(render_text->GetUpdatedCursorBounds().width(), 1);
1530 }
1531
1532 TEST_F(RenderTextTest, SelectWord) {
1533   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1534   render_text->SetText(ASCIIToUTF16(" foo  a.bc.d bar"));
1535
1536   struct {
1537     size_t cursor;
1538     size_t selection_start;
1539     size_t selection_end;
1540   } cases[] = {
1541     { 0,   0,  1 },
1542     { 1,   1,  4 },
1543     { 2,   1,  4 },
1544     { 3,   1,  4 },
1545     { 4,   4,  6 },
1546     { 5,   4,  6 },
1547     { 6,   6,  7 },
1548     { 7,   7,  8 },
1549     { 8,   8, 10 },
1550     { 9,   8, 10 },
1551     { 10, 10, 11 },
1552     { 11, 11, 12 },
1553     { 12, 12, 13 },
1554     { 13, 13, 16 },
1555     { 14, 13, 16 },
1556     { 15, 13, 16 },
1557     { 16, 13, 16 },
1558   };
1559
1560   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
1561     render_text->SetCursorPosition(cases[i].cursor);
1562     render_text->SelectWord();
1563     EXPECT_EQ(Range(cases[i].selection_start, cases[i].selection_end),
1564               render_text->selection());
1565   }
1566 }
1567
1568 // Make sure the last word is selected when the cursor is at text.length().
1569 TEST_F(RenderTextTest, LastWordSelected) {
1570   const std::string kTestURL1 = "http://www.google.com";
1571   const std::string kTestURL2 = "http://www.google.com/something/";
1572
1573   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1574
1575   render_text->SetText(ASCIIToUTF16(kTestURL1));
1576   render_text->SetCursorPosition(kTestURL1.length());
1577   render_text->SelectWord();
1578   EXPECT_EQ(ASCIIToUTF16("com"), GetSelectedText(render_text.get()));
1579   EXPECT_FALSE(render_text->selection().is_reversed());
1580
1581   render_text->SetText(ASCIIToUTF16(kTestURL2));
1582   render_text->SetCursorPosition(kTestURL2.length());
1583   render_text->SelectWord();
1584   EXPECT_EQ(ASCIIToUTF16("/"), GetSelectedText(render_text.get()));
1585   EXPECT_FALSE(render_text->selection().is_reversed());
1586 }
1587
1588 // When given a non-empty selection, SelectWord should expand the selection to
1589 // nearest word boundaries.
1590 TEST_F(RenderTextTest, SelectMultipleWords) {
1591   const std::string kTestURL = "http://www.google.com";
1592
1593   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1594
1595   render_text->SetText(ASCIIToUTF16(kTestURL));
1596   render_text->SelectRange(Range(16, 20));
1597   render_text->SelectWord();
1598   EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
1599   EXPECT_FALSE(render_text->selection().is_reversed());
1600
1601   // SelectWord should preserve the selection direction.
1602   render_text->SelectRange(Range(20, 16));
1603   render_text->SelectWord();
1604   EXPECT_EQ(ASCIIToUTF16("google.com"), GetSelectedText(render_text.get()));
1605   EXPECT_TRUE(render_text->selection().is_reversed());
1606 }
1607
1608 // TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac
1609 //                  does not implement this yet. http://crbug.com/131618
1610 #if !defined(OS_MACOSX)
1611 TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) {
1612   ASSERT_FALSE(base::i18n::IsRTL());
1613   ASSERT_FALSE(base::i18n::ICUIsRTL());
1614
1615   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1616   render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
1617   render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
1618                                            CURSOR_FORWARD));
1619   int width = render_text->GetStringSize().width();
1620   ASSERT_GT(width, 10);
1621
1622   // Ensure that the cursor is placed at the width of its preceding text.
1623   render_text->SetDisplayRect(Rect(width + 10, 1));
1624   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1625
1626   // Ensure that shrinking the display rectangle keeps the cursor in view.
1627   render_text->SetDisplayRect(Rect(width - 10, 1));
1628   EXPECT_EQ(render_text->display_rect().width(),
1629             render_text->GetUpdatedCursorBounds().right());
1630
1631   // Ensure that the text will pan to fill its expanding display rectangle.
1632   render_text->SetDisplayRect(Rect(width - 5, 1));
1633   EXPECT_EQ(render_text->display_rect().width(),
1634             render_text->GetUpdatedCursorBounds().right());
1635
1636   // Ensure that a sufficiently large display rectangle shows all the text.
1637   render_text->SetDisplayRect(Rect(width + 10, 1));
1638   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1639
1640   // Repeat the test with RTL text.
1641   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
1642       L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
1643   render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1644   width = render_text->GetStringSize().width();
1645   ASSERT_GT(width, 10);
1646
1647   // Ensure that the cursor is placed at the width of its preceding text.
1648   render_text->SetDisplayRect(Rect(width + 10, 1));
1649   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1650
1651   // Ensure that shrinking the display rectangle keeps the cursor in view.
1652   render_text->SetDisplayRect(Rect(width - 10, 1));
1653   EXPECT_EQ(render_text->display_rect().width(),
1654             render_text->GetUpdatedCursorBounds().right());
1655
1656   // Ensure that the text will pan to fill its expanding display rectangle.
1657   render_text->SetDisplayRect(Rect(width - 5, 1));
1658   EXPECT_EQ(render_text->display_rect().width(),
1659             render_text->GetUpdatedCursorBounds().right());
1660
1661   // Ensure that a sufficiently large display rectangle shows all the text.
1662   render_text->SetDisplayRect(Rect(width + 10, 1));
1663   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
1664 }
1665
1666 TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
1667   // Set the application default text direction to RTL.
1668   const bool was_rtl = base::i18n::IsRTL();
1669   SetRTL(true);
1670
1671   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1672   render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
1673   render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1674   int width = render_text->GetStringSize().width();
1675   ASSERT_GT(width, 10);
1676
1677   // Ensure that the cursor is placed at the width of its preceding text.
1678   render_text->SetDisplayRect(Rect(width + 10, 1));
1679   EXPECT_EQ(render_text->display_rect().width() - width - 1,
1680             render_text->GetUpdatedCursorBounds().x());
1681
1682   // Ensure that shrinking the display rectangle keeps the cursor in view.
1683   render_text->SetDisplayRect(Rect(width - 10, 1));
1684   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1685
1686   // Ensure that the text will pan to fill its expanding display rectangle.
1687   render_text->SetDisplayRect(Rect(width - 5, 1));
1688   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1689
1690   // Ensure that a sufficiently large display rectangle shows all the text.
1691   render_text->SetDisplayRect(Rect(width + 10, 1));
1692   EXPECT_EQ(render_text->display_rect().width() - width - 1,
1693             render_text->GetUpdatedCursorBounds().x());
1694
1695   // Repeat the test with RTL text.
1696   render_text->SetText(WideToUTF16(L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7"
1697       L"\x5d8\x5d9\x5da\x5db\x5dc\x5dd\x5de\x5df"));
1698   render_text->MoveCursorTo(SelectionModel(render_text->text().length(),
1699                                            CURSOR_FORWARD));
1700   width = render_text->GetStringSize().width();
1701   ASSERT_GT(width, 10);
1702
1703   // Ensure that the cursor is placed at the width of its preceding text.
1704   render_text->SetDisplayRect(Rect(width + 10, 1));
1705   EXPECT_EQ(render_text->display_rect().width() - width - 1,
1706             render_text->GetUpdatedCursorBounds().x());
1707
1708   // Ensure that shrinking the display rectangle keeps the cursor in view.
1709   render_text->SetDisplayRect(Rect(width - 10, 1));
1710   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1711
1712   // Ensure that the text will pan to fill its expanding display rectangle.
1713   render_text->SetDisplayRect(Rect(width - 5, 1));
1714   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
1715
1716   // Ensure that a sufficiently large display rectangle shows all the text.
1717   render_text->SetDisplayRect(Rect(width + 10, 1));
1718   EXPECT_EQ(render_text->display_rect().width() - width - 1,
1719             render_text->GetUpdatedCursorBounds().x());
1720
1721   // Reset the application default text direction to LTR.
1722   SetRTL(was_rtl);
1723   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
1724 }
1725 #endif  // !defined(OS_MACOSX)
1726
1727 // Changing colors between or inside ligated glyphs should not break shaping.
1728 TEST_F(RenderTextTest, SelectionKeepsLigatures) {
1729   const wchar_t* kTestStrings[] = {
1730     L"\x644\x623",
1731     L"\x633\x627"
1732   };
1733
1734   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
1735   render_text->set_selection_color(SK_ColorRED);
1736   Canvas canvas;
1737
1738   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1739     render_text->SetText(WideToUTF16(kTestStrings[i]));
1740     const int expected_width = render_text->GetStringSize().width();
1741     render_text->MoveCursorTo(SelectionModel(Range(0, 1), CURSOR_FORWARD));
1742     EXPECT_EQ(expected_width, render_text->GetStringSize().width());
1743     // Draw the text. It shouldn't hit any DCHECKs or crash.
1744     // See http://crbug.com/214150
1745     render_text->Draw(&canvas);
1746     render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
1747   }
1748 }
1749
1750 #if defined(OS_WIN)
1751 // Ensure strings wrap onto multiple lines for a small available width.
1752 TEST_F(RenderTextTest, Multiline_MinWidth) {
1753   const wchar_t* kTestStrings[] = { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl,
1754                                     kRtlLtr, kRtlLtrRtl };
1755
1756   scoped_ptr<RenderTextWin> render_text(
1757       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1758   render_text->SetDisplayRect(Rect(1, 1000));
1759   render_text->SetMultiline(true);
1760   Canvas canvas;
1761
1762   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1763     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1764     render_text->SetText(WideToUTF16(kTestStrings[i]));
1765     render_text->Draw(&canvas);
1766     EXPECT_GT(render_text->lines_.size(), 1U);
1767   }
1768 }
1769
1770 // Ensure strings wrap onto multiple lines for a normal available width.
1771 TEST_F(RenderTextTest, Multiline_NormalWidth) {
1772   const struct {
1773     const wchar_t* const text;
1774     const Range first_line_char_range;
1775     const Range second_line_char_range;
1776   } kTestStrings[] = {
1777     { L"abc defg hijkl", Range(0, 9), Range(9, 14) },
1778     { L"qwertyzxcvbn", Range(0, 8), Range(8, 12) },
1779     { L"\x062A\x0641\x0627\x062D\x05EA\x05E4\x05D5\x05D6\x05D9\x05DD",
1780           Range(4, 10), Range(0, 4) }
1781   };
1782
1783   scoped_ptr<RenderTextWin> render_text(
1784       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1785   render_text->SetDisplayRect(Rect(50, 1000));
1786   render_text->SetMultiline(true);
1787   Canvas canvas;
1788
1789   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestStrings); ++i) {
1790     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1791     render_text->SetText(WideToUTF16(kTestStrings[i].text));
1792     render_text->Draw(&canvas);
1793     ASSERT_EQ(2U, render_text->lines_.size());
1794     ASSERT_EQ(1U, render_text->lines_[0].segments.size());
1795     EXPECT_EQ(kTestStrings[i].first_line_char_range,
1796               render_text->lines_[0].segments[0].char_range);
1797     ASSERT_EQ(1U, render_text->lines_[1].segments.size());
1798     EXPECT_EQ(kTestStrings[i].second_line_char_range,
1799               render_text->lines_[1].segments[0].char_range);
1800   }
1801 }
1802
1803 // Ensure strings don't wrap onto multiple lines for a sufficient available
1804 // width.
1805 TEST_F(RenderTextTest, Multiline_SufficientWidth) {
1806   const wchar_t* kTestStrings[] = { L"", L" ", L".", L" . ", L"abc", L"a b c",
1807                                     L"\x62E\x628\x632", L"\x62E \x628 \x632" };
1808
1809   scoped_ptr<RenderTextWin> render_text(
1810       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1811   render_text->SetDisplayRect(Rect(30, 1000));
1812   render_text->SetMultiline(true);
1813   Canvas canvas;
1814
1815   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
1816     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1817     render_text->SetText(WideToUTF16(kTestStrings[i]));
1818     render_text->Draw(&canvas);
1819     EXPECT_EQ(1U, render_text->lines_.size());
1820   }
1821 }
1822
1823 TEST_F(RenderTextTest, Multiline_Newline) {
1824   const struct {
1825     const wchar_t* const text;
1826     // Ranges of the characters on each line preceding the newline.
1827     const Range first_line_char_range;
1828     const Range second_line_char_range;
1829   } kTestStrings[] = {
1830     { L"abc\ndef", Range(0, 3), Range(4, 7) },
1831     { L"a \n b ", Range(0, 2), Range(3, 6) },
1832     { L"\n" , Range::InvalidRange(), Range::InvalidRange() }
1833   };
1834
1835   scoped_ptr<RenderTextWin> render_text(
1836       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1837   render_text->SetDisplayRect(Rect(200, 1000));
1838   render_text->SetMultiline(true);
1839   Canvas canvas;
1840
1841   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestStrings); ++i) {
1842     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "]", i));
1843     render_text->SetText(WideToUTF16(kTestStrings[i].text));
1844     render_text->Draw(&canvas);
1845
1846     ASSERT_EQ(2U, render_text->lines_.size());
1847
1848     const Range first_expected_range = kTestStrings[i].first_line_char_range;
1849     ASSERT_EQ(first_expected_range.IsValid() ? 2U : 1U,
1850               render_text->lines_[0].segments.size());
1851     if (first_expected_range.IsValid())
1852       EXPECT_EQ(first_expected_range,
1853                 render_text->lines_[0].segments[0].char_range);
1854
1855     const internal::LineSegment& newline_segment =
1856         render_text->lines_[0].segments[first_expected_range.IsValid() ? 1 : 0];
1857     ASSERT_EQ(1U, newline_segment.char_range.length());
1858     EXPECT_EQ(L'\n', kTestStrings[i].text[newline_segment.char_range.start()]);
1859
1860     const Range second_expected_range = kTestStrings[i].second_line_char_range;
1861     ASSERT_EQ(second_expected_range.IsValid() ? 1U : 0U,
1862               render_text->lines_[1].segments.size());
1863     if (second_expected_range.IsValid())
1864       EXPECT_EQ(second_expected_range,
1865                 render_text->lines_[1].segments[0].char_range);
1866   }
1867 }
1868
1869
1870 TEST_F(RenderTextTest, Win_BreakRunsByUnicodeBlocks) {
1871   scoped_ptr<RenderTextWin> render_text(
1872       static_cast<RenderTextWin*>(RenderText::CreateInstance()));
1873
1874   // The '\x25B6' "play character" should break runs. http://crbug.com/278913
1875   render_text->SetText(WideToUTF16(L"x\x25B6y"));
1876   render_text->EnsureLayout();
1877   ASSERT_EQ(3U, render_text->runs_.size());
1878   EXPECT_EQ(Range(0, 1), render_text->runs_[0]->range);
1879   EXPECT_EQ(Range(1, 2), render_text->runs_[1]->range);
1880   EXPECT_EQ(Range(2, 3), render_text->runs_[2]->range);
1881
1882   render_text->SetText(WideToUTF16(L"x \x25B6 y"));
1883   render_text->EnsureLayout();
1884   ASSERT_EQ(3U, render_text->runs_.size());
1885   EXPECT_EQ(Range(0, 2), render_text->runs_[0]->range);
1886   EXPECT_EQ(Range(2, 3), render_text->runs_[1]->range);
1887   EXPECT_EQ(Range(3, 5), render_text->runs_[2]->range);
1888 }
1889 #endif  // defined(OS_WIN)
1890
1891 }  // namespace gfx