Autofill i18n: Set postal code and state field labels based on the selected country.

chrome/browser/autofill/address.cc

 // Copyright (c) 2010 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/address.h"
 
 #include "base/basictypes.h"
 #include "base/string_util.h"
+#include "chrome/browser/autofill/autofill_country.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/field_types.h"
 
 namespace {
 
 const char16 kAddressSplitChars[] = {'-', ',', '#', '.', ' ', 0};
 
 const AutoFillType::FieldTypeSubGroup kAutoFillAddressTypes[] = {
   AutoFillType::ADDRESS_LINE1,
   AutoFillType::ADDRESS_LINE2,
@@ skipping 54 matching lines @@
 
   if (!city_.empty())
     available_types->insert(ADDRESS_HOME_CITY);
 
   if (!state_.empty())
     available_types->insert(ADDRESS_HOME_STATE);
 
   if (!zip_code_.empty())
     available_types->insert(ADDRESS_HOME_ZIP);
 
-  if (!country_.empty())
+  if (!country_code_.empty())
     available_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 void Address::FindInfoMatches(const AutoFillType& type,
                               const string16& info,
                               std::vector<string16>* matched_text) const {
   DCHECK(matched_text);
 
   string16 match;
   if (type.field_type() == UNKNOWN_TYPE) {
@@ skipping 18 matching lines @@
   if (field_type == ADDRESS_HOME_CITY)
     return city_;
 
   if (field_type == ADDRESS_HOME_STATE)
     return state_;
 
   if (field_type ==  ADDRESS_HOME_ZIP)
     return zip_code_;
 
   if (field_type == ADDRESS_HOME_COUNTRY)
-    return country_;
+    return Country();
 
   return string16();
 }
 
 void Address::SetInfo(const AutoFillType& type, const string16& value) {
   FieldTypeSubGroup subgroup = type.subgroup();
   if (subgroup == AutoFillType::ADDRESS_LINE1)
     set_line1(value);
   else if (subgroup == AutoFillType::ADDRESS_LINE2)
     set_line2(value);
   else if (subgroup == AutoFillType::ADDRESS_CITY)
     city_ = value;
   else if (subgroup == AutoFillType::ADDRESS_STATE)
     state_ = value;
   else if (subgroup == AutoFillType::ADDRESS_COUNTRY)
-    country_ = value;
+    SetCountry(value);
   else if (subgroup == AutoFillType::ADDRESS_ZIP)
     zip_code_ = value;
   else
     NOTREACHED();
 }
 
 void Address::Clear() {
   line1_tokens_.clear();
   line1_.clear();
   line2_tokens_.clear();
   line2_.clear();
   city_.clear();
   state_.clear();
-  country_.clear();
+  country_code_.clear();
   zip_code_.clear();
 }
 
 Address::Address(const Address& address)
     : FormGroup(),
       line1_tokens_(address.line1_tokens_),
       line2_tokens_(address.line2_tokens_),
       line1_(address.line1_),
       line2_(address.line2_),
       city_(address.city_),
       state_(address.state_),
-      country_(address.country_),
+      country_code_(address.country_code_),
       zip_code_(address.zip_code_) {
 }
 
+string16 Address::Country() const {
+  if (country_code().empty())
+    return string16();
+
+  std::string app_locale = AutoFillCountry::ApplicationLocale();
+  return AutoFillCountry(country_code(), app_locale).name();
+}
+
 void Address::set_line1(const string16& line1) {
   line1_ = line1;
   line1_tokens_.clear();
   Tokenize(line1, kAddressSplitChars, &line1_tokens_);
   LineTokens::iterator iter;
   for (iter = line1_tokens_.begin(); iter != line1_tokens_.end(); ++iter)
     *iter = StringToLowerASCII(*iter);
 }
 
 void Address::set_line2(const string16& line2) {
   line2_ = line2;
   line2_tokens_.clear();
   Tokenize(line2, kAddressSplitChars, &line2_tokens_);
   LineTokens::iterator iter;
   for (iter = line2_tokens_.begin(); iter != line2_tokens_.end(); ++iter)
     *iter = StringToLowerASCII(*iter);
 }
 
+void Address::SetCountry(const string16& country) {
+  std::string app_locale = AutoFillCountry::ApplicationLocale();
+  country_code_ = AutoFillCountry::GetCountryCode(country, app_locale);
+}
+
 bool Address::IsLine1(const string16& text) const {
   return IsLineMatch(text, line1_tokens_);
 }
 
 bool Address::IsLine2(const string16& text) const {
   return IsLineMatch(text, line2_tokens_);
 }
 
 bool Address::IsCity(const string16& text) const {
   return (StringToLowerASCII(city_) == StringToLowerASCII(text));
 }
 
 bool Address::IsState(const string16& text) const {
   return (StringToLowerASCII(state_) == StringToLowerASCII(text));
 }
 
 bool Address::IsCountry(const string16& text) const {
-  return (StringToLowerASCII(country_) == StringToLowerASCII(text));
+  std::string app_locale = AutoFillCountry::ApplicationLocale();
+  std::string country_code = AutoFillCountry::GetCountryCode(text, app_locale);
+  return (!country_code.empty() && country_code_ == country_code);
 }
 
 bool Address::IsZipCode(const string16& text) const {
   return zip_code_ == text;
 }
 
 bool Address::FindInfoMatchesHelper(const FieldTypeSubGroup& subgroup,
                                     const string16& info,
                                     string16* match) const {
   DCHECK(match);
 
   match->clear();
   if (subgroup == AutoFillType::ADDRESS_LINE1 &&
       StartsWith(line1_, info, false)) {
     *match = line1_;
   } else if (subgroup == AutoFillType::ADDRESS_LINE2 &&
              StartsWith(line2_, info, false)) {
     *match = line2_;
   } else if (subgroup == AutoFillType::ADDRESS_CITY &&
              StartsWith(city_, info, false)) {
     *match = city_;
   } else if (subgroup == AutoFillType::ADDRESS_STATE &&
              StartsWith(state_, info, false)) {
     *match = state_;
   } else if (subgroup == AutoFillType::ADDRESS_COUNTRY &&
-             StartsWith(country_, info, false)) {
-    *match = country_;
+             StartsWith(Country(), info, false)) {
+    *match = Country();
   } else if (subgroup == AutoFillType::ADDRESS_ZIP &&
              StartsWith(zip_code_, info, true)) {
     *match = zip_code_;
   }
 
   return !match->empty();
 }
 
 bool Address::IsLineMatch(const string16& text,
                           const LineTokens& line_tokens) const {
@@ skipping 24 matching lines @@
 bool Address::IsWordInLine(const string16& word,
                            const LineTokens& line_tokens) const {
   LineTokens::const_iterator iter;
   for (iter = line_tokens.begin(); iter != line_tokens.end(); ++iter) {
     if (StringToLowerASCII(word) == *iter)
       return true;
   }
 
   return false;
 }