AsyncHostResolver: integrated HostCache, temporarily, until we have RR cache.

net/base/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/base/async_host_resolver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 48 matching lines @@
       dict->Set("source_dependency", source_.ToValue());
 
     return dict;
   }
 
  private:
   const HostResolver::RequestInfo info_;
   const NetLog::Source source_;
 };
 
+HostCache* CreateDefaultCache() {

[cbentzel, 2011/07/21 15:31:10]

This should be shared with the one in host_resolver_impl

[agayev, 2011/07/21 17:48:03]

Done.

+  static const size_t kMaxHostCacheEntries = 100;
+
+  HostCache* cache = new HostCache(
+      kMaxHostCacheEntries,
+      base::TimeDelta::FromMinutes(1),
+      base::TimeDelta::FromSeconds(0));  // Disable caching of failed DNS.
+
+  return cache;
+}
+
 }  // namespace
 
 HostResolver* CreateAsyncHostResolver(size_t max_concurrent_resolves,
                                       const IPAddressNumber& dns_ip,
                                       NetLog* net_log) {
   size_t max_transactions = max_concurrent_resolves;
   if (max_transactions == 0)
     max_transactions = 20;
   size_t max_pending_requests = max_transactions * 100;
   HostResolver* resolver = new AsyncHostResolver(
       IPEndPoint(dns_ip, 53),
       max_transactions,
       max_pending_requests,
       base::Bind(&base::RandInt),
+      CreateDefaultCache(),
       NULL,
       net_log);
   return resolver;
 }
 
 //-----------------------------------------------------------------------------
 class AsyncHostResolver::Request {
  public:
   Request(const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
@@ skipping 11 matching lines @@
         addresses_(addresses) {
     DCHECK(addresses_);
   }
 
   int id() const { return id_; }
   const HostResolver::RequestInfo& info() const { return info_; }
   const Key& key() const { return key_; }
   RequestPriority priority() const { return info_.priority(); }
   const BoundNetLog& source_net_log() const { return source_net_log_; }
   const BoundNetLog& request_net_log() const { return request_net_log_; }
-  const AddressList* addresses() const { return addresses_; }
+  void set_addresses(const AddressList& addresses) { *addresses_ = addresses; }
 
   void OnComplete(int result, const IPAddressList& ip_addresses) {
     DCHECK(callback_);
     if (result == OK)
       *addresses_ =
           AddressList::CreateFromIPAddressList(ip_addresses, info_.port());
     callback_->Run(result);
   }
 
  private:
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
   const int id_;
   const HostResolver::RequestInfo info_;
   const Key key_;
   CompletionCallback* callback_;
   AddressList* addresses_;
 };
 
 //-----------------------------------------------------------------------------
 AsyncHostResolver::AsyncHostResolver(const IPEndPoint& dns_server,
                                      size_t max_transactions,
                                      size_t max_pending_requests,
                                      const RandIntCallback& rand_int_cb,
+                                     HostCache* cache,
                                      ClientSocketFactory* factory,
                                      NetLog* net_log)
     : max_transactions_(max_transactions),
       max_pending_requests_(max_pending_requests),
       dns_server_(dns_server),
       rand_int_cb_(rand_int_cb),
+      cache_(cache),
       factory_(factory),
       next_request_id_(0),
       net_log_(net_log) {
 }
 
 AsyncHostResolver::~AsyncHostResolver() {
+  // Destroy request lists.
   for (KeyRequestListMap::iterator it = requestlist_map_.begin();
        it != requestlist_map_.end(); ++it)
     STLDeleteElements(&it->second);
+
+  // Destroy transactions.
   STLDeleteElements(&transactions_);
+
+  // Destroy pending requests.
+  for (size_t i = 0; i < arraysize(pending_requests_); ++i)
+    STLDeleteElements(&pending_requests_[i]);
 }
 
 int AsyncHostResolver::Resolve(const RequestInfo& info,
                                AddressList* addresses,
                                CompletionCallback* callback,
                                RequestHandle* out_req,
                                const BoundNetLog& source_net_log) {
   DCHECK(addresses);
-
   IPAddressNumber ip_number;
   std::string dns_name;
   int rv = ERR_UNEXPECTED;
   if (info.hostname().empty())
     rv = ERR_NAME_NOT_RESOLVED;
   else if (ParseIPLiteralToNumber(info.hostname(), &ip_number))
     rv = ResolveAsIp(info, ip_number, addresses);
   else if (!DNSDomainFromDot(info.hostname(), &dns_name))
     rv = ERR_NAME_NOT_RESOLVED;
-  else if (info.only_use_cached_response())  // TODO(agayev): support caching
-    rv = ERR_NAME_NOT_RESOLVED;
 
   Request* request = CreateNewRequest(
       info, dns_name, callback, addresses, source_net_log);
 
   OnStart(request);
+  if (rv == ERR_UNEXPECTED) {
+    if (ServeFromCache(request))
+      rv = OK;
+    else if (info.only_use_cached_response())
+      rv = ERR_NAME_NOT_RESOLVED;
+  }
+
   if (rv != ERR_UNEXPECTED) {
     OnFinish(request, rv);
     delete request;
-    return rv;
+    return rv;  // Synchronous resolution ends here.
   }
 
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(request);
-
   if (AttachToRequestList(request))
     return ERR_IO_PENDING;
   if (transactions_.size() < max_transactions_)
     return StartNewTransactionFor(request);
   return Enqueue(request);
 }
 
 void AsyncHostResolver::OnStart(Request* request) {
   DCHECK(request);
 
@@ skipping 73 matching lines @@
 }
 
 HostResolverImpl* AsyncHostResolver::GetAsHostResolverImpl() {
   return NULL;
 }
 
 void AsyncHostResolver::OnTransactionComplete(
     int result,
     const DnsTransaction* transaction,
     const IPAddressList& ip_addresses) {
-
   DCHECK(std::find(transactions_.begin(), transactions_.end(), transaction)
          != transactions_.end());
   DCHECK(requestlist_map_.find(transaction->key()) != requestlist_map_.end());
 
   // Run callback of every request that was depending on this transaction,
   // also notify observers.
   RequestList& requests = requestlist_map_[transaction->key()];
   for (RequestList::iterator it = requests.begin(); it != requests.end();
        ++it) {
     Request* request = *it;
     OnFinish(request, result);
     request->OnComplete(result, ip_addresses);
   }
 
+  // It is possible that the requests that caused |transaction| to be
+  // created are cancelled by the time |transaction| 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, (c)
+  // recreating info from DnsTransaction::Key adds a lot of temporary

[cbentzel, 2011/07/21 15:31:10]

It seems like it should still be possible to cache when requests is empty -
doesnt transaction->key() have enough information?

[agayev, 2011/07/21 17:48:03]

Well, it doesn't have host_resolver_flags, whose usefulness we need to rethink. 
This flag affects how the lookup is made, thus it affects how the AddressList is
formed.  In RR cache we would not store AddressList in cache, and
AsyncHostResolver would look at flags and use data in RR cache to form the
AddressList and pass it back.  E.g. if HOST_RESOLVER_CANONNAME is set, it would
set ai_canonname field of the first element of addrinfo chain to canonical name
of the host.

[cbentzel, 2011/07/21 18:22:15]

Yes, I agree that's how it would be done. I think holding off until a real RR
cache is in place is good. 

+  // code/functions (like converting back from qtype to AddressFamily.)
+  // Also, we only cache positive results.  All of this will change when RR
+  // cache is added.
+  if (result == OK && cache_.get() && !requests.empty()) {
+    Request* request = requests.front();
+    HostResolver::RequestInfo info = request->info();
+    HostCache::Key key(
+        info.hostname(), info.address_family(), info.host_resolver_flags());
+    AddressList addrlist =
+      AddressList::CreateFromIPAddressList(ip_addresses, info.port());
+    cache_->Set(key, result, addrlist, base::TimeTicks::Now());
+  }
+
   // Cleanup requests.
   STLDeleteElements(&requests);
   requestlist_map_.erase(transaction->key());
 
   // Cleanup transaction and start a new one if there are pending requests.
   delete transaction;
   transactions_.remove(transaction);
   ProcessPending();
 }
 
+bool AsyncHostResolver::ServeFromCache(Request* request) const {
+  // Sanity check -- it shouldn't be the case that allow_cached_response is
+  // false while only_use_cached_response is true.
+  DCHECK(request->info().allow_cached_response() ||
+         !request->info().only_use_cached_response());
+
+  if (!cache_.get() || !request->info().allow_cached_response())
+    return false;
+
+  HostResolver::RequestInfo info = request->info();
+  HostCache::Key key(info.hostname(), info.address_family(),
+                     info.host_resolver_flags());
+  const HostCache::Entry* cache_entry = cache_->Lookup(
+      key, base::TimeTicks::Now());
+  if (cache_entry) {
+    request->request_net_log().AddEvent(
+        NetLog::TYPE_ASYNC_HOST_RESOLVER_CACHE_HIT, NULL);
+    DCHECK_EQ(OK, cache_entry->error);

[cbentzel, 2011/07/21 15:31:10]

Ah - I was going to ask you to handle non-OK error codes, but it looks like you
don't need to due to OnTransactionComplete logic.

+    request->set_addresses(
+        CreateAddressListUsingPort(cache_entry->addrlist, info.port()));
+    return true;
+  }
+  return false;
+}
+
 AsyncHostResolver::Request* AsyncHostResolver::CreateNewRequest(
     const RequestInfo& info,
     const std::string& dns_name,
     CompletionCallback* callback,
     AddressList* addresses,
     const BoundNetLog& source_net_log) {
 
   uint16 query_type = QueryTypeFromAddressFamily(info.address_family());
   Key key(dns_name, query_type);
 
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
       NetLog::SOURCE_ASYNC_HOST_RESOLVER_REQUEST);
 
   int id = next_request_id_++;
-  Request* request = new Request(
+  return new Request(
       source_net_log, request_net_log, id, info, key, callback, addresses);
-  return request;
 }
 
 bool AsyncHostResolver::AttachToRequestList(Request* request) {
   KeyRequestListMap::iterator it = requestlist_map_.find(request->key());
   if (it == requestlist_map_.end())
     return false;
   it->second.push_back(request);
   return true;
 }
 
@@ skipping 32 matching lines @@
 AsyncHostResolver::Request* AsyncHostResolver::Insert(Request* request) {
   pending_requests_[request->priority()].push_back(request);
   if (GetNumPending() > max_pending_requests_) {
     Request* req = RemoveLowest();
     DCHECK(req);
     return req;
   }
   return NULL;
 }
 
-size_t AsyncHostResolver::GetNumPending() {
+size_t AsyncHostResolver::GetNumPending() const {
   size_t num_pending = 0;
   for (size_t i = 0; i < arraysize(pending_requests_); ++i)
     num_pending += pending_requests_[i].size();
   return num_pending;
 }
 
 AsyncHostResolver::Request* AsyncHostResolver::RemoveLowest() {
   for (int i = static_cast<int>(arraysize(pending_requests_)) - 1;
        i >= 0; --i) {
     RequestList& requests = pending_requests_[i];
@@ skipping 31 matching lines @@
         it = requests.erase(it);
       } else {
         ++it;
       }
     }
   }
   StartNewTransactionFor(request);
 }
 
 }  // namespace net