Retry downloading rules for libaddressinput.

third_party/libaddressinput/chromium/chrome_address_validator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "third_party/libaddressinput/chromium/chrome_address_validator.h"
 
-#include <cstddef>
-#include <string>
-#include <vector>
+#include <cmath>
 
-#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "third_party/libaddressinput/chromium/addressinput_util.h"
 #include "third_party/libaddressinput/chromium/input_suggester.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
-#include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_field.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_normalizer.h"
-#include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_validator.h"
-#include "third_party/libaddressinput/src/cpp/include/libaddressinput/callback.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/downloader.h"
-#include "third_party/libaddressinput/src/cpp/include/libaddressinput/preload_supplier.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/storage.h"
 
 namespace autofill {
+namespace {
 
 using ::i18n::addressinput::AddressData;
 using ::i18n::addressinput::AddressField;
 using ::i18n::addressinput::AddressNormalizer;
 using ::i18n::addressinput::BuildCallback;
 using ::i18n::addressinput::Downloader;
 using ::i18n::addressinput::FieldProblemMap;
 using ::i18n::addressinput::PreloadSupplier;
 using ::i18n::addressinput::Storage;
 
 using ::i18n::addressinput::ADMIN_AREA;
 using ::i18n::addressinput::DEPENDENT_LOCALITY;
 using ::i18n::addressinput::POSTAL_CODE;
 
+// The number of seconds to wait between the first and second attempts to load

[Evan Stade, 2014/07/16 02:11:25]

this isn't quite right. It's the amount of time between the first attempt's
failure and the second attempt's initiation, right?

[please use gerrit instead, 2014/07/16 23:22:03]

Right. Fixed.

+// rules, if the first attempt failed.
+static const int kLoadRulesRetryPeriodSeconds = 60;

[Evan Stade, 2014/07/16 02:11:25]

I think we should set this lower. As noted above, it already has to wait for a
request to timeout before the retry period starts. So maybe start at 8 seconds?

[please use gerrit instead, 2014/07/16 23:22:03]

Done.

+
+// The maximum number attempts to load rules.
+static const int kMaxAttemptsNumber = 8;
+
+}  // namespace
+
 AddressValidator::AddressValidator(const std::string& validation_data_url,
                                    scoped_ptr<Downloader> downloader,
                                    scoped_ptr<Storage> storage,
                                    LoadRulesListener* load_rules_listener)
     : supplier_(new PreloadSupplier(validation_data_url,
                                     downloader.release(),
                                     storage.release())),
       input_suggester_(new InputSuggester(supplier_.get())),
       normalizer_(new AddressNormalizer(supplier_.get())),
       validator_(new ::i18n::addressinput::AddressValidator(supplier_.get())),
       validated_(BuildCallback(this, &AddressValidator::Validated)),
       rules_loaded_(BuildCallback(this, &AddressValidator::RulesLoaded)),
-      load_rules_listener_(load_rules_listener) {}
+      load_rules_listener_(load_rules_listener),
+      weak_factory_(this) {
+  retrier_.reset(new Retrier(weak_factory_.GetWeakPtr()));
+}
 
 AddressValidator::~AddressValidator() {}
 
 void AddressValidator::LoadRules(const std::string& region_code) {
-  DCHECK(supplier_);
+  retrier_->ResetRetryCount(region_code);
   supplier_->LoadRules(region_code, *rules_loaded_);
 }
 
 AddressValidator::Status AddressValidator::ValidateAddress(
     const AddressData& address,
     const FieldProblemMap* filter,
     FieldProblemMap* problems) const {
-  DCHECK(supplier_);
-  DCHECK(validator_);
-
   if (supplier_->IsPending(address.region_code)) {
     if (problems)
       addressinput::ValidateRequiredFields(address, filter, problems);
     return RULES_NOT_READY;
   }
 
   if (!supplier_->IsLoaded(address.region_code)) {
     if (problems)
       addressinput::ValidateRequiredFields(address, filter, problems);
     return RULES_UNAVAILABLE;
@@ skipping 10 matching lines @@
                        *validated_);
 
   return SUCCESS;
 }
 
 AddressValidator::Status AddressValidator::GetSuggestions(
     const AddressData& user_input,
     AddressField focused_field,
     size_t suggestion_limit,
     std::vector<AddressData>* suggestions) const {
-  DCHECK(supplier_);
-  DCHECK(input_suggester_);
-
   if (supplier_->IsPending(user_input.region_code))
     return RULES_NOT_READY;
 
   if (!supplier_->IsLoaded(user_input.region_code))
     return RULES_UNAVAILABLE;
 
   if (!suggestions)
     return SUCCESS;
 
   suggestions->clear();
 
   if (focused_field == POSTAL_CODE ||
       (focused_field >= ADMIN_AREA && focused_field <= DEPENDENT_LOCALITY)) {
     input_suggester_->GetSuggestions(
         user_input, focused_field, suggestion_limit, suggestions);
   }
 
   return SUCCESS;
 }
 
 bool AddressValidator::CanonicalizeAdministrativeArea(
     AddressData* address) const {
-  DCHECK(address);
-  DCHECK(supplier_);
-  DCHECK(normalizer_);
-
   if (!supplier_->IsLoaded(address->region_code))
     return false;
 
   // TODO: It would probably be beneficial to use the full canonicalization.
   AddressData tmp(*address);
   normalizer_->Normalize(&tmp);
   address->administrative_area = tmp.administrative_area;
 
   return true;
 }
 
-AddressValidator::AddressValidator() : load_rules_listener_(NULL) {}
+AddressValidator::Retrier::Retrier(
+    const base::WeakPtr<AddressValidator>& rule_loader)
+    : rule_loader_(rule_loader),
+      retry_period_(
+          base::TimeDelta::FromSeconds(kLoadRulesRetryPeriodSeconds)) {}
+
+AddressValidator::Retrier::~Retrier() {}
+
+void AddressValidator::Retrier::ResetRetryCount(
+    const std::string& region_code) {
+  attempts_number_[region_code] = 0;
+}
+
+void AddressValidator::Retrier::RetryLoadRules(const std::string& region_code) {
+  // Count the first failed attempt and this attempt as well.
+  if (attempts_number_[region_code] + 2 > kMaxAttemptsNumber)
+    return;

[Evan Stade, 2014/07/16 02:11:25]

nit: \n

[please use gerrit instead, 2014/07/16 23:22:03]

Done.

+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AddressValidator::RetryLoadRules, rule_loader_, region_code),
+      retry_period_ * pow(2, attempts_number_[region_code]++));
+}
+
+AddressValidator::AddressValidator()
+    : load_rules_listener_(NULL), weak_factory_(this) {}
 
 void AddressValidator::Validated(bool success,
                                  const AddressData&,
                                  const FieldProblemMap&) {
   DCHECK(success);
 }
 
 void AddressValidator::RulesLoaded(bool success,
-                                   const std::string& country_code,
+                                   const std::string& region_code,
                                    int) {
   if (load_rules_listener_)
-    load_rules_listener_->OnAddressValidationRulesLoaded(country_code, success);
+    load_rules_listener_->OnAddressValidationRulesLoaded(region_code, success);
+
+  if (success)
+    retrier_->ResetRetryCount(region_code);

[Evan Stade, 2014/07/16 02:11:25]

why do you need to reset it here?

[please use gerrit instead, 2014/07/16 23:22:03]

True, come to think of it, I don't need it. Removed.

+  else
+    retrier_->RetryLoadRules(region_code);
+}
+
+void AddressValidator::RetryLoadRules(const std::string& region_code) {
+  // Do not reset retry count.
+  supplier_->LoadRules(region_code, *rules_loaded_);
 }
 
 }  // namespace autofill