Autofill: Remove fax number completely.

chrome/browser/autofill/autofill_profile.cc

 // Copyright (c) 2011 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 <set>
@@ skipping 38 matching lines @@
   static const AutofillFieldType kDefaultDistinguishingFields[] = {
     NAME_FULL,
     ADDRESS_HOME_LINE1,
     ADDRESS_HOME_LINE2,
     ADDRESS_HOME_CITY,
     ADDRESS_HOME_STATE,
     ADDRESS_HOME_ZIP,
     ADDRESS_HOME_COUNTRY,
     EMAIL_ADDRESS,
     PHONE_HOME_WHOLE_NUMBER,
-    PHONE_FAX_WHOLE_NUMBER,
     COMPANY_NAME,
   };
 
   if (!suggested_fields) {
     DCHECK_EQ(excluded_field, UNKNOWN_TYPE);
     distinguishing_fields->assign(
         kDefaultDistinguishingFields,
         kDefaultDistinguishingFields + arraysize(kDefaultDistinguishingFields));
     return;
   }
@@ skipping 90 matching lines @@
         break;
 
       case PHONE_HOME_NUMBER:
       case PHONE_HOME_CITY_CODE:
       case PHONE_HOME_COUNTRY_CODE:
       case PHONE_HOME_CITY_AND_NUMBER:
       case PHONE_HOME_WHOLE_NUMBER:
         collapsed_set.insert(PHONE_HOME_WHOLE_NUMBER);
         break;
 
-      case PHONE_FAX_NUMBER:
-      case PHONE_FAX_CITY_CODE:
-      case PHONE_FAX_COUNTRY_CODE:
-      case PHONE_FAX_CITY_AND_NUMBER:
-      case PHONE_FAX_WHOLE_NUMBER:
-        collapsed_set.insert(PHONE_FAX_WHOLE_NUMBER);
-        break;
-
       default:
         collapsed_set.insert(*iter);
     }
   }
   std::swap(*type_set, collapsed_set);
 }
 
 class FindByPhone {
  public:
   FindByPhone(const string16& phone, const std::string& country_code)
@@ skipping 13 matching lines @@
   string16 phone_;
   std::string country_code_;
 };
 
 }  // namespace
 
 AutofillProfile::AutofillProfile(const std::string& guid)
     : guid_(guid),
       name_(1),
       email_(1),
-      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME, this)),
-      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX, this)) {
+      home_number_(1, PhoneNumber(this)) {
 }
 
 AutofillProfile::AutofillProfile()
     : guid_(guid::GenerateGUID()),
       name_(1),
       email_(1),
-      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME, this)),
-      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX, this)) {
+      home_number_(1, PhoneNumber(this)) {
 }
 
 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
     : FormGroup() {
   operator=(profile);
 }
 
 AutofillProfile::~AutofillProfile() {
 }
 
 AutofillProfile& AutofillProfile::operator=(const AutofillProfile& profile) {
   if (this == &profile)
     return *this;
 
   label_ = profile.label_;
   guid_ = profile.guid_;
 
   name_ = profile.name_;
   email_ = profile.email_;
   company_ = profile.company_;
   home_number_ = profile.home_number_;
-  for (size_t i = 0; i < home_number_.size(); ++i) {
+
+  for (size_t i = 0; i < home_number_.size(); ++i)
     home_number_[i].set_profile(this);
-  }
-  fax_number_ = profile.fax_number_;
-  for (size_t i = 0; i < fax_number_.size(); ++i) {
-    fax_number_[i].set_profile(this);
-  }
+
   address_ = profile.address_;
 
   return *this;
 }
 
 void AutofillProfile::GetSupportedTypes(FieldTypeSet* supported_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
     (*it)->GetSupportedTypes(supported_types);
 }
@@ skipping 47 matching lines @@
     case AutofillType::NAME:
       CopyValuesToItems(type, values, &name_, NameInfo());
       break;
     case AutofillType::EMAIL:
       CopyValuesToItems(type, values, &email_, EmailInfo());
       break;
     case AutofillType::PHONE_HOME:
       CopyValuesToItems(type,
                         values,
                         &home_number_,
-                        PhoneNumber(AutofillType::PHONE_HOME, this));
-      break;
-    case AutofillType::PHONE_FAX:
-      CopyValuesToItems(type,
-                        values,
-                        &fax_number_,
-                        PhoneNumber(AutofillType::PHONE_FAX, this));
+                        PhoneNumber(this));
       break;
     default:
       if (values.size() == 1) {
         SetInfo(type, values[0]);
       } else if (values.size() == 0) {
         SetInfo(type, string16());
       } else {
         NOTREACHED()
             << "Attempt to set multiple values on single-valued field.";
       }
@@ skipping 17 matching lines @@
   switch (AutofillType(type).group()) {
     case AutofillType::NAME:
       CopyItemsToValues(type, name_, canonicalize, values);
       break;
     case AutofillType::EMAIL:
       CopyItemsToValues(type, email_, canonicalize, values);
       break;
     case AutofillType::PHONE_HOME:
       CopyItemsToValues(type, home_number_, canonicalize, values);
       break;
-    case AutofillType::PHONE_FAX:
-      CopyItemsToValues(type, fax_number_, canonicalize, values);
-      break;
     default:
       values->resize(1);
       (*values)[0] = GetInfo(type);
   }
 }
 
 // static
 bool AutofillProfile::SupportsMultiValue(AutofillFieldType type) {
   AutofillType::FieldTypeGroup group = AutofillType(type).group();
   return group == AutofillType::NAME ||
          group == AutofillType::EMAIL ||
-         group == AutofillType::PHONE_HOME ||
-         group == AutofillType::PHONE_FAX;
+         group == AutofillType::PHONE_HOME;
 }
 
 const string16 AutofillProfile::Label() const {
   return label_;
 }
 
 const std::string AutofillProfile::CountryCode() const {
   return address_.country_code();
 }
 
