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

chrome/browser/ui/autofill/autofill_dialog_controller_impl.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 "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 512 matching lines @@
       base::Bind(NullGetInfo), std::string(),
       g_browser_process->GetApplicationLocale());
 
   transaction_amount_ = form_structure_.GetUniqueValue(
       HTML_TYPE_TRANSACTION_AMOUNT);
   transaction_currency_ = form_structure_.GetUniqueValue(
       HTML_TYPE_TRANSACTION_CURRENCY);
   acceptable_cc_types_ = form_structure_.PossibleValues(CREDIT_CARD_TYPE);
 
   validator_.reset(new AddressValidator(
-      scoped_ptr< ::i18n::addressinput::Source>(
+      std::unique_ptr<::i18n::addressinput::Source>(
           new autofill::ChromeMetadataSource(I18N_ADDRESS_VALIDATION_DATA_URL,
                                              profile_->GetRequestContext())),
-      ValidationRulesStorageFactory::CreateStorage(),
-      this));
+      ValidationRulesStorageFactory::CreateStorage(), this));
 
   SuggestionsUpdated();
   SubmitButtonDelayBegin();
   view_.reset(CreateView());
   view_->Show();
   GetManager()->AddObserver(this);
 
   LogDialogLatencyToShow();
 }
 
@@ skipping 81 matching lines @@
       GetValidator()->LoadRules(
           CountryNames::GetInstance()->GetCountryCode(it->initial_value));
     }
   }
 }
 
 void AutofillDialogControllerImpl::ShowEditUiIfBadSuggestion(
     DialogSection section) {
   // |CreateWrapper()| returns an empty wrapper if |IsEditingExistingData()|, so
   // get the wrapper before this potentially happens below.
-  scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
 
   // If the chosen item in |model| yields an empty suggestion text, it is
   // invalid. In this case, show the edit UI and highlight invalid fields.
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   base::string16 unused, unused2;
   if (IsASuggestionItemKey(model->GetItemKeyForCheckedItem()) &&
       !SuggestionTextForSection(section, &unused, &unused2)) {
     SetEditingExistingData(section, true);
   }
 
@@ skipping 192 matching lines @@
   if (!IsASuggestionItemKey(item_key))
     return false;
 
   if (section == SECTION_BILLING || section == SECTION_SHIPPING) {
     // Also check if the address is invalid (rules may have loaded since
     // the dialog was shown).
     if (HasInvalidAddress(*GetManager()->GetProfileByGUID(item_key)))
       return false;
   }
 
-  scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   return wrapper->GetDisplayText(vertically_compact, horizontally_compact);
 }
 
 base::string16 AutofillDialogControllerImpl::ExtraSuggestionTextForSection(
     DialogSection section) const {
   if (section == SECTION_CC)
     return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC);
 
   return base::string16();
 }
 
