Move RTL related functions from app/l10n_util to base/i18n/rtl...

app/gfx/canvas_win.cc

 // Copyright (c) 2010 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 "app/gfx/canvas.h"
 
 #include <limits>
 
 #include "app/gfx/font.h"
-#include "app/l10n_util.h"
+#include "base/i18n/rtl.h"
 #include "gfx/rect.h"
 #include "third_party/skia/include/core/SkShader.h"
 
 namespace {
 
 // We make sure that LTR text we draw in an RTL context is modified
 // appropriately to make sure it maintains it LTR orientation.
 void DoDrawText(HDC hdc, const std::wstring& text,
                 RECT* text_bounds, int flags) {
   std::wstring localized_text;
   const wchar_t* string_ptr = text.c_str();
   int string_size = static_cast<int>(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)) {
+    if (base::i18n::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);
 }
 
 // Compute the windows flags necessary to implement the provided text Canvas
 // flags.
 int ComputeFormatFlags(int flags, const std::wstring& text) {
   // Setting the text alignment explicitly in case it hasn't already been set.
   // This will make sure that we don't align text to the left on RTL locales
   // just because no alignment flag was passed to DrawStringInt().
   if (!(flags & (gfx::Canvas::TEXT_ALIGN_CENTER |
                  gfx::Canvas::TEXT_ALIGN_RIGHT |
                  gfx::Canvas::TEXT_ALIGN_LEFT))) {
-    flags |= l10n_util::DefaultCanvasTextAlignment();
+    flags |= gfx::Canvas::DefaultCanvasTextAlignment();
   }
 
   // horizontal alignment
   int f = 0;
   if (flags & gfx::Canvas::TEXT_ALIGN_CENTER)
     f |= DT_CENTER;
   else if (flags & gfx::Canvas::TEXT_ALIGN_RIGHT)
     f |= DT_RIGHT;
   else
     f |= DT_LEFT;
@@ skipping 50 matching lines @@
   // 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.
   //
   // Note that if the caller is explicitly requesting displaying the text
   // using RTL directionality then we respect that and pass DT_RTLREADING to
   // ::DrawText even if the locale is LTR.
   if ((flags & gfx::Canvas::FORCE_RTL_DIRECTIONALITY) ||
-      ((l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) &&
-       (f & DT_RIGHT) && l10n_util::StringContainsStrongRTLChars(text))) {
+      (base::i18n::IsRTL() &&
+       (f & DT_RIGHT) && base::i18n::StringContainsStrongRTLChars(text))) {
     f |= DT_RTLREADING;
   }
 
   return f;
 }
 
 }  // anonymous namespace
 
 namespace gfx {
 
@@ skipping 149 matching lines @@
         text_row[cur_x] |= 0xff << SK_A32_SHIFT;  // Make opaque.
       }
     }
   }
 
   // Draw the halo bitmap with blur.
   drawBitmap(text_bitmap, SkIntToScalar(x - 1), SkIntToScalar(y - 1));
 }
 
 }  // namespace gfx