net: plumb DnsRRResolver from IOThread to HttpNetworkSession.

net/http/http_network_layer.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/http/http_network_layer.h"
 
 #include "base/field_trial.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
 // static
 HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
     HostResolver* host_resolver,
+    DnsRRResolver* dnsrr_resolver,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     HttpNetworkDelegate* network_delegate,
     NetLog* net_log) {
   DCHECK(proxy_service);
 
   return new HttpNetworkLayer(ClientSocketFactory::GetDefaultFactory(),
-                              host_resolver, proxy_service, ssl_config_service,
-                              http_auth_handler_factory,
+                              host_resolver, dnsrr_resolver, proxy_service,
+                              ssl_config_service, http_auth_handler_factory,
                               network_delegate,
                               net_log);
 }
 
 // static
 HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
     HttpNetworkSession* session) {
   DCHECK(session);
 
   return new HttpNetworkLayer(session);
 }
 
 //-----------------------------------------------------------------------------
 HttpNetworkLayer::HttpNetworkLayer(
     ClientSocketFactory* socket_factory,
     HostResolver* host_resolver,
+    DnsRRResolver* dnsrr_resolver,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     HttpNetworkDelegate* network_delegate,
     NetLog* net_log)
     : socket_factory_(socket_factory),
       host_resolver_(host_resolver),
+      dnsrr_resolver_(dnsrr_resolver),
       proxy_service_(proxy_service),
       ssl_config_service_(ssl_config_service),
       session_(NULL),
       spdy_session_pool_(NULL),
       http_auth_handler_factory_(http_auth_handler_factory),
       network_delegate_(network_delegate),
       net_log_(net_log),
       suspended_(false) {
   DCHECK(proxy_service_);
   DCHECK(ssl_config_service_.get());
 }
 
 HttpNetworkLayer::HttpNetworkLayer(
     ClientSocketFactory* socket_factory,
     HostResolver* host_resolver,
+    DnsRRResolver* dnsrr_resolver,
     ProxyService* proxy_service,
     SSLConfigService* ssl_config_service,
     SpdySessionPool* spdy_session_pool,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     HttpNetworkDelegate* network_delegate,
     NetLog* net_log)
     : socket_factory_(socket_factory),
       host_resolver_(host_resolver),
+      dnsrr_resolver_(dnsrr_resolver),
       proxy_service_(proxy_service),
       ssl_config_service_(ssl_config_service),
       session_(NULL),
       spdy_session_pool_(spdy_session_pool),
       http_auth_handler_factory_(http_auth_handler_factory),
       network_delegate_(network_delegate),
       net_log_(net_log),
       suspended_(false) {
   DCHECK(proxy_service_);
   DCHECK(ssl_config_service_.get());
 }
 
 HttpNetworkLayer::HttpNetworkLayer(HttpNetworkSession* session)
     : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
+      dnsrr_resolver_(NULL),
       ssl_config_service_(NULL),
       session_(session),
       spdy_session_pool_(NULL),
       http_auth_handler_factory_(NULL),
       network_delegate_(NULL),
       net_log_(NULL),
       suspended_(false) {
   DCHECK(session_.get());
 }
 
@@ skipping 19 matching lines @@
     session_->tcp_socket_pool()->CloseIdleSockets();
 }
 
 HttpNetworkSession* HttpNetworkLayer::GetSession() {
   if (!session_) {
     DCHECK(proxy_service_);
     if (!spdy_session_pool_.get())
       spdy_session_pool_.reset(new SpdySessionPool(ssl_config_service_));
     session_ = new HttpNetworkSession(
         host_resolver_,
+        dnsrr_resolver_,
         proxy_service_,
         socket_factory_,
         ssl_config_service_,
         spdy_session_pool_.release(),
         http_auth_handler_factory_,
         network_delegate_,
         net_log_);
     // These were just temps for lazy-initializing HttpNetworkSession.
     host_resolver_ = NULL;
+    dnsrr_resolver_ = NULL;
     proxy_service_ = NULL;
     socket_factory_ = NULL;
     http_auth_handler_factory_ = NULL;
     net_log_ = NULL;
     network_delegate_ = NULL;
   }
   return session_;
 }
 
 // static
@@ skipping 72 matching lines @@
       pair.protocol = HttpAlternateProtocols::NPN_SPDY_2;
       HttpAlternateProtocols::ForceAlternateProtocol(pair);
     } else if (option.empty() && it == spdy_options.begin()) {
       continue;
     } else {
       LOG(DFATAL) << "Unrecognized spdy option: " << option;
     }
   }
 }
 }  // namespace net