net: perform a non-A DNS lookup for HTTPS hosts.

net/socket/ssl_host_info.cc

 // Copyright (c) 2010 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/socket/ssl_host_info.h"
 
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/string_piece.h"
+#include "net/base/dns_util.h"
+#include "net/base/dnsrr_resolver.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/x509_certificate.h"
 #include "net/socket/ssl_client_socket.h"
 
 namespace net {
 
 SSLHostInfo::State::State()
     : npn_valid(false),
       npn_status(SSLClientSocket::kNextProtoUnsupported) {
 }
@@ skipping 13 matching lines @@
     : cert_verification_complete_(false),
       cert_verification_error_(ERR_CERT_INVALID),
       hostname_(hostname),
       cert_parsing_failed_(false),
       cert_verification_callback_(NULL),
       rev_checking_enabled_(ssl_config.rev_checking_enabled),
       verify_ev_cert_(ssl_config.verify_ev_cert),
       verifier_(cert_verifier),
       callback_(new CancelableCompletionCallback<SSLHostInfo>(
                         ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                        &SSLHostInfo::VerifyCallback)) {
+                        &SSLHostInfo::VerifyCallback)),
+      dnsrr_resolver_(NULL),
+      dns_callback_(NULL),
+      dns_handle_(DnsRRResolver::kInvalidHandle) {
   state_.npn_valid = false;
 }
 
-SSLHostInfo::~SSLHostInfo() {}
+SSLHostInfo::~SSLHostInfo() {
+  if (dns_handle_ != DnsRRResolver::kInvalidHandle) {
+    dnsrr_resolver_->CancelResolve(dns_handle_);
+    delete dns_callback_;
+  }
+}
+
+void SSLHostInfo::StartDnsLookup(DnsRRResolver* dnsrr_resolver) {
+#if defined(OS_LINUX)
+  dnsrr_resolver_ = dnsrr_resolver;
+  dns_callback_ = NewCallback(this, &SSLHostInfo::DnsComplete);
+  dns_lookup_start_time_ = base::TimeTicks::Now();
+
+  dns_handle_ = dnsrr_resolver->Resolve(
+      hostname_, kDNS_CAA, DnsRRResolver::FLAG_WANT_DNSSEC, dns_callback_,
+      &dns_response_, 0, BoundNetLog());
+#endif
+}
 
 const SSLHostInfo::State& SSLHostInfo::state() const {
   return state_;
 }
 
 SSLHostInfo::State* SSLHostInfo::mutable_state() {
   return &state_;
 }
 
 bool SSLHostInfo::Parse(const std::string& data) {
@@ skipping 131 matching lines @@
   verification_end_time_ = now;
   cert_verification_complete_ = true;
   cert_verification_error_ = rv;
   if (cert_verification_callback_) {
     CompletionCallback* callback = cert_verification_callback_;
     cert_verification_callback_ = NULL;
     callback->Run(rv);
   }
 }
 
+void SSLHostInfo::DnsComplete(int rv) {
+  dns_handle_ = DnsRRResolver::kInvalidHandle;
+  dns_callback_ = NULL;
+
+  const base::TimeTicks now = base::TimeTicks::Now();
+  const base::TimeDelta elapsed = now - dns_lookup_start_time_;
+  UMA_HISTOGRAM_TIMES("Net.SSLHostInfoDNSLookup", elapsed);
+}
+
 SSLHostInfoFactory::~SSLHostInfoFactory() {}
 
 }  // namespace net