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 62 matching lines @@
                                       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),
+      HostCache::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);
@@ skipping 14 matching lines @@
   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
+  // 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);
+    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);
 
@@ skipping 48 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