Add RenderText DirectionalityMode enum and support; 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"
+#include "ui/gfx/text_constants.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
 namespace gfx {
 
 namespace {
 
+// Various weak, LTR, RTL, and Bidi string cases with three characters each.
+const wchar_t kWeak[] =      L" . ";
+const wchar_t kLtr[] =       L"abc";
+const wchar_t kLtrRtl[] =    L"a"L"\x5d0\x5d1";
+const wchar_t kLtrRtlLtr[] = L"a"L"\x5d1"L"b";
+const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
+const wchar_t kRtlLtr[] =    L"\x5d0\x5d1"L"a";
+const wchar_t kRtlLtrRtl[] = L"\x5d0"L"a"L"\x5d1";
+
 // 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.
@@ skipping 178 matching lines @@
   EXPECT_EQ(ui::Range(2, 10), render_text->style_ranges()[1].range);
   EXPECT_EQ(SK_ColorRED, render_text->style_ranges()[1].foreground);
   EXPECT_EQ(ui::Range(10, 12), render_text->style_ranges()[2].range);
   EXPECT_TRUE(render_text->style_ranges()[2].underline);
   EXPECT_TRUE(render_text->style_ranges()[2].strike);
 }
 
 static void SetTextWith2ExtraStyles(RenderText* render_text) {
   render_text->SetText(ASCIIToUTF16("abcdefghi"));
 
-  gfx::StyleRange strike;
+  StyleRange strike;
   strike.strike = true;
   strike.range = ui::Range(0, 3);
   render_text->ApplyStyleRange(strike);
 
-  gfx::StyleRange underline;
+  StyleRange underline;
   underline.underline = true;
   underline.range = ui::Range(3, 6);
   render_text->ApplyStyleRange(underline);
 }
 
 TEST_F(RenderTextTest, StyleRangesAdjust) {
   // Test that style ranges adjust to the text size.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("abcdef"));
   EXPECT_EQ(1U, render_text->style_ranges().size());
@@ skipping 138 matching lines @@
   };
   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) {
+  struct {
+    const wchar_t* text;
+    const base::i18n::TextDirection text_direction;
+  } cases[] = {
+    // Blank strings and those with no/weak directionality default to LTR.
+    { L"",        base::i18n::LEFT_TO_RIGHT },
+    { kWeak,      base::i18n::LEFT_TO_RIGHT },
+    // Strings that begin with strong LTR characters.
+    { kLtr,       base::i18n::LEFT_TO_RIGHT },
+    { kLtrRtl,    base::i18n::LEFT_TO_RIGHT },
+    { kLtrRtlLtr, base::i18n::LEFT_TO_RIGHT },
+    // Strings that begin with strong RTL characters.
+    { kRtl,       base::i18n::RIGHT_TO_LEFT },
+    { kRtlLtr,    base::i18n::RIGHT_TO_LEFT },
+    { kRtlLtrRtl, base::i18n::RIGHT_TO_LEFT },
+  };
+
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   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::CreateInstance());
+
   for (size_t i = 0; i < 2; ++i) {
     // Toggle the application default text direction (to try each direction).
     SetRTL(!base::i18n::IsRTL());
+    const base::i18n::TextDirection ui_direction = base::i18n::IsRTL() ?
+        base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
 
-    // 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());
+    // Ensure that directionality modes yield the correct text directions.
+    for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
+      render_text->SetText(WideToUTF16(cases[j].text));
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+      EXPECT_EQ(render_text->GetTextDirection(), cases[j].text_direction);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_UI);
+      EXPECT_EQ(render_text->GetTextDirection(), ui_direction);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_LTR);
+      EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
+      render_text->SetDirectionalityMode(DIRECTIONALITY_FORCE_RTL);
+      EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
+    }
+  }
 
-    // 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());
+
+  // Ensure that text changes update the direction for DIRECTIONALITY_FROM_TEXT.
+  render_text->SetDirectionalityMode(DIRECTIONALITY_FROM_TEXT);
+  render_text->SetText(WideToUTF16(kLtr));
+  EXPECT_EQ(render_text->GetTextDirection(), base::i18n::LEFT_TO_RIGHT);
+  render_text->SetText(WideToUTF16(kRtl));
+  EXPECT_EQ(render_text->GetTextDirection(), base::i18n::RIGHT_TO_LEFT);
 }
 
 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.
@@ skipping 295 matching lines @@
         render_text->EdgeSelectionModel(ltr ? CURSOR_LEFT : CURSOR_RIGHT);
     EXPECT_EQ(start_edge, SelectionModel(0, CURSOR_BACKWARD));
 
     SelectionModel end_edge =
         render_text->EdgeSelectionModel(ltr ? CURSOR_RIGHT : CURSOR_LEFT);
     EXPECT_EQ(end_edge, SelectionModel(cases[i].text.length(), CURSOR_FORWARD));
   }
 }
 
 TEST_F(RenderTextTest, SelectAll) {
-  const wchar_t* const cases[] = {
-    L"abc",
-    L"a"L"\x5d0\x5d1",
-    L"a"L"\x5d1"L"b",
-    L"\x5d0\x5d1\x5d2",
-    L"\x5d0\x5d1"L"a",
-    L"\x5d0"L"a"L"\x5d1",
-  };
+  const wchar_t* const cases[] =
+      { kWeak, kLtr, kLtrRtl, kLtrRtlLtr, kRtl, kRtlLtr, kRtlLtrRtl };
 
   // Ensure that SelectAll respects the |reversed| argument regardless of
   // application locale and text content directionality.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   const SelectionModel expected_reversed(ui::Range(3, 0), CURSOR_FORWARD);
   const SelectionModel expected_forwards(ui::Range(0, 3), CURSOR_BACKWARD);
   const bool was_rtl = base::i18n::IsRTL();
 
   for (size_t i = 0; i < 2; ++i) {
     SetRTL(!base::i18n::IsRTL());
+    // Test that an empty string produces an empty selection model.
+    render_text->SetText(string16());
+    EXPECT_EQ(render_text->selection_model(), SelectionModel());
+
+    // Test the weak, LTR, RTL, and Bidi string cases.
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases); j++) {
       render_text->SetText(WideToUTF16(cases[j]));
       render_text->SelectAll(false);
       EXPECT_EQ(render_text->selection_model(), expected_forwards);
       render_text->SelectAll(true);
       EXPECT_EQ(render_text->selection_model(), expected_reversed);
     }
   }
 
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
@@ skipping 511 matching lines @@
   EXPECT_EQ(render_text->display_rect().width() - width - 1,
             render_text->GetUpdatedCursorBounds().x());
 
   // Reset the application default text direction to LTR.
   SetRTL(was_rtl);
   EXPECT_EQ(was_rtl, base::i18n::IsRTL());
 }
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace gfx