DnsClient refactoring + features (timeout, suffix search, server rotation).

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 57 matching lines @@
   config.nameservers.push_back(IPEndPoint(dns_ip, 53));
   DnsSession* session = new DnsSession(
       config,
       ClientSocketFactory::GetDefaultFactory(),
       base::Bind(&base::RandInt),
       net_log);
   HostResolver* resolver = new AsyncHostResolver(
       max_dns_requests,
       max_pending_requests,
       HostCache::CreateDefaultCache(),
-      DnsClient::CreateClient(session),
+      DnsTransactionFactory::CreateFactory(session),
       net_log);
   return resolver;
 }
 
 //-----------------------------------------------------------------------------
 // Every call to Resolve() results in Request object being created.  Such a
 // call may complete either synchronously or asynchronously or it may get
 // cancelled, which can be either through specific CancelRequest call or by
 // the destruction of AsyncHostResolver, which would destruct pending or
 // in-progress requests, causing them to be cancelled.  Synchronous
@@ skipping 10 matching lines @@
       : resolver_(resolver),
         source_net_log_(source_net_log),
         request_net_log_(request_net_log),
         info_(info),
         callback_(callback),
         addresses_(addresses),
         result_(ERR_UNEXPECTED) {
     DCHECK(addresses_);
     DCHECK(resolver_);
     resolver_->OnStart(this);
-    std::string dns_name;
-    if (DNSDomainFromDot(info.hostname(), &dns_name))
-      key_ = Key(dns_name, QueryTypeFromAddressFamily(info.address_family()));
+    key_ = Key(info.hostname(),
+               QueryTypeFromAddressFamily(info.address_family()));
   }
 
   ~Request() {
     if (!callback_.is_null())
       resolver_->OnCancel(this);
   }
 
   int result() const { return result_; }
   const Key& key() const {
     DCHECK(IsValid());
@@ skipping 76 matching lines @@
   Key key_;
   CompletionCallback callback_;
   AddressList* addresses_;
   int result_;
 };
 
 //-----------------------------------------------------------------------------
 AsyncHostResolver::AsyncHostResolver(size_t max_dns_requests,
                                      size_t max_pending_requests,
                                      HostCache* cache,
-                                     DnsClient* client,
+                                     scoped_ptr<DnsTransactionFactory> client,
                                      NetLog* net_log)
     : max_dns_requests_(max_dns_requests),
       max_pending_requests_(max_pending_requests),
       cache_(cache),
-      client_(client),
+      client_(client.Pass()),
       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 DNS requests.
@@ skipping 101 matching lines @@
 }
 
 AddressFamily AsyncHostResolver::GetDefaultAddressFamily() const {
   return ADDRESS_FAMILY_IPV4;
 }
 
 HostCache* AsyncHostResolver::GetHostCache() {
   return cache_.get();
 }
 
-void AsyncHostResolver::OnDnsRequestComplete(
-    DnsClient::Request* dns_req,
+void AsyncHostResolver::OnDnsTransactionComplete(
+    DnsTransaction* transaction,
     int result,
     const DnsResponse* response) {
-  DCHECK(std::find(dns_requests_.begin(), dns_requests_.end(), dns_req)
+  DCHECK(std::find(dns_requests_.begin(), dns_requests_.end(), transaction)
          != dns_requests_.end());
 
   // 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()));
+      std::make_pair(transaction->GetHostname(), transaction->GetType()));
   DCHECK(rit != requestlist_map_.end());
   RequestList& requests = rit->second;
   int port = requests.empty() ? 80 : requests.front()->info().port();
 
   // Extract AddressList out of DnsResponse.
   AddressList addr_list;
   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() &&
+      if (record.type == transaction->GetType() &&
           (record.rdata.size() == kIPv4AddressSize ||
            record.rdata.size() == kIPv6AddressSize)) {
         ip_addresses.push_back(IPAddressNumber(record.rdata.begin(),
                                                record.rdata.end()));
       }
     }
     if (!ip_addresses.empty())
       addr_list = AddressList::CreateFromIPAddressList(ip_addresses, port);
     else
       result = ERR_NAME_NOT_RESOLVED;
@@ skipping 19 matching lines @@
     HostCache::Key key(
         info.hostname(), info.address_family(), info.host_resolver_flags());
     cache_->Set(key, result, addr_list, base::TimeTicks::Now());
   }
 
   // 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;
+  dns_requests_.remove(transaction);
+  delete transaction;
   ProcessPending();
 }
 
 AsyncHostResolver::Request* AsyncHostResolver::CreateNewRequest(
     const RequestInfo& info,
     const CompletionCallback& callback,
     AddressList* addresses,
     const BoundNetLog& source_net_log) {
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
       NetLog::SOURCE_ASYNC_HOST_RESOLVER_REQUEST);
@@ skipping 10 matching lines @@
 }
 
 int AsyncHostResolver::StartNewDnsRequestFor(Request* request) {
   DCHECK(requestlist_map_.find(request->key()) == requestlist_map_.end());
   DCHECK(dns_requests_.size() < max_dns_requests_);
 
   request->request_net_log().AddEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER_CREATE_DNS_TRANSACTION, NULL);
 
   requestlist_map_[request->key()].push_back(request);
-  DnsClient::Request* dns_req = client_->CreateRequest(
+  scoped_ptr<DnsTransaction> dns_req = client_->CreateTransaction(

[mmenke, 2012/01/19 17:24:47]

nit:  "scoped_ptr<DnsTransaction> dns_req(client_...);" is preferred.

[mmenke, 2012/01/19 17:24:47]

nit:  dns_transaction

       request->key().first,
       request->key().second,
-      base::Bind(&AsyncHostResolver::OnDnsRequestComplete,
+      base::Bind(&AsyncHostResolver::OnDnsTransactionComplete,
                  base::Unretained(this)),
       request->request_net_log());
-  dns_requests_.push_back(dns_req);
-  return dns_req->Start();
+  int rv = dns_req->Start();
+  if (rv == ERR_IO_PENDING)
+    dns_requests_.push_back(dns_req.release());
+  return rv;
 }
 
 int AsyncHostResolver::Enqueue(Request* request) {
   Request* evicted_request = Insert(request);
   int rv = ERR_HOST_RESOLVER_QUEUE_TOO_LARGE;
   if (evicted_request == request)
     return rv;
   if (evicted_request != NULL) {
     evicted_request->OnAsyncComplete(rv, AddressList());
     delete evicted_request;
@@ skipping 56 matching lines @@
         it = requests.erase(it);
       } else {
         ++it;
       }
     }
   }
   StartNewDnsRequestFor(request);
 }
 
 }  // namespace net