Remove application locale cache in autofill code.

components/autofill/browser/autofill_profile.cc

 // Copyright (c) 2012 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/autofill_profile.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <ostream>
@@ skipping 168 matching lines @@
 
       default:
         collapsed_set.insert(*iter);
     }
   }
   std::swap(*type_set, collapsed_set);
 }
 
 class FindByPhone {
  public:
-  FindByPhone(const string16& phone, const std::string& country_code)
+  FindByPhone(const string16& phone,
+              const std::string& country_code,
+              const std::string& app_locale)
       : phone_(phone),
-        country_code_(country_code) {
+        country_code_(country_code),
+        app_locale_(app_locale) {
   }
 
   bool operator()(const string16& phone) {
-    return autofill_i18n::PhoneNumbersMatch(phone, phone_, country_code_);
+    return autofill_i18n::PhoneNumbersMatch(
+        phone, phone_, country_code_, app_locale_);
   }
 
   bool operator()(const string16* phone) {
-    return autofill_i18n::PhoneNumbersMatch(*phone, phone_, country_code_);
+    return autofill_i18n::PhoneNumbersMatch(
+        *phone, phone_, country_code_, app_locale_);
   }
 
  private:
   string16 phone_;
   std::string country_code_;
+  std::string app_locale_;
 };
 
 // Functor used to check for case-insensitive equality of two strings.
 struct CaseInsensitiveStringEquals
     : public std::binary_function<string16, string16, bool>
 {
   bool operator()(const string16& x, const string16& y) const {
     return
         x.size() == y.size() && StringToLowerASCII(x) == StringToLowerASCII(y);
   }
@@ skipping 126 matching lines @@
 }
 
 void AutofillProfile::GetMultiInfo(AutofillFieldType type,
                                    const std::string& app_locale,
                                    std::vector<string16>* values) const {
   GetMultiInfoImpl(type, app_locale, values);
 }
 
 void AutofillProfile::FillFormField(const AutofillField& field,
                                     size_t variant,
+                                    const std::string& app_locale,
                                     FormFieldData* field_data) const {
   AutofillFieldType type = field.type();
   DCHECK_NE(AutofillType::CREDIT_CARD, AutofillType(type).group());
   DCHECK(field_data);
 
   if (type == PHONE_HOME_NUMBER) {
-    FillPhoneNumberField(field, variant, field_data);
+    FillPhoneNumberField(field, variant, app_locale, field_data);
   } else if (field_data->form_control_type == "select-one") {
-    FillSelectControl(type, field_data);
+    FillSelectControl(type, app_locale, field_data);
   } else {
     std::vector<string16> values;
-    GetMultiInfo(type, AutofillCountry::ApplicationLocale(), &values);
+    GetMultiInfo(type, app_locale, &values);
     if (variant >= values.size()) {
       // If the variant is unavailable, bail.  This case is reachable, for
       // example if Sync updates a profile during the filling process.
       return;
     }
 
     field_data->value = values[variant];
   }
 }
 
 void AutofillProfile::FillPhoneNumberField(const AutofillField& field,
                                            size_t variant,
+                                           const std::string& app_locale,
                                            FormFieldData* field_data) const {
   std::vector<string16> values;
-  GetMultiInfo(field.type(), AutofillCountry::ApplicationLocale(), &values);
+  GetMultiInfo(field.type(), app_locale, &values);
   DCHECK(variant < values.size());
 
   // If we are filling a phone number, check to see if the size field
   // matches the "prefix" or "suffix" sizes and fill accordingly.
   string16 number = values[variant];
   if (number.length() ==
           PhoneNumber::kPrefixLength + PhoneNumber::kSuffixLength) {
     if (field.phone_part() == AutofillField::PHONE_PREFIX ||
         field_data->max_length == PhoneNumber::kPrefixLength) {
       number = number.substr(PhoneNumber::kPrefixOffset,
                              PhoneNumber::kPrefixLength);
     } else if (field.phone_part() == AutofillField::PHONE_SUFFIX ||
                field_data->max_length == PhoneNumber::kSuffixLength) {
       number = number.substr(PhoneNumber::kSuffixOffset,
                              PhoneNumber::kSuffixLength);
     }
   }
 
   field_data->value = number;
 }
 
 const string16 AutofillProfile::Label() const {
   return label_;
 }
 
-bool AutofillProfile::IsEmpty() const {
+bool AutofillProfile::IsEmpty(const std::string& app_locale) const {
   FieldTypeSet types;
-  GetNonEmptyTypes(AutofillCountry::ApplicationLocale(), &types);
+  GetNonEmptyTypes(app_locale, &types);
   return types.empty();
 }
 
 int AutofillProfile::Compare(const AutofillProfile& profile) const {
   const AutofillFieldType single_value_types[] = { COMPANY_NAME,
                                                    ADDRESS_HOME_LINE1,
                                                    ADDRESS_HOME_LINE2,
                                                    ADDRESS_HOME_CITY,
                                                    ADDRESS_HOME_STATE,
                                                    ADDRESS_HOME_ZIP,
@@ skipping 36 matching lines @@
 }
 
 bool AutofillProfile::operator!=(const AutofillProfile& profile) const {
   return !operator==(profile);
 }
 
 const string16 AutofillProfile::PrimaryValue() const {
   return GetRawInfo(ADDRESS_HOME_LINE1) + GetRawInfo(ADDRESS_HOME_CITY);
 }
 
-bool AutofillProfile::IsSubsetOf(const AutofillProfile& profile) const {
+bool AutofillProfile::IsSubsetOf(const AutofillProfile& profile,
+                                 const std::string& app_locale) const {
   FieldTypeSet types;
-  GetNonEmptyTypes(AutofillCountry::ApplicationLocale(), &types);
+  GetNonEmptyTypes(app_locale, &types);
 
   for (FieldTypeSet::const_iterator iter = types.begin(); iter != types.end();
        ++iter) {
     if (*iter == NAME_FULL) {
       // Ignore the compound "full name" field type.  We are only interested in
       // comparing the constituent parts.  For example, if |this| has a middle
       // name saved, but |profile| lacks one, |profile| could still be a subset
       // of |this|.
       continue;
     } else if (AutofillType(*iter).group() == AutofillType::PHONE) {
       // Phone numbers should be canonicalized prior to being compared.
       if (*iter != PHONE_HOME_WHOLE_NUMBER) {
         continue;
       } else if (!autofill_i18n::PhoneNumbersMatch(
             GetRawInfo(*iter),
             profile.GetRawInfo(*iter),
-            UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY)))) {
+            UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY)),
+            app_locale)) {
         return false;
       }
     } else if (StringToLowerASCII(GetRawInfo(*iter)) !=
                    StringToLowerASCII(profile.GetRawInfo(*iter))) {
       return false;
     }
   }
 
   return true;
 }
 
