components/autofill: scoped_ptr -> unique_ptr

components/autofill/content/browser/wallet/wallet_address.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/content/browser/wallet/wallet_address.h"
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 151 matching lines @@
       sorting_code_(sorting_code),
       phone_number_(phone_number),
       phone_object_(phone_number, country_name_code),
       object_id_(object_id),
       is_complete_address_(true),
       language_code_(language_code) {}
 
 Address::~Address() {}
 
 // static
-scoped_ptr<Address> Address::CreateAddressWithID(
+std::unique_ptr<Address> Address::CreateAddressWithID(
     const base::DictionaryValue& dictionary) {
   std::string object_id;
   if (!dictionary.GetString("id", &object_id)) {
     DLOG(ERROR) << "Response from Google Payments missing object id";
-    return scoped_ptr<Address>();
+    return std::unique_ptr<Address>();
   }
-  return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
+  return std::unique_ptr<Address>(CreateAddressInternal(dictionary, object_id));
 }
 
 // static
-scoped_ptr<Address> Address::CreateAddress(
+std::unique_ptr<Address> Address::CreateAddress(
     const base::DictionaryValue& dictionary) {
   std::string object_id;
   dictionary.GetString("id", &object_id);
-  return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
+  return std::unique_ptr<Address>(CreateAddressInternal(dictionary, object_id));
 }
 
 // static
-scoped_ptr<Address> Address::CreateDisplayAddress(
+std::unique_ptr<Address> Address::CreateDisplayAddress(
     const base::DictionaryValue& dictionary) {
   std::string country_code;
   if (!dictionary.GetString("country_code", &country_code)) {
     DLOG(ERROR) << "Reponse from Google Payments missing country code";
-    return scoped_ptr<Address>();
+    return std::unique_ptr<Address>();
   }
 
   base::string16 name;
   if (!dictionary.GetString("name", &name)) {
     DLOG(ERROR) << "Reponse from Google Payments missing name";
-    return scoped_ptr<Address>();
+    return std::unique_ptr<Address>();
   }
 
   base::string16 postal_code;
   if (!dictionary.GetString("postal_code", &postal_code)) {
     DLOG(ERROR) << "Reponse from Google Payments missing postal code";
-    return scoped_ptr<Address>();
+    return std::unique_ptr<Address>();
   }
 
   base::string16 sorting_code;
   if (!dictionary.GetString("sorting_code", &sorting_code)) {
     DVLOG(1) << "Reponse from Google Payments missing sorting code";
   }
 
   std::vector<base::string16> street_address;
   base::string16 address1;
   if (dictionary.GetString("address1", &address1))
@@ skipping 28 matching lines @@
     DVLOG(1) << "Reponse from Google Payments missing phone number";
 
   std::string address_state;
   if (!dictionary.GetString("type", &address_state))
     DVLOG(1) << "Response from Google Payments missing type/state of address";
 
   std::string language_code;
   if (!dictionary.GetString("language_code", &language_code))
     DVLOG(1) << "Response from Google Payments missing language code";
 
-  scoped_ptr<Address> address(
-      new Address(country_code,
-                  name,
-                  street_address,
-                  city,
-                  dependent_locality_name,
-                  state,
-                  postal_code,
-                  sorting_code,
-                  phone_number,
-                  std::string(),
-                  language_code));
+  std::unique_ptr<Address> address(new Address(
+      country_code, name, street_address, city, dependent_locality_name, state,
+      postal_code, sorting_code, phone_number, std::string(), language_code));
   address->set_is_complete_address(address_state == kFullAddress);
 
   return address;
 }
 
-scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithID() const {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> Address::ToDictionaryWithID() const {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   if (!object_id_.empty())
     dict->SetString("id", object_id_);
   dict->SetString("phone_number", phone_number_);
   dict->Set("postal_address", ToDictionaryWithoutID().release());
 
   return dict;
 }
 
-scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithoutID() const {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> Address::ToDictionaryWithoutID() const {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-  scoped_ptr<base::ListValue> address_lines(new base::ListValue());
+  std::unique_ptr<base::ListValue> address_lines(new base::ListValue());
   address_lines->AppendStrings(street_address_);
   dict->Set("address_line", address_lines.release());
 
   dict->SetString("country_name_code", country_name_code_);
   dict->SetString("recipient_name", recipient_name_);
   dict->SetString("locality_name", locality_name_);
   dict->SetString("dependent_locality_name", dependent_locality_name_);
   dict->SetString("administrative_area_name",
                   administrative_area_name_);
   dict->SetString("postal_code_number", postal_code_number_);
@@ skipping 114 matching lines @@
          language_code_ == other.language_code_ &&
          EqualsIgnoreID(other);
 }
 
 bool Address::operator!=(const Address& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill