Add PersistenceDelegate to HostCache

net/dns/host_cache.h

 // 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.
 
 #ifndef NET_DNS_HOST_CACHE_H_
 #define NET_DNS_HOST_CACHE_H_
 
 #include <stddef.h>
 
 #include <functional>
@@ skipping 106 matching lines @@
 
     base::TimeTicks expires_;
     // Copied from the cache's network_changes_ when the entry is set; can0
     // later be compared to it to see if the entry was received on the current
     // network.
     int network_changes_;
     int total_hits_;
     int stale_hits_;
   };
 
+  // Interface for interacting with persistent storage, to be provided by the
+  // embedder. Does not include support for writes that must happen immediately.
+  class PersistenceDelegate {
+   public:
+    // Calling ScheduleWrite() signals that data has changed and should be
+    // written to persistent storage. The write might be delayed.
+    virtual void ScheduleWrite() = 0;
+  };
+
   using EntryMap = std::map<Key, Entry>;
   using EvictionCallback = base::Callback<void(const Key&, const Entry&)>;
 
   // Constructs a HostCache that stores up to |max_entries|.
   explicit HostCache(size_t max_entries);
 
   ~HostCache();
 
   // Returns a pointer to the entry for |key|, which is valid at time
   // |now|. If there is no such entry, returns NULL.
@@ skipping 14 matching lines @@
            base::TimeTicks now,
            base::TimeDelta ttl);
 
   // Marks all entries as stale on account of a network change.
   void OnNetworkChange();
 
   void set_eviction_callback(const EvictionCallback& callback) {
     eviction_callback_ = callback;
   }
 
+  void set_persistence_delegate(PersistenceDelegate* delegate) {
+    delegate_ = delegate;
+  }
+
   // Empties the cache.
   void clear();
 
   // Clears hosts matching |host_filter| from the cache.
   void ClearForHosts(
       const base::Callback<bool(const std::string&)>& host_filter);
 
   // Returns the contents of the cache represented as a base::ListValue for
   // serialization.
   std::unique_ptr<base::ListValue> GetAsListValue(bool include_staleness) const;
@@ skipping 18 matching lines @@
 
   enum SetOutcome : int;
   enum LookupOutcome : int;
   enum EraseReason : int;
 
   Entry* LookupInternal(const Key& key);
 
   void RecordSet(SetOutcome outcome,
                  base::TimeTicks now,
                  const Entry* old_entry,
-                 const Entry& new_entry);
+                 const Entry& new_entry,
+                 AddressListDeltaType delta);
   void RecordUpdateStale(AddressListDeltaType delta,
                          const EntryStaleness& stale);
   void RecordLookup(LookupOutcome outcome,
                     base::TimeTicks now,
                     const Entry* entry);
   void RecordErase(EraseReason reason, base::TimeTicks now, const Entry& entry);
   void RecordEraseAll(EraseReason reason, base::TimeTicks now);
 
   // Returns true if this HostCache can contain no entries.
   bool caching_is_disabled() const { return max_entries_ == 0; }
 
   void EvictOneEntry(base::TimeTicks now);
   // Helper to insert an Entry into the cache.
   void AddEntry(const Key& key, const Entry& entry);
 
   // Map from hostname (presumably in lowercase canonicalized format) to
   // a resolved result entry.
   EntryMap entries_;
   size_t max_entries_;
   int network_changes_;
   EvictionCallback eviction_callback_;
 
+  PersistenceDelegate* delegate_;
+
   THREAD_CHECKER(thread_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(HostCache);
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_CACHE_H_