Add HostCachePersistenceManager for Cronet

net/dns/host_cache.cc

 // Copyright (c) 2012 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 "net/dns/host_cache.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 230 matching lines @@
   DCHECK_GT(max_entries_, size());
   DCHECK_EQ(0u, entries_.count(key));
   entries_.insert(std::make_pair(key, entry));
   DCHECK_GE(max_entries_, size());
 }
 
 void HostCache::OnNetworkChange() {
   ++network_changes_;
 }
 
+void HostCache::set_persistence_delegate(PersistenceDelegate* delegate) {
+  // A PersistenceDelegate shouldn't be added if there already was one, and
+  // shouldn't be removed (by setting to nullptr) if it wasn't previously there.
+  DCHECK_NE(delegate == nullptr, delegate_ == nullptr);
+  delegate_ = delegate;
+}
+
 void HostCache::clear() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   RecordEraseAll(ERASE_CLEAR, base::TimeTicks::Now());
 
   // Don't bother scheduling a write if there's nothing to clear.
   if (size() == 0)
     return;
 
   entries_.clear();
   if (delegate_)
@@ skipping 20 matching lines @@
       changed = true;
     }
 
     it = next_it;
   }
 
   if (delegate_ && changed)
     delegate_->ScheduleWrite();
 }
 
-std::unique_ptr<base::ListValue> HostCache::GetAsListValue(
-    bool include_staleness) const {
-  std::unique_ptr<base::ListValue> entry_list(new base::ListValue());
+void HostCache::GetAsListValue(base::ListValue* entry_list,
+                               bool include_staleness) const {
+  DCHECK(entry_list);
+  entry_list->Clear();
 
   for (const auto& pair : entries_) {
     const Key& key = pair.first;
     const Entry& entry = pair.second;
 
     std::unique_ptr<base::DictionaryValue> entry_dict(
         new base::DictionaryValue());
 
     entry_dict->SetString(kHostnameKey, key.hostname);
     entry_dict->SetInteger(kAddressFamilyKey,
@@ skipping 21 matching lines @@
       const AddressList& addresses = entry.addresses();
       // Append all of the resolved addresses.
       auto addresses_value = base::MakeUnique<base::ListValue>();
       for (size_t i = 0; i < addresses.size(); ++i)
         addresses_value->AppendString(addresses[i].ToStringWithoutPort());
       entry_dict->SetList(kAddressesKey, std::move(addresses_value));
     }
 
     entry_list->Append(std::move(entry_dict));
   }
-
-  return entry_list;
 }
 
 // TODO(mgersh): Add histograms to track failures.
 bool HostCache::RestoreFromListValue(const base::ListValue& old_cache) {
   for (auto it = old_cache.begin(); it != old_cache.end(); it++) {
     const base::DictionaryValue* entry_dict;
     if (!it->GetAsDictionary(&entry_dict))
       return false;
 
     std::string hostname;
@@ skipping 183 matching lines @@
     CACHE_HISTOGRAM_TIME("EraseValid.ValidFor", -stale.expired_by);
   }
 }
 
 void HostCache::RecordEraseAll(EraseReason reason, base::TimeTicks now) {
   for (const auto& it : entries_)
     RecordErase(reason, now, it.second);
 }
 
 }  // namespace net