Revert 151586 - [net/dns] Resolve AF_UNSPEC on dual-stacked systems. Sort addresses according to RF…

net/base/host_resolver_impl.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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 20 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
 #include "net/base/dns_reloader.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
-#include "net/dns/address_sorter.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
@@ skipping 551 matching lines @@
     net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
     StartLookupAttempt();
   }
 
   // Cancels this ProcTask. It will be orphaned. Any outstanding resolve
   // attempts running on worker threads will continue running. Only once all the
   // attempts complete will the final reference to this ProcTask be released.
   void Cancel() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
 
-    if (was_canceled() || was_completed())
+    if (was_canceled())
       return;
 
     callback_.Reset();
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);
   }
 
   void set_had_non_speculative_request() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
     had_non_speculative_request_ = true;
   }
@@ skipping 412 matching lines @@
 
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);
 };
 
 //-----------------------------------------------------------------------------
 
 // Resolves the hostname using DnsTransaction.
 // TODO(szym): This could be moved to separate source file as well.
-class HostResolverImpl::DnsTask : public base::SupportsWeakPtr<DnsTask> {
+class HostResolverImpl::DnsTask {
  public:
   typedef base::Callback<void(int net_error,
                               const AddressList& addr_list,
                               base::TimeDelta ttl)> Callback;
 
-  DnsTask(DnsClient* client,
+  DnsTask(DnsTransactionFactory* factory,
           const Key& key,
           const Callback& callback,
           const BoundNetLog& job_net_log)
-      : client_(client),
-        family_(key.address_family),
-        callback_(callback),
-        net_log_(job_net_log) {
-    DCHECK(client);
+      : callback_(callback), net_log_(job_net_log) {
+    DCHECK(factory);
     DCHECK(!callback.is_null());
 
-    // If unspecified, do IPv4 first, because suffix search will be faster.
-    uint16 qtype = (family_ == ADDRESS_FAMILY_IPV6) ?
-                   dns_protocol::kTypeAAAA :
-                   dns_protocol::kTypeA;
-    transaction_ = client_->GetTransactionFactory()->CreateTransaction(
+    // For now we treat ADDRESS_FAMILY_UNSPEC as if it was IPV4.
+    uint16 qtype = (key.address_family == ADDRESS_FAMILY_IPV6)
+                   ? dns_protocol::kTypeAAAA
+                   : dns_protocol::kTypeA;
+    // TODO(szym): Implement "happy eyeballs".
+    transaction_ = factory->CreateTransaction(
         key.hostname,
         qtype,
         base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),
-                   true /* first_query */, base::TimeTicks::Now()),
+                   base::TimeTicks::Now()),
         net_log_);
+    DCHECK(transaction_.get());
   }
 
   int Start() {
     net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK);
     return transaction_->Start();
   }
 
- private:
-  void OnTransactionComplete(bool first_query,
-                             const base::TimeTicks& start_time,
+  void OnTransactionComplete(const base::TimeTicks& start_time,
                              DnsTransaction* transaction,
                              int net_error,
                              const DnsResponse* response) {
     DCHECK(transaction);
     // Run |callback_| last since the owning Job will then delete this DnsTask.
-    if (net_error != OK) {
+    DnsResponse::Result result = DnsResponse::DNS_SUCCESS;
+    if (net_error == OK) {
+      CHECK(response);
+      DNS_HISTOGRAM("AsyncDNS.TransactionSuccess",
+                    base::TimeTicks::Now() - start_time);
+      AddressList addr_list;
+      base::TimeDelta ttl;
+      result = response->ParseToAddressList(&addr_list, &ttl);
+      UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ParseToAddressList",
+                                result,
+                                DnsResponse::DNS_PARSE_RESULT_MAX);
+      if (result == DnsResponse::DNS_SUCCESS) {
+        net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
+                          addr_list.CreateNetLogCallback());
+        callback_.Run(net_error, addr_list, ttl);
+        return;
+      }
+      net_error = ERR_DNS_MALFORMED_RESPONSE;
+    } else {
       DNS_HISTOGRAM("AsyncDNS.TransactionFailure",
                     base::TimeTicks::Now() - start_time);
-      OnFailure(net_error, DnsResponse::DNS_PARSE_OK);
-      return;
     }
-
-    CHECK(response);
-    DNS_HISTOGRAM("AsyncDNS.TransactionSuccess",
-                  base::TimeTicks::Now() - start_time);
-    AddressList addr_list;
-    base::TimeDelta ttl;
-    DnsResponse::Result result = response->ParseToAddressList(&addr_list, &ttl);
-    UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ParseToAddressList",
-                              result,
-                              DnsResponse::DNS_PARSE_RESULT_MAX);
-    if (result != DnsResponse::DNS_PARSE_OK) {
-      // Fail even if the other query succeeds.
-      OnFailure(ERR_DNS_MALFORMED_RESPONSE, result);
-      return;
-    }
-
-    bool needs_sort = false;
-    if (first_query) {
-      DCHECK(client_->GetConfig()) <<
-          "Transaction should have been aborted when config changed!";
-      if (family_ == ADDRESS_FAMILY_IPV6) {
-        needs_sort = (addr_list.size() > 1);
-      } else if (family_ == ADDRESS_FAMILY_UNSPECIFIED) {
-        first_addr_list_ = addr_list;
-        first_ttl_ = ttl;
-        // Use fully-qualified domain name to avoid search.
-        transaction_ = client_->GetTransactionFactory()->CreateTransaction(
-            response->GetDottedName() + ".",
-            dns_protocol::kTypeAAAA,
-            base::Bind(&DnsTask::OnTransactionComplete, base::Unretained(this),
-                       false /* first_query */, base::TimeTicks::Now()),
-            net_log_);
-        net_error = transaction_->Start();
-        if (net_error != ERR_IO_PENDING)
-          OnFailure(net_error, DnsResponse::DNS_PARSE_OK);
-        return;
-      }
-    } else {
-      DCHECK_EQ(ADDRESS_FAMILY_UNSPECIFIED, family_);
-      bool has_ipv6_addresses = !addr_list.empty();
-      if (!first_addr_list_.empty()) {
-        ttl = std::min(ttl, first_ttl_);
-        // Place IPv4 addresses after IPv6.
-        addr_list.insert(addr_list.end(), first_addr_list_.begin(),
-                                          first_addr_list_.end());
-      }
-      needs_sort = (has_ipv6_addresses && addr_list.size() > 1);
-    }
-
-    if (addr_list.empty()) {
-      // TODO(szym): Don't fallback to ProcTask in this case.
-      OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
-      return;
-    }
-
-    if (needs_sort) {
-      // Sort could complete synchronously.
-      client_->GetAddressSorter()->Sort(
-          addr_list,
-          base::Bind(&DnsTask::OnSortComplete, AsWeakPtr(),
-                     base::TimeTicks::Now(),
-                     ttl));
-    } else {
-      OnSuccess(addr_list, ttl);
-    }
-  }
-
-  void OnSortComplete(base::TimeTicks start_time,
-                      base::TimeDelta ttl,
-                      bool success,
-                      const AddressList& addr_list) {
-    if (!success) {
-      DNS_HISTOGRAM("AsyncDNS.SortFailure",
-                    base::TimeTicks::Now() - start_time);
-      OnFailure(ERR_DNS_SORT_ERROR, DnsResponse::DNS_PARSE_OK);
-      return;
-    }
-
-    DNS_HISTOGRAM("AsyncDNS.SortSuccess",
-                  base::TimeTicks::Now() - start_time);
-
-    // AddressSorter prunes unusable destinations.
-    if (addr_list.empty()) {
-      LOG(WARNING) << "Address list empty after RFC3484 sort";
-      OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
-      return;
-    }
-
-    OnSuccess(addr_list, ttl);
-  }
-
-  void OnFailure(int net_error, DnsResponse::Result result) {
-    DCHECK_NE(OK, net_error);
     net_log_.EndEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
         base::Bind(&NetLogDnsTaskFailedCallback, net_error, result));
     callback_.Run(net_error, AddressList(), base::TimeDelta());
   }
 
