[rac] Use stale libaddressinput data if download fails

third_party/libaddressinput/chromium/cpp/src/retriever.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 10 matching lines @@
 #include <libaddressinput/util/scoped_ptr.h>
 
 #include <cassert>
 #include <cstddef>
 #include <map>
 #include <string>
 #include <utility>
 
 #include "fallback_data_store.h"
 #include "util/stl_util.h"
+#include "wrapper.h"
 
 namespace i18n {
 namespace addressinput {
 
+namespace {
+
+// The number of seconds after which data is considered stale. The staleness
+// threshold is 30 days:
+//    30 days *
+//    24 hours per day *
+//    60 minutes per hour *
+//    60 seconds per minute.
+static const double kStaleDataAgeInSeconds = 30.0 * 24.0 * 60.0 * 60.0;
+
+}  // namespace
+
 Retriever::Retriever(const std::string& validation_data_url,
                      scoped_ptr<Downloader> downloader,
                      scoped_ptr<Storage> storage)
     : validation_data_url_(validation_data_url),
       downloader_(downloader.Pass()),
-      storage_(storage.Pass()) {
+      storage_(storage.Pass()),
+      stale_data_() {
   assert(validation_data_url_.length() > 0);
   assert(validation_data_url_[validation_data_url_.length() - 1] == '/');
   assert(storage_ != NULL);
   assert(downloader_ != NULL);
 }
 
 Retriever::~Retriever() {
   STLDeleteValues(&requests_);
 }
 
 void Retriever::Retrieve(const std::string& key,
                          scoped_ptr<Callback> retrieved) {
   std::map<std::string, Callback*>::iterator request_it =
       requests_.find(key);
   if (request_it != requests_.end()) {
     // Abandon a previous request.
     delete request_it->second;
     requests_.erase(request_it);
   }
 
   requests_[key] = retrieved.release();
   storage_->Get(key,
                 BuildCallback(this, &Retriever::OnDataRetrievedFromStorage));
 }
 
 void Retriever::OnDataRetrievedFromStorage(bool success,
                                            const std::string& key,
                                            const std::string& stored_data) {
-  // TODO(rouslan): Add validation for data integrity and freshness. If a
-  // download fails, then it's OK to use stale data.
-  if (success) {
+  std::string unwrapped = stored_data;
+  double age_in_seconds = 0.0;
+  bool valid_format = Wrapper::Unwrap(&unwrapped, &age_in_seconds);
+  if (success && valid_format && age_in_seconds < kStaleDataAgeInSeconds) {
     scoped_ptr<Callback> retrieved = GetCallbackForKey(key);
     if (retrieved != NULL) {
-      (*retrieved)(success, key, stored_data);
+      (*retrieved)(success, key, unwrapped);
     }
   } else {
+    if (success && valid_format) {
+      stale_data_[key] = unwrapped;
+    }
     downloader_->Download(GetUrlForKey(key),
                           BuildCallback(this, &Retriever::OnDownloaded));
   }
 }
 
 void Retriever::OnDownloaded(bool success,
                              const std::string& url,
                              const std::string& downloaded_data) {
   const std::string& key = GetKeyForUrl(url);
   std::string response;
+  std::map<std::string, std::string>::iterator stale_data_it =
+      stale_data_.find(key);
+
   if (success) {
-    storage_->Put(key, downloaded_data);
+    storage_->Put(key, Wrapper::Wrap(downloaded_data));
     response = downloaded_data;
+  } else if (stale_data_it != stale_data_.end()) {
+    success = true;
+    response = stale_data_it->second;
   } else {
     success = FallbackDataStore::Get(key, &response);
   }
 
+  if (stale_data_it != stale_data_.end()) {
+    stale_data_.erase(stale_data_it);
+  }
+
   scoped_ptr<Callback> retrieved = GetCallbackForKey(key);
   if (retrieved != NULL) {
     (*retrieved)(success, key, response);
   }
 }
 
 std::string Retriever::GetUrlForKey(const std::string& key) const {
   return validation_data_url_ + key;
 }
 
@@ skipping 17 matching lines @@
     // An abandonened request.
     return scoped_ptr<Callback>();
   }
   scoped_ptr<Callback> callback(iter->second);
   requests_.erase(iter);
   return callback.Pass();
 }
 
 }  // namespace addressinput
 }  // namespace i18n