Fix RenderTextWin base dir and adjacent char code; remove test exceptions; etc.

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 "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+#if defined(TOOLKIT_GTK)
+#include <gtk/gtk.h>
+#endif
+
 namespace gfx {
 
 namespace {
 
 // Checks whether |range| contains |index|. This is not the same as calling
 // |range.Contains(ui::Range(index))| - as that would return true when
 // |index| == |range.end()|.
 bool IndexInRange(const ui::Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
+// A test utility function to set the application default text direction.
+void SetRTL(bool rtl) {
+  // Override the current locale/direction.
+  base::i18n::SetICUDefaultLocale(rtl ? "he" : "en");
+#if defined(TOOLKIT_GTK)
+  // Do the same for GTK, which does not rely on the ICU default locale.
+  gtk_widget_set_default_direction(rtl ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
+#endif
+  EXPECT_EQ(rtl, base::i18n::IsRTL());
+}
+
 }  // namespace
 
 class RenderTextTest : public testing::Test {
 };
 
 TEST_F(RenderTextTest, DefaultStyle) {
   // Defaults to empty text with no styles.
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   EXPECT_TRUE(render_text->text().empty());
   EXPECT_TRUE(render_text->style_ranges().empty());
@@ skipping 291 matching lines @@
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(seuss, render_text->GetDisplayText());
 
 // TODO(benrg): No Windows implementation yet.
 #if !defined(OS_WIN)
-
   render_text->SetObscured(true);
 
   // Surrogate pairs are counted as one code point.
   const char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
   render_text->SetText(invalid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
   const char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
   EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Cursoring is independent of the underlying characters when the text is
   // obscured.
   const wchar_t* const texts[] = {
     L"hop on pop",           // word boundaries
     L"ab \x5D0\x5D1" L"12",  // bidi embedding level of 2
     L"\x5D0\x5D1" L"12",     // RTL paragraph direction on Linux
     L"\x5D0\x5D1"            // pure RTL
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(texts); ++i) {
     string16 text = WideToUTF16(texts[i]);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, false);
     TestVisualCursorMotionInObscuredField(render_text.get(), text, true);
   }
 #endif  // !defined(OS_WIN)
 }
 
+TEST_F(RenderTextTest, GetTextDirection) {
+  const bool was_rtl = base::i18n::IsRTL();
+  // Ensure that text direction is set by the first strong character direction.
+  scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
+  for (size_t i = 0; i < 2; ++i) {
+    // Toggle the application default text direction (to try each direction).
+    SetRTL(!base::i18n::IsRTL());
+
+    // Blank strings (and those without directionality) default to LTR.
+    render_text->SetText(string16());
+    EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+    render_text->SetText(ASCIIToUTF16(" "));
+    EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+
+    // Pure LTR.
+    render_text->SetText(ASCIIToUTF16("abc"));
+    EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+    // LTR-RTL
+    render_text->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
+    EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+    // LTR-RTL-LTR.
+    render_text->SetText(WideToUTF16(L"a"L"\x05d1"L"b"));
+    EXPECT_EQ(base::i18n::LEFT_TO_RIGHT, render_text->GetTextDirection());
+    // Pure RTL.
+    render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
+    EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+    // RTL-LTR
+    render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"L"abc"));
+    EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+    // RTL-LTR-RTL.
+    render_text->SetText(WideToUTF16(L"\x05d0"L"a"L"\x05d1"));
+    EXPECT_EQ(base::i18n::RIGHT_TO_LEFT, render_text->GetTextDirection());
+  }
+  EXPECT_EQ(was_rtl, base::i18n::IsRTL());
+}
+
 void RunMoveCursorLeftRightTest(RenderText* render_text,
     const std::vector<SelectionModel>& expected,
     VisualCursorDirection direction) {
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i], render_text->selection_model());
     render_text->MoveCursor(CHARACTER_BREAK, direction, false);
   }
   // Check that cursoring is clamped at the line edge.
   EXPECT_EQ(expected.back(), render_text->selection_model());
   // Check that it is the line edge.
@@ skipping 74 matching lines @@
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtl) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // Pure RTL.
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
 
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#else
-  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#endif
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#else
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#endif
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
 
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#else
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#endif
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#else
-  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#endif
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtr) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // RTL-LTR
   render_text->SetText(WideToUTF16(L"\x05d0\x05d1\x05d2"L"abc"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(5, CURSOR_FORWARD));
   expected.push_back(SelectionModel(4, CURSOR_FORWARD));
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
-#else
-  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(5, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(4, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#endif
-
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(6, CURSOR_FORWARD));
   expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#else
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(4, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(5, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(6, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(6, CURSOR_FORWARD));
-#endif
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 TEST_F(RenderTextTest, MoveCursorLeftRightInRtlLtrRtl) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   // RTL-LTR-RTL.
   render_text->SetText(WideToUTF16(L"\x05d0"L"a"L"\x05d1"));
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, false);
   std::vector<SelectionModel> expected;
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(1, CURSOR_FORWARD));
   expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#else
-  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(3, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(1, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(1, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#endif
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_LEFT);
 
   expected.clear();
-#if defined(OS_LINUX)
   expected.push_back(SelectionModel(3, CURSOR_FORWARD));
   expected.push_back(SelectionModel(2, CURSOR_FORWARD));
   expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
   expected.push_back(SelectionModel(0, CURSOR_FORWARD));
   expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-#else
-  expected.push_back(SelectionModel(0, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(0, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(2, CURSOR_BACKWARD));
-  expected.push_back(SelectionModel(2, CURSOR_FORWARD));
-  expected.push_back(SelectionModel(3, CURSOR_FORWARD));
-#endif
   RunMoveCursorLeftRightTest(render_text.get(), expected, CURSOR_RIGHT);
 }
 
 // TODO(xji): temporarily disable in platform Win since the complex script
 // characters turned into empty square due to font regression. So, not able
 // to test 2 characters belong to the same grapheme.
 #if defined(OS_LINUX)
 TEST_F(RenderTextTest, MoveCursorLeftRight_ComplexScript) {
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
 
@@ skipping 108 matching lines @@
   const string16 kHebrewLatin = WideToUTF16(L"\x05e0\x05b8"L"a"L"\x05e0\x05b8");
 
   struct {
     string16 text;
     base::i18n::TextDirection expected_text_direction;
   } cases[] = {
     { string16(),   base::i18n::LEFT_TO_RIGHT },
     { kLatin,       base::i18n::LEFT_TO_RIGHT },
     { kLTRGrapheme, base::i18n::LEFT_TO_RIGHT },
     { kHindiLatin,  base::i18n::LEFT_TO_RIGHT },
-#if defined(OS_LINUX)
-    // On Linux, the whole string is displayed RTL, rather than individual runs.
     { kRTLGrapheme, base::i18n::RIGHT_TO_LEFT },
     { kHebrewLatin, base::i18n::RIGHT_TO_LEFT },
-#else
-    { kRTLGrapheme, base::i18n::LEFT_TO_RIGHT },
-    { kHebrewLatin, base::i18n::LEFT_TO_RIGHT },
-#endif
   };
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
@@ skipping 453 matching lines @@
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(render_text->display_rect().width() - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(width, render_text->GetUpdatedCursorBounds().x());
 }
 
-// TODO(asvitkine): This test fails on desktop Linux. http://crbug.com/134009
-#if !defined(OS_LINUX) || defined(OS_CHROMEOS)
 TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) {
-  // Set the locale to Hebrew for RTL UI.
-  std::string locale = l10n_util::GetApplicationLocale("");
-  base::i18n::SetICUDefaultLocale("he");
+  // Set the application default text direction to RTL.
+  const bool was_rtl = base::i18n::IsRTL();
+  SetRTL(true);
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg"));
   render_text->MoveCursorTo(SelectionModel(0, CURSOR_FORWARD));
   int width = render_text->GetStringSize().width();
   ASSERT_GT(width, 10);
 
   // Ensure that the cursor is placed at the width of its preceding text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
@@ skipping 31 matching lines @@
 
   // Ensure that the text will pan to fill its expanding display rectangle.
   render_text->SetDisplayRect(Rect(width - 5, 1));
   EXPECT_EQ(0, render_text->GetUpdatedCursorBounds().x());
 
   // Ensure that a sufficiently large display rectangle shows all the text.
   render_text->SetDisplayRect(Rect(width + 10, 1));
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
-  // Reset locale.
-  base::i18n::SetICUDefaultLocale(locale);
+  // Reset the application default text direction to LTR.
+  SetRTL(was_rtl);
+  EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
-#endif  // !defined(OS_LINUX) || defined(OS_CHROMEOS)
 
 }  // namespace gfx