requestAutocomplete should not unlatinize administrative region names.

third_party/libaddressinput/chromium/cpp/src/rule.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 179 matching lines @@
     return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL
                  : IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL;
   }
   if (postal_code_type == "zip") {
     return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL
                  : IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
   }
   return INVALID_MESSAGE_ID;
 }
 
+// Finds |target| in |values_to_compare| and sets |selected_value| to the
+// associated value from |values_to_select|. Returns true if |target| is in
+// |values_to_compare|. |selected_value| should not be NULL. |values_to_compare|
+// should not be larger than |values_to_select|.
+bool GetMatchingValue(const std::string& target,
+                      const std::vector<std::string>& values_to_compare,
+                      const std::vector<std::string>& values_to_select,
+                      std::string* selected_value) {
+  assert(selected_value != NULL);
+  assert(values_to_select.size() >= values_to_compare.size());
+  for (size_t i = 0; i < values_to_compare.size(); ++i) {
+    if (LooseStringCompare(values_to_compare[i], target)) {
+      *selected_value = values_to_select[i];
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 FormatElement::FormatElement(AddressField field)
     : field(field), literal() {}
 
 FormatElement::FormatElement(const std::string& literal)
     : field(COUNTRY), literal(literal) {
   assert(!literal.empty());
 }
 
@@ skipping 159 matching lines @@
     case DEPENDENT_LOCALITY:
       return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL;
     case POSTAL_CODE:
       return invalid_postal_code_message_id_;
     default:
       return IDS_LIBADDRESSINPUT_I18N_INVALID_ENTRY;
   }
 }
 
 bool Rule::CanonicalizeSubKey(const std::string& user_input,
+                              bool keep_input_latin,
                               std::string* sub_key) const {
+  assert(sub_key != NULL);
+
   if (sub_keys_.empty()) {
     *sub_key = user_input;
     return true;
   }
 
-  return GetMatchingSubKey(user_input, sub_keys_, sub_key) ||
-      GetMatchingSubKey(user_input, sub_names_, sub_key) ||
-      GetMatchingSubKey(user_input, sub_lnames_, sub_key);
-}
-
-bool Rule::GetMatchingSubKey(const std::string& target,
-                             const std::vector<std::string>& values,
-                             std::string* sub_key) const {
-  for (size_t i = 0; i < values.size(); ++i) {
-    if (LooseStringCompare(values[i], target)) {
-      *sub_key = sub_keys_[i];
-      return true;
-    }
-  }
-  return false;
+  return GetMatchingValue(user_input, sub_keys_, sub_keys_, sub_key) ||
+      GetMatchingValue(user_input, sub_names_, sub_keys_, sub_key) ||
+      (keep_input_latin &&
+       GetMatchingValue(user_input, sub_lnames_, sub_lnames_, sub_key)) ||
+      GetMatchingValue(user_input, sub_lnames_, sub_keys_, sub_key);
 }
 
 }  // namespace addressinput
 }  // namespace i18n