Revert of Determine language code and type of format for address.

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,
 // 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 "rule.h"
 
 #include <libaddressinput/address_field.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
 #include <cassert>
 #include <cstddef>
 #include <string>
 #include <vector>
 
 #include "grit.h"
 #include "grit/libaddressinput_strings.h"
 #include "region_data_constants.h"
 #include "util/json.h"
-#include "util/string_util.h"
+#include "util/string_compare.h"
+#include "util/string_split.h"
 
 namespace i18n {
 namespace addressinput {
 
 namespace {
 
 bool ParseToken(char c, AddressField* field) {
   assert(field != NULL);
   switch (c) {
     case 'R':
@@ skipping 171 matching lines @@
 
 bool FormatElement::operator==(const FormatElement& other) const {
   return field == other.field && literal == other.literal;
 }
 
 Rule::Rule()
     : key_(),
       name_(),
       latin_name_(),
       format_(),
-      latin_format_(),
       required_(),
       sub_keys_(),
       sub_names_(),
       sub_lnames_(),
       languages_(),
-      input_languages_(),
       language_(),
       postal_code_format_(),
       admin_area_name_message_id_(INVALID_MESSAGE_ID),
       invalid_admin_area_message_id_(INVALID_MESSAGE_ID),
       postal_code_name_message_id_(INVALID_MESSAGE_ID),
       invalid_postal_code_message_id_(INVALID_MESSAGE_ID) {}
 
 Rule::~Rule() {}
 
 // static
 const Rule& Rule::GetDefault() {
   // Allocated once and leaked on shutdown.
   static Rule* default_rule = NULL;
   if (default_rule == NULL) {
     default_rule = new Rule;
     default_rule->ParseSerializedRule(
         RegionDataConstants::GetDefaultRegionData());
   }
   return *default_rule;
 }
 
 void Rule::CopyFrom(const Rule& rule) {
   key_ = rule.key_;
   name_ = rule.name_;
   latin_name_ = rule.latin_name_;
   format_ = rule.format_;
-  latin_format_ = rule.latin_format_;
   required_ = rule.required_;
   sub_keys_ = rule.sub_keys_;
   languages_ = rule.languages_;
-  input_languages_ = rule.input_languages_;
   language_ = rule.language_;
   sub_keys_ = rule.sub_keys_;
   sub_names_ = rule.sub_names_;
   sub_lnames_ = rule.sub_lnames_;
   postal_code_format_ = rule.postal_code_format_;
   admin_area_name_message_id_ = rule.admin_area_name_message_id_;
   invalid_admin_area_message_id_ = rule.invalid_admin_area_message_id_;
   postal_code_name_message_id_ = rule.postal_code_name_message_id_;
   invalid_postal_code_message_id_ = rule.invalid_postal_code_message_id_;
 }
@@ skipping 18 matching lines @@
   }
 
   if (json_rule.GetStringValueForKey("lname", &value)) {
     latin_name_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("fmt", &value)) {
     ParseAddressFieldsFormat(value, &format_);
   }
 
-  if (json_rule.GetStringValueForKey("lfmt", &value)) {
-    ParseAddressFieldsFormat(value, &latin_format_);
-  }
-
   if (json_rule.GetStringValueForKey("require", &value)) {
     ParseAddressFieldsRequired(value, &required_);
   }
 
   // Used as a separator in a list of items. For example, the list of supported
   // languages can be "de~fr~it".
   static const char kSeparator = '~';
   if (json_rule.GetStringValueForKey("sub_keys", &value)) {
     SplitString(value, kSeparator, &sub_keys_);
   }
 
   if (json_rule.GetStringValueForKey("sub_names", &value)) {
     SplitString(value, kSeparator, &sub_names_);
     assert(sub_names_.size() == sub_keys_.size());
   }
 
   if (json_rule.GetStringValueForKey("sub_lnames", &value)) {
     SplitString(value, kSeparator, &sub_lnames_);
     assert(sub_lnames_.size() == sub_keys_.size());
   }
 
   if (json_rule.GetStringValueForKey("languages", &value)) {
     SplitString(value, kSeparator, &languages_);
   }
 
-  if (json_rule.GetStringValueForKey("input_languages", &value)) {
-    SplitString(value, kSeparator, &input_languages_);
-  }
-
   if (json_rule.GetStringValueForKey("lang", &value)) {
     language_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("zip", &value)) {
     postal_code_format_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("state_name_type", &value)) {
     admin_area_name_message_id_ = GetAdminAreaMessageId(value, false);
@@ skipping 54 matching lines @@
     if (LooseStringCompare(values[i], target)) {
       *sub_key = sub_keys_[i];
       return true;
     }
   }
   return false;
 }
 
 }  // namespace addressinput
 }  // namespace i18n