ICU msg format support with more than one arguments

ui/base/l10n/formatter.cc

 // Copyright 2014 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/base/l10n/formatter.h"
 
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "third_party/icu/source/common/unicode/unistr.h"
 #include "third_party/icu/source/i18n/unicode/msgfmt.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/l10n/l10n_util_plurals.h"
 #include "ui/strings/grit/ui_strings.h"
 
 namespace ui {
 
 UI_BASE_EXPORT bool formatter_force_fallback = false;
 
 struct Pluralities {
   int id;
   const char* const fallback_one;
   const char* const fallback_other;
@@ skipping 108 matching lines @@
   IDS_TIME_DAYS_1ST,
   "one{# day and }",
   " other{# days and }"
 };
 static const Pluralities IDS_DURATION_HOUR_2ND = {
   IDS_TIME_HOURS_2ND,
   "one{# hour}",
   " other{# hours}"
 };
 
+namespace {
+
+scoped_ptr<icu::PluralRules> BuildPluralRules() {
+  UErrorCode err = U_ZERO_ERROR;
+  scoped_ptr<icu::PluralRules> rules(
+      icu::PluralRules::forLocale(icu::Locale::getDefault(), err));
+  if (U_FAILURE(err)) {
+    err = U_ZERO_ERROR;
+    icu::UnicodeString fallback_rules("one: n is 1", -1, US_INV);
+    rules.reset(icu::PluralRules::createRules(fallback_rules, err));
+    DCHECK(U_SUCCESS(err));
+  }
+  return rules.Pass();
+}
+
+void FormatNumberInPlural(const icu::MessageFormat& format, int number,
+                          icu::UnicodeString* result, UErrorCode* err) {
+  if (U_FAILURE(*err)) return;
+  icu::Formattable formattable(number);
+  icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
+  format.format(&formattable, 1, *result, ignore, *err);
+  DCHECK(U_SUCCESS(*err));
+  return;
+}
+
+}  // namespace
+
 Formatter::Formatter(const Pluralities& sec_pluralities,
                      const Pluralities& min_pluralities,
                      const Pluralities& hour_pluralities,
                      const Pluralities& day_pluralities) {
   simple_format_[UNIT_SEC] = InitFormat(sec_pluralities);
   simple_format_[UNIT_MIN] = InitFormat(min_pluralities);
   simple_format_[UNIT_HOUR] = InitFormat(hour_pluralities);
   simple_format_[UNIT_DAY] = InitFormat(day_pluralities);
 }
 
@@ skipping 18 matching lines @@
   detailed_format_[TWO_UNITS_DAY_HOUR][0] = InitFormat(day_hour_pluralities1);
   detailed_format_[TWO_UNITS_DAY_HOUR][1] = InitFormat(day_hour_pluralities2);
 }
 
 void Formatter::Format(Unit unit,
                        int value,
                        icu::UnicodeString* formatted_string) const {
   DCHECK(simple_format_[unit]);
   DCHECK(formatted_string->isEmpty() == TRUE);
   UErrorCode error = U_ZERO_ERROR;
-  l10n_util::FormatNumberInPlural(*simple_format_[unit],
-                                  value, formatted_string, &error);
+  FormatNumberInPlural(*simple_format_[unit],
+                        value, formatted_string, &error);
   DCHECK(U_SUCCESS(error)) << "Error in icu::PluralFormat::format().";
   return;
 }
 
 void Formatter::Format(TwoUnits units,
                        int value_1,
                        int value_2,
                        icu::UnicodeString* formatted_string) const {
   DCHECK(detailed_format_[units][0])
       << "Detailed() not implemented for your (format, length) combination!";
   DCHECK(detailed_format_[units][1])
       << "Detailed() not implemented for your (format, length) combination!";
   DCHECK(formatted_string->isEmpty() == TRUE);
   UErrorCode error = U_ZERO_ERROR;
-  l10n_util::FormatNumberInPlural(*detailed_format_[units][0], value_1,
-                                  formatted_string, &error);
+  FormatNumberInPlural(*detailed_format_[units][0], value_1,
+                       formatted_string, &error);
   DCHECK(U_SUCCESS(error));
-  l10n_util::FormatNumberInPlural(*detailed_format_[units][1], value_2,
-                                  formatted_string, &error);
+  FormatNumberInPlural(*detailed_format_[units][1], value_2,
+                        formatted_string, &error);
   DCHECK(U_SUCCESS(error));
   return;
 }
 
 scoped_ptr<icu::MessageFormat> Formatter::CreateFallbackFormat(
     const icu::PluralRules& rules,
     const Pluralities& pluralities) const {
   icu::UnicodeString pattern("{NUMBER, plural, ");
   if (rules.isKeyword(UNICODE_STRING_SIMPLE("one")))
     pattern += icu::UnicodeString(pluralities.fallback_one);
@@ skipping 12 matching lines @@
   if (!formatter_force_fallback) {
     base::string16 pattern = l10n_util::GetStringUTF16(pluralities.id);
     UErrorCode error = U_ZERO_ERROR;
     scoped_ptr<icu::MessageFormat> format(new icu::MessageFormat(
         icu::UnicodeString(FALSE, pattern.data(), pattern.length()), error));
     DCHECK(U_SUCCESS(error));
     if (format.get())
       return format.Pass();
   }
 
-  scoped_ptr<icu::PluralRules> rules(l10n_util::BuildPluralRules());
+  scoped_ptr<icu::PluralRules> rules(BuildPluralRules());
   return CreateFallbackFormat(*rules, pluralities);
 }
 
 const Formatter* FormatterContainer::Get(TimeFormat::Format format,
                                          TimeFormat::Length length) const {
   DCHECK(formatter_[format][length])
       << "Combination of FORMAT_ELAPSED and LENGTH_LONG is not implemented!";
   return formatter_[format][length].get();
 }
 
@@ skipping 41 matching lines @@
 
 void FormatterContainer::Shutdown() {
   for (int format = 0; format < TimeFormat::FORMAT_COUNT; ++format) {
     for (int length = 0; length < TimeFormat::LENGTH_COUNT; ++length) {
       formatter_[format][length].reset();
     }
   }
 }
 
 }  // namespace ui