Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/webui/options/autofill_options_handler.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 "chrome/browser/ui/webui/options/autofill_options_handler.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 50 matching lines @@
 static const char kDependentLocalityField[] = "dependentLocality";
 static const char kCityField[] = "city";
 static const char kStateField[] = "state";
 static const char kPostalCodeField[] = "postalCode";
 static const char kSortingCodeField[] = "sortingCode";
 static const char kCountryField[] = "country";
 
 static const char kComponents[] = "components";
 static const char kLanguageCode[] = "languageCode";
 
-scoped_ptr<base::DictionaryValue> CreditCardToDictionary(
+std::unique_ptr<base::DictionaryValue> CreditCardToDictionary(
     const CreditCard& card) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("guid", card.guid());
   std::pair<base::string16, base::string16> label_pieces = card.LabelPieces();
   value->SetString("label", label_pieces.first);
   value->SetString("sublabel", label_pieces.second);
   value->SetBoolean("isLocal", card.record_type() == CreditCard::LOCAL_CARD);
   value->SetBoolean("isCached",
                     card.record_type() == CreditCard::FULL_SERVER_CARD);
   return value;
 }
 
@@ skipping 33 matching lines @@
   static const char kField[] = "field";
   static const char kLength[] = "length";
   for (size_t i = 0; i < components.size(); ++i) {
     if (i == 0 ||
         components[i - 1].length_hint == AddressUiComponent::HINT_LONG ||
         components[i].length_hint == AddressUiComponent::HINT_LONG) {
       line = new base::ListValue;
       address_components->Append(line);
     }
 
-    scoped_ptr<base::DictionaryValue> component(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> component(new base::DictionaryValue);
     component->SetString("name", components[i].name);
 
     switch (components[i].field) {
       case i18n::addressinput::COUNTRY:
         component->SetString(kField, kCountryField);
         break;
       case i18n::addressinput::ADMIN_AREA:
         component->SetString(kField, kStateField);
         break;
       case i18n::addressinput::LOCALITY:
@@ skipping 35 matching lines @@
 // Sets data related to the country <select>.
 void SetCountryData(const PersonalDataManager& manager,
                     base::DictionaryValue* localized_strings) {
   autofill::CountryComboboxModel model;
   model.SetCountries(manager, base::Callback<bool(const std::string&)>());
   const std::vector<AutofillCountry*>& countries = model.countries();
   localized_strings->SetString("defaultCountryCode",
                                countries.front()->country_code());
 
   // An ordered list of options to show in the <select>.
-  scoped_ptr<base::ListValue> country_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> country_list(new base::ListValue());
   for (size_t i = 0; i < countries.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> option_details(
+    std::unique_ptr<base::DictionaryValue> option_details(
         new base::DictionaryValue());
     option_details->SetString("name", model.GetItemAt(i));
     option_details->SetString(
         "value",
         countries[i] ? countries[i]->country_code() : "separator");
     country_list->Append(option_details.release());
   }
   localized_strings->Set("autofillCountrySelectList", country_list.release());
 
-  scoped_ptr<base::ListValue> default_country_components(new base::ListValue);
+  std::unique_ptr<base::ListValue> default_country_components(
+      new base::ListValue);
   std::string default_country_language_code;
   GetAddressComponents(countries.front()->country_code(),
                        g_browser_process->GetApplicationLocale(),
                        default_country_components.get(),
                        &default_country_language_code);
   localized_strings->Set("autofillDefaultCountryComponents",
                          default_country_components.release());
   localized_strings->SetString("autofillDefaultCountryLanguageCode",
                                default_country_language_code);
 }
@@ skipping 139 matching lines @@
   for (size_t i = 0; i < profiles.size(); ++i) {
     // Skip showing auxiliary profiles (e.g. Mac Contacts) for now.
     if (profiles[i]->record_type() == AutofillProfile::AUXILIARY_PROFILE)
       continue;
 
     base::string16 separator =
         l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR);
     std::vector<base::string16> label_parts;
     base::SplitStringUsingSubstr(labels[i], separator, &label_parts);
 
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
     value->SetString("guid", profiles[i]->guid());
     value->SetString("label", label_parts[0]);
     value->SetString("sublabel", labels[i].substr(label_parts[0].size()));
     value->SetBoolean("isLocal", profiles[i]->record_type() ==
                                      AutofillProfile::LOCAL_PROFILE);
     addresses.Append(value.release());
   }
 
   web_ui()->CallJavascriptFunction("AutofillOptions.setAddressList", addresses);
 
@@ skipping 46 matching lines @@
 
 void AutofillOptionsHandler::LoadAddressEditorComponents(
     const base::ListValue* args) {
   std::string country_code;
   if (!args->GetString(0, &country_code)) {
     NOTREACHED();
     return;
   }
 
   base::DictionaryValue input;
-  scoped_ptr<base::ListValue> components(new base::ListValue);
+  std::unique_ptr<base::ListValue> components(new base::ListValue);
   std::string language_code;
   GetAddressComponents(country_code, g_browser_process->GetApplicationLocale(),
                        components.get(), &language_code);
   input.Set(kComponents, components.release());
   input.SetString(kLanguageCode, language_code);
 
   web_ui()->CallJavascriptFunction(
       "AutofillEditAddressOverlay.loadAddressComponents", input);
 }
 
@@ skipping 165 matching lines @@
                      profile.GetRawInfo(autofill::ADDRESS_HOME_SORTING_CODE));
   address->SetString(kPostalCodeField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_ZIP));
   address->SetString(kCountryField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY));
   address->SetString("phone",
                      profile.GetRawInfo(autofill::PHONE_HOME_WHOLE_NUMBER));
   address->SetString("email", profile.GetRawInfo(autofill::EMAIL_ADDRESS));
   address->SetString(kLanguageCode, profile.language_code());
 
-  scoped_ptr<base::ListValue> components(new base::ListValue);
+  std::unique_ptr<base::ListValue> components(new base::ListValue);
   GetAddressComponents(
       base::UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY)),
       profile.language_code(),
       components.get(),
       NULL);
   address->Set(kComponents, components.release());
 }
 
 }  // namespace options