-  void OnSuccess(const AddressList& addr_list, base::TimeDelta ttl) {
-    net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,
-                      addr_list.CreateNetLogCallback());
-    callback_.Run(OK, addr_list, ttl);
-  }
-
-  DnsClient* client_;
-  AddressFamily family_;
+ private:
   // The listener to the results of this DnsTask.
   Callback callback_;
+
   const BoundNetLog net_log_;
 
   scoped_ptr<DnsTransaction> transaction_;
-
-  // Results from the first transaction. Used only if |family_| is unspecified.
-  AddressList first_addr_list_;
-  base::TimeDelta first_ttl_;
-
-  DISALLOW_COPY_AND_ASSIGN(DnsTask);
 };
 
 //-----------------------------------------------------------------------------
 
 // Aggregates all Requests for the same Key. Dispatched via PriorityDispatch.
 class HostResolverImpl::Job : public PrioritizedDispatcher::Job {
  public:
   // Creates new job for |key| where |request_net_log| is bound to the
   // request that spawned it.
   Job(HostResolverImpl* resolver,
@@ skipping 78 matching lines @@
       if (proc_task_)
         proc_task_->set_had_non_speculative_request();
     }
 
     requests_.push_back(req.release());
 
     UpdatePriority();
   }
 
   // Marks |req| as cancelled. If it was the last active Request, also finishes
