These changes *are* for review :)

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 <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/address.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/contact_info.h"
-#include "chrome/browser/autofill/fax_number.h"
-#include "chrome/browser/autofill/home_phone_number.h"
+#include "chrome/browser/autofill/phone_number.h"
+#include "chrome/browser/autofill/phone_number_i18n.h"
 #include "chrome/common/guid.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Like |AutofillType::GetEquivalentFieldType()|, but also returns |NAME_FULL|
 // for first, middle, and last name field types.
 AutofillFieldType GetEquivalentFieldTypeCollapsingNames(
     AutofillFieldType field_type) {
@@ skipping 80 matching lines @@
     if (i > 0)
       accumulate += ASCIIToUTF16(" ");
     accumulate += values[i];
   }
   return accumulate;
 }
 
 template <class T>
 void CopyValuesToItems(AutofillFieldType type,
                        const std::vector<string16>& values,
-                       std::vector<T>* form_group_items) {
+                       std::vector<T>* form_group_items,
+                       const T& prototype) {
   form_group_items->resize(values.size());
   for (size_t i = 0; i < form_group_items->size(); ++i)
     (*form_group_items)[i].SetInfo(type, CollapseWhitespace(values[i], false));
   // Must have at least one (possibly empty) element.
   if (form_group_items->empty())
-    form_group_items->resize(1);
+    form_group_items->resize(1, prototype);
 }
 
 template <class T>
 void CopyItemsToValues(AutofillFieldType type,
                        const std::vector<T>& form_group_items,
                        std::vector<string16>* values) {
   values->resize(form_group_items.size());
   for (size_t i = 0; i < values->size(); ++i)
     (*values)[i] = form_group_items[i].GetInfo(type);
 }
@@ skipping 30 matching lines @@
         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)
+      : phone_(phone),
+        country_code_(country_code) {
+  }
+
+  bool operator()(const string16& phone) {
+    return autofill_i18n::PhoneNumbersMatch(phone, phone_, country_code_);
+  }
+
+  bool operator()(const string16* phone) {
+    return autofill_i18n::PhoneNumbersMatch(*phone, phone_, country_code_);
+  }
+
+ private:
+  string16 phone_;
+  std::string country_code_;
+};
+
 }  // namespace
 
 AutofillProfile::AutofillProfile(const std::string& guid)
-    : guid_(guid), name_(1), email_(1), home_number_(1), fax_number_(1) {
+    : guid_(guid),
+      name_(1),
+      email_(1),
+      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME)),
+      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX)) {
 }
 
 AutofillProfile::AutofillProfile()
     : guid_(guid::GenerateGUID()),
       name_(1),
       email_(1),
-      home_number_(1),
-      fax_number_(1) {
+      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME)),
+      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX)) {
 }
 
 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
     : FormGroup() {
   operator=(profile);
 }
 
 AutofillProfile::~AutofillProfile() {
 }
 
@@ skipping 40 matching lines @@
 void AutofillProfile::SetInfo(AutofillFieldType type, const string16& value) {
   FormGroup* form_group = MutableFormGroupForType(type);
   if (form_group)
     form_group->SetInfo(type, CollapseWhitespace(value, false));
 }
 
 void AutofillProfile::SetMultiInfo(AutofillFieldType type,
                                    const std::vector<string16>& values) {
   switch (AutofillType(type).group()) {
     case AutofillType::NAME:
-      CopyValuesToItems(type, values, &name_);
+      CopyValuesToItems(type, values, &name_, NameInfo());
       break;
     case AutofillType::EMAIL:
-      CopyValuesToItems(type, values, &email_);
+      CopyValuesToItems(type, values, &email_, EmailInfo());
       break;
     case AutofillType::PHONE_HOME:
-      CopyValuesToItems(type, values, &home_number_);
+      CopyValuesToItems(type,
+                        values,
+                        &home_number_,
+                        PhoneNumber(AutofillType::PHONE_HOME));
       break;
     case AutofillType::PHONE_FAX:
-      CopyValuesToItems(type, values, &fax_number_);
+      CopyValuesToItems(type,
+                        values,
+                        &fax_number_,
+                        PhoneNumber(AutofillType::PHONE_FAX));
       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 187 matching lines @@
 
 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
   return !operator==(profile);
 }
 
 const string16 AutofillProfile::PrimaryValue() const {
   return GetInfo(ADDRESS_HOME_LINE1) +
          GetInfo(ADDRESS_HOME_CITY);
 }
 
+bool AutofillProfile::NormalizePhones() {
+  // Successful either if nothing to parse, or everything is parsed correctly.
+  bool success = true;
+  for (size_t i = 0; i < home_number_.size(); ++i) {
+    home_number_[i].set_locale(CountryCode());
+    if (!home_number_[i].NormalizePhone())
+      success = false;
+  }
+  for (size_t i = 0; i < fax_number_.size(); ++i) {
+    fax_number_[i].set_locale(CountryCode());
+    if (!fax_number_[i].NormalizePhone())
+      success = false;
+  }
+  return success;
+}
+
 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile) {
   FieldTypeSet field_types;
   profile.GetNonEmptyTypes(&field_types);
 
   // Only transfer "full" types (e.g. full name) and not fragments (e.g.
   // first name, last name).
   CollapseCompoundFieldTypes(&field_types);
 
   for (FieldTypeSet::const_iterator iter = field_types.begin();
        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 (std::find(existing_values.begin(), existing_values.end(),
-                      *value_iter) == existing_values.end()) {
-          existing_values.insert(existing_values.end(), *value_iter);
+        if (group == AutofillType::PHONE_HOME ||
+            group == AutofillType::PHONE_FAX) {
+          AddPhoneIfUnique(*value_iter, &existing_values);
+        } else {
+          if (std::find(existing_values.begin(), existing_values.end(),
+                        *value_iter) == existing_values.end()) {
+            existing_values.insert(existing_values.end(), *value_iter);
+          }
         }
       }
       SetMultiInfo(*iter, existing_values);
     } else {
       SetInfo(*iter, profile.GetInfo(*iter));
     }
   }
 }
 
+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.
+  std::vector<string16>::const_iterator phone_iter;
+  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();
@@ skipping 163 matching lines @@
       << 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));
 }