libaddressinput string translations

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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include <libaddressinput/address_validator.h>
 
 #include <libaddressinput/address_data.h>
 #include <libaddressinput/downloader.h>
 #include <libaddressinput/load_rules_delegate.h>
-#include <libaddressinput/localization.h>
 #include <libaddressinput/storage.h>
 #include <libaddressinput/util/basictypes.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <map>
 #include <set>
 #include <string>
@@ skipping 59 matching lines @@
       aggregator_.AggregateRules(
           country_code,
           BuildScopedPtrCallback(this, &AddressValidatorImpl::OnRulesLoaded));
     }
   }
 
   // AddressValidator implementation.
   virtual Status ValidateAddress(
       const AddressData& address,
       const AddressProblemFilter& filter,
-      const Localization& localization,
       AddressProblems* problems) const {
     std::map<std::string, const Ruleset*>::const_iterator ruleset_it =
         rules_.find(address.country_code);
     if (ruleset_it == rules_.end()) {
       return loading_rules_.find(address.country_code) != loading_rules_.end()
           ? RULES_NOT_READY
           : RULES_UNAVAILABLE;
     }
 
     const Ruleset* ruleset = ruleset_it->second;
     assert(ruleset != NULL);
     const Rule& country_rule =
         ruleset->GetLanguageCodeRule(address.language_code);
 
     // Validate required fields.
     for (std::vector<AddressField>::const_iterator
              field_it = country_rule.GetRequired().begin();
          field_it != country_rule.GetRequired().end();
          ++field_it) {
       if (address.GetField(*field_it).empty() &&
           FilterAllows(
               filter, *field_it, AddressProblem::MISSING_REQUIRED_FIELD)) {
         problems->push_back(AddressProblem(
             *field_it,
             AddressProblem::MISSING_REQUIRED_FIELD,
-            localization.GetString(
-                IDS_LIBADDRESSINPUT_I18N_MISSING_REQUIRED_FIELD)));
+            IDS_LIBADDRESSINPUT_I18N_MISSING_REQUIRED_FIELD));
       }
     }
 
     // Validate general postal code format. A country-level rule specifies the
     // regular expression for the whole postal code.
     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,
-          localization.GetString(
-              country_rule.GetInvalidPostalCodeMessageId())));
+          country_rule.GetInvalidPostalCodeMessageId()));
     }
 
     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);
       const std::string& sub_field = address.GetField(sub_field_type);
       const std::vector<std::string>& sub_keys = rule.GetSubKeys();
       if (!sub_field.empty() &&
           !sub_keys.empty() &&
           FilterAllows(filter, sub_field_type, AddressProblem::UNKNOWN_VALUE) &&
           std::find(sub_keys.begin(), sub_keys.end(), sub_field) ==
               sub_keys.end()) {
         problems->push_back(AddressProblem(
             sub_field_type,
             AddressProblem::UNKNOWN_VALUE,
-            localization.GetString(
-                country_rule.GetInvalidFieldMessageId(sub_field_type))));
+            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.
       int match_position = -1;
       if (ruleset->field() > COUNTRY &&
           !address.postal_code.empty() &&
           !rule.GetPostalCodeFormat().empty() &&
           FilterAllows(filter,
                        POSTAL_CODE,
                        AddressProblem::MISMATCHING_VALUE) &&
           (!RE2::PartialMatch(address.postal_code,
                               rule.GetPostalCodeFormat(),
                               &match_position) ||
            match_position != 0)) {
         problems->push_back(AddressProblem(
             POSTAL_CODE,
             AddressProblem::MISMATCHING_VALUE,
-            localization.GetString(
-                country_rule.GetInvalidPostalCodeMessageId())));
+            country_rule.GetInvalidPostalCodeMessageId()));
       }
 
       ruleset = ruleset->GetSubRegionRuleset(sub_field);
     }
 
     return SUCCESS;
   }
 
  private:
   // Called when CountryRulesAggregator::AggregateRules loads the |ruleset| for
@@ skipping 37 matching lines @@
 scoped_ptr<AddressValidator> AddressValidator::Build(
     scoped_ptr<Downloader> downloader,
     scoped_ptr<Storage> storage,
     LoadRulesDelegate* load_rules_delegate) {
   return scoped_ptr<AddressValidator>(new AddressValidatorImpl(
       downloader.Pass(), storage.Pass(), load_rules_delegate));
 }
 
 }  // namespace addressinput
 }  // namespace i18n