autocomplete: add ability to get full address (hidden behind a flag).

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 16 matching lines @@
 #include <cstddef>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include <re2/re2.h>
 
 #include "country_rules_aggregator.h"
+#include "grit.h"
 #include "grit/libaddressinput_strings.h"
 #include "region_data_constants.h"
 #include "retriever.h"
 #include "rule.h"
 #include "ruleset.h"
 #include "util/stl_util.h"
 #include "util/string_util.h"
 
 namespace i18n {
 namespace addressinput {
@@ skipping 43 matching lines @@
 bool IsEmptyStreetAddress(const std::vector<std::string>& street_address) {
   for (std::vector<std::string>::const_iterator it = street_address.begin();
        it != street_address.end(); ++it) {
     if (!it->empty()) {
       return false;
     }
   }
   return true;
 }
 
+// Returns the ID of the string that should be displayed when the given field
+// is invalid in the context of |country_rule|.
+int GetInvalidFieldMessageId(const Rule& country_rule, AddressField field) {
+  switch (field) {
+    case LOCALITY:
+      return IDS_LIBADDRESSINPUT_I18N_INVALID_LOCALITY_LABEL;
+    case DEPENDENT_LOCALITY:
+      return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL;
+
+    case ADMIN_AREA: {
+      const std::string& admin_area_name_type =
+          country_rule.GetAdminAreaNameType();
+      if (admin_area_name_type == "area") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_AREA;
+      }
+      if (admin_area_name_type == "county") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_COUNTY_LABEL;
+      }
+      if (admin_area_name_type == "department") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPARTMENT;
+      }
+      if (admin_area_name_type == "district") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL;
+      }
+      if (admin_area_name_type == "do_si") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI;
+      }
+      if (admin_area_name_type == "emirate") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_EMIRATE;
+      }
+      if (admin_area_name_type == "island") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_ISLAND;
+      }
+      if (admin_area_name_type == "parish") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_PARISH;
+      }
+      if (admin_area_name_type == "prefecture") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_PREFECTURE;
+      }
+      if (admin_area_name_type == "province") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_PROVINCE;
+      }
+      if (admin_area_name_type == "state") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_STATE_LABEL;
+      }
+      return INVALID_MESSAGE_ID;
+    }
+
+    case POSTAL_CODE: {
+      const std::string& postal_code_name_type =
+          country_rule.GetPostalCodeNameType();
+      if (postal_code_name_type == "postal") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL;
+      }
+      if (postal_code_name_type == "zip") {
+        return IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL;
+      }
+      return INVALID_MESSAGE_ID;
+    }
+
+    default:
+      return IDS_LIBADDRESSINPUT_I18N_INVALID_ENTRY;
+  }
+}
+
 // Collects rulesets based on whether they have a parent in the given list.
 class ParentedRulesetCollector {
  public:
   // Retains a reference to both of the parameters. Does not make a copy of
   // |parent_rulesets|. Does not take ownership of |rulesets_with_parents|. The
   // |rulesets_with_parents| parameter should not be NULL.
   ParentedRulesetCollector(const Rulesets& parent_rulesets,
                            Rulesets* rulesets_with_parents)
       : parent_rulesets_(parent_rulesets),
         rulesets_with_parents_(rulesets_with_parents) {
@@ skipping 90 matching lines @@
     if (!address.postal_code.empty() &&
         !country_rule.GetPostalCodeFormat().empty() &&
         FilterAllows(filter,
                      POSTAL_CODE,
                      AddressProblem::UNRECOGNIZED_FORMAT) &&
         !RE2::FullMatch(
             address.postal_code, country_rule.GetPostalCodeFormat())) {
       problems->push_back(AddressProblem(
           POSTAL_CODE,
           AddressProblem::UNRECOGNIZED_FORMAT,
-          country_rule.GetInvalidPostalCodeMessageId()));
+          GetInvalidFieldMessageId(country_rule, POSTAL_CODE)));
     }
 
     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, false, &sub_key)) {
         problems->push_back(AddressProblem(
             sub_field_type,
             AddressProblem::UNKNOWN_VALUE,
-            country_rule.GetInvalidFieldMessageId(sub_field_type)));
+            GetInvalidFieldMessageId(country_rule, 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() &&
           !rule.GetPostalCodeFormat().empty() &&
           FilterAllows(filter,
                        POSTAL_CODE,
                        AddressProblem::MISMATCHING_VALUE) &&
           !ValueMatchesPrefixRegex(
               address.postal_code, rule.GetPostalCodeFormat())) {
         problems->push_back(AddressProblem(
             POSTAL_CODE,
             AddressProblem::MISMATCHING_VALUE,
-            country_rule.GetInvalidPostalCodeMessageId()));
+            GetInvalidFieldMessageId(country_rule, POSTAL_CODE)));
       }
 
       ruleset = ruleset->GetSubRegionRuleset(sub_key);
     }
 
     return SUCCESS;
   }
 
   // AddressValidator implementation.
   virtual Status GetSuggestions(const AddressData& user_input,
@@ skipping 270 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