Use Android API for GetDisplayNameForLocale().

chrome/browser/autofill/autofill_country.cc

 // Copyright (c) 2011 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/browser/autofill/autofill_country.h"
 
 #include <map>
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 372 matching lines @@
 
   // Returns an ICU collator -- i.e. string comparator -- appropriate for the
   // given |locale|.
   icu::Collator* GetCollatorForLocale(const std::string& locale);
 
   // Returns the ICU sort key corresponding to |str| for the given |collator|.
   // Uses |buffer| as temporary storage, and might resize |buffer| as a side-
   // effect. |buffer_size| should specify the |buffer|'s size, and is updated if
   // the |buffer| is resized.
   const std::string GetSortKey(const icu::Collator& collator,
-                               const icu::UnicodeString& str,
+                               const string16& str,
                                scoped_array<uint8_t>* buffer,
                                int32_t* buffer_size) const;
 
 
   // Maps from common country names, including 2- and 3-letter country codes,
   // to the corresponding 2-letter country codes. The keys are uppercase ASCII
   // strings.
   std::map<std::string, std::string> common_names_;
 
   // The outer map keys are ICU locale identifiers.
@@ skipping 72 matching lines @@
 }
 
 void CountryNames::AddLocalizedNamesForLocale(const std::string& locale) {
   // Nothing to do if we've previously added the localized names for the given
   // |locale|.
   if (locales_to_localized_names_.count(locale))
     return;
 
   std::map<std::string, std::string> localized_names;
 
   icu::Locale icu_locale(locale.c_str());

[Ilya Sherman, 2012/04/25 20:10:36]

nit: This seems to no longer be used.

[Xianzhu, 2012/04/25 22:31:46]

Done.

   const icu::Collator* collator = GetCollatorForLocale(locale);
 
   int32_t buffer_size = 1000;
   scoped_array<uint8_t> buffer(new uint8_t[buffer_size]);
 
   for (CountryDataMap::Iterator it = CountryDataMap::Begin();
        it != CountryDataMap::End();
        ++it) {
     const std::string& country_code = it->first;
-
-    icu::Locale country_locale(NULL, country_code.c_str());
-    icu::UnicodeString country_name;
-    country_locale.getDisplayName(icu_locale, country_name);
+    string16 country_name = l10n_util::GetDisplayNameForCountry(country_code,
+                                                                locale, false);

[Ilya Sherman, 2012/04/25 20:10:36]

nit: I don't fully follow the significance of the last parameter, but the
localized country names are indeed used in the UI -- though I don't think
there's ever any other text adjacent to them.  So, I'm not sure what the value
of this last param ought to be; wanted to make sure you'd considered it and
chosen appropriately, rather than just defaulting to |false|.

[Xianzhu, 2012/04/25 22:31:46]

I'm also not sure about this. I included the parameter in the function to match
the original l10n_util::GetDisplayNameForLocale(), and use |false| here to the
changed code equivalent to the original code.

The is_for_ui parameter of GetDisplayNameForLocale has been there since the
first public commit of l10n_util.h. I doubt if it is still useful now. I'll ask
related people about it. 

[Xianzhu, 2012/04/25 22:49:27]

Just noticed that the is_for_ui parameter of the original
GetDisplayNameForLocale() is for correct RTL placing of parenthesis. As we don't
have parenthesis in country display names, I removed the parameter in Patch Set
3.

     std::string sort_key = GetSortKey(*collator,
                                       country_name,
                                       &buffer,
                                       &buffer_size);
 
     localized_names.insert(std::make_pair(sort_key, country_code));
   }
 
   locales_to_localized_names_.insert(std::make_pair(locale, localized_names));
 }
 
 const std::string CountryNames::GetCountryCodeForLocalizedName(
     const string16& country_name,
     const std::string& locale) {
   AddLocalizedNamesForLocale(locale);
 
   icu::Collator* collator = GetCollatorForLocale(locale);
 
   // As recommended[1] by ICU, initialize the buffer size to four times the
   // source string length.
   // [1] http://userguide.icu-project.org/collation/api#TOC-Examples
   int32_t buffer_size = country_name.size() * 4;
   scoped_array<uint8_t> buffer(new uint8_t[buffer_size]);
   std::string sort_key = GetSortKey(*collator,
-                                    country_name.c_str(),
+                                    country_name,
                                     &buffer,
                                     &buffer_size);
 
   const std::map<std::string, std::string>& localized_names =
       locales_to_localized_names_[locale];
   std::map<std::string, std::string>::const_iterator result =
       localized_names.find(sort_key);
 
   if (result != localized_names.end())
     return result->second;
@@ skipping 13 matching lines @@
     ignored = U_ZERO_ERROR;
     collator->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, ignored);
 
     collators_.insert(std::make_pair(locale, collator));
   }
 
   return collators_[locale];
 }
 
 const std::string CountryNames::GetSortKey(const icu::Collator& collator,
-                                           const icu::UnicodeString& str,
+                                           const string16& str,
                                            scoped_array<uint8_t>* buffer,
                                            int32_t* buffer_size) const {
   DCHECK(buffer);
   DCHECK(buffer_size);
 
-  int32_t expected_size = collator.getSortKey(str, buffer->get(), *buffer_size);
+  icu::UnicodeString icu_str(str.c_str(), str.length());
+  int32_t expected_size = collator.getSortKey(icu_str, buffer->get(),
+                                              *buffer_size);
   if (expected_size > *buffer_size) {
     // If there wasn't enough space, grow the buffer and try again.
     *buffer_size = expected_size;
     buffer->reset(new uint8_t[*buffer_size]);
     DCHECK(buffer->get());
 
-    expected_size = collator.getSortKey(str, buffer->get(), *buffer_size);
+    expected_size = collator.getSortKey(icu_str, buffer->get(), *buffer_size);
     DCHECK_EQ(*buffer_size, expected_size);
   }
 
   return std::string(reinterpret_cast<const char*>(buffer->get()));
 }
 
-// Returns the country name corresponding to |country_code|, localized to the
-// |display_locale|.
-string16 GetDisplayName(const std::string& country_code,
-                        const icu::Locale& display_locale) {
-  icu::Locale country_locale(NULL, country_code.c_str());
-  icu::UnicodeString name;
-  country_locale.getDisplayName(display_locale, name);
-
-  DCHECK_GT(name.length(), 0);
-  return string16(name.getBuffer(), name.length());
-}
-
 }  // namespace
 
 AutofillCountry::AutofillCountry(const std::string& country_code,
                                  const std::string& locale) {
   const CountryDataMap::Iterator result = CountryDataMap::Find(country_code);
   DCHECK(result != CountryDataMap::End());
   const CountryData& data = result->second;
 
   country_code_ = country_code;
-  name_ = GetDisplayName(country_code, icu::Locale(locale.c_str()));
+  name_ = l10n_util::GetDisplayNameForCountry(country_code, locale, false);
   postal_code_label_ = l10n_util::GetStringUTF16(data.postal_code_label_id);
   state_label_ = l10n_util::GetStringUTF16(data.state_label_id);
 }
 
 AutofillCountry::~AutofillCountry() {
 }
 
 // static
 void AutofillCountry::GetAvailableCountries(
     std::vector<std::string>* country_codes) {
@@ skipping 41 matching lines @@
 
 AutofillCountry::AutofillCountry(const std::string& country_code,
                                  const string16& name,
                                  const string16& postal_code_label,
                                  const string16& state_label)
     : country_code_(country_code),
       name_(name),
       postal_code_label_(postal_code_label),
       state_label_(state_label) {
 }