Reland of "Use address_data.h from upstream libaddressinput".

third_party/libaddressinput/chromium/cpp/src/address_validator.cc

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 214 matching lines @@
           BuildScopedPtrCallback(this, &AddressValidatorImpl::OnRulesLoaded));
     }
   }
 
   // AddressValidator implementation.
   virtual Status ValidateAddress(
       const AddressData& address,
       const AddressProblemFilter& filter,
       AddressProblems* problems) const {
     std::map<std::string, Ruleset*>::const_iterator ruleset_it =
-        rules_.find(address.country_code);
+        rules_.find(address.region_code);
 
     // We can still validate the required fields even if the full ruleset isn't
     // ready.
     if (ruleset_it == rules_.end()) {
       if (problems != NULL) {
         Rule rule;
         rule.CopyFrom(Rule::GetDefault());
         if (rule.ParseSerializedRule(
-                 RegionDataConstants::GetRegionData(address.country_code))) {
+                 RegionDataConstants::GetRegionData(address.region_code))) {
           EnforceRequiredFields(rule, address, filter, problems);
         }
       }
 
-      return loading_rules_.find(address.country_code) != loading_rules_.end()
+      return loading_rules_.find(address.region_code) != loading_rules_.end()
           ? RULES_NOT_READY
           : RULES_UNAVAILABLE;
     }
 
     if (problems == NULL) {
       return SUCCESS;
     }
 
     const Ruleset* ruleset = ruleset_it->second;
     assert(ruleset != NULL);
@@ skipping 54 matching lines @@
 
     return SUCCESS;
   }
 
   // AddressValidator implementation.
   virtual Status GetSuggestions(const AddressData& user_input,
                                 AddressField focused_field,
                                 size_t suggestions_limit,
                                 std::vector<AddressData>* suggestions) const {
     std::map<std::string, Ruleset*>::const_iterator ruleset_it =
-        rules_.find(user_input.country_code);
+        rules_.find(user_input.region_code);
 
     if (ruleset_it == rules_.end()) {
       return
-          loading_rules_.find(user_input.country_code) != loading_rules_.end()
+          loading_rules_.find(user_input.region_code) != loading_rules_.end()
               ? RULES_NOT_READY
               : RULES_UNAVAILABLE;
     }
 
     if (suggestions == NULL) {
       return SUCCESS;
     }
     suggestions->clear();
 
     assert(ruleset_it->second != NULL);
@@ skipping 131 matching lines @@
         rule_field = Rule::KEY;
       } else if (matching_rule_fields.test(Rule::NAME)) {
         rule_field = Rule::NAME;
       } else if (matching_rule_fields.test(Rule::LATIN_NAME)) {
         rule_field = Rule::LATIN_NAME;
       } else {
         assert(false);
       }
 
       AddressData suggestion;
-      suggestion.country_code = user_input.country_code;
+      suggestion.region_code = user_input.region_code;
       suggestion.postal_code = user_input.postal_code;
 
       // Traverse the tree of rulesets from the most specific |ruleset| to the
       // country-wide "root" of the tree. Use the region names found at each of
       // the levels of the ruleset tree to build the |suggestion|.
       for (const Ruleset* suggestion_ruleset = &ruleset;
            suggestion_ruleset->parent() != NULL;
            suggestion_ruleset = suggestion_ruleset->parent()) {
         const Rule& suggestion_rule =
             suggestion_ruleset->GetLanguageCodeRule(user_input.language_code);
         suggestion.SetFieldValue(suggestion_ruleset->field(),
                                  suggestion_rule.GetIdentityField(rule_field));
       }
 
       suggestions->push_back(suggestion);
     }
 
     return SUCCESS;
   }
 
   // AddressValidator implementation.
   virtual bool CanonicalizeAdministrativeArea(AddressData* address_data) const {
     std::map<std::string, Ruleset*>::const_iterator ruleset_it =
-        rules_.find(address_data->country_code);
+        rules_.find(address_data->region_code);
     if (ruleset_it == rules_.end()) {
       return false;
     }
     const Rule& rule =
         ruleset_it->second->GetLanguageCodeRule(address_data->language_code);
 
     return rule.CanonicalizeSubKey(address_data->administrative_area,
                                    true,  // Keep input latin.
                                    &address_data->administrative_area);
   }
@@ skipping 22 matching lines @@
                              const AddressData& address,
                              const AddressProblemFilter& filter,
                              AddressProblems* problems) const {
     assert(problems != NULL);
     for (std::vector<AddressField>::const_iterator
              field_it = country_rule.GetRequired().begin();
          field_it != country_rule.GetRequired().end();
          ++field_it) {
       bool field_empty = *field_it != STREET_ADDRESS
           ? address.GetFieldValue(*field_it).empty()
-          : IsEmptyStreetAddress(address.address_lines);
+          : IsEmptyStreetAddress(address.address_line);
       if (field_empty &&
           FilterAllows(
               filter, *field_it, AddressProblem::MISSING_REQUIRED_FIELD)) {
         problems->push_back(AddressProblem(
             *field_it,
             AddressProblem::MISSING_REQUIRED_FIELD,
             IDS_LIBADDRESSINPUT_I18N_MISSING_REQUIRED_FIELD));
       }
     }
   }
@@ skipping 32 matching lines @@
     scoped_ptr<Downloader> downloader,
     scoped_ptr<Storage> storage,
     LoadRulesDelegate* load_rules_delegate) {
   return scoped_ptr<AddressValidator>(new AddressValidatorImpl(
       validation_data_url, downloader.Pass(), storage.Pass(),
       load_rules_delegate));
 }
 
 }  // namespace addressinput
 }  // namespace i18n