* Avoid doing concurrent DNS resolves of the same hostname in HostResolver.

* Add a 1 minute cache for host resolves.

* Refactor HostResolver to handle multiple requests.

* Make HostResolver a dependency of URLRequestContext. operate the HostResolver
in async mode for proxy resolver (bridging to IO thread).

TEST=unittests
BUG=13163

Review URL: http://codereview.chromium.org/118100

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18236 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 48 insertions, 23 deletions

diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 497e141..7baa3fc 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -960,13 +960,15 @@ void HttpCache::Transaction::OnCacheReadCompleted(int result) {
 
 //-----------------------------------------------------------------------------
 
-HttpCache::HttpCache(ProxyService* proxy_service,
+HttpCache::HttpCache(HostResolver* host_resolver,
+                     ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
-      network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
+      network_layer_(HttpNetworkLayer::CreateFactory(
+          host_resolver, proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(false),
       cache_size_(cache_size) {
@@ -984,10 +986,13 @@ HttpCache::HttpCache(HttpNetworkSession* session,
       cache_size_(cache_size) {
 }
 
-HttpCache::HttpCache(ProxyService* proxy_service, int cache_size)
+HttpCache::HttpCache(HostResolver* host_resolver,
+                     ProxyService* proxy_service,
+                     int cache_size)
     : mode_(NORMAL),
       type_(MEMORY_CACHE),
-      network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
+      network_layer_(HttpNetworkLayer::CreateFactory(
+          host_resolver, proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       in_memory_cache_(true),
       cache_size_(cache_size) {
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index 70aaf0d..9fca9ae 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -31,6 +31,7 @@ class Entry;
 
 namespace net {
 
+class HostResolver;
 class HttpNetworkSession;
 class HttpRequestInfo;
 class HttpResponseInfo;
@@ -57,7 +58,8 @@ class HttpCache : public HttpTransactionFactory {
   // Initialize the cache from the directory where its data is stored. The
   // disk cache is initialized lazily (by CreateTransaction) in this case. If
   // |cache_size| is zero, a default value will be calculated automatically.
-  HttpCache(ProxyService* proxy_service,
+  HttpCache(HostResolver* host_resolver,
+            ProxyService* proxy_service,
             const std::wstring& cache_dir,
             int cache_size);
 
@@ -73,7 +75,9 @@ class HttpCache : public HttpTransactionFactory {
   // Initialize using an in-memory cache. The cache is initialized lazily
   // (by CreateTransaction) in this case. If |cache_size| is zero, a default
   // value will be calculated automatically.
-  HttpCache(ProxyService* proxy_service, int cache_size);
+  HttpCache(HostResolver* host_resolver,
+            ProxyService* proxy_service,
+            int cache_size);
 
   // Initialize the cache from its component parts, which is useful for
   // testing.  The lifetime of the network_layer and disk_cache are managed by
diff --git a/net/http/http_network_layer.cc b/net/http/http_network_layer.cc
index b46012f..3a8122f 100644
--- a/net/http/http_network_layer.cc
+++ b/net/http/http_network_layer.cc
@@ -15,10 +15,11 @@ namespace net {
 
 // static
 HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
+    HostResolver* host_resolver,
     ProxyService* proxy_service) {
   DCHECK(proxy_service);
 
-  return new HttpNetworkLayer(proxy_service);
+  return new HttpNetworkLayer(host_resolver, proxy_service);
 }
 
 // static
@@ -31,8 +32,12 @@ HttpTransactionFactory* HttpNetworkLayer::CreateFactory(
 
 //-----------------------------------------------------------------------------
 
-HttpNetworkLayer::HttpNetworkLayer(ProxyService* proxy_service)
-    : proxy_service_(proxy_service), session_(NULL), suspended_(false) {
+HttpNetworkLayer::HttpNetworkLayer(HostResolver* host_resolver,
+                                   ProxyService* proxy_service)
+    : host_resolver_(host_resolver),
+      proxy_service_(proxy_service),
+      session_(NULL),
+      suspended_(false) {
   DCHECK(proxy_service_);
 }
 
@@ -66,7 +71,7 @@ void HttpNetworkLayer::Suspend(bool suspend) {
 HttpNetworkSession* HttpNetworkLayer::GetSession() {
   if (!session_) {
     DCHECK(proxy_service_);
-    session_ = new HttpNetworkSession(proxy_service_,
+    session_ = new HttpNetworkSession(host_resolver_, proxy_service_,
                                       ClientSocketFactory::GetDefaultFactory());
   }
   return session_;
diff --git a/net/http/http_network_layer.h b/net/http/http_network_layer.h
index 2011a6c..acee57e 100644
--- a/net/http/http_network_layer.h
+++ b/net/http/http_network_layer.h
@@ -11,14 +11,16 @@
 
 namespace net {
 
+class HostResolver;
 class HttpNetworkSession;
 class ProxyInfo;
 class ProxyService;
 
 class HttpNetworkLayer : public HttpTransactionFactory {
  public:
-  // |proxy_service| must remain valid for the lifetime of HttpNetworkLayer.
-  explicit HttpNetworkLayer(ProxyService* proxy_service);
+  // |proxy_service| and |host_resolver| must remain valid for the lifetime of
+  // HttpNetworkLayer.
+  HttpNetworkLayer(HostResolver* host_resolver, ProxyService* proxy_service);
   // Construct a HttpNetworkLayer with an existing HttpNetworkSession which
   // contains a valid ProxyService.
   explicit HttpNetworkLayer(HttpNetworkSession* session);
@@ -26,7 +28,8 @@ class HttpNetworkLayer : public HttpTransactionFactory {
 
   // This function hides the details of how a network layer gets instantiated
   // and allows other implementations to be substituted.
-  static HttpTransactionFactory* CreateFactory(ProxyService* proxy_service);
+  static HttpTransactionFactory* CreateFactory(HostResolver* host_resolver,
+                                               ProxyService* proxy_service);
   // Create a transaction factory that instantiate a network layer over an
   // existing network session. Network session contains some valuable
   // information (e.g. authentication data) that we want to share across
@@ -43,6 +46,9 @@ class HttpNetworkLayer : public HttpTransactionFactory {
   HttpNetworkSession* GetSession();
 
  private:
+  // The host resolver being used for the session.
+  HostResolver* host_resolver_;
+
   // The proxy service being used for the session.
   ProxyService* proxy_service_;
 
diff --git a/net/http/http_network_layer_unittest.cc b/net/http/http_network_layer_unittest.cc
index 33891b4..335cb93 100644
--- a/net/http/http_network_layer_unittest.cc
+++ b/net/http/http_network_layer_unittest.cc
@@ -26,15 +26,17 @@ class HttpNetworkLayerTest : public PlatformTest {
 };
 
 TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
+  net::HostResolver host_resolver;
   scoped_ptr<net::ProxyService> proxy_service(net::ProxyService::CreateNull());
-  net::HttpNetworkLayer factory(proxy_service.get());
+  net::HttpNetworkLayer factory(&host_resolver, proxy_service.get());
 
   scoped_ptr<net::HttpTransaction> trans(factory.CreateTransaction());
 }
 
 TEST_F(HttpNetworkLayerTest, Suspend) {
+  net::HostResolver host_resolver;
   scoped_ptr<net::ProxyService> proxy_service(net::ProxyService::CreateNull());
-  net::HttpNetworkLayer factory(proxy_service.get());
+  net::HttpNetworkLayer factory(&host_resolver, proxy_service.get());
 
   scoped_ptr<net::HttpTransaction> trans(factory.CreateTransaction());
   trans.reset();
@@ -50,8 +52,9 @@ TEST_F(HttpNetworkLayerTest, Suspend) {
 }
 
 TEST_F(HttpNetworkLayerTest, GoogleGET) {
+  net::HostResolver host_resolver;
   scoped_ptr<net::ProxyService> proxy_service(net::ProxyService::CreateNull());
-  net::HttpNetworkLayer factory(proxy_service.get());
+  net::HttpNetworkLayer factory(&host_resolver, proxy_service.get());
 
   TestCompletionCallback callback;
 
diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h
index cb023a0..c7ebb3c 100644
--- a/net/http/http_network_session.h
+++ b/net/http/http_network_session.h
@@ -13,21 +13,24 @@
 namespace net {
 
 class ClientSocketFactory;
+class HostResolver;
 class ProxyService;
 
 // This class holds session objects used by HttpNetworkTransaction objects.
 class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
  public:
-  HttpNetworkSession(ProxyService* proxy_service,
+  HttpNetworkSession(HostResolver* host_resolver, ProxyService* proxy_service,
                      ClientSocketFactory* client_socket_factory)
       : connection_pool_(new TCPClientSocketPool(
-            max_sockets_per_group_, client_socket_factory)),
+            max_sockets_per_group_, host_resolver, client_socket_factory)),
+        host_resolver_(host_resolver),
         proxy_service_(proxy_service) {
     DCHECK(proxy_service);
   }
 
   HttpAuthCache* auth_cache() { return &auth_cache_; }
   ClientSocketPool* connection_pool() { return connection_pool_; }
+  HostResolver* host_resolver() { return host_resolver_; }
   ProxyService* proxy_service() { return proxy_service_; }
 #if defined(OS_WIN)
   SSLConfigService* ssl_config_service() { return &ssl_config_service_; }
@@ -43,6 +46,7 @@ class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
 
   HttpAuthCache auth_cache_;
   scoped_refptr<ClientSocketPool> connection_pool_;
+  HostResolver* host_resolver_;
   ProxyService* proxy_service_;
 #if defined(OS_WIN)
   // TODO(port): Port the SSLConfigService class to Linux and Mac OS X.
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 8bfe386..b4185df 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -13,7 +13,6 @@
 #include "net/base/client_socket_factory.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/dns_resolution_observer.h"
-#include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index af3a5f4..fb21384 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -292,9 +292,6 @@ class HttpNetworkTransaction : public HttpTransaction {
   ProxyService::PacRequest* pac_request_;
   ProxyInfo proxy_info_;
 
-  HostResolver resolver_;
-  AddressList addresses_;
-
   ClientSocketFactory* socket_factory_;
   ClientSocketHandle connection_;
   scoped_ptr<HttpStream> http_stream_;
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 852612f..e5c4ccc 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -41,6 +41,7 @@ class SessionDependencies {
   explicit SessionDependencies(ProxyService* proxy_service)
       : proxy_service(proxy_service) {}
 
+  HostResolver host_resolver;
   scoped_ptr<ProxyService> proxy_service;
   MockClientSocketFactory socket_factory;
 };
@@ -53,7 +54,8 @@ ProxyService* CreateFixedProxyService(const std::string& proxy) {
 
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(session_deps->proxy_service.get(),
+  return new HttpNetworkSession(&session_deps->host_resolver,
+                                session_deps->proxy_service.get(),
                                 &session_deps->socket_factory);
 }