Remove application locale cache in autofill code.

components/autofill/browser/phone_number_i18n.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 "components/autofill/browser/phone_number_i18n.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "components/autofill/browser/autofill_country.h"
 #include "third_party/libphonenumber/src/phonenumber_api.h"
 
 using i18n::phonenumbers::PhoneNumber;
 using i18n::phonenumbers::PhoneNumberUtil;
 
 namespace {
 
-std::string SanitizeRegion(const std::string& region) {
+std::string SanitizeRegion(const std::string& region,
+                           const std::string& app_locale) {
   if (region.length() == 2)
     return region;
 
-  return AutofillCountry::CountryCodeForLocale(
-      AutofillCountry::ApplicationLocale());
+  return AutofillCountry::CountryCodeForLocale(app_locale);
 }
 
 // Returns true if |phone_number| is valid.
 bool IsValidPhoneNumber(const PhoneNumber& phone_number) {
   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
   if (!phone_util->IsPossibleNumber(phone_number))
     return false;
 
   // Verify that the number has a valid area code (that in some cases could be
   // empty) for the parsed country code.  Also verify that this is a valid
@@ skipping 105 matching lines @@
         !StartsWith(normalized_number, *country_code,
                     true /* case_sensitive */)) {
       country_code->clear();
     }
   }
 
   return true;
 }
 
 string16 NormalizePhoneNumber(const string16& value,
-                              std::string const& region) {
+                              const std::string& region) {
+  DCHECK_EQ(2u, region.size());
   string16 country_code;
   string16 unused_city_code;
   string16 unused_number;
   PhoneNumber phone_number;
-  if (!ParsePhoneNumber(value, SanitizeRegion(region), &country_code,
-                        &unused_city_code, &unused_number, &phone_number)) {
+  if (!ParsePhoneNumber(value, region, &country_code, &unused_city_code,
+                        &unused_number, &phone_number)) {
     return string16();  // Parsing failed - do not store phone.
   }
 
   string16 normalized_number;
   FormatValidatedNumber(phone_number, country_code, NULL, &normalized_number);
   return normalized_number;
 }
 
 bool ConstructPhoneNumber(const string16& country_code,
                           const string16& city_code,
                           const string16& number,
                           const std::string& region,
                           string16* whole_number) {
+  DCHECK_EQ(2u, region.size());
   whole_number->clear();
 
   string16 unused_country_code;
   string16 unused_city_code;
   string16 unused_number;
   PhoneNumber phone_number;
-  if (!ParsePhoneNumber(country_code + city_code + number,
-                        SanitizeRegion(region),
+  if (!ParsePhoneNumber(country_code + city_code + number, region,
                         &unused_country_code, &unused_city_code, &unused_number,
                         &phone_number)) {
     return false;
   }
 
   FormatValidatedNumber(phone_number, country_code, whole_number, NULL);
   return true;
 }
 
 bool PhoneNumbersMatch(const string16& number_a,
                        const string16& number_b,
-                       const std::string& raw_region) {
+                       const std::string& raw_region,
+                       const std::string& app_locale) {
   // Sanitize the provided |raw_region| before trying to use it for parsing.
-  const std::string region = SanitizeRegion(raw_region);
+  const std::string region = SanitizeRegion(raw_region, app_locale);
 
   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
 
   // Parse phone numbers based on the region
   PhoneNumber i18n_number1;
   if (phone_util->Parse(UTF16ToUTF8(number_a), region.c_str(), &i18n_number1) !=
           PhoneNumberUtil::NO_PARSING_ERROR) {
     return false;
   }
 
@@ skipping 11 matching lines @@
       return false;
     case PhoneNumberUtil::NSN_MATCH:
     case PhoneNumberUtil::EXACT_MATCH:
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
-PhoneObject::PhoneObject(const string16& number, const std::string& region)
-    : region_(SanitizeRegion(region)),
+PhoneObject::PhoneObject(const string16& number,
+                         const std::string& region)
+    : region_(region),
       i18n_number_(NULL) {
+  DCHECK_EQ(2u, region.size());
   // TODO(isherman): Autofill profiles should always have a |region| set, but in
   // some cases it should be marked as implicit.  Otherwise, phone numbers
   // might behave differently when they are synced across computers:
   // [ http://crbug.com/100845 ].  Once the bug is fixed, add a DCHECK here to
   // verify.
 
   scoped_ptr<PhoneNumber> i18n_number(new PhoneNumber);
   if (ParsePhoneNumber(number, region_, &country_code_, &city_code_, &number_,
                        i18n_number.get())) {
     // The phone number was successfully parsed, so store the parsed version.
@@ skipping 49 matching lines @@
   city_code_ = other.city_code_;
   number_ = other.number_;
 
   formatted_number_ = other.formatted_number_;
   whole_number_ = other.whole_number_;
 
   return *this;
 }
 
 }  // namespace autofill_i18n