This CL fixes issue 6099 -- bad display of multi-line English message in pop ups.

(http://crbug.com/6099)

Currently, in RTL locales, a pure *multi-line* English message is displayed as right aligned and has RTL directionality (such as the ending punctuation appears at the very left).

Single-line message works fine.

I do not know why, but simply putting LRE-PDF around a multi-line English text which has the following flags 
DT_WORDBREAK | DT_RTLREADING 
wont render the English message as LTR.
We have to remove the DT_RTLREADING to render multi-line English message correctly in LTR direction.


The fix is that in RTL locales, for JavaScript message, if the message is pure English, the alignment is set to be left-aligned, and the directionality is set to be left-to-right. If the message is mixed BiDi text, the alignment and the directionality is determined by the directionality of the first character with strong directionality in the text. 

JavaScript message is a MessageBoxView, and the message is a view::Label. Both MessageBoxView and Label are used by Chrome's UI  as well.
If the message is one of Chrome UI's, the alignment and directionality of the message should be taken from that of the UI's.

In order to distinguish where the message comes from, a new flag kFlagWebMessage is introduced in MessageBoxView, and a new argument is introduced in Label::SetHorizontalAlignment() to control whether the alignment need to be flipped or not for RTL locales.

Consequently, quite a few files which calls Label::SetHorizontalAlignment() are changed.

The main changes are in 5 areas. Other files are changed due to the signature change of Label::SetHorizontalAlignment().

1. jsmessage_box_handler.cc: pass in extra flag kFlagWebPage when creating MessageBoxView to indicate the message box is one from a web page, not from Chrome UI.

2. l10n_util.h/.cc
added function GetFirstStrongDirection()

3. label.h/.cc
a new argument is introduced in Label::SetHorizontalAlignment() to control whether the alignment need to be flipped or not for RTL locales.

4. message_box_view.cc
when init message box view, if the flag is kFlagWebPage, get the text directionality from the text itself (not Chrome UI's) and calls Label::SetHorizontalAlignment() to not resetting the flag for RTL locales.

5. chrome_canvas_win.cc
5.1 ComputeFormatFlags()
only set flag DT_RTLREADING for RTL locales if the text contains strong RTL characters and the alignment is RIGHT aligned. All labels of Chrome's UI and other Chrome UI components in RTL locales have been set as (or flipped to) RIGHT aligned. 

5.2 DoDrawText()
Only adjust string for locale is the reading direction is DT_RTLREADING.



Review URL: http://codereview.chromium.org/18863

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@10178 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 173 insertions, 9 deletions

diff --git a/chrome/common/gfx/chrome_canvas_win.cc b/chrome/common/gfx/chrome_canvas_win.cc
index f28b0cb..770effb 100644
--- a/chrome/common/gfx/chrome_canvas_win.cc
+++ b/chrome/common/gfx/chrome_canvas_win.cc
@@ -21,9 +21,14 @@ void DoDrawText(HDC hdc, const std::wstring& text,
   std::wstring localized_text;
   const wchar_t* string_ptr = text.c_str();
   int string_size = static_cast<int>(text.length());
-  if (l10n_util::AdjustStringForLocaleDirection(text, &localized_text)) {
-    string_ptr = localized_text.c_str();
-    string_size = static_cast<int>(localized_text.length());
+  // Only adjust string directionality if both of the following are true:
+  // 1. The current locale is RTL.
+  // 2. The string itself has RTL directionality.
+  if (flags & DT_RTLREADING) {
+    if (l10n_util::AdjustStringForLocaleDirection(text, &localized_text)) {
+      string_ptr = localized_text.c_str();
+      string_size = static_cast<int>(localized_text.length());
+    }
   }
 
   DrawText(hdc, string_ptr, string_size, text_bounds, flags);
@@ -31,7 +36,7 @@ void DoDrawText(HDC hdc, const std::wstring& text,
 
 // Compute the windows flags necessary to implement the provided text
 // ChromeCanvas flags.
-int ComputeFormatFlags(int flags) {
+int ComputeFormatFlags(int flags, const std::wstring& text) {
   int f = 0;
 
   // Setting the text alignment explicitly in case it hasn't already been set.
@@ -82,9 +87,30 @@ int ComputeFormatFlags(int flags) {
   // English) this flag also makes sure that if there is not enough space to
   // display the entire string, the ellipsis is displayed on the left hand side
   // of the truncated string and not on the right hand side.
-  if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
-    f |= DT_RTLREADING;
-
+  //
+  // We make a distinction between Chrome UI strings and text coming from a web
+  // page.
+  //
+  // For text coming from a web page we determine the alignment based on the
+  // first character with strong directionality. If the directionality of the
+  // first character with strong directionality in the text is LTR, the
+  // alignment is set to DT_LEFT, and the directionality should not be set as
+  // DT_RTLREADING.
+  //
+  // This heuristic doesn't work for Chrome UI strings since even in RTL
+  // locales, some of those might start with English text but we know they're
+  // localized so we always want them to be right aligned, and their
+  // directionality should be set as DT_RTLREADING.
+  //
+  // Caveat: If the string is purely LTR, don't set DTL_RTLREADING since when
+  // the flag is set, LRE-PDF don't have the desired effect of rendering
+  // multiline English-only text as LTR.
+  if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT &&
+      (f & DT_RIGHT)) {
+    if (l10n_util::StringContainsStrongRTLChars(text)) {
+      f |= DT_RTLREADING;
+    }
+  }
   return f;
 }
 
@@ -115,7 +141,7 @@ void ChromeCanvas::SizeStringInt(const std::wstring& text,
     b.right = 1;
   }
   b.bottom = *height;
-  DoDrawText(dc, text, &b, ComputeFormatFlags(flags) | DT_CALCRECT);
+  DoDrawText(dc, text, &b, ComputeFormatFlags(flags, text) | DT_CALCRECT);
 
   // Restore the old font. This way we don't have to worry if the caller
   // deletes the font and the DC lives longer.
@@ -141,7 +167,7 @@ void ChromeCanvas::DrawStringInt(const std::wstring& text, HFONT font,
                              SkColorGetB(color));
   SetTextColor(dc, brush_color);
 
-  int f = ComputeFormatFlags(flags);
+  int f = ComputeFormatFlags(flags, text);
   DoDrawText(dc, text, &text_bounds, f);
   endPlatformPaint();
 
diff --git a/chrome/common/l10n_util.cc b/chrome/common/l10n_util.cc
index 6365291..6fb5286 100644
--- a/chrome/common/l10n_util.cc
+++ b/chrome/common/l10n_util.cc
@@ -502,6 +502,40 @@ TextDirection GetTextDirection() {
   return g_text_direction;
 }
 
+TextDirection GetFirstStrongCharacterDirection(const std::wstring& text) {
+#if defined(WCHAR_T_IS_UTF32)
+  string16 text_utf16 = WideToUTF16(text);
+  const UChar* string = text_utf16.c_str();
+#else
+  const UChar* string = text.c_str();
+#endif
+  size_t length = text.length();
+  size_t position = 0;
+  while (position < length) {
+    UChar32 character;
+    size_t next_position = position;
+    U16_NEXT(string, next_position, length, character);
+
+    // Now that we have the character, we use ICU in order to query for the
+    // appropriate Unicode BiDi character type.
+    int32_t property = u_getIntPropertyValue(character, UCHAR_BIDI_CLASS);
+    if ((property == U_RIGHT_TO_LEFT) ||
+        (property == U_RIGHT_TO_LEFT_ARABIC) ||
+        (property == U_RIGHT_TO_LEFT_EMBEDDING) ||
+        (property == U_RIGHT_TO_LEFT_OVERRIDE)) {
+      return RIGHT_TO_LEFT;
+    } else if ((property == U_LEFT_TO_RIGHT) ||
+               (property == U_LEFT_TO_RIGHT_EMBEDDING) ||
+               (property == U_LEFT_TO_RIGHT_OVERRIDE)) {
+      return LEFT_TO_RIGHT;
+    }
+
+    position = next_position;
+  }
+
+  return LEFT_TO_RIGHT;
+}
+
 bool AdjustStringForLocaleDirection(const std::wstring& text,
                                     std::wstring* localized_text) {
   if (GetTextDirection() == LEFT_TO_RIGHT || text.length() == 0)
diff --git a/chrome/common/l10n_util.h b/chrome/common/l10n_util.h
index 0c67712..c0a5d0d 100644
--- a/chrome/common/l10n_util.h
+++ b/chrome/common/l10n_util.h
@@ -116,6 +116,14 @@ enum TextDirection {
 //  * UNKNOWN_DIRECTION: unknown (or error).
 TextDirection GetTextDirection();
 
+// Given the string in |text|, returns the directionality of the first
+// character with strong directionality in the string. If no character in the
+// text has strong directionality, LEFT_TO_RIGHT is returned. The Bidi
+// character types L, LRE, LRO, R, AL, RLE, and RLO are considered as strong
+// directionality characters. Please refer to http://unicode.org/reports/tr9/
+// for more information.
+TextDirection GetFirstStrongCharacterDirection(const std::wstring& text);
+
 // Given the string in |text|, this function creates a copy of the string with
 // the appropriate Unicode formatting marks that mark the string direction
 // (either left-to-right or right-to-left). The new string is returned in
diff --git a/chrome/common/l10n_util_unittest.cc b/chrome/common/l10n_util_unittest.cc
index 3d93ef7..88c1cad 100644
--- a/chrome/common/l10n_util_unittest.cc
+++ b/chrome/common/l10n_util_unittest.cc
@@ -160,6 +160,102 @@ TEST_F(L10nUtilTest, GetAppLocale) {
   Locale::setDefault(locale, error_code);
 }
 
+TEST_F(L10nUtilTest, GetFirstStrongCharacterDirection) {
+  // Test pure LTR string.
+  std::wstring string(L"foo bar");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type L.
+  string.assign(L"foo \x05d0 bar");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type R.
+  string.assign(L"\x05d0 foo bar");
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string which starts with a character with weak directionality
+  // and in which the first character with strong directionality is a character
+  // with type L.
+  string.assign(L"!foo \x05d0 bar");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string which starts with a character with weak directionality
+  // and in which the first character with strong directionality is a character
+  // with type R.
+  string.assign(L",\x05d0 foo bar");
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type LRE.
+  string.assign(L"\x202a \x05d0 foo  bar");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type LRO.
+  string.assign(L"\x202d \x05d0 foo  bar");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type RLE.
+  string.assign(L"\x202b foo \x05d0 bar");
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type RLO.
+  string.assign(L"\x202e foo \x05d0 bar");
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test bidi string in which the first character with strong directionality
+  // is a character with type AL.
+  string.assign(L"\x0622 foo \x05d0 bar");
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test a string without strong directionality characters.
+  string.assign(L",!.{}");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test empty string.
+  string.assign(L"");
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+  // Test characters in non-BMP (e.g. Phoenician letters. Please refer to
+  // http://demo.icu-project.org/icu-bin/ubrowse?scr=151&b=10910 for more
+  // information).
+#if defined(WCHAR_T_IS_UTF32)
+  string.assign(L" ! \x10910" L"abc 123");
+#elif defined(WCHAR_T_IS_UTF16)
+  string.assign(L" ! \xd802\xdd10" L"abc 123");
+#else
+#error wchar_t should be either UTF-16 or UTF-32
+#endif
+  EXPECT_EQ(l10n_util::RIGHT_TO_LEFT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+
+#if defined(WCHAR_T_IS_UTF32)
+  string.assign(L" ! \x10401" L"abc 123");
+#elif defined(WCHAR_T_IS_UTF16)
+  string.assign(L" ! \xd801\xdc01" L"abc 123");
+#else
+#error wchar_t should be either UTF-16 or UTF-32
+#endif
+  EXPECT_EQ(l10n_util::LEFT_TO_RIGHT,
+            l10n_util::GetFirstStrongCharacterDirection(string));
+}
+
 typedef struct {
   std::wstring path;
   std::wstring wrapped_path;