Fix incorrect forcing of text directionality in canvas_skia.cc.

ui/gfx/canvas_skia.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/canvas.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/range/range.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 
-// Based on |flags| and |text| content, returns whether text should be
-// rendered right-to-left.
-bool IsTextRTL(int flags, const string16& text) {
-  if (flags & gfx::Canvas::FORCE_RTL_DIRECTIONALITY)
+// If necessary, wraps |text| with RTL/LTR directionality characters based on
+// |flags| and |text| content.
+// Returns true if the text will be rendered right-to-left.
+// TODO(asvitkine): Support setting directionality directly on RenderText, so
+//                  that wrapping the text is not needed.
+bool AdjustStringDirection(int flags, string16* text) {
+  // If the string is empty or LTR was forced, simply return false since the
+  // default RenderText directionality is already LTR.
+  if (text->empty() || (flags & gfx::Canvas::FORCE_LTR_DIRECTIONALITY))
+    return false;
+
+  // If RTL is forced, apply it to the string.
+  if (flags & gfx::Canvas::FORCE_RTL_DIRECTIONALITY) {
+    base::i18n::WrapStringWithRTLFormatting(text);
     return true;
-  if (flags & gfx::Canvas::FORCE_LTR_DIRECTIONALITY)
-    return false;
-  return base::i18n::IsRTL() && base::i18n::StringContainsStrongRTLChars(text);
+  }
+
+  // If a direction wasn't forced but the UI language is RTL and there were
+  // strong RTL characters, ensure RTL is applied.
+  if (base::i18n::IsRTL() && base::i18n::StringContainsStrongRTLChars(*text)) {
+    base::i18n::WrapStringWithRTLFormatting(text);
+    return true;
+  }
+
+  // In the default case, the string should be rendered as LTR. RenderText's
+  // default directionality is LTR, so the text doesn't need to be wrapped.
+  // Note that individual runs within the string may still be rendered RTL
+  // (which will be the case for RTL text under non-RTL locales, since under RTL
+  // locales it will be handled by the if statement above).
+  return false;
 }
 
 // Checks each pixel immediately adjacent to the given pixel in the bitmap. If
 // any of them are not the halo color, returns true. This defines the halo of
 // pixels that will appear around the text. Note that we have to check each
 // pixel against both the halo color and transparent since |DrawStringWithHalo|
 // will modify the bitmap as it goes, and cleared pixels shouldn't count as
 // changed.
 bool PixelShouldGetHalo(const SkBitmap& bitmap,
                         int x, int y,
@@ skipping 128 matching lines @@
 
 // static
 void Canvas::SizeStringInt(const string16& text,
                            const gfx::Font& font,
                            int* width, int* height,
                            int flags) {
   DCHECK_GE(*width, 0);
   DCHECK_GE(*height, 0);
 
   flags = AdjustPlatformSpecificFlags(text, flags);
+
+  string16 adjusted_text = text;
+#if defined(OS_WIN)
+  AdjustStringDirection(flags, &adjusted_text);
+#endif
+
   if ((flags & MULTI_LINE) && *width != 0) {
     ui::WordWrapBehavior wrap_behavior = ui::TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = ui::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = ui::ELIDE_LONG_WORDS;
 
     gfx::Rect rect(*width, INT_MAX);
     std::vector<string16> strings;
-    ui::ElideRectangleText(text, font, rect.width(), rect.height(),
+    ui::ElideRectangleText(adjusted_text, font, rect.width(), rect.height(),
                            wrap_behavior, &strings);
     scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
     UpdateRenderText(rect, string16(), font, flags, 0, render_text.get());
 
     int h = 0;
     int w = 0;
     for (size_t i = 0; i < strings.size(); ++i) {
       StripAcceleratorChars(flags, &strings[i]);
       render_text->SetText(strings[i]);
       const Size string_size = render_text->GetStringSize();
       w = std::max(w, string_size.width());
       h += string_size.height();
     }
     *width = w;
     *height = h;
   } else {
     // If the string is too long, the call by |RenderTextWin| to |ScriptShape()|
     // will inexplicably fail with result E_INVALIDARG. Guard against this.
     const size_t kMaxRenderTextLength = 5000;
-    if (text.length() >= kMaxRenderTextLength) {
-      *width = text.length() * font.GetAverageCharacterWidth();
+    if (adjusted_text.length() >= kMaxRenderTextLength) {
+      *width = adjusted_text.length() * font.GetAverageCharacterWidth();
       *height = font.GetHeight();
     } else {
       scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
       gfx::Rect rect(*width, *height);
-      string16 adjusted_text = text;
       StripAcceleratorChars(flags, &adjusted_text);
       UpdateRenderText(rect, adjusted_text, font, flags, 0, render_text.get());
       const Size string_size = render_text->GetStringSize();
       *width = string_size.width();
       *height = string_size.height();
     }
   }
 }
 
 void Canvas::DrawStringWithShadows(const string16& text,
@@ skipping 19 matching lines @@
   gfx::Rect clip_rect(text_bounds);
   clip_rect.Inset(ShadowValue::GetMargin(shadows));
 
   canvas_->save(SkCanvas::kClip_SaveFlag);
   ClipRect(clip_rect);
 
   gfx::Rect rect(text_bounds);
   string16 adjusted_text = text;
 
 #if defined(OS_WIN)
-  if (IsTextRTL(flags, adjusted_text))
-    base::i18n::AdjustStringForLocaleDirection(&adjusted_text);
+  AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   render_text->SetTextShadows(shadows);
 
   if (flags & MULTI_LINE) {
     ui::WordWrapBehavior wrap_behavior = ui::IGNORE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = ui::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
@@ skipping 120 matching lines @@
 
   // If the whole string fits in the destination then just draw it directly.
   if (GetStringWidth(text, font) <= display_rect.width()) {
     DrawStringInt(text, font, color, display_rect.x(), display_rect.y(),
                   display_rect.width(), display_rect.height(), flags);
     return;
   }
 
   scoped_ptr<RenderText> render_text(RenderText::CreateRenderText());
   string16 clipped_text = text;
-  const bool is_rtl = IsTextRTL(flags, text);
-  if (is_rtl)
-    base::i18n::AdjustStringForLocaleDirection(&clipped_text);
+  const bool is_rtl = AdjustStringDirection(flags, &clipped_text);
 
   switch (truncate_mode) {
     case TruncateFadeTail:
       render_text->set_fade_tail(true);
       if (is_rtl)
         flags |= TEXT_ALIGN_RIGHT;
       break;
     case TruncateFadeHead:
       render_text->set_fade_head(true);
       if (!is_rtl)
@@ skipping 30 matching lines @@
   render_text->SetDisplayRect(rect);
 
   canvas_->save(SkCanvas::kClip_SaveFlag);
   ClipRect(display_rect);
   render_text->Draw(this);
   canvas_->restore();
 }
 #endif
 
 }  // namespace gfx