components/autofill: scoped_ptr -> unique_ptr

components/autofill/core/browser/autofill_profile.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_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>

[Mathieu, 2016/04/04 13:36:17]

#include <memory>

[vabr (Chromium), 2016/04/04 14:29:04]

Done.

 #include <ostream>
 #include <set>
 
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
@@ skipping 294 matching lines @@
 void AutofillProfile::SetRawInfo(ServerFieldType type,
                                  const base::string16& value) {
   FormGroup* form_group = MutableFormGroupForType(AutofillType(type));
   if (form_group)
     form_group->SetRawInfo(type, value);
 }
 
 base::string16 AutofillProfile::GetInfo(const AutofillType& type,
                                         const std::string& app_locale) const {
   if (type.html_type() == HTML_TYPE_FULL_ADDRESS) {
-    scoped_ptr<AddressData> address_data =
+    std::unique_ptr<AddressData> address_data =
         i18n::CreateAddressDataFromAutofillProfile(*this, app_locale);
     if (!addressinput::HasAllRequiredFields(*address_data))
       return base::string16();
 
     std::vector<std::string> lines;
     ::i18n::addressinput::GetFormattedNationalAddress(*address_data, &lines);
     return base::UTF8ToUTF16(base::JoinString(lines, "\n"));
   }
 
   const FormGroup* form_group = FormGroupForType(type);
@@ skipping 103 matching lines @@
                                  const std::string& app_locale) const {
   ServerFieldTypeSet types;
   GetSupportedTypes(&types);
   return IsSubsetOfForFieldSet(profile, app_locale, types);
 }
 
 bool AutofillProfile::IsSubsetOfForFieldSet(
     const AutofillProfile& profile,
     const std::string& app_locale,
     const ServerFieldTypeSet& types) const {
-  scoped_ptr<l10n::CaseInsensitiveCompare> compare;
+  std::unique_ptr<l10n::CaseInsensitiveCompare> compare;
 
   for (ServerFieldType type : types) {
     base::string16 value = GetRawInfo(type);
     if (value.empty())
       continue;
 
     if (type == NAME_FULL || type == ADDRESS_HOME_STREET_ADDRESS) {
       // Ignore the compound "full name" field type.  We are only interested in
       // comparing the constituent parts.  For example, if |this| has a middle
       // name saved, but |profile| lacks one, |profile| could still be a subset
@@ skipping 403 matching lines @@
 
     AutofillType autofill_type(*it);
     base::string16 field_value = GetInfo(autofill_type, app_locale);
     if (field_value.empty())
       continue;
 
     trimmed_profile.SetInfo(autofill_type, field_value, app_locale);
     --num_fields_to_use;
   }
 
-  scoped_ptr<AddressData> address_data =
+  std::unique_ptr<AddressData> address_data =
       i18n::CreateAddressDataFromAutofillProfile(trimmed_profile, app_locale);
   std::string address_line;
   ::i18n::addressinput::GetFormattedNationalAddressLine(
       *address_data, &address_line);
   base::string16 label = base::UTF8ToUTF16(address_line);
 
   for (std::vector<ServerFieldType>::const_iterator it =
            remaining_fields.begin();
        it != remaining_fields.end() && num_fields_to_use > 0;
        ++it) {
@@ skipping 165 matching lines @@
             << " " << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY)) << " "
             << profile.language_code() << " "
             << UTF16ToUTF8(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill