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 "base/utf_string_conversions.h"

[James Hawkins, 2011/02/16 19:49:01]

Where is it used?

[Ilya Sherman, 2011/02/17 23:09:11]

Removed.  I wish cpplint.py would tell me about things like this though!

+#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 57 matching lines @@
 
   if (!city().empty())
     available_types->insert(GetCityType());
 
   if (!state().empty())
     available_types->insert(GetStateType());
 
   if (!zip_code().empty())
     available_types->insert(GetZipCodeType());
 
-  if (!country().empty())
+  if (!country_code().empty())
     available_types->insert(GetCountryType());
 }
 
 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 21 matching lines @@
   if (field_type == GetCityType())
     return city();
 
   if (field_type == GetStateType())
     return state();
 
   if (field_type ==  GetZipCodeType())
     return zip_code();
 
   if (field_type == GetCountryType())
-    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_APT_NUM)
     set_apt_num(value);
   else if (subgroup == AutoFillType::ADDRESS_CITY)
     set_city(value);
   else if (subgroup == AutoFillType::ADDRESS_STATE)
     set_state(value);
   else if (subgroup == AutoFillType::ADDRESS_COUNTRY)
-    set_country(value);
+    SetCountry(value);
   else if (subgroup == AutoFillType::ADDRESS_ZIP)
     set_zip_code(value);
   else
     NOTREACHED();
 }
 
 void Address::Clear() {
   line1_tokens_.clear();
   line1_.clear();
   line2_tokens_.clear();
   line2_.clear();
   apt_num_.clear();
   city_.clear();
   state_.clear();
-  country_.clear();
+  country_code_.clear();
   zip_code_.clear();
 }
 
 void Address::Clone(const Address& address) {
-  set_line1(address.line1());
-  set_line2(address.line2());
-  set_apt_num(address.apt_num());
-  set_city(address.city());
-  set_state(address.state());
-  set_country(address.country());
-  set_zip_code(address.zip_code());
+  line1_tokens_ = address.line1_tokens_;
+  line2_tokens_ = address.line2_tokens_;
+  line1_ = address.line1_;
+  line2_ = address.line2_;
+  apt_num_ = address.apt_num_;
+  city_ = address.city_;
+  state_ = address.state_;
+  country_code_ = address.country_code_;
+  zip_code_ = address.zip_code_;
 }
 
 Address::Address(const Address& address)
     : FormGroup(),
       line1_tokens_(address.line1_tokens_),
       line2_tokens_(address.line2_tokens_),
       line1_(address.line1_),
       line2_(address.line2_),
       apt_num_(address.apt_num_),
       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();
+
+  return AutoFillCountry(country_code()).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) {
+  country_code_ = AutoFillCountry::GetCountryCode(country);
+}
+
 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::IsAptNum(const string16& text) const {
   return (StringToLowerASCII(apt_num_) == StringToLowerASCII(text));
 }
 
 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 country_code = AutoFillCountry::GetCountryCode(text);
+  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_APT_NUM &&
              StartsWith(apt_num(), info, false)) {
     *match = apt_num();
   } 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;
 }