[rac] Download country code data in a single HTTP request.

third_party/libaddressinput/chromium/cpp/src/country_rules_aggregator.cc

 // Copyright (C) 2014 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 "country_rules_aggregator.h"
 
 #include <libaddressinput/address_field.h>
 #include <libaddressinput/callback.h>
-#include <libaddressinput/util/basictypes.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <map>
 #include <string>
-#include <utility>
+#include <vector>
 
 #include "retriever.h"
 #include "rule.h"
 #include "ruleset.h"
-#include "util/stl_util.h"
+#include "util/json.h"
 
 namespace i18n {
 namespace addressinput {
 
-// Information about data requests sent to Retriever. This data is not returned
-// as part of the ruleset, but is useful in constructing the ruleset
-// asynchronously.
-struct CountryRulesAggregator::RequestData {
-  // Does not take ownership of |parent|.
-  RequestData(Ruleset* parent,
-              AddressField level,
-              bool is_language_code,
-              const std::string& id)
-      : parent(parent),
-        level(level),
-        is_language_code(is_language_code),
-        id(id) {
-    assert(parent != NULL || level == COUNTRY);
-  }
-
-  ~RequestData() {}
-
-  // The parent ruleset of the data being downloaded. If NULL, then this is the
-  // root ruleset at the COUNTRY level. The language-specific and sub-region
-  // rules are added to this ruleset. Owned by |CountryRulesRetriever|.
-  Ruleset* parent;
-
-  // The level of the data being requested. Ranges from COUNTRY to
-  // DEPENDENT_LOCALITY. If COUNTRY, then the rule should use default rules from
-  // Rule::GetDefault().
-  AddressField level;
-
-  // If true, then |id| is a language. The data received for this request should
-  // be placed into a language-specific rule.
-  bool is_language_code;
-
-  // Can be a region name (e.g. "CA") or a language (e.g. "fr"). Used to add a
-  // sub-region or a language-specific rule to |parent|.
-  std::string id;
-};
-
 CountryRulesAggregator::CountryRulesAggregator(scoped_ptr<Retriever> retriever)
     : retriever_(retriever.Pass()),
-      requests_(),
       country_code_(),
+      key_(),
       rules_ready_(),
-      root_(),
-      default_language_(),
-      languages_() {
+      json_(),
+      non_default_languages_() {
   assert(retriever_ != NULL);
 }
 
 CountryRulesAggregator::~CountryRulesAggregator() {}
 
 void CountryRulesAggregator::AggregateRules(const std::string& country_code,
                                             scoped_ptr<Callback> rules_ready) {
   Reset();
   country_code_ = country_code;
   rules_ready_.reset(rules_ready.release());
 
   // Key construction:
   // https://code.google.com/p/libaddressinput/wiki/AddressValidationMetadata
   // Example of a country-level key: "data/CA".
-  std::string key = "data/" + country_code_;
-  requests_.insert(std::make_pair(
-      key, RequestData(NULL, COUNTRY, false, std::string())));
-
+  key_ = "data/" + country_code_;
   retriever_->Retrieve(
-      key, BuildCallback(this, &CountryRulesAggregator::OnDataReady));
+      key_, BuildCallback(this, &CountryRulesAggregator::OnDataReady));
 }
 
 void CountryRulesAggregator::OnDataReady(bool success,
                                          const std::string& key,
                                          const std::string& data) {
-  std::map<std::string, RequestData>::iterator request_it =
-      requests_.find(key);
-  if (request_it == requests_.end()) {
+  if (key != key_) {
     return;  // An abandoned request.
   }
 
-  if (!success) {
+  json_ = Json::Build().Pass();
+  if (!success || !json_->ParseObject(data)) {
     (*rules_ready_)(false, country_code_, scoped_ptr<Ruleset>());
     Reset();
     return;
   }
 
-  RequestData request = request_it->second;
-  requests_.erase(request_it);
+  scoped_ptr<Ruleset> ruleset = Build(key_, COUNTRY);
+  (*rules_ready_)(ruleset != NULL, country_code_, ruleset.Pass());
+  Reset();
+}
 
-  // All country-level rules are based on the default rule.
-  scoped_ptr<Rule> rule(new Rule);
-  if (request.level == COUNTRY) {
-    rule->CopyFrom(Rule::GetDefault());
+scoped_ptr<Ruleset> CountryRulesAggregator::Build(const std::string& key,
+                                                  AddressField field) {
+  scoped_ptr<Rule> rule = ParseRule(key, field);
+  if (rule == NULL) {
+    return scoped_ptr<Ruleset>();
   }
 
-  if (!rule->ParseSerializedRule(data)) {
-    (*rules_ready_)(false, country_code_, scoped_ptr<Ruleset>());
-    Reset();
-    return;
-  }
-
-  // Place the rule in the correct location in the ruleset.
-  Ruleset* ruleset = NULL;
-  if (request.is_language_code) {
-    assert(request.parent != NULL);
-    request.parent->AddLanguageCodeRule(request.id, rule.Pass());
-    ruleset = request.parent;
-  } else if (request.level == COUNTRY) {
-    // The default language and all supported languages for the country code are
-    // in the country-level rule without a language code identifier. For
-    // example: "data/CA".
-    default_language_ = rule->GetLanguage();
-    languages_ = rule->GetLanguages();
-
-    root_.reset(new Ruleset(request.level, rule.Pass()));
-    ruleset = root_.get();
-  } else {
-    assert(request.parent != NULL);
-    ruleset = new Ruleset(request.level, rule.Pass());
-    request.parent->AddSubRegionRuleset(
-        request.id, scoped_ptr<Ruleset>(ruleset));
-  }
-
-  if (!request.is_language_code) {
-    // Retrieve the language-specific rules for this region.
-    for (std::vector<std::string>::const_iterator
-             lang_it = languages_.begin();
-         lang_it != languages_.end();
-         ++lang_it) {
-      if (*lang_it == default_language_) {
-        continue;
-      }
-      // Example of a language-specific key: "data/CA--fr".
-      std::string language_code_key = key + "--" + *lang_it;
-      requests_.insert(std::make_pair(
-          key, RequestData(ruleset, request.level, true, *lang_it)));
-      retriever_->Retrieve(
-          language_code_key,
-          BuildCallback(this, &CountryRulesAggregator::OnDataReady));
-    }
-
-    if (request.level < DEPENDENT_LOCALITY) {
-      // Retrieve the sub-region rules for this region.
-      for (std::vector<std::string>::const_iterator
-               subkey_it = ruleset->rule().GetSubKeys().begin();
-           subkey_it != ruleset->rule().GetSubKeys().end();
-           ++subkey_it) {
-        // Example of a sub-region key: "data/CA/AB".
-        std::string sub_region_key = key + "/" + *subkey_it;
-        requests_.insert(std::make_pair(
-            key,
-            RequestData(ruleset,
-                        static_cast<AddressField>(request.level + 1),
-                        false,
-                        *subkey_it)));
-        retriever_->Retrieve(
-            sub_region_key,
-            BuildCallback(this, &CountryRulesAggregator::OnDataReady));
-      }
+  // Determine the languages that have language-specific rules. For example,
+  // the default language in Switzerland is "de", but "fr" and "it" have
+  // language specific rules.
+  if (field == COUNTRY) {
+    non_default_languages_ = rule->GetLanguages();
+    std::vector<std::string>::iterator default_language_it =
+        std::find(non_default_languages_.begin(),
+                  non_default_languages_.end(),
+                  rule->GetLanguage());
+    if (default_language_it != non_default_languages_.end()) {
+      non_default_languages_.erase(default_language_it);
     }
   }
 
-  if (requests_.empty()) {
-    (*rules_ready_)(true, country_code_, root_.Pass());
-    Reset();
+  scoped_ptr<Ruleset> ruleset(new Ruleset(field, rule.Pass()));
+
+  // Parse the language-specific rules. For example, parse the rules for "fr"
+  // and "it" languages in Switzerland.
+  for (std::vector<std::string>::const_iterator
+            lang_it = non_default_languages_.begin();
+        lang_it != non_default_languages_.end(); ++lang_it) {
+    scoped_ptr<Rule> lang_rule = ParseRule(key + "--" + *lang_it, field);
+    if (lang_rule == NULL) {
+      return scoped_ptr<Ruleset>();
+    }
+    ruleset->AddLanguageCodeRule(*lang_it, lang_rule.Pass());
   }
+
+  // A dependent locality rule should not have sub-keys.
+  assert(field != DEPENDENT_LOCALITY || ruleset->rule().GetSubKeys().empty());

[Evan Stade, 2014/01/22 01:22:03]

even this seems out of place to me; I might expect it somewhere in the Ruleset
class but not here. Also, here you assert, but in other places you (silently)
return early after detecting bad data. That doesn't seem consistent.

[please use gerrit instead, 2014/01/22 01:46:21]

Done.

+
+  // Parse the sub-keys. For example, parse the rules for all of the states in
+  // US: "CA", "TX", "NY", etc.
+  for (std::vector<std::string>::const_iterator
+            subkey_it = ruleset->rule().GetSubKeys().begin();
+        subkey_it != ruleset->rule().GetSubKeys().end(); ++subkey_it) {

[Evan Stade, 2014/01/22 01:22:03]

indent is off by one

[please use gerrit instead, 2014/01/22 01:46:21]

Done.

+    scoped_ptr<Ruleset> sub_ruleset =
+        Build(key + "/" + *subkey_it, static_cast<AddressField>(field + 1));
+    if (sub_ruleset == NULL) {
+      return scoped_ptr<Ruleset>();
+    }
+    ruleset->AddSubRegionRuleset(*subkey_it, sub_ruleset.Pass());
+  }
+
+  return ruleset.Pass();
+}
+
+scoped_ptr<Rule> CountryRulesAggregator::ParseRule(const std::string& key,
+                                                   AddressField field) const {
+  scoped_ptr<Json> value;
+  if (!json_->GetJsonValueForKey(key, &value) || value == NULL) {
+    return scoped_ptr<Rule>();
+  }
+  scoped_ptr<Rule> rule(new Rule);
+  if (field == COUNTRY) {
+    rule->CopyFrom(Rule::GetDefault());
+  }
+  rule->ParseJsonRule(*value);
+  return rule.Pass();
 }
 
 void CountryRulesAggregator::Reset() {
-  requests_.clear();
   country_code_.clear();
+  key_.clear();
   rules_ready_.reset();
-  root_.reset();
-  default_language_.clear();
-  languages_.clear();
+  json_.reset();
+  non_default_languages_.clear();
 }
 
 }  // namespace addressinput
 }  // namespace i18n