Autofill's CountryCode should use scoped_ptr for owned pointers

components/autofill/core/browser/autofill_country.cc

 // Copyright 2013 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 "components/autofill/core/browser/autofill_country.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <utility>
@@ skipping 853 matching lines @@
 
   // Interprets |country_name| as a full country name localized to the given
   // |locale| and returns the corresponding country code stored in
   // |locales_to_localized_names_|, or an empty string if there is none.
   const std::string GetCountryCodeForLocalizedName(
       const base::string16& country_name,
       const std::string& locale);
 
   // Returns an ICU collator -- i.e. string comparator -- appropriate for the
   // given |locale|, or null if no collator is available.
-  icu::Collator* GetCollatorForLocale(const std::string& locale);
+  const 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 base::string16& str,
                                scoped_ptr<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.
   // The inner maps map from localized country names to their corresponding
   // country codes. The inner map keys are ICU collation sort keys corresponding
   // to the target localized country name.
   std::map<std::string, std::map<std::string, std::string> >
       locales_to_localized_names_;
 
   // Maps ICU locale names to their corresponding collators.
-  std::map<std::string, icu::Collator*> collators_;
+  std::map<std::string, scoped_ptr<icu::Collator>> collators_;
 
   DISALLOW_COPY_AND_ASSIGN(CountryNames);
 };
 
 // static
 CountryNames* CountryNames::GetInstance() {
   return base::Singleton<CountryNames>::get();
 }
 
 CountryNames::CountryNames() {
@@ skipping 14 matching lines @@
 
   // Add a few other common synonyms.
   common_names_.insert(std::make_pair("UNITED STATES OF AMERICA", "US"));
   common_names_.insert(std::make_pair("U.S.A.", "US"));
   common_names_.insert(std::make_pair("GREAT BRITAIN", "GB"));
   common_names_.insert(std::make_pair("UK", "GB"));
   common_names_.insert(std::make_pair("BRASIL", "BR"));
   common_names_.insert(std::make_pair("DEUTSCHLAND", "DE"));
 }
 
-CountryNames::~CountryNames() {
-  STLDeleteContainerPairSecondPointers(collators_.begin(),
-                                       collators_.end());
-}
+CountryNames::~CountryNames() {}
 
 const std::string CountryNames::GetCountryCode(const base::string16& country,
                                                const std::string& locale) {
   // First, check common country names, including 2- and 3-letter country codes.
   std::string country_utf8 = base::UTF16ToUTF8(base::ToUpperASCII(country));
   const auto result = common_names_.find(country_utf8);
   if (result != common_names_.end())
     return result->second;
 
   // Next, check country names localized to |locale|.
@@ skipping 31 matching lines @@
   }
 
   locales_to_localized_names_.insert(std::make_pair(locale, localized_names));
 }
 
 const std::string CountryNames::GetCountryCodeForLocalizedName(
     const base::string16& country_name,
     const std::string& locale) {
   AddLocalizedNamesForLocale(locale);
 
-  icu::Collator* collator = GetCollatorForLocale(locale);
+  const icu::Collator* collator = GetCollatorForLocale(locale);
   // In very rare cases, the collator fails to initialize.
   if (!collator)
     return std::string();
 
   // 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_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   std::string sort_key = GetSortKey(*collator,
                                     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;
 
   return std::string();
 }
 
-icu::Collator* CountryNames::GetCollatorForLocale(const std::string& locale) {
-  if (!collators_.count(locale)) {
-    icu::Collator* collator(
+const icu::Collator* CountryNames::GetCollatorForLocale(
+    const std::string& locale) {
+  if (!ContainsKey(collators_, locale)) {
+    scoped_ptr<icu::Collator> collator(
         autofill::l10n::GetCollatorForLocale(icu::Locale(locale.c_str())));
     if (!collator)
       return nullptr;
 
     // Compare case-insensitively and ignoring punctuation.
     UErrorCode ignored = U_ZERO_ERROR;
     collator->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, ignored);
     ignored = U_ZERO_ERROR;
     collator->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, ignored);
 
-    collators_.insert(std::make_pair(locale, collator));
+    collators_[locale] = std::move(collator);
   }
 
-  return collators_[locale];
+  return collators_[locale].get();
 }
 
 const std::string CountryNames::GetSortKey(const icu::Collator& collator,
                                            const base::string16& str,
                                            scoped_ptr<uint8_t[]>* buffer,
                                            int32_t* buffer_size) const {
   DCHECK(buffer);
   DCHECK(buffer_size);
 
   icu::UnicodeString icu_str(str.c_str(), str.length());
@@ skipping 74 matching lines @@
                                  const base::string16& name,
                                  const base::string16& postal_code_label,
                                  const base::string16& state_label)
     : country_code_(country_code),
       name_(name),
       postal_code_label_(postal_code_label),
       state_label_(state_label) {
 }
 
 }  // namespace autofill