Use 'icu::' namespace explicitly

app/l10n_util.cc

 // Copyright (c) 2006-2008 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/l10n_util.h"
 
 #include "app/app_paths.h"
 #include "app/app_switches.h"
 #include "app/gfx/canvas.h"
 #include "app/resource_bundle.h"
@@ skipping 27 matching lines @@
 
 // Added to the end of strings that are too big in TrucateString.
 static const wchar_t* const kElideString = L"\x2026";
 
 // Get language and region from the OS.
 void GetLanguageAndRegionFromOS(std::string* lang, std::string* region) {
   // Later we may have to change this to be OS-dependent so that
   // it's not affected by ICU's default locale. It's all right
   // to do this way because SetICUDefaultLocale is internal
   // to this file and we know where/when it's called.
-  Locale locale = Locale::getDefault();
+  icu::Locale locale = icu::Locale::getDefault();
   const char* language = locale.getLanguage();
   const char* country = locale.getCountry();
   DCHECK(language);
   *lang = language;
   *region = country;
 }
 
 // Convert Chrome locale name to ICU locale name
 std::string ICULocaleName(const std::string& locale_string) {
   // If not Spanish, just return it.
@@ skipping 23 matching lines @@
 
 // Sets the default locale of ICU.
 // When the application locale (UI locale) of Chrome is specified with
 // '--lang' command line flag or 'intl.app_locale' entry in the "Preferences",
 // the default locale of ICU need to be changed to match the application locale
 // so that ICU functions work correctly in a locale-dependent manner.
 // This is handy in that we don't have to call GetApplicationLocale()
 // everytime we call locale-dependent ICU APIs as long as we make sure
 // that this is called before any locale-dependent API is called.
 UBool SetICUDefaultLocale(const std::string& locale_string) {
-  Locale locale(ICULocaleName(locale_string).c_str());
+  icu::Locale locale(ICULocaleName(locale_string).c_str());
   UErrorCode error_code = U_ZERO_ERROR;
-  Locale::setDefault(locale, error_code);
+  icu::Locale::setDefault(locale, error_code);
   // This return value is actually bogus because Locale object is
   // an ID and setDefault seems to always succeed (regardless of the
   // presence of actual locale data). However,
   // it does not hurt to have it as a sanity check.
   return U_SUCCESS(error_code);
 }
 
 // Returns true if |locale_name| has an alias in the ICU data file.
 bool IsDuplicateName(const std::string& locale_name) {
   static const char* const kDuplicateNames[] = {
@@ skipping 343 matching lines @@
     return kElideString;
   }
 
 #if defined(WCHAR_T_IS_UTF32)
   const string16 string_utf16 = WideToUTF16(string);
 #else
   const std::wstring &string_utf16 = string;
 #endif
   // Use a line iterator to find the first boundary.
   UErrorCode status = U_ZERO_ERROR;
-  scoped_ptr<RuleBasedBreakIterator> bi(static_cast<RuleBasedBreakIterator*>(
-      RuleBasedBreakIterator::createLineInstance(Locale::getDefault(),
-                                                 status)));
+  scoped_ptr<icu::RuleBasedBreakIterator> bi(
+      static_cast<icu::RuleBasedBreakIterator*>(
+          icu::RuleBasedBreakIterator::createLineInstance(
+              icu::Locale::getDefault(), status)));
   if (U_FAILURE(status))
     return string.substr(0, max) + kElideString;
   bi->setText(string_utf16.c_str());
   int32_t index = bi->preceding(static_cast<int32_t>(max));
-  if (index == BreakIterator::DONE) {
+  if (index == icu::BreakIterator::DONE) {
     index = static_cast<int32_t>(max);
   } else {
     // Found a valid break (may be the beginning of the string). Now use
     // a character iterator to find the previous non-whitespace character.
-    StringCharacterIterator char_iterator(string_utf16.c_str());
+    icu::StringCharacterIterator char_iterator(string_utf16.c_str());
     if (index == 0) {
       // No valid line breaks. Start at the end again. This ensures we break
       // on a valid character boundary.
       index = static_cast<int32_t>(max);
     }
     char_iterator.setIndex(index);
     while (char_iterator.hasPrevious()) {
       char_iterator.previous();
       if (!(u_isspace(char_iterator.current()) ||
             u_charType(char_iterator.current()) == U_CONTROL_CHAR ||
@@ skipping 15 matching lines @@
   return string.substr(0, index) + kElideString;
 }
 
 #if defined(WCHAR_T_IS_UTF32)
 std::wstring ToLower(const std::wstring& string) {
   return UTF16ToWide(ToLower(WideToUTF16(string)));
 }
 #endif  // defined(WCHAR_T_IS_UTF32)
 
 string16 ToLower(const string16& string) {
-  UnicodeString lower_u_str(
-      UnicodeString(string.c_str()).toLower(Locale::getDefault()));
+  icu::UnicodeString lower_u_str(
+      icu::UnicodeString(string.c_str()).toLower(icu::Locale::getDefault()));
   string16 result;
   lower_u_str.extract(0, lower_u_str.length(),
                       WriteInto(&result, lower_u_str.length() + 1));
   return result;
 }
 
 // Returns the text direction for the default ICU locale. It is assumed
 // that SetICUDefaultLocale has been called to set the default locale to
 // the UI locale of Chrome.
 TextDirection GetTextDirection() {
   if (g_text_direction == UNKNOWN_DIRECTION) {
 #if defined(TOOLKIT_GTK)
     GtkTextDirection gtk_dir = gtk_widget_get_default_direction();
     g_text_direction =
         (gtk_dir == GTK_TEXT_DIR_LTR) ? LEFT_TO_RIGHT : RIGHT_TO_LEFT;
 #else
-    const Locale& locale = Locale::getDefault();
+    const icu::Locale& locale = icu::Locale::getDefault();
     g_text_direction = GetTextDirectionForLocale(locale.getName());
 #endif
   }
   return g_text_direction;
 }
 
 TextDirection GetTextDirectionForLocale(const char* locale_name) {
   UScriptCode scripts[10];  // 10 scripts should be enough for any locale.
   UErrorCode error = U_ZERO_ERROR;
   int n = uscript_getCode(locale_name, scripts, 10, &error);
@@ skipping 126 matching lines @@
   if (GetTextDirection() == LEFT_TO_RIGHT) {
     return gfx::Canvas::TEXT_ALIGN_LEFT;
   } else {
     return gfx::Canvas::TEXT_ALIGN_RIGHT;
   }
 }
 
 
 // Compares the character data stored in two different strings by specified
 // Collator instance.
-UCollationResult CompareStringWithCollator(const Collator* collator,
+UCollationResult CompareStringWithCollator(const icu::Collator* collator,
                                            const std::wstring& lhs,
                                            const std::wstring& rhs) {
   DCHECK(collator);
   UErrorCode error = U_ZERO_ERROR;
 #if defined(WCHAR_T_IS_UTF32)
   // Need to convert to UTF-16 to be compatible with UnicodeString's
   // constructor.
   string16 lhs_utf16 = WideToUTF16(lhs);
   string16 rhs_utf16 = WideToUTF16(rhs);
 
@@ skipping 102 matching lines @@
 }
 
 void BiDiLineIterator::GetLogicalRun(int start,
                                      int* end,
                                      UBiDiLevel* level) {
   DCHECK(bidi_ != NULL);
   ubidi_getLogicalRun(bidi_, start, end, level);
 }
 
 }