Add PersistenceDelegate to HostCache

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 127 matching lines @@
 void HostCache::Entry::GetStaleness(base::TimeTicks now,
                                     int network_changes,
                                     EntryStaleness* out) const {
   DCHECK(out);
   out->expired_by = now - expires_;
   out->network_changes = network_changes - network_changes_;
   out->stale_hits = stale_hits_;
 }
 
 HostCache::HostCache(size_t max_entries)
-    : max_entries_(max_entries), network_changes_(0) {}
+    : max_entries_(max_entries), network_changes_(0), delegate_(nullptr) {}
 
 HostCache::~HostCache() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   RecordEraseAll(ERASE_DESTRUCT, base::TimeTicks::Now());
 }
 
 const HostCache::Entry* HostCache::Lookup(const Key& key,
                                           base::TimeTicks now) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (caching_is_disabled())
@@ skipping 44 matching lines @@
 
 void HostCache::Set(const Key& key,
                     const Entry& entry,
                     base::TimeTicks now,
                     base::TimeDelta ttl) {
   TRACE_EVENT0(kNetTracingCategory, "HostCache::Set");
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (caching_is_disabled())
     return;
 
+  bool result_changed = false;
   auto it = entries_.find(key);
   if (it != entries_.end()) {
     bool is_stale = it->second.IsStale(now, network_changes_);
+    AddressListDeltaType delta =
+        FindAddressListDeltaType(it->second.addresses(), entry.addresses());
     RecordSet(is_stale ? SET_UPDATE_STALE : SET_UPDATE_VALID, now, &it->second,
-              entry);
+              entry, delta);
     // TODO(juliatuttle): Remember some old metadata (hit count or frequency or
     // something like that) if it's useful for better eviction algorithms?
+    result_changed =
+        entry.error() == OK &&
+        (it->second.error() != entry.error() || delta != DELTA_IDENTICAL);
     entries_.erase(it);
   } else {
+    result_changed = true;
     if (size() == max_entries_)
       EvictOneEntry(now);
-    RecordSet(SET_INSERT, now, nullptr, entry);
+    RecordSet(SET_INSERT, now, nullptr, entry, DELTA_DISJOINT);
   }
 
   AddEntry(Key(key), Entry(entry, now, ttl, network_changes_));
+
+  if (delegate_ && result_changed)
+    delegate_->ScheduleWrite();
 }
 
 void HostCache::AddEntry(const Key& key, const Entry& entry) {
   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::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_)
+    delegate_->ScheduleWrite();
 }
 
 void HostCache::ClearForHosts(
     const base::Callback<bool(const std::string&)>& host_filter) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (host_filter.is_null()) {
     clear();
     return;
   }
 
+  bool changed = false;
   base::TimeTicks now = base::TimeTicks::Now();
   for (EntryMap::iterator it = entries_.begin(); it != entries_.end();) {
     EntryMap::iterator next_it = std::next(it);
 
     if (host_filter.Run(it->first.hostname)) {
       RecordErase(ERASE_CLEAR, now, it->second);
       entries_.erase(it);
+      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());
 
   for (const auto& pair : entries_) {
     const Key& key = pair.first;
     const Entry& entry = pair.second;
 
@@ skipping 133 matching lines @@
 
   if (!eviction_callback_.is_null())
     eviction_callback_.Run(oldest_it->first, oldest_it->second);
   RecordErase(ERASE_EVICT, now, oldest_it->second);
   entries_.erase(oldest_it);
 }
 
 void HostCache::RecordSet(SetOutcome outcome,
                           base::TimeTicks now,
                           const Entry* old_entry,
-                          const Entry& new_entry) {
+                          const Entry& new_entry,
+                          AddressListDeltaType delta) {
   CACHE_HISTOGRAM_ENUM("Set", outcome, MAX_SET_OUTCOME);
   switch (outcome) {
     case SET_INSERT:
     case SET_UPDATE_VALID:
       // Nothing to log here.
       break;
     case SET_UPDATE_STALE: {
       EntryStaleness stale;
       old_entry->GetStaleness(now, network_changes_, &stale);
       CACHE_HISTOGRAM_TIME("UpdateStale.ExpiredBy", stale.expired_by);
       CACHE_HISTOGRAM_COUNT("UpdateStale.NetworkChanges",
                             stale.network_changes);
       CACHE_HISTOGRAM_COUNT("UpdateStale.StaleHits", stale.stale_hits);
       if (old_entry->error() == OK && new_entry.error() == OK) {
-        AddressListDeltaType delta = FindAddressListDeltaType(
-            old_entry->addresses(), new_entry.addresses());
         RecordUpdateStale(delta, stale);
       }
       break;
     }
     case MAX_SET_OUTCOME:
       NOTREACHED();
       break;
   }
 }
 
@@ skipping 62 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