-scoped_ptr<DataModelWrapper> AutofillDialogControllerImpl::CreateWrapper(
+std::unique_ptr<DataModelWrapper> AutofillDialogControllerImpl::CreateWrapper(
     DialogSection section) {
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   std::string item_key = model->GetItemKeyForCheckedItem();
   if (!IsASuggestionItemKey(item_key) || IsManuallyEditingSection(section))
-    return scoped_ptr<DataModelWrapper>();
+    return std::unique_ptr<DataModelWrapper>();
 
   if (section == SECTION_CC) {
     CreditCard* card = GetManager()->GetCreditCardByGUID(item_key);
     DCHECK(card);
-    return scoped_ptr<DataModelWrapper>(new AutofillCreditCardWrapper(card));
+    return std::unique_ptr<DataModelWrapper>(
+        new AutofillCreditCardWrapper(card));
   }
 
   AutofillProfile* profile = GetManager()->GetProfileByGUID(item_key);
   DCHECK(profile);
   if (section == SECTION_SHIPPING) {
-    return scoped_ptr<DataModelWrapper>(
+    return std::unique_ptr<DataModelWrapper>(
         new AutofillShippingAddressWrapper(profile));
   }
   DCHECK_EQ(SECTION_BILLING, section);
-  return scoped_ptr<DataModelWrapper>(
-      new AutofillProfileWrapper(profile));
+  return std::unique_ptr<DataModelWrapper>(new AutofillProfileWrapper(profile));
 }
 
 gfx::Image AutofillDialogControllerImpl::SuggestionIconForSection(
     DialogSection section) {
-  scoped_ptr<DataModelWrapper> model = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> model = CreateWrapper(section);
   if (!model.get())
     return gfx::Image();
 
   return model->GetIcon();
 }
 
 gfx::Image AutofillDialogControllerImpl::ExtraSuggestionIconForSection(
     DialogSection section) {
   if (section != SECTION_CC)
     return gfx::Image();
 
-  scoped_ptr<DataModelWrapper> model = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> model = CreateWrapper(section);
   if (!model.get())
     return gfx::Image();
 
   return CvcIconForCreditCardType(
       model->GetInfo(AutofillType(CREDIT_CARD_TYPE)));
 }
 
 FieldIconMap AutofillDialogControllerImpl::IconsForFields(
     const FieldValueMap& user_inputs) const {
   FieldIconMap result;
@@ skipping 103 matching lines @@
     DialogSection section,
     const FieldValueMap& inputs) {
   ValidityMessages messages;
   if (inputs.empty())
     return messages;
 
   AddressValidator::Status status = AddressValidator::SUCCESS;
   if (section != SECTION_CC) {
     AutofillProfile profile;
     FillFormGroupFromOutputs(inputs, &profile);
-    scoped_ptr<AddressData> address_data =
+    std::unique_ptr<AddressData> address_data =
         i18n::CreateAddressDataFromAutofillProfile(
             profile, g_browser_process->GetApplicationLocale());
     address_data->language_code = AddressLanguageCodeForSection(section);
 
     Localization localization;
     localization.SetGetter(l10n_util::GetStringUTF8);
     FieldProblemMap problems;
     status = GetValidator()->ValidateAddress(*address_data, NULL, &problems);
     bool billing = section != SECTION_SHIPPING;
 
@@ skipping 257 matching lines @@
 void AutofillDialogControllerImpl::DidAcceptSuggestion(
     const base::string16& value,
     int identifier,
     int position) {
   DCHECK_NE(UNKNOWN_TYPE, popup_input_type_);
   // Because |HidePopup()| can be called from |UpdateSection()|, remember the
   // type of the input for later here.
   const ServerFieldType popup_input_type = popup_input_type_;
 
   ScopedViewUpdates updates(view_.get());
-  scoped_ptr<DataModelWrapper> wrapper;
+  std::unique_ptr<DataModelWrapper> wrapper;
 
   if (static_cast<size_t>(identifier) < popup_suggestion_ids_.size()) {
     const std::string& guid = popup_suggestion_ids_[identifier];
     if (IsCreditCardType(popup_input_type)) {
       wrapper.reset(new AutofillCreditCardWrapper(
           GetManager()->GetCreditCardByGUID(guid)));
     } else {
       wrapper.reset(new AutofillProfileWrapper(
           GetManager()->GetProfileByGUID(guid)));
     }
@@ skipping 329 matching lines @@
     const FormStructure::InputFieldComparator& compare) {
   if (!SectionIsActive(section))
     return;
 
   DetailInputs inputs;
   std::string country_code = CountryCodeForSection(section);
   BuildInputsForSection(section, country_code, &inputs,
                         MutableAddressLanguageCodeForSection(section));
   std::vector<ServerFieldType> types = TypesFromInputs(inputs);
 
-  scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper) {
     // Only fill in data that is associated with this section.
     wrapper->FillFormStructure(types, compare, &form_structure_);
 
     // CVC needs special-casing because the CreditCard class doesn't store or
     // handle them. This isn't necessary when filling the combined CC and
     // billing section as CVC comes from |full_wallet_| in this case.
     if (section == SECTION_CC)
       SetOutputForFieldsOfType(CREDIT_CARD_VERIFICATION_CODE, view_->GetCvc());
 
@@ skipping 60 matching lines @@
     if (field->Type().GetStorableType() == type)
       field->value = output;
   }
 }
 
 base::string16 AutofillDialogControllerImpl::GetValueFromSection(
     DialogSection section,
     ServerFieldType type) {
   DCHECK(SectionIsActive(section));
 
-  scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper)
     return wrapper->GetInfo(AutofillType(type));
 
   FieldValueMap output;
   view_->GetUserInput(section, &output);
   return output[type];
 }
 
 bool AutofillDialogControllerImpl::CanAcceptCountry(
     DialogSection section,
@@ skipping 68 matching lines @@
   AddressField focused_field;
   if (!i18n::FieldForType(type, &focused_field))
     return;
 
   FieldValueMap inputs;
   view_->GetUserInput(section, &inputs);
 
   AutofillProfile profile;
   FillFormGroupFromOutputs(inputs, &profile);
 
-  scoped_ptr<AddressData> user_input =
+  std::unique_ptr<AddressData> user_input =
       i18n::CreateAddressDataFromAutofillProfile(
           profile, g_browser_process->GetApplicationLocale());
   user_input->language_code = AddressLanguageCodeForSection(section);
 
   static const size_t kSuggestionsLimit = 10;
   AddressValidator::Status status = GetValidator()->GetSuggestions(
       *user_input, focused_field, kSuggestionsLimit,
       &i18n_validator_suggestions_);
 
   if (status != AddressValidator::SUCCESS)
@@ skipping 46 matching lines @@
 
 std::vector<ServerFieldType> AutofillDialogControllerImpl::
     RequestedTypesForSection(DialogSection section) const {
   return TypesFromInputs(RequestedFieldsForSection(section));
 }
 
 std::string AutofillDialogControllerImpl::CountryCodeForSection(
     DialogSection section) {
   base::string16 country;
 
-  scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
+  std::unique_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper) {
     country = wrapper->GetInfo(AutofillType(CountryTypeForSection(section)));
   } else {
     FieldValueMap outputs;
     view_->GetUserInput(section, &outputs);
     country = outputs[CountryTypeForSection(section)];
   }
 
   return CountryNames::GetInstance()->GetCountryCode(country);
 }
@@ skipping 127 matching lines @@
   if (acceptable_cc_types_.find(base::i18n::ToUpper(type)) ==
           acceptable_cc_types_.end()) {
     return true;
   }
 
   return false;
 }
 
 bool AutofillDialogControllerImpl::HasInvalidAddress(
     const AutofillProfile& profile) {
-  scoped_ptr<AddressData> address_data =
+  std::unique_ptr<AddressData> address_data =
       i18n::CreateAddressDataFromAutofillProfile(
           profile, g_browser_process->GetApplicationLocale());
 
   FieldProblemMap problems;
   GetValidator()->ValidateAddress(*address_data, NULL, &problems);
   return !problems.empty();
 }
 
 bool AutofillDialogControllerImpl::ShouldUseBillingForShipping() {
   return SectionIsActive(SECTION_SHIPPING) &&
@@ skipping 81 matching lines @@
       ShowEditUiIfBadSuggestion(section);
       UpdateSection(section);
     }
   }
 }
 
 void AutofillDialogControllerImpl::PersistAutofillChoice(
     DialogSection section,
     const std::string& guid) {
   DCHECK(ShouldOfferToSaveInChrome());
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString(kGuidPrefKey, guid);
 
   DictionaryPrefUpdate updater(profile()->GetPrefs(),
                                ::prefs::kAutofillDialogAutofillDefault);
   base::DictionaryValue* autofill_choice = updater.Get();
   autofill_choice->Set(SectionToPrefString(section), value.release());
 }
 
 void AutofillDialogControllerImpl::GetDefaultAutofillChoice(
     DialogSection section,
@@ skipping 111 matching lines @@
 }
 
 void AutofillDialogControllerImpl::OnSubmitButtonDelayEnd() {
   if (!view_)
     return;
   ScopedViewUpdates updates(view_.get());
   view_->UpdateButtonStrip();
 }
 
 }  // namespace autofill