i18n of Zoom % to use locally correct numeric glyphs

base/i18n/number_formatting.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 "base/i18n/number_formatting.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/icu/source/common/unicode/ustring.h"
 #include "third_party/icu/source/i18n/unicode/numfmt.h"
 
 namespace base {
 
 namespace {
 
 // A simple wrapper around icu::NumberFormat that allows for resetting it
 // (as LazyInstance does not).
-struct NumberFormatWrapper {
-  NumberFormatWrapper() {
-    Reset();
-  }
-
-  void Reset() {
+struct FormatWrapper {
+  void Reset(UNumberFormatStyle kind) {
     // There's no ICU call to destroy a NumberFormat object other than
     // operator delete, so use the default Delete, which calls operator delete.
     // This can cause problems if a different allocator is used by this file
     // than by ICU.
     UErrorCode status = U_ZERO_ERROR;
-    number_format.reset(icu::NumberFormat::createInstance(status));
+    number_format.reset(icu::NumberFormat::createInstance(
+        icu::Locale::getDefault(), kind, status));
     DCHECK(U_SUCCESS(status));
   }
 
   std::unique_ptr<icu::NumberFormat> number_format;
 };
 
+struct NumberFormatWrapper : FormatWrapper {
+  NumberFormatWrapper() { Reset(UNUM_DECIMAL); }
+};
+
+struct PercentFormatWrapper : FormatWrapper {
+  PercentFormatWrapper() { Reset(UNUM_PERCENT); }
+};
+
 LazyInstance<NumberFormatWrapper> g_number_format_int =
     LAZY_INSTANCE_INITIALIZER;
 LazyInstance<NumberFormatWrapper> g_number_format_float =
     LAZY_INSTANCE_INITIALIZER;
+LazyInstance<PercentFormatWrapper> g_number_format_percent =
+    LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 string16 FormatNumber(int64_t number) {
   icu::NumberFormat* number_format =
       g_number_format_int.Get().number_format.get();
 
   if (!number_format) {
     // As a fallback, just return the raw number in a string.
     return UTF8ToUTF16(StringPrintf("%" PRId64, number));
@@ skipping 13 matching lines @@
     return UTF8ToUTF16(StringPrintf("%f", number));
   }
   number_format->setMaximumFractionDigits(fractional_digits);
   number_format->setMinimumFractionDigits(fractional_digits);
   icu::UnicodeString ustr;
   number_format->format(number, ustr);
 
   return string16(ustr.getBuffer(), static_cast<size_t>(ustr.length()));
 }
 
+string16 FormatPercent(int number) {
+  return FormatPercentFromDouble(static_cast<double>(number) / 100.0, 0);

[Greg Levin, 2016/05/17 18:17:44]

I don't totally understand why the NumberFormat objects are being cached, and
separately.  Is it okay that I have FormatPercent() and
FormatPercentFromDouble() using the same cached formatter?  I'm not sure that
any code will need to access FormatPercentFromDouble() externally, but since I
had to do the int->double conversion anyway, I thought I'd make it available.

[jungshik at Google, 2016/05/17 23:58:42]

Well, none of percent format used in our UI has fractional percent (e.g. 35.7%),
 I don't see a need for FormatPercent helper. 

You can just use MessageFormatter, can't you (as I suggested and you did in the
other CL)? 

Zoom level: {0,number,percent} 

will do the job. 

If you want, you can just add a wrapper over that to ui/base/l10n/l10n_util.cc
(to simplify the call site). See
GetSingleOrMultipleStringUTF16. 

[Greg Levin, 2016/05/18 21:33:44]

Sure.  This function can just be

return i18n::MessageFormatter::FormatWithNumberedArgs(
    ASCIIToUTF16("{0,number,percent}"), static_cast<double>(number) / 100.0);

(I was planning on going back and using FormatPercent() in the battery code.)
Couldn't FormatNumber() do something similar?  As I said, I don't know why the
other functions in this file are using this complex caching mechanism.  Since
FormatPercent() seems like nearly the same thing, I started by copying them. 
Would FormatPercent() make more sense in l10n_util.cc?  If I go with the
MessageFormatter version, it's structurally more similar to those functions, but
API-wise, it seems more like FormatNumber() (for instance, it doesn't have a
message_id arg).
See reply to subsequent CL comment.

+}
+
+string16 FormatPercentFromDouble(double number, int fractional_digits) {
+  icu::NumberFormat* percent_format =
+      g_number_format_percent.Get().number_format.get();
+
+  if (!percent_format) {
+    // As a fallback, just return the default percent formatting in a string.
+    return UTF8ToUTF16(
+        StringPrintf("%.*f%%", fractional_digits, number * 100.0));
+  }
+  percent_format->setMaximumFractionDigits(fractional_digits);
+  percent_format->setMinimumFractionDigits(fractional_digits);
+  icu::UnicodeString ustr;
+  percent_format->format(number, ustr);
+
+  return string16(ustr.getBuffer(), static_cast<size_t>(ustr.length()));
+}
+
 namespace testing {
 
 void ResetFormatters() {
-  g_number_format_int.Get().Reset();
-  g_number_format_float.Get().Reset();
+  g_number_format_int.Get().Reset(UNUM_DECIMAL);
+  g_number_format_float.Get().Reset(UNUM_DECIMAL);
+  g_number_format_percent.Get().Reset(UNUM_PERCENT);
 }
 
 }  // namespace testing
 
 }  // namespace base