-void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile) {
+void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile,
+                                           const std::string& app_locale) {
   FieldTypeSet field_types;
-  profile.GetNonEmptyTypes(AutofillCountry::ApplicationLocale(), &field_types);
+  profile.GetNonEmptyTypes(app_locale, &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.GetRawMultiInfo(*iter, &new_values);
       std::vector<string16> existing_values;
       GetRawMultiInfo(*iter, &existing_values);
 
       // GetMultiInfo always returns at least one element, even if the profile
       // has no data stored for this field type.
       if (existing_values.size() == 1 && existing_values.front().empty())
         existing_values.clear();
 
       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) {
-          AddPhoneIfUnique(*value_iter, &existing_values);
+          AddPhoneIfUnique(*value_iter, app_locale, &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);
         }
       }
       SetRawMultiInfo(*iter, existing_values);
     } else {
@@ skipping 76 matching lines @@
     }
   }
 }
 
 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);
 }
 
-bool AutofillProfile::FillCountrySelectControl(FormFieldData* field_data)
-    const {
+bool AutofillProfile::FillCountrySelectControl(
+    const std::string& app_locale,
+    FormFieldData* field_data) const {
   std::string country_code = UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY));
-  std::string app_locale = AutofillCountry::ApplicationLocale();
 
   DCHECK_EQ(field_data->option_values.size(),
             field_data->option_contents.size());
   for (size_t i = 0; i < field_data->option_values.size(); ++i) {
     // Canonicalize each <option> value to a country code, and compare to the
     // target country code.
     string16 value = field_data->option_values[i];
     string16 contents = field_data->option_contents[i];
     if (country_code == AutofillCountry::GetCountryCode(value, app_locale) ||
         country_code == AutofillCountry::GetCountryCode(contents, app_locale)) {
@@ skipping 18 matching lines @@
     case AutofillType::PHONE:
       CopyItemsToValues(type, home_number_, app_locale, values);
       break;
     default:
       values->resize(1);
       (*values)[0] = GetFormGroupInfo(*this, type, app_locale);
   }
 }
 
 void AutofillProfile::AddPhoneIfUnique(const string16& phone,
+                                       const std::string& app_locale,
                                        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.
-  if (std::find_if(
-          existing_phones->begin(), existing_phones->end(),
-          FindByPhone(phone, UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY)))) ==
+  std::string country_code = UTF16ToASCII(GetRawInfo(ADDRESS_HOME_COUNTRY));
+  if (std::find_if(existing_phones->begin(), existing_phones->end(),
+                   FindByPhone(phone, country_code, app_locale)) ==
       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_ADDRESS_SUMMARY_SEPARATOR);
@@ skipping 158 matching lines @@
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))
       << " "
       << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))
       << " "
       << UTF16ToUTF8(MultiString(profile, PHONE_HOME_WHOLE_NUMBER));
 }