@@ skipping 77 matching lines @@
                                       NAME_MIDDLE,
                                       NAME_LAST,
                                       EMAIL_ADDRESS,
                                       COMPANY_NAME,
                                       ADDRESS_HOME_LINE1,
                                       ADDRESS_HOME_LINE2,
                                       ADDRESS_HOME_CITY,
                                       ADDRESS_HOME_STATE,
                                       ADDRESS_HOME_ZIP,
                                       ADDRESS_HOME_COUNTRY,
-                                      PHONE_HOME_NUMBER,
-                                      PHONE_FAX_NUMBER };
+                                      PHONE_HOME_NUMBER };
 
   for (size_t index = 0; index < arraysize(types); ++index) {
     int comparison = GetInfo(types[index]).compare(
         profile.GetInfo(types[index]));
     if (comparison != 0)
       return comparison;
   }
 
   return 0;
 }
@@ skipping 11 matching lines @@
     int comparison = GetInfo(single_value_types[i]).compare(
         profile.GetInfo(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,
-                                                  PHONE_FAX_NUMBER };
+                                                  PHONE_HOME_NUMBER };
 
   for (size_t i = 0; i < arraysize(multi_value_types); ++i) {
     std::vector<string16> values_a;
     std::vector<string16> values_b;
     GetMultiInfo(multi_value_types[i], &values_a);
     profile.GetMultiInfo(multi_value_types[i], &values_b);
     if (values_a.size() < values_b.size())
       return -1;
     if (values_a.size() > values_b.size())
       return 1;
@@ skipping 42 matching lines @@
        iter != field_types.end(); ++iter) {
     if (AutofillProfile::SupportsMultiValue(*iter)) {
       std::vector<string16> new_values;
       profile.GetMultiInfo(*iter, &new_values);
       std::vector<string16> existing_values;
       GetMultiInfo(*iter, &existing_values);
       FieldTypeGroup group = AutofillType(*iter).group();
       for (std::vector<string16>::iterator value_iter = new_values.begin();
            value_iter != new_values.end(); ++value_iter) {
         // Don't add duplicates.
-        if (group == AutofillType::PHONE_HOME ||
-            group == AutofillType::PHONE_FAX) {
+        if (group == AutofillType::PHONE_HOME) {
           AddPhoneIfUnique(*value_iter, &existing_values);
         } 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);
@@ skipping 28 matching lines @@
            included_fields.begin();
        it != included_fields.end() && num_fields_used < num_fields_to_use;
        ++it) {
     string16 field = GetInfo(*it);
     if (field.empty())
       continue;
 
     if (!label.empty())
       label.append(separator);
 
-    // Fax number has special format, to indicate that this is a fax number.
-    if (*it == PHONE_FAX_WHOLE_NUMBER) {
-      field = l10n_util::GetStringFUTF16(
-          IDS_AUTOFILL_DIALOG_ADDRESS_SUMMARY_FAX_FORMAT, field);
-    }
     label.append(field);
     ++num_fields_used;
   }
   return label;
 }
 
 // static
 void AutofillProfile::CreateDifferentiatingLabels(
     const std::vector<AutofillProfile*>& profiles,
     const std::list<size_t>& indices,
@@ skipping 64 matching lines @@
         break;
     }
 
     (*created_labels)[*it] =
         profile->ConstructInferredLabel(label_fields,
                                         label_fields.size());
   }
 }
 
 AutofillProfile::FormGroupList AutofillProfile::FormGroups() const {
-  FormGroupList v(6);
+  FormGroupList v(5);
   v[0] = &name_[0];
   v[1] = &email_[0];
   v[2] = &company_;
   v[3] = &home_number_[0];
-  v[4] = &fax_number_[0];
-  v[5] = &address_;
+  v[4] = &address_;
   return v;
 }
 
 const FormGroup* AutofillProfile::FormGroupForType(
     AutofillFieldType type) const {
   return const_cast<AutofillProfile*>(this)->MutableFormGroupForType(type);
 }
 
 FormGroup* AutofillProfile::MutableFormGroupForType(AutofillFieldType type) {
  FormGroup* form_group = NULL;
   switch (AutofillType(type).group()) {
     case AutofillType::NAME:
       form_group = &name_[0];
       break;
     case AutofillType::EMAIL:
       form_group = &email_[0];
       break;
     case AutofillType::COMPANY:
       form_group = &company_;
       break;
     case AutofillType::PHONE_HOME:
       form_group = &home_number_[0];
       break;
-    case AutofillType::PHONE_FAX:
-      form_group = &fax_number_[0];
-      break;
     case AutofillType::ADDRESS_HOME:
       form_group = &address_;
       break;
     default:
       break;
   }
   return form_group;
 }
 
 // So we can compare AutofillProfiles with EXPECT_EQ().
@@ skipping 18 matching lines @@
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_LINE2))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_CITY))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_STATE))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_ZIP))
       << " "
       << UTF16ToUTF8(profile.GetInfo(ADDRESS_HOME_COUNTRY))
       << " "
-      << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER))
-      << " "
-      << UTF16ToUTF8(MultiString(profile, PHONE_FAX_WHOLE_NUMBER));
+      << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }