[Autofill] Rename GetInfo and SetInfo to GetRawInfo and SetRawInfo

chrome/browser/autofill/autofill_profile.cc

 // Copyright (c) 2012 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/autofill/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
@@ skipping 104 matching lines @@
   }
   return accumulate;
 }
 
 template <class T>
 void CopyValuesToItems(AutofillFieldType type,
                        const std::vector<string16>& values,
                        std::vector<T>* form_group_items,
                        const T& prototype) {
   form_group_items->resize(values.size(), prototype);
-  for (size_t i = 0; i < form_group_items->size(); ++i)
-    (*form_group_items)[i].SetInfo(type, CollapseWhitespace(values[i], false));
+  for (size_t i = 0; i < form_group_items->size(); ++i) {
+    (*form_group_items)[i].SetRawInfo(type,
+                                      CollapseWhitespace(values[i], false));
+  }
   // Must have at least one (possibly empty) element.
   if (form_group_items->empty())
     form_group_items->resize(1, prototype);
 }
 
 template <class T>
 void CopyItemsToValues(AutofillFieldType type,
                        const std::vector<T>& form_group_items,
                        bool canonicalize,
                        std::vector<string16>* values) {
   values->resize(form_group_items.size());
   for (size_t i = 0; i < values->size(); ++i) {
     if (canonicalize)
       (*values)[i] = form_group_items[i].GetCanonicalizedInfo(type);
     else
-      (*values)[i] = form_group_items[i].GetInfo(type);
+      (*values)[i] = form_group_items[i].GetRawInfo(type);
   }
 }
 
 // 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(FieldTypeSet* type_set) {
   FieldTypeSet collapsed_set;
   for (FieldTypeSet::iterator iter = type_set->begin(); iter != type_set->end();
        ++iter) {
     switch (*iter) {
@@ skipping 102 matching lines @@
 }
 
 void AutofillProfile::GetMatchingTypes(const string16& text,
                                        FieldTypeSet* matching_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
     (*it)->GetMatchingTypes(text, matching_types);
 }
 
 
-string16 AutofillProfile::GetInfo(AutofillFieldType type) const {
+string16 AutofillProfile::GetRawInfo(AutofillFieldType type) const {
   AutofillFieldType return_type = AutofillType::GetEquivalentFieldType(type);
   const FormGroup* form_group = FormGroupForType(return_type);
   if (!form_group)
     return string16();
 
-  return form_group->GetInfo(return_type);
+  return form_group->GetRawInfo(return_type);
 }
 
-void AutofillProfile::SetInfo(AutofillFieldType type, const string16& value) {
+void AutofillProfile::SetRawInfo(AutofillFieldType type,
+                                 const string16& value) {
   FormGroup* form_group = MutableFormGroupForType(type);
   if (form_group)
-    form_group->SetInfo(type, CollapseWhitespace(value, false));
+    form_group->SetRawInfo(type, CollapseWhitespace(value, false));
 }
 
 string16 AutofillProfile::GetCanonicalizedInfo(AutofillFieldType type) const {
   AutofillFieldType return_type = AutofillType::GetEquivalentFieldType(type);
   const FormGroup* form_group = FormGroupForType(return_type);
   if (!form_group)
     return string16();
 
   return form_group->GetCanonicalizedInfo(return_type);
 }
@@ skipping 19 matching lines @@
       CopyValuesToItems(type, values, &email_, EmailInfo());
       break;
     case AutofillType::PHONE:
       CopyValuesToItems(type,
                         values,
                         &home_number_,
                         PhoneNumber(this));
       break;
     default:
       if (values.size() == 1) {
-        SetInfo(type, values[0]);
+        SetRawInfo(type, values[0]);
       } else if (values.size() == 0) {
-        SetInfo(type, string16());
+        SetRawInfo(type, string16());
       } else {
-        NOTREACHED()
-            << "Attempt to set multiple values on single-valued field.";
+        // Shouldn't attempt to set multiple values on single-valued field.
+        NOTREACHED();
       }
       break;
   }
 }
 
 void AutofillProfile::GetMultiInfo(AutofillFieldType type,
                                    std::vector<string16>* values) const {
   GetMultiInfoImpl(type, false, values);
 }
 
@@ skipping 10 matching lines @@
       CopyItemsToValues(type, name_, canonicalize, values);
       break;
     case AutofillType::EMAIL:
       CopyItemsToValues(type, email_, canonicalize, values);
       break;
     case AutofillType::PHONE:
       CopyItemsToValues(type, home_number_, canonicalize, values);
       break;
     default:
       values->resize(1);
-      (*values)[0] = GetInfo(type);
+      (*values)[0] = GetRawInfo(type);
   }
 }
 
 // static
 bool AutofillProfile::SupportsMultiValue(AutofillFieldType type) {
   AutofillType::FieldTypeGroup group = AutofillType(type).group();
   return group == AutofillType::NAME ||
          group == AutofillType::EMAIL ||
          group == AutofillType::PHONE;
 }
