[Autofill] remove *MultiInfo* functions

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 168 matching lines @@
          it != suggested_fields->end(); ++it) {
       if (*it != excluded_field &&
           GetStorableTypeCollapsingGroups(*it) == effective_excluded_type) {
         distinguishing_fields->push_back(effective_excluded_type);
         break;
       }
     }
   }
 }
 
-// A helper function for string streaming.  Concatenates multi-valued entries
-// stored for a given |type| into a single string.  This string is returned.
-const base::string16 MultiString(const AutofillProfile& p,
-                                 ServerFieldType type) {
-  std::vector<base::string16> values;
-  p.GetRawMultiInfo(type, &values);
-  base::string16 accumulate;
-  for (size_t i = 0; i < values.size(); ++i) {
-    if (i > 0)
-      accumulate += ASCIIToUTF16(" ");
-    accumulate += values[i];
-  }
-  return accumulate;
-}
-
-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);
-}
-
 // 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 54 matching lines @@
   DCHECK(type == SERVER_PROFILE);
 }
 
 AutofillProfile::AutofillProfile()
     : AutofillDataModel(base::GenerateGUID(), std::string()),
       record_type_(LOCAL_PROFILE),
       phone_number_(this) {
 }
 
 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
-    : AutofillDataModel(std::string(), std::string()),
-      phone_number_(this) {
+    : 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());
@@ skipping 69 matching lines @@
                               const std::string& app_locale) {
   FormGroup* form_group = MutableFormGroupForType(type);
   if (!form_group)
     return false;
 
   base::string16 trimmed_value;
   base::TrimWhitespace(value, base::TRIM_ALL, &trimmed_value);
   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;
-
-    default:
-      if (values.size() == 1U) {
-        SetRawInfo(type, values[0]);
-      } else if (values.empty()) {
-        SetRawInfo(type, base::string16());
-      } else {
-        NOTREACHED();
-      }
-      break;
-  }
-}
-
-void AutofillProfile::GetRawMultiInfo(
-    ServerFieldType type,
-    std::vector<base::string16>* values) const {
-  GetMultiInfoImpl(AutofillType(type), std::string(), values);
-}
-
 bool AutofillProfile::IsEmpty(const std::string& app_locale) const {
   ServerFieldTypeSet types;
   GetNonEmptyTypes(app_locale, &types);
   return types.empty();
 }
 
 bool AutofillProfile::IsPresentButInvalid(ServerFieldType type) const {
   std::string country = UTF16ToUTF8(GetRawInfo(ADDRESS_HOME_COUNTRY));
   base::string16 data = GetRawInfo(type);
   if (data.empty())
@@ skipping 281 matching lines @@
       // We have more than one profile with the same label, so add
       // differentiating fields.
       CreateInferredLabelsHelper(profiles, it->second, fields_to_use,
                                  minimal_fields_shown, app_locale, labels);
     }
   }
 }
 
 void AutofillProfile::GenerateServerProfileIdentifier() {
   DCHECK_EQ(SERVER_PROFILE, record_type());
-  base::string16 contents = MultiString(*this, NAME_FIRST);
-  contents.append(MultiString(*this, NAME_MIDDLE));
-  contents.append(MultiString(*this, NAME_LAST));
-  contents.append(MultiString(*this, EMAIL_ADDRESS));
+  base::string16 contents = GetRawInfo(NAME_FIRST);
+  contents.append(GetRawInfo(NAME_MIDDLE));
+  contents.append(GetRawInfo(NAME_LAST));
+  contents.append(GetRawInfo(EMAIL_ADDRESS));
   contents.append(GetRawInfo(COMPANY_NAME));
   contents.append(GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
   contents.append(GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY));
   contents.append(GetRawInfo(ADDRESS_HOME_CITY));
   contents.append(GetRawInfo(ADDRESS_HOME_STATE));
   contents.append(GetRawInfo(ADDRESS_HOME_ZIP));
   contents.append(GetRawInfo(ADDRESS_HOME_SORTING_CODE));
   contents.append(GetRawInfo(ADDRESS_HOME_COUNTRY));
-  contents.append(MultiString(*this, PHONE_HOME_WHOLE_NUMBER));
+  contents.append(GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
   std::string contents_utf8 = UTF16ToUTF8(contents);
   contents_utf8.append(language_code());
   server_id_ = base::SHA1HashString(contents_utf8);
 }
 
 // static
 base::string16 AutofillProfile::CanonicalizeProfileString(
     const base::string16& str) {
   base::string16 ret;
   ret.reserve(str.size());
@@ skipping 58 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 {
-  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);
 
   AutofillType region_code_type(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
   const base::string16& profile_region_code =
@@ skipping 186 matching lines @@
 }
 
 bool AutofillProfile::EqualsSansGuid(const AutofillProfile& profile) const {
   return origin() == profile.origin() &&
          language_code() == profile.language_code() &&
          Compare(profile) == 0;
 }
 
 // So we can compare AutofillProfiles with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const AutofillProfile& profile) {
-  return os
-      << profile.guid()
-      << " "
-      << profile.origin()
-      << " "
-      << UTF16ToUTF8(MultiString(profile, NAME_FIRST))
-      << " "
-      << UTF16ToUTF8(MultiString(profile, NAME_MIDDLE))
-      << " "
-      << UTF16ToUTF8(MultiString(profile, NAME_LAST))
-      << " "
-      << UTF16ToUTF8(MultiString(profile, EMAIL_ADDRESS))
-      << " "
-      << UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME))
-      << " "
-      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1))
-      << " "
-      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2))
-      << " "
-      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY))
-      << " "
-      << 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(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
+  return os << profile.guid() << " " << profile.origin() << " "
+            << UTF16ToUTF8(profile.GetRawInfo(NAME_FIRST)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(NAME_MIDDLE)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(NAME_LAST)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(EMAIL_ADDRESS)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2)) << " "
+            << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY))
+            << " " << 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