Use 'icu::' namespace explicitly

chrome/common/time_format.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 "chrome/common/time_format.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/logging.h"
@@ skipping 95 matching lines @@
 enum FormatType {
   FORMAT_SHORT,
   FORMAT_REMAINING,
   FORMAT_ELAPSED,
 };
 
 }  // namespace
 
 class TimeFormatter {
   public:
-    const std::vector<PluralFormat*>& formatter(FormatType format_type) {
+    const std::vector<icu::PluralFormat*>& formatter(FormatType format_type) {
       switch (format_type) {
         case FORMAT_SHORT:
           return short_formatter_;
         case FORMAT_REMAINING:
           return time_left_formatter_;
         case FORMAT_ELAPSED:
           return time_elapsed_formatter_;
         default:
           NOTREACHED();
           return short_formatter_;
@@ skipping 37 matching lines @@
       STLDeleteContainerPointers(short_formatter_.begin(),
                                  short_formatter_.end());
       STLDeleteContainerPointers(time_left_formatter_.begin(),
                                  time_left_formatter_.end());
       STLDeleteContainerPointers(time_elapsed_formatter_.begin(),
                                  time_elapsed_formatter_.end());
     }
     friend class Singleton<TimeFormatter>;
     friend struct DefaultSingletonTraits<TimeFormatter>;
 
-    std::vector<PluralFormat*> short_formatter_;
-    std::vector<PluralFormat*> time_left_formatter_;
-    std::vector<PluralFormat*> time_elapsed_formatter_;
+    std::vector<icu::PluralFormat*> short_formatter_;
+    std::vector<icu::PluralFormat*> time_left_formatter_;
+    std::vector<icu::PluralFormat*> time_elapsed_formatter_;
     static void BuildFormats(FormatType format_type,
-                             std::vector<PluralFormat*>* time_formats);
-    static PluralFormat* createFallbackFormat(const PluralRules& rules,
-                                              int index,
-                                              FormatType format_type);
+                             std::vector<icu::PluralFormat*>* time_formats);
+    static icu::PluralFormat* createFallbackFormat(
+        const icu::PluralRules& rules, int index, FormatType format_type);
 
     DISALLOW_EVIL_CONSTRUCTORS(TimeFormatter);
 };
 
-void TimeFormatter::BuildFormats(FormatType format_type,
-                                 std::vector<PluralFormat*>* time_formats) {
-  const static UnicodeString kKeywords[] = {
+void TimeFormatter::BuildFormats(
+    FormatType format_type, std::vector<icu::PluralFormat*>* time_formats) {
+  static const icu::UnicodeString kKeywords[] = {
     UNICODE_STRING_SIMPLE("other"), UNICODE_STRING_SIMPLE("one"),
     UNICODE_STRING_SIMPLE("zero"), UNICODE_STRING_SIMPLE("two"),
     UNICODE_STRING_SIMPLE("few"), UNICODE_STRING_SIMPLE("many")
   };
   UErrorCode err = U_ZERO_ERROR;
-  scoped_ptr<PluralRules> rules(
-      PluralRules::forLocale(Locale::getDefault(), err));
+  scoped_ptr<icu::PluralRules> rules(
+      icu::PluralRules::forLocale(icu::Locale::getDefault(), err));
   if (U_FAILURE(err)) {
     err = U_ZERO_ERROR;
-    UnicodeString fallback_rules("one: n is 1", -1, US_INV);
-    rules.reset(PluralRules::createRules(fallback_rules, err));
+    icu::UnicodeString fallback_rules("one: n is 1", -1, US_INV);
+    rules.reset(icu::PluralRules::createRules(fallback_rules, err));
     DCHECK(U_SUCCESS(err));
   }
 
   const MessageIDs& message_ids = GetMessageIDs(format_type);
 
   for (int i = 0; i < 4; ++i) {
-    UnicodeString pattern;
+    icu::UnicodeString pattern;
     for (size_t j = 0; j < arraysize(kKeywords); ++j) {
       int msg_id = message_ids.ids[i][j];
       std::string sub_pattern = WideToUTF8(l10n_util::GetString(msg_id));
       // NA means this keyword is not used in the current locale.
       // Even if a translator translated for this keyword, we do not
       // use it unless it's 'other' (j=0) or it's defined in the rules
       // for the current locale. Special-casing of 'other' will be removed
       // once ICU's isKeyword is fixed to return true for isKeyword('other').
       if (sub_pattern.compare("NA") != 0 &&
           (j == 0 || rules->isKeyword(kKeywords[j]))) {
           pattern += kKeywords[j];
           pattern += UNICODE_STRING_SIMPLE("{");
-          pattern += UnicodeString(sub_pattern.c_str(), "UTF-8");
+          pattern += icu::UnicodeString(sub_pattern.c_str(), "UTF-8");
           pattern += UNICODE_STRING_SIMPLE("}");
       }
     }
-    PluralFormat* format = new PluralFormat(*rules, pattern, err);
+    icu::PluralFormat* format = new icu::PluralFormat(*rules, pattern, err);
     if (U_SUCCESS(err)) {
       time_formats->push_back(format);
     } else {
       delete format;
       time_formats->push_back(createFallbackFormat(*rules, i, format_type));
       // Reset it so that next ICU call can proceed.
       err = U_ZERO_ERROR;
     }
   }
 }
 
 // Create a hard-coded fallback plural format. This will never be called
 // unless translators make a mistake.
-PluralFormat* TimeFormatter::createFallbackFormat(const PluralRules& rules,
-                                                  int index,
-                                                  FormatType format_type) {
-  const static UnicodeString kUnits[4][2] = {
+icu::PluralFormat* TimeFormatter::createFallbackFormat(
+    const icu::PluralRules& rules, int index, FormatType format_type) {
+  static const icu::UnicodeString kUnits[4][2] = {
     { UNICODE_STRING_SIMPLE("sec"), UNICODE_STRING_SIMPLE("secs") },
     { UNICODE_STRING_SIMPLE("min"), UNICODE_STRING_SIMPLE("mins") },
     { UNICODE_STRING_SIMPLE("hour"), UNICODE_STRING_SIMPLE("hours") },
     { UNICODE_STRING_SIMPLE("day"), UNICODE_STRING_SIMPLE("days") }
   };
-  UnicodeString suffix(GetFallbackFormatSuffix(format_type), -1, US_INV);
-  UnicodeString pattern;
+  icu::UnicodeString suffix(GetFallbackFormatSuffix(format_type), -1, US_INV);
+  icu::UnicodeString pattern;
   if (rules.isKeyword(UNICODE_STRING_SIMPLE("one"))) {
     pattern += UNICODE_STRING_SIMPLE("one{# ") + kUnits[index][0] + suffix;
   }
   pattern += UNICODE_STRING_SIMPLE(" other{# ") + kUnits[index][1] + suffix;
   UErrorCode err = U_ZERO_ERROR;
-  PluralFormat* format = new PluralFormat(rules, pattern, err);
+  icu::PluralFormat* format = new icu::PluralFormat(rules, pattern, err);
   DCHECK(U_SUCCESS(err));
   return format;
 }
 
 Singleton<TimeFormatter> time_formatter;
 
 static std::wstring FormatTimeImpl(const TimeDelta& delta,
                                    FormatType format_type) {
   if (delta.ToInternalValue() < 0) {
     NOTREACHED() << "Negative duration";
     return std::wstring();
   }
 
   int number;
 
-  const std::vector<PluralFormat*>& formatters =
+  const std::vector<icu::PluralFormat*>& formatters =
     time_formatter->formatter(format_type);
 
   UErrorCode error = U_ZERO_ERROR;
-  UnicodeString time_string;
+  icu::UnicodeString time_string;
   // Less than a minute gets "X seconds left"
   if (delta.ToInternalValue() < Time::kMicrosecondsPerMinute) {
     number = static_cast<int>(delta.ToInternalValue() /
                               Time::kMicrosecondsPerSecond);
     time_string = formatters[0]->format(number, error);
 
   // Less than 1 hour gets "X minutes left".
   } else if (delta.ToInternalValue() < Time::kMicrosecondsPerHour) {
     number = static_cast<int>(delta.ToInternalValue() /
                               Time::kMicrosecondsPerMinute);
@@ skipping 47 matching lines @@
 
   // Filter out "today" and "yesterday"
   if (time >= midnight_today)
     return l10n_util::GetString(IDS_PAST_TIME_TODAY);
   else if (time >= midnight_today -
                    TimeDelta::FromMicroseconds(Time::kMicrosecondsPerDay))
     return l10n_util::GetString(IDS_PAST_TIME_YESTERDAY);
 
   return std::wstring();
 }