[rac] Download all rules for a country code in libaddressinput.

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 30 matching lines @@
   assert(storage_ != NULL);
   assert(downloader_ != NULL);
 }
 
 Retriever::~Retriever() {
   STLDeleteValues(&requests_);
 }
 
 void Retriever::Retrieve(const std::string& key,
                          scoped_ptr<Callback> retrieved) {
-  assert(requests_.find(key) == requests_.end());
-  requests_.insert(std::make_pair(key, retrieved.release()));
+  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& data) {
+  // TODO(rouslan): Add validation for data integrity and freshness. If a
+  // download fails, then it's OK to use stale data.
   if (success) {
     scoped_ptr<Callback> retrieved = GetCallbackForKey(key);
-    (*retrieved)(success, key, data);
+    if (retrieved != NULL) {
+      (*retrieved)(success, key, data);
+    }
   } else {
     downloader_->Download(lookup_key_util_.GetUrlForKey(key),
                           BuildCallback(this, &Retriever::OnDownloaded));
   }
 }
 
 void Retriever::OnDownloaded(bool success,
                              const std::string& url,
                              const std::string& data) {
   const std::string& key = lookup_key_util_.GetKeyForUrl(url);
   if (success) {
     storage_->Put(key, data);
   }
   scoped_ptr<Callback> retrieved = GetCallbackForKey(key);
-  (*retrieved)(success, key, success ? data : std::string());
+  if (retrieved != NULL) {
+    (*retrieved)(success, key, success ? data : std::string());
+  }
 }
 
 scoped_ptr<Retriever::Callback> Retriever::GetCallbackForKey(
     const std::string& key) {
   std::map<std::string, Callback*>::iterator iter =
       requests_.find(key);
-  assert(iter != requests_.end());
+  if (iter == requests_.end()) {
+    // An abandonened request.
+    return scoped_ptr<Callback>();
+  }
   scoped_ptr<Callback> callback(iter->second);
   requests_.erase(iter);
   return callback.Pass();
 }
 
 }  // namespace addressinput
 }  // namespace i18n