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 141 matching lines @@
         collapsed_set.insert(*iter);
     }
   }
   std::swap(*type_set, collapsed_set);
 }
 
 }  // namespace
 
 AutofillProfile::AutofillProfile(const std::string& guid)
     : guid_(guid), name_(1), email_(1), home_number_(1), fax_number_(1) {
+  // Set the type of the phones - it is set on first SetInfo() call.

[dhollowa, 2011/05/13 18:55:35]

Better to use the vector initializer to set the phone/fax types here, i.e.:

AutofillProfile::AutofillProfile(const std::string& guid)
    : guid_(guid), name_(1), email_(1),
      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME)),
      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX)) {

[GeorgeY, 2011/05/18 17:41:45]

Done.

+  home_number_[0].SetInfo(PHONE_HOME_WHOLE_NUMBER, string16());
+  fax_number_[0].SetInfo(PHONE_FAX_WHOLE_NUMBER, string16());
 }
 
 AutofillProfile::AutofillProfile()
     : guid_(guid::GenerateGUID()),
       name_(1),
       email_(1),
       home_number_(1),
       fax_number_(1) {
+  // Set the type of the phones - it is set on first SetInfo() call.

[dhollowa, 2011/05/13 18:55:35]

Better to use the vector initializer to set the phone/fax types here, i.e.:

AutofillProfile::AutofillProfile(const std::string& guid)
    : guid_(guid), name_(1), email_(1),
      home_number_(1, PhoneNumber(AutofillType::PHONE_HOME)),
      fax_number_(1, PhoneNumber(AutofillType::PHONE_FAX)) {

[GeorgeY, 2011/05/18 17:41:45]

Done.

+  home_number_[0].SetInfo(PHONE_HOME_WHOLE_NUMBER, string16());
+  fax_number_[0].SetInfo(PHONE_FAX_WHOLE_NUMBER, string16());
 }
 
 AutofillProfile::AutofillProfile(const AutofillProfile& profile)
     : FormGroup() {
   operator=(profile);
 }
 
 AutofillProfile::~AutofillProfile() {
 }
 
@@ skipping 46 matching lines @@
 void AutofillProfile::SetMultiInfo(AutofillFieldType type,
                                    const std::vector<string16>& values) {
   switch (AutofillType(type).group()) {
     case AutofillType::NAME:
       CopyValuesToItems(type, values, &name_);
       break;
     case AutofillType::EMAIL:
       CopyValuesToItems(type, values, &email_);
       break;
     case AutofillType::PHONE_HOME:
       CopyValuesToItems(type, values, &home_number_);

[dhollowa, 2011/05/13 18:55:35]

Let's keep the initialization logic cohesive within |CopyValuesToItems|.  Like
this:

Here:
      CopyValuesToItems(type, values, &home_number_,
                        PhoneNumber(AutofillType::PHONE_HOME));

And add a |prototype| parameter to |CopyValuesToItems| like this:

void CopyValuesToItems(AutofillFieldType type,
                       const std::vector<string16>& values,
                       std::vector<T>* form_group_items,
                       const T& prototype) {
...
  if (form_group_items->empty())
    form_group_items->resize(1, prototype);
}

[GeorgeY, 2011/05/18 17:41:45]

OK

+      // If it was cleared, set the type.
+      if (values.empty())
+        home_number_[0].SetInfo(PHONE_HOME_WHOLE_NUMBER, string16());
       break;
     case AutofillType::PHONE_FAX:
       CopyValuesToItems(type, values, &fax_number_);
+      // If it was cleared, set the type.
+      if (values.empty())
+        fax_number_[0].SetInfo(PHONE_FAX_WHOLE_NUMBER, string16());
       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 ||

[dhollowa, 2011/05/13 18:55:35]

A few things here:
 (1) Let's split this logic out into a helper function to keep things readable. 
Maybe something like |bool AddPhoneOrFax(...)|

 (2) We should use |autofill_i18n::PhoneNumbersMatch| here I believe,

 (3) I to keep consistent with existing use of |std::find| let's use
|std::find_if| in conjunction with |autofill_i18n::PhoneNumbersMatch|.

[GeorgeY, 2011/05/18 17:41:45]

Done.

+            group == AutofillType::PHONE_FAX) {
+          // 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;
+          for (phone_iter = existing_values.begin();
+               phone_iter != existing_values.end();
+               ++phone_iter) {
+             autofill_i18n::PhoneMatch match = autofill_i18n::ComparePhones(
+                 *phone_iter, *value_iter, CountryCode());
+             if (match == autofill_i18n::PHONES_EQUAL ||
+                 match == autofill_i18n::PHONES_SUBMATCH) {
+               break;
+             }
+          }
+          // Add phone if it does not match any other.
+          if (phone_iter == existing_values.end())
+            existing_values.insert(existing_values.end(), *value_iter);
+        } 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));
     }
   }
 }
 
 string16 AutofillProfile::ConstructInferredLabel(
@@ skipping 172 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));
 }