[Autofill] Ensure that clients pass the correct region info when parsing phone numbers.

chrome/browser/autofill/phone_number.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/phone_number.h"
 
 #include "base/basictypes.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 10 matching lines @@
 // The number of digits in a phone number.
 const size_t kPhoneNumberLength = 7;
 
 // The number of digits in an area code.
 const size_t kPhoneCityCodeLength = 3;
 
 void StripPunctuation(string16* number) {
   RemoveChars(*number, kPhoneNumberSeparators, number);
 }
 
+// Returns the region code for this phone number, which is an ISO 3166 2-letter
+// country code.  The returned value is based on the |profile|; if the |profile|
+// does not have a country code associated with it, falls back to the country
+// code corresponding to the |app_locale|.
+std::string GetRegion(const AutofillProfile& profile,
+                      const std::string& app_locale) {
+  std::string country_code = profile.CountryCode();
+  if (!country_code.empty())
+    return country_code;
+
+  return AutofillCountry::CountryCodeForLocale(app_locale);
+}
+
 }  // namespace
 
 PhoneNumber::PhoneNumber(AutofillProfile* profile)
     : profile_(profile) {
 }
 
 PhoneNumber::PhoneNumber(const PhoneNumber& number)
     : FormGroup(),
       profile_(NULL) {
   *this = number;
@@ skipping 49 matching lines @@
 // If the phone cannot be normalized, returns the stored value verbatim.
 string16 PhoneNumber::GetInfo(AutofillFieldType type,
                               const std::string& app_locale) const {
   if (type == PHONE_HOME_WHOLE_NUMBER) {
     // Whole numbers require special handling: If normalization for the number
     // fails, return the non-normalized number instead.
     string16 phone = GetRawInfo(type);
 
     // TODO(isherman): Can/should this use the cached_parsed_phone_?
     string16 normalized_phone =
-        autofill_i18n::NormalizePhoneNumber(phone, GetRegion(app_locale));
+        autofill_i18n::NormalizePhoneNumber(phone,
+                                            GetRegion(*profile_, app_locale));
     return !normalized_phone.empty() ? normalized_phone : phone;
   }
 
   UpdateCacheIfNeeded(app_locale);
   if (!cached_parsed_phone_.IsValidNumber())
     return string16();
 
   switch (type) {
     case PHONE_HOME_NUMBER:
       return cached_parsed_phone_.GetNumber();
@@ skipping 38 matching lines @@
 void PhoneNumber::GetMatchingTypes(const string16& text,
                                    const std::string& app_locale,
                                    FieldTypeSet* matching_types) const {
   string16 stripped_text = text;
   StripPunctuation(&stripped_text);
   FormGroup::GetMatchingTypes(stripped_text, app_locale, matching_types);
 
   // For US numbers, also compare to the three-digit prefix and the four-digit
   // suffix, since web sites often split numbers into these two fields.
   string16 number = GetInfo(PHONE_HOME_NUMBER, app_locale);
-  if (GetRegion(app_locale) == "US" &&
+  if (GetRegion(*profile_, app_locale) == "US" &&
       number.size() == (kPrefixLength + kSuffixLength)) {
     string16 prefix = number.substr(kPrefixOffset, kPrefixLength);
     string16 suffix = number.substr(kSuffixOffset, kSuffixLength);
     if (text == prefix || text == suffix)
       matching_types->insert(PHONE_HOME_NUMBER);
   }
 
   string16 whole_number = GetInfo(PHONE_HOME_WHOLE_NUMBER, app_locale);
   if (!whole_number.empty()) {
     string16 normalized_number =
-        autofill_i18n::NormalizePhoneNumber(text, GetRegion(app_locale));
+        autofill_i18n::NormalizePhoneNumber(text,
+                                            GetRegion(*profile_, app_locale));
     if (normalized_number == whole_number)
       matching_types->insert(PHONE_HOME_WHOLE_NUMBER);
   }
 }
 
-std::string PhoneNumber::GetRegion(const std::string& app_locale) const {
-  const std::string country_code = profile_->CountryCode();
-  if (country_code.empty())
-    return AutofillCountry::CountryCodeForLocale(app_locale);
-
-  return country_code;
-}
-
 void PhoneNumber::UpdateCacheIfNeeded(const std::string& app_locale) const {
-  std::string region = GetRegion(app_locale);
+  std::string region = GetRegion(*profile_, app_locale);
   if (!number_.empty() && cached_parsed_phone_.GetRegion() != region)
     cached_parsed_phone_ = autofill_i18n::PhoneObject(number_, region);
 }
 
 PhoneNumber::PhoneCombineHelper::PhoneCombineHelper() {
 }
 
 PhoneNumber::PhoneCombineHelper::~PhoneCombineHelper() {
 }
 
@@ skipping 20 matching lines @@
   }
 
   if (field_type == PHONE_HOME_NUMBER) {
     phone_.append(value);
     return true;
   }
 
   return false;
 }
 
-bool PhoneNumber::PhoneCombineHelper::ParseNumber(const std::string& region,
-                                                  string16* value) {
+bool PhoneNumber::PhoneCombineHelper::ParseNumber(
+    const AutofillProfile& profile,
+    const std::string& app_locale,
+    string16* value) {
+  if (IsEmpty())
+    return false;
+
   if (!whole_number_.empty()) {
     *value = whole_number_;
     return true;
   }
 
   return autofill_i18n::ConstructPhoneNumber(
-      country_, city_, phone_, region,
+      country_, city_, phone_, GetRegion(profile, app_locale),
       (country_.empty() ?
           autofill_i18n::NATIONAL : autofill_i18n::INTERNATIONAL),
       value);
 }
 
 bool PhoneNumber::PhoneCombineHelper::IsEmpty() const {
   return phone_.empty() && whole_number_.empty();
 }