[Autofill] More variant-related code deletion

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>
 #include <ostream>
@@ skipping 191 matching lines @@
 }
 
 base::string16 GetFormGroupInfo(const FormGroup& form_group,
                                 const AutofillType& type,
                                 const std::string& app_locale) {
   return app_locale.empty() ?
       form_group.GetRawInfo(type.GetStorableType()) :
       form_group.GetInfo(type, app_locale);
 }
 
-template <class T>
-void CopyRawValuesToItems(ServerFieldType type,
-                          const std::vector<base::string16>& values,
-                          const T& prototype,
-                          std::vector<T>* form_group_items) {
-  form_group_items->resize(values.size(), prototype);
-  for (size_t i = 0; i < form_group_items->size(); ++i) {
-    (*form_group_items)[i].SetRawInfo(type, values[i]);
-  }
-  // Must have at least one (possibly empty) element.
-  form_group_items->resize(std::max<size_t>(1UL, values.size()), prototype);
-}
-
-template <class T>
-void CopyValuesToItems(AutofillType type,
-                       const std::vector<base::string16>& values,
-                       const T& prototype,
-                       const std::string& app_locale,
-                       std::vector<T>* form_group_items) {
-  form_group_items->resize(values.size(), prototype);
-  for (size_t i = 0; i < form_group_items->size(); ++i) {
-    (*form_group_items)[i].SetInfo(type, values[i], app_locale);
-  }
-  // Must have at least one (possibly empty) element.
-  form_group_items->resize(std::max<size_t>(1UL, values.size()), prototype);
-}
-
-template <class T>
-void CopyItemsToValues(const AutofillType& type,
-                       const std::vector<T>& form_group_items,
-                       const std::string& app_locale,
-                       std::vector<base::string16>* values) {
-  values->resize(form_group_items.size());
-  for (size_t i = 0; i < values->size(); ++i) {
-    (*values)[i] = GetFormGroupInfo(form_group_items[i], type, app_locale);
-  }
-}
-
 // Collapse compound field types to their "full" type.  I.e. First name
 // collapses to full name, area code collapses to full phone, etc.
 void CollapseCompoundFieldTypes(ServerFieldTypeSet* type_set) {
   ServerFieldTypeSet collapsed_set;
   for (ServerFieldTypeSet::iterator it = type_set->begin();
        it != type_set->end(); ++it) {
     switch (*it) {
       case NAME_FIRST:
       case NAME_MIDDLE:
       case NAME_LAST:
@@ skipping 36 matching lines @@
   std::string country_code_;
   std::string app_locale_;
 };
 
 }  // namespace
 
 AutofillProfile::AutofillProfile(const std::string& guid,
                                  const std::string& origin)
     : AutofillDataModel(guid, origin),
       record_type_(LOCAL_PROFILE),
-      email_(1),
-      phone_number_(1, PhoneNumber(this)) {
+      phone_number_(this) {
 }
 
 AutofillProfile::AutofillProfile(RecordType type, const std::string& server_id)
     : AutofillDataModel(base::GenerateGUID(), std::string()),
       record_type_(type),
-      email_(1),
-      phone_number_(1, PhoneNumber(this)),
+      phone_number_(this),
       server_id_(server_id) {
   DCHECK(type == SERVER_PROFILE);
 }
 
 AutofillProfile::AutofillProfile()
     : AutofillDataModel(base::GenerateGUID(), std::string()),
       record_type_(LOCAL_PROFILE),
-      email_(1),
-      phone_number_(1, PhoneNumber(this)) {
+      phone_number_(this) {
 }
 
 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
-    : AutofillDataModel(std::string(), std::string()) {
+    : AutofillDataModel(std::string(), std::string()),
+      phone_number_(this) {
   operator=(profile);
 }
 
 AutofillProfile::~AutofillProfile() {
 }
 
 AutofillProfile& AutofillProfile::operator=(const AutofillProfile& profile) {
   set_use_count(profile.use_count());
   set_use_date(profile.use_date());
   set_modification_date(profile.modification_date());
 
   if (this == &profile)
     return *this;
 
   set_guid(profile.guid());
   set_origin(profile.origin());
 
   record_type_ = profile.record_type_;
 
   name_ = profile.name_;
   email_ = profile.email_;
   company_ = profile.company_;
   phone_number_ = profile.phone_number_;
-
-  for (size_t i = 0; i < phone_number_.size(); ++i)
-    phone_number_[i].set_profile(this);
+  phone_number_.set_profile(this);
 
   address_ = profile.address_;
   set_language_code(profile.language_code());
 
   server_id_ = profile.server_id();
 
   return *this;
 }
 
 void AutofillProfile::GetMatchingTypes(
@@ skipping 52 matching lines @@
   return form_group->SetInfo(type, trimmed_value, app_locale);
 }
 
 // TODO(estade): remove this function.
 void AutofillProfile::SetRawMultiInfo(
     ServerFieldType type,
     const std::vector<base::string16>& values) {
   switch (AutofillType(type).group()) {
     case NAME:
     case NAME_BILLING:
+    case EMAIL:
+    case PHONE_HOME:
+    case PHONE_BILLING:
       SetRawInfo(type, values.empty() ? base::string16() : values[0]);
       break;
 
-    case EMAIL:
-      CopyRawValuesToItems(type, values, EmailInfo(), &email_);
-      break;
-
-    case PHONE_HOME:
-    case PHONE_BILLING:
-      CopyRawValuesToItems(type, values, PhoneNumber(this), &phone_number_);
-      break;
-
     default:
       if (values.size() == 1U) {
         SetRawInfo(type, values[0]);
       } else if (values.empty()) {
         SetRawInfo(type, base::string16());
       } else {
         NOTREACHED();
       }
       break;
   }
@@ skipping 390 matching lines @@
   return CanonicalizeProfileString(a) == CanonicalizeProfileString(b);
 }
 
 void AutofillProfile::GetSupportedTypes(
     ServerFieldTypeSet* supported_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
     (*it)->GetSupportedTypes(supported_types);
 }
 
+// TODO(estade): remove this function.
 void AutofillProfile::GetMultiInfoImpl(
     const AutofillType& type,
     const std::string& app_locale,
     std::vector<base::string16>* values) const {
-  switch (type.group()) {
-    case EMAIL:
-      CopyItemsToValues(type, email_, app_locale, values);
-      break;
-    case PHONE_HOME:
-    case PHONE_BILLING:
-      CopyItemsToValues(type, phone_number_, app_locale, values);
-      break;
-    default:
-      values->resize(1);
-      (*values)[0] = GetFormGroupInfo(*this, type, app_locale);
-  }
+  values->resize(1);
+  (*values)[0] = GetFormGroupInfo(*this, type, app_locale);
 }
 
 base::string16 AutofillProfile::ConstructInferredLabel(
     const std::vector<ServerFieldType>& included_fields,
     size_t num_fields_to_use,
     const std::string& app_locale) const {
   // TODO(estade): use libaddressinput?
   base::string16 separator =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_SUMMARY_SEPARATOR);
 
@@ skipping 136 matching lines @@
     }
 
     (*labels)[*it] = profile->ConstructInferredLabel(
         label_fields, label_fields.size(), app_locale);
   }
 }
 
 AutofillProfile::FormGroupList AutofillProfile::FormGroups() const {
   FormGroupList v(5);
   v[0] = &name_;
-  v[1] = &email_[0];
+  v[1] = &email_;
   v[2] = &company_;
-  v[3] = &phone_number_[0];
+  v[3] = &phone_number_;
   v[4] = &address_;
   return v;
 }
 
 const FormGroup* AutofillProfile::FormGroupForType(
     const AutofillType& type) const {
   return const_cast<AutofillProfile*>(this)->MutableFormGroupForType(type);
 }
 
 FormGroup* AutofillProfile::MutableFormGroupForType(const AutofillType& type) {
   switch (type.group()) {
     case NAME:
     case NAME_BILLING:
       return &name_;
 
     case EMAIL:
-      return &email_[0];
+      return &email_;
 
     case COMPANY:
       return &company_;
 
     case PHONE_HOME:
     case PHONE_BILLING:
-      return &phone_number_[0];
+      return &phone_number_;
 
     case ADDRESS_HOME:
     case ADDRESS_BILLING:
       return &address_;
 
     case NO_GROUP:
     case CREDIT_CARD:
     case PASSWORD_FIELD:
     case USERNAME_FIELD:
     case TRANSACTION:
@@ skipping 42 matching lines @@
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << profile.language_code()
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }
 
 }  // namespace autofill