@@ skipping 82 matching lines @@
 int AutofillProfile::Compare(const AutofillProfile& profile) const {
   const AutofillFieldType single_value_types[] = { COMPANY_NAME,
                                                    ADDRESS_HOME_LINE1,
                                                    ADDRESS_HOME_LINE2,
                                                    ADDRESS_HOME_CITY,
                                                    ADDRESS_HOME_STATE,
                                                    ADDRESS_HOME_ZIP,
                                                    ADDRESS_HOME_COUNTRY };
 
   for (size_t i = 0; i < arraysize(single_value_types); ++i) {
-    int comparison = GetInfo(single_value_types[i]).compare(
-        profile.GetInfo(single_value_types[i]));
+    int comparison = GetRawInfo(single_value_types[i]).compare(
+        profile.GetRawInfo(single_value_types[i]));
     if (comparison != 0)
       return comparison;
   }
 
   const AutofillFieldType multi_value_types[] = { NAME_FIRST,
                                                   NAME_MIDDLE,
                                                   NAME_LAST,
                                                   EMAIL_ADDRESS,
                                                   PHONE_HOME_NUMBER };
 
@@ skipping 18 matching lines @@
 
 bool AutofillProfile::operator==(const AutofillProfile& profile) const {
   return guid_ == profile.guid_ && Compare(profile) == 0;
 }
 
 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
   return !operator==(profile);
 }
 
 const string16 AutofillProfile::PrimaryValue() const {
-  return GetInfo(ADDRESS_HOME_LINE1) +
-         GetInfo(ADDRESS_HOME_CITY);
+  return GetRawInfo(ADDRESS_HOME_LINE1) +
+         GetRawInfo(ADDRESS_HOME_CITY);
 }
 
 bool AutofillProfile::IsSubsetOf(const AutofillProfile& profile) const {
   FieldTypeSet types;
   GetNonEmptyTypes(&types);
 
   for (FieldTypeSet::const_iterator iter = types.begin(); iter != types.end();
        ++iter) {
     if (*iter == NAME_FULL) {
       // 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
       // of |this|.
       continue;
     } else if (AutofillType(*iter).group() == AutofillType::PHONE) {
       // Phone numbers should be canonicalized prior to being compared.
       if (*iter != PHONE_HOME_WHOLE_NUMBER) {
         continue;
-      } else if (!autofill_i18n::PhoneNumbersMatch(GetInfo(*iter),
-                                                   profile.GetInfo(*iter),
+      } else if (!autofill_i18n::PhoneNumbersMatch(GetRawInfo(*iter),
+                                                   profile.GetRawInfo(*iter),
                                                    CountryCode())) {
         return false;
       }
-    } else if (StringToLowerASCII(GetInfo(*iter)) !=
-                   StringToLowerASCII(profile.GetInfo(*iter))) {
+    } else if (StringToLowerASCII(GetRawInfo(*iter)) !=
+                   StringToLowerASCII(profile.GetRawInfo(*iter))) {
       return false;
     }
   }
 
   return true;
 }
 
 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile) {
   FieldTypeSet field_types;
   profile.GetNonEmptyTypes(&field_types);
@@ skipping 24 matching lines @@
         } else {
           std::vector<string16>::const_iterator existing_iter = std::find_if(
               existing_values.begin(), existing_values.end(),
               std::bind1st(CaseInsensitiveStringEquals(), *value_iter));
           if (existing_iter == existing_values.end())
             existing_values.insert(existing_values.end(), *value_iter);
         }
       }
       SetMultiInfo(*iter, existing_values);
     } else {
-      string16 new_value = profile.GetInfo(*iter);
-      if (StringToLowerASCII(GetInfo(*iter)) != StringToLowerASCII(new_value))
-        SetInfo(*iter, new_value);
+      string16 new_value = profile.GetRawInfo(*iter);
+      if (StringToLowerASCII(GetRawInfo(*iter)) !=
+              StringToLowerASCII(new_value)) {
+        SetRawInfo(*iter, new_value);
+      }
     }
   }
 }
 
 void AutofillProfile::AddPhoneIfUnique(const string16& phone,
                                        std::vector<string16>* existing_phones) {
   DCHECK(existing_phones);
   // Phones allow "fuzzy" matching, so "1-800-FLOWERS", "18003569377",
   // "(800)356-9377" and "356-9377" are considered the same.
   if (std::find_if(existing_phones->begin(), existing_phones->end(),
                    FindByPhone(phone, CountryCode())) ==
       existing_phones->end()) {
     existing_phones->push_back(phone);
   }
 }
 
 string16 AutofillProfile::ConstructInferredLabel(
     const std::vector<AutofillFieldType>& included_fields,
     size_t num_fields_to_use) const {
   const string16 separator =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADDRESS_SUMMARY_SEPARATOR);
 
   string16 label;
   size_t num_fields_used = 0;
   for (std::vector<AutofillFieldType>::const_iterator it =
            included_fields.begin();
        it != included_fields.end() && num_fields_used < num_fields_to_use;
        ++it) {
-    string16 field = GetInfo(*it);
+    string16 field = GetRawInfo(*it);
     if (field.empty())
       continue;
 
     if (!label.empty())
       label.append(separator);
 
     label.append(field);
     ++num_fields_used;
   }
   return label;
