requestAutocomplete should not unlatinize administrative region names.

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 202 matching lines @@
     while (ruleset != NULL) {
       const Rule& rule = ruleset->GetLanguageCodeRule(address.language_code);
 
       // Validate the field values, e.g. state names in US.
       AddressField sub_field_type =
           static_cast<AddressField>(ruleset->field() + 1);
       std::string sub_key;
       const std::string& user_input = address.GetFieldValue(sub_field_type);
       if (!user_input.empty() &&
           FilterAllows(filter, sub_field_type, AddressProblem::UNKNOWN_VALUE) &&
-          !rule.CanonicalizeSubKey(user_input, &sub_key)) {
+          !rule.CanonicalizeSubKey(user_input, false, &sub_key)) {
         problems->push_back(AddressProblem(
             sub_field_type,
             AddressProblem::UNKNOWN_VALUE,
             country_rule.GetInvalidFieldMessageId(sub_field_type)));
       }
 
       // Validate sub-region specific postal code format. A sub-region specifies
       // the regular expression for a prefix of the postal code.
       if (ruleset->field() > COUNTRY &&
           !address.postal_code.empty() &&
@@ skipping 202 matching lines @@
   virtual bool CanonicalizeAdministrativeArea(AddressData* address_data) const {
     std::map<std::string, Ruleset*>::const_iterator ruleset_it =
         rules_.find(address_data->country_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);
   }
 
  private:
   // Called when CountryRulesAggregator::AggregateRules loads the |ruleset| for
   // the |country_code|.
   void OnRulesLoaded(bool success,
                      const std::string& country_code,
                      scoped_ptr<Ruleset> ruleset) {
     assert(rules_.find(country_code) == rules_.end());
@@ skipping 67 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