-  // this Job, marking it as cancelled, and deletes it.
+  // this Job marking it either as aborted or cancelled, and deletes it.
   void CancelRequest(Request* req) {
     DCHECK_EQ(key_.hostname, req->info().hostname());
     DCHECK(!req->was_canceled());
 
     // Don't remove it from |requests_| just mark it canceled.
     req->MarkAsCanceled();
     LogCancelRequest(req->source_net_log(), req->request_net_log(),
                      req->info());
 
     priority_tracker_.Remove(req->info().priority());
@@ skipping 146 matching lines @@
         kNegativeCacheEntryTTLSeconds);
     if (net_error == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
 
     CompleteRequests(net_error, addr_list, ttl);
   }
 
   void StartDnsTask() {
     DCHECK(resolver_->HaveDnsConfig());
     dns_task_.reset(new DnsTask(
-        resolver_->dns_client_.get(),
+        resolver_->dns_client_->GetTransactionFactory(),
         key_,
         base::Bind(&Job::OnDnsTaskComplete, base::Unretained(this)),
         net_log_));
 
     int rv = dns_task_->Start();
     if (rv != ERR_IO_PENDING) {
       DCHECK_NE(OK, rv);
       dns_task_error_ = rv;
       dns_task_.reset();
       StartProcTask();
@@ skipping 13 matching lines @@
       // TODO(szym): Run ServeFromHosts now if nsswitch.conf says so.
       // http://crbug.com/117655
 
       // TODO(szym): Some net errors indicate lack of connectivity. Starting
       // ProcTask in that case is a waste of time.
       StartProcTask();
       return;
     }
 
     UmaAsyncDnsResolveStatus(RESOLVE_STATUS_DNS_SUCCESS);
-
     CompleteRequests(net_error, addr_list, ttl);
   }
 
   // Performs Job's last rites. Completes all Requests. Deletes this.
   void CompleteRequests(int net_error,
                         const AddressList& addr_list,
                         base::TimeDelta ttl) {
     CHECK(resolver_);
 
     // This job must be removed from resolver's |jobs_| now to make room for a
@@ skipping 623 matching lines @@
   // |this| may be deleted inside AbortAllInProgressJobs().
   if (self)
     TryServingAllJobsFromHosts();
 }
 
 bool HostResolverImpl::HaveDnsConfig() const {
   return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL);
 }
 
 }  // namespace net