@@ skipping 11 matching lines @@
   std::map<AutofillFieldType,
            std::map<string16, size_t> > field_text_frequencies_by_field;
   for (std::vector<AutofillFieldType>::const_iterator field = fields.begin();
        field != fields.end(); ++field) {
     std::map<string16, size_t>& field_text_frequencies =
         field_text_frequencies_by_field[*field];
 
     for (std::list<size_t>::const_iterator it = indices.begin();
          it != indices.end(); ++it) {
       const AutofillProfile* profile = profiles[*it];
-      string16 field_text = profile->GetInfo(*field);
+      string16 field_text = profile->GetRawInfo(*field);
 
       // If this label is not already in the map, add it with frequency 0.
       if (!field_text_frequencies.count(field_text))
         field_text_frequencies[field_text] = 0;
 
       // Now, increment the frequency for this label.
       ++field_text_frequencies[field_text];
     }
   }
 
   // Now comes the meat of the algorithm. For each profile, we scan the list of
   // fields to use, looking for two things:
   //  1. A (non-empty) field that differentiates the profile from all others
   //  2. At least |num_fields_to_include| non-empty fields
   // Before we've satisfied condition (2), we include all fields, even ones that
   // are identical across all the profiles. Once we've satisfied condition (2),
   // we only include fields that that have at last two distinct values.
   for (std::list<size_t>::const_iterator it = indices.begin();
        it != indices.end(); ++it) {
     const AutofillProfile* profile = profiles[*it];
 
     std::vector<AutofillFieldType> label_fields;
     bool found_differentiating_field = false;
     for (std::vector<AutofillFieldType>::const_iterator field = fields.begin();
          field != fields.end(); ++field) {
       // Skip over empty fields.
-      string16 field_text = profile->GetInfo(*field);
+      string16 field_text = profile->GetRawInfo(*field);
       if (field_text.empty())
         continue;
 
       std::map<string16, size_t>& field_text_frequencies =
           field_text_frequencies_by_field[*field];
       found_differentiating_field |=
           !field_text_frequencies.count(string16()) &&
           (field_text_frequencies[field_text] == 1);
 
       // Once we've found enough non-empty fields, skip over any remaining
@@ skipping 64 matching lines @@
       << profile.guid()
       << " "
       << UTF16ToUTF8(MultiString(profile, NAME_FIRST))
       << " "
       << UTF16ToUTF8(MultiString(profile, NAME_MIDDLE))
       << " "
       << UTF16ToUTF8(MultiString(profile, NAME_LAST))
       << " "
       << UTF16ToUTF8(MultiString(profile, EMAIL_ADDRESS))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(COMPANY_NAME))
+      << UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_LINE1))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_LINE2))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_CITY))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_STATE))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_ZIP))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))
       << " "
-      << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_COUNTRY))
+      << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }