Adds custom ttl argument to HostCache::Set.

net/dns/async_host_resolver.cc

 // Copyright (c) 2011 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/async_host_resolver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 331 matching lines @@
   // If by the time requests that caused |dns_req| are cancelled, we do
   // not have a port number to associate with the result, therefore, we
   // assume the most common port, otherwise we use the port number of the
   // first request.
   KeyRequestListMap::iterator rit = requestlist_map_.find(
       std::make_pair(dns_req->qname(), dns_req->qtype()));
   DCHECK(rit != requestlist_map_.end());
   RequestList& requests = rit->second;
   int port = requests.empty() ? 80 : requests.front()->info().port();
 
-  // Extract AddressList out of DnsResponse.
+  // Extract AddressList and TTL out of DnsResponse.
   AddressList addr_list;
+  uint32 ttl = kuint32max;
   if (result == OK) {
     IPAddressList ip_addresses;
     DnsRecordParser parser = response->Parser();
     DnsResourceRecord record;
     // TODO(szym): Add stricter checking of names, aliases and address lengths.
     while (parser.ParseRecord(&record)) {
       if (record.type == dns_req->qtype() &&
           (record.rdata.size() == kIPv4AddressSize ||
            record.rdata.size() == kIPv6AddressSize)) {
         ip_addresses.push_back(IPAddressNumber(record.rdata.begin(),
                                                record.rdata.end()));
+        ttl = std::min(ttl, record.ttl);

[cbentzel, 2012/01/20 11:04:53]

I thought all of the RR's in the RRSet need to have identical TTL's. Did you
decide to be permissive here? Is this consistent with other resolvers?

[szym, 2012/01/20 16:31:46]

This policy is just a stub. We really should check that the A/AAAA-RRs that we
are collecting match the QNAME or a CNAME alias. The TTL should then be the
min(CNAME.TTL, A.TTL).

I'm planning to write this policy and tests for it in HostResolverImpl.

       }
     }
     if (!ip_addresses.empty())
       addr_list = AddressList::CreateFromIPAddressList(ip_addresses, port);
     else
       result = ERR_NAME_NOT_RESOLVED;
   }
 
   // Run callback of every request that was depending on this DNS request,
   // also notify observers.
   for (RequestList::iterator it = requests.begin(); it != requests.end(); ++it)
     (*it)->OnAsyncComplete(result, addr_list);
 
   // It is possible that the requests that caused |dns_req| to be
   // created are cancelled by the time |dns_req| completes.  In that
   // case |requests| would be empty.  We are knowingly throwing away the
   // result of a DNS resolution in that case, because (a) if there are no
   // requests, we do not have info to obtain a key from, (b) DnsTransaction
   // does not have info(), adding one into it just temporarily doesn't make
   // sense, since HostCache will be replaced with RR cache soon.

[cbentzel, 2012/01/20 11:04:53]

This comment about replacing HostCache with RR cache can probably go away. 

   // Also, we only cache positive results.  All of this will change when RR
   // cache is added.
   if (result == OK && cache_.get() && !requests.empty()) {

[cbentzel, 2012/01/20 11:04:53]

Should we insert into the cache even if the result is non-OK? This would be more
consistent with the non-async case.

[szym, 2012/01/20 16:31:46]

Probably, but rather than updating AsyncHostResolver, I'd wait until we can put
DnsConfigService + DnsTransactionFactory into HostResolverImpl, as to avoid
duplicated maintenance effort.

     Request* request = requests.front();
     HostResolver::RequestInfo info = request->info();
     HostCache::Key key(
         info.hostname(), info.address_family(), info.host_resolver_flags());
-    cache_->Set(key, result, addr_list, base::TimeTicks::Now());
+    cache_->Set(key,
+                result,
+                addr_list,
+                base::TimeTicks::Now(),
+                base::TimeDelta::FromSeconds(ttl));
   }
 
   // Cleanup requests.
   STLDeleteElements(&requests);
   requestlist_map_.erase(rit);
 
   // Cleanup |dns_req| and start a new one if there are pending requests.
   dns_requests_.remove(dns_req);
   delete dns_req;
   ProcessPending();
@@ skipping 103 matching lines @@
         it = requests.erase(it);
       } else {
         ++it;
       }
     }
   }
   StartNewDnsRequestFor(request);
 }
 
 }  // namespace net