Make HostCache::RestoreFromListValue() take a const reference

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 23 matching lines @@
 // String constants for dictionary keys.
 const char kHostnameKey[] = "hostname";
 const char kAddressFamilyKey[] = "address_family";
 const char kFlagsKey[] = "flags";
 const char kExpirationKey[] = "expiration";
 const char kTtlKey[] = "ttl";
 const char kNetworkChangesKey[] = "network_changes";
 const char kErrorKey[] = "error";
 const char kAddressesKey[] = "addresses";
 
-bool AddressListFromListValue(base::ListValue* value, AddressList* list) {
+bool AddressListFromListValue(const base::ListValue* value, AddressList* list) {
   list->clear();
   for (base::ListValue::const_iterator it = value->begin(); it != value->end();
        it++) {
     IPAddress address;
     std::string addr_string;
     if (!it->GetAsString(&addr_string) ||
         !address.AssignFromIPLiteral(addr_string)) {
       return false;
     }
     list->push_back(IPEndPoint(address, 0));
@@ skipping 253 matching lines @@
       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(base::ListValue& old_cache) {
-  for (base::ListValue::iterator it = old_cache.begin(); it != old_cache.end();
-       it++) {
-    base::DictionaryValue* entry_dict;
+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;
     int address_family;
     HostResolverFlags flags;
     int error = OK;
     std::string expiration;
     base::ListValue empty_list;
-    base::ListValue* addresses_value = &empty_list;
+    const base::ListValue* addresses_value = &empty_list;
     AddressList address_list;
 
     if (!entry_dict->GetString(kHostnameKey, &hostname) ||
         !entry_dict->GetInteger(kFlagsKey, &flags) ||
         !entry_dict->GetInteger(kAddressFamilyKey, &address_family) ||
         !entry_dict->GetString(kExpirationKey, &expiration)) {
       return false;
     }
 
     // Only one of these fields should be in the dictionary.
@@ skipping 168 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