[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 60 matching lines @@
 
 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);
+    // TODO(szym): Consider making this check less aggressive.
+    // Other implementations simply ignore mismatched responses.
     if (!response_->InitParse(rv, *query_))
       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;
@@ skipping 72 matching lines @@
   }
 
   virtual int Start() OVERRIDE {
     int rv = PrepareSearch();
     if (rv == OK)
       rv = StartQuery();
     DCHECK_NE(OK, rv);
     return rv;
   }
 
+  virtual const BoundNetLog& net_log() const {

[mmenke, 2012/02/14 18:46:00]

nit:  OVERRIDE

+    return net_log_;
+  }
+
  private:
   // Prepares |qnames_| according to the DnsConfig.
   int PrepareSearch() {
     const DnsConfig& config = session_->config();
 
     std::string labeled_hostname;
     if (!DNSDomainFromDot(hostname_, &labeled_hostname))
       return ERR_INVALID_ARGUMENT;
 
     if (hostname_[hostname_.size() - 1] == '.') {
@@ skipping 64 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 127 matching lines @@
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net