[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/dns/dns_transaction.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/dns_transaction.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
 }
 
 bool IsIPLiteral(const std::string& hostname) {
   IPAddressNumber ip;
   return ParseIPLiteralToNumber(hostname, &ip);
 }
 
 class StartParameters : public NetLog::EventParameters {
  public:
   StartParameters(const std::string& hostname,
-                  uint16 qtype,
-                  const NetLog::Source& source)
-      : hostname_(hostname), qtype_(qtype), source_(source) {}
+                  uint16 qtype)
+      : hostname_(hostname), qtype_(qtype) {}
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("hostname", hostname_);
     dict->SetInteger("query_type", qtype_);
-    dict->Set("source_dependency", source_.ToValue());
     return dict;
   }
 
  private:
   const std::string hostname_;
   const uint16 qtype_;
-  const NetLog::Source source_;
 };
 
 class ResponseParameters : public NetLog::EventParameters {
  public:
   ResponseParameters(int rcode, int answer_count, const NetLog::Source& source)
       : rcode_(rcode), answer_count_(answer_count), source_(source) {}
 
   virtual Value* ToValue() const OVERRIDE {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger("rcode", rcode_);
     dict->SetInteger("answer_count", answer_count_);
-    dict->Set("socket_source", source_.ToValue());
+    dict->Set("source_dependency", source_.ToValue());
     return dict;
   }
 
  private:
   const int rcode_;
   const int answer_count_;
   const NetLog::Source source_;
 };
 
 // ----------------------------------------------------------------------------
@@ skipping 112 matching lines @@
                          base::Bind(&DnsUDPAttempt::OnIOComplete,
                                     base::Unretained(this)));
   }
 
   int DoReadResponseComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     DCHECK(rv);
-    if (!response_->InitParse(rv, *query_))
+    if (!response_->InitParse(rv, *query_)) {
+      // TODO(szym): Consider making this reaction less aggressive.
+      // Other implementations simply ignore mismatched responses. Since each
+      // DnsUDPAttempt binds to a different port, we might find that responses
+      // to previously timed out queries lead to failures in the future.
+      // http://crbug.com/107413
       return ERR_DNS_MALFORMED_RESPONSE;
+    }
     if (response_->flags() & dns_protocol::kFlagTC)
       return ERR_DNS_SERVER_REQUIRES_TCP;
     if (response_->rcode() != dns_protocol::kRcodeNOERROR &&
         response_->rcode() != dns_protocol::kRcodeNXDOMAIN) {
       return ERR_DNS_SERVER_FAILED;
     }
     if (response_->answer_count() == 0)
       return ERR_NAME_NOT_RESOLVED;
 
     return OK;
@@ skipping 25 matching lines @@
 // The timeout for each DnsUDPAttempt is given by DnsSession::NextTimeout.
 // The first server to attempt on each query is given by
 // DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
 // Each server is attempted DnsConfig::attempts times.
 class DnsTransactionImpl : public DnsTransaction, public base::NonThreadSafe {
  public:
   DnsTransactionImpl(DnsSession* session,
                      const std::string& hostname,
                      uint16 qtype,
                      const DnsTransactionFactory::CallbackType& callback,
-                     const BoundNetLog& source_net_log)
+                     const BoundNetLog& net_log)
     : session_(session),
       hostname_(hostname),
       qtype_(qtype),
       callback_(callback),
-      net_log_(BoundNetLog::Make(session->net_log(),
-                                 NetLog::SOURCE_DNS_TRANSACTION)),
+      net_log_(net_log),
       first_server_index_(0) {
     DCHECK(session_);
     DCHECK(!hostname_.empty());
     DCHECK(!callback_.is_null());
 
     DCHECK(!IsIPLiteral(hostname_));
 
     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION, make_scoped_refptr(
-        new StartParameters(hostname_, qtype_, source_net_log.source())));
+        new StartParameters(hostname_, qtype_)));
   }
 
   virtual ~DnsTransactionImpl() {
     STLDeleteElements(&attempts_);
     if (!callback_.is_null()) {
       net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
                                         ERR_ABORTED);
     }
   }
 
   virtual const std::string& GetHostname() const OVERRIDE {
     DCHECK(CalledOnValidThread());
     return hostname_;
   }
 
   virtual uint16 GetType() const OVERRIDE {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
   virtual int Start() OVERRIDE {
     int rv = PrepareSearch();
     if (rv == OK)
       rv = StartQuery();
-    DCHECK_NE(OK, rv);
+    if (rv == OK) {
+      // In the very unlikely case that we immediately received the response, we
+      // cannot simply return OK nor run the callback, but instead complete
+      // asynchronously.
+      // TODO(szym): replace Unretained with WeakPtr factory.
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&DnsTransactionImpl::DoCallback,
+                     base::Unretained(this),
+                     OK,
+                     attempts_.back()));
+      return ERR_IO_PENDING;
+    }
     return rv;
   }
 
  private:
   // Prepares |qnames_| according to the DnsConfig.
   int PrepareSearch() {
     const DnsConfig& config = session_->config();
 
     std::string labeled_hostname;
     if (!DNSDomainFromDot(hostname_, &labeled_hostname))
@@ skipping 67 matching lines @@
 
     uint16 id = session_->NextQueryId();
     scoped_ptr<DnsQuery> query;
     if (attempts_.empty()) {
       query.reset(new DnsQuery(id, qnames_.front(), qtype_));
     } else {
       query.reset(attempts_[0]->query()->CloneWithNewId(id));
     }
 
     net_log_.AddEvent(NetLog::TYPE_DNS_TRANSACTION_ATTEMPT, make_scoped_refptr(
-        new NetLogSourceParameter("socket_source", socket->NetLog().source())));
+        new NetLogSourceParameter("source_dependency",
+                                  socket->NetLog().source())));
 
     const DnsConfig& config = session_->config();
 
     unsigned server_index = first_server_index_ +
         (attempt_number % config.nameservers.size());
 
     DnsUDPAttempt* attempt = new DnsUDPAttempt(
         socket.Pass(),
         config.nameservers[server_index],
         query.Pass(),
@@ skipping 43 matching lines @@
         qnames_.pop_front();
         if (qnames_.empty())
           rv = ERR_NAME_NOT_RESOLVED;
         else
           rv = StartQuery();
         break;
       case OK:
         DoCallback(rv, attempt);
         return;
       default:
-        // TODO(szym): Some nameservers could fail so try the next one.
+        // Some nameservers could fail so try the next one.
         const DnsConfig& config = session_->config();
         if (attempts_.size() < config.attempts * config.nameservers.size()) {
           rv = MakeAttempt();
         } else {
           // TODO(szym): Should this be different than the timeout case?
           rv = ERR_DNS_SERVER_FAILED;
         }
         break;
     }
     if (rv != ERR_IO_PENDING)
@@ skipping 40 matching lines @@
 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
  public:
   explicit DnsTransactionFactoryImpl(DnsSession* session) {
     session_ = session;
   }
 
   virtual scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16 qtype,
       const CallbackType& callback,
-      const BoundNetLog& source_net_log) OVERRIDE {
+      const BoundNetLog& net_log) OVERRIDE {
     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(session_,
                                                              hostname,
                                                              qtype,
                                                              callback,
-                                                             source_net_log));
+                                                             net_log));
   }
 
  private:
   scoped_refptr<DnsSession> session_;
 };
 
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net