Close idle sockets next time we are about to send data.

net/http/http_cache.cc

 // Copyright (c) 2011 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_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 35 matching lines @@
     CertVerifier* cert_verifier,
     OriginBoundCertService* origin_bound_cert_service,
     DnsRRResolver* dnsrr_resolver,
     DnsCertProvenanceChecker* dns_cert_checker,
     ProxyService* proxy_service,
     SSLHostInfoFactory* ssl_host_info_factory,
     SSLConfigService* ssl_config_service,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     NetworkDelegate* network_delegate,
     HttpServerProperties* http_server_properties,
-    NetLog* net_log) {
+    NetLog* net_log,
+    HttpCache::IdleSocketCleanupMode cleanup_mode) {
+
   HttpNetworkSession::Params params;
   params.host_resolver = host_resolver;
   params.cert_verifier = cert_verifier;
   params.origin_bound_cert_service = origin_bound_cert_service;
   params.dnsrr_resolver = dnsrr_resolver;
   params.dns_cert_checker = dns_cert_checker;
   params.proxy_service = proxy_service;
   params.ssl_host_info_factory = ssl_host_info_factory;
   params.ssl_config_service = ssl_config_service;
   params.http_auth_handler_factory = http_auth_handler_factory;
   params.network_delegate = network_delegate;
   params.http_server_properties = http_server_properties;
   params.net_log = net_log;
+  params.use_cleanup_timer = (cleanup_mode == HttpCache::USE_CLEANUP_TIMER);
   return new HttpNetworkSession(params);
 }
 
 }  // namespace
 
 HttpCache::DefaultBackend::DefaultBackend(CacheType type,
                                           const FilePath& path,
                                           int max_bytes,
                                           base::MessageLoopProxy* thread)
     : type_(type),
@@ skipping 239 matching lines @@
                      CertVerifier* cert_verifier,
                      OriginBoundCertService* origin_bound_cert_service,
                      DnsRRResolver* dnsrr_resolver,
                      DnsCertProvenanceChecker* dns_cert_checker_,
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      HttpAuthHandlerFactory* http_auth_handler_factory,
                      NetworkDelegate* network_delegate,
                      HttpServerProperties* http_server_properties,
                      NetLog* net_log,
-                     BackendFactory* backend_factory)
+                     BackendFactory* backend_factory,
+                     IdleSocketCleanupMode cleanup_mode)
     : net_log_(net_log),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       ssl_host_info_factory_(new SSLHostInfoFactoryAdaptor(
           cert_verifier,
           ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       network_layer_(
           new HttpNetworkLayer(
               CreateNetworkSession(
                   host_resolver,
                   cert_verifier,
                   origin_bound_cert_service,
                   dnsrr_resolver,
                   dns_cert_checker_,
                   proxy_service,
                   ssl_host_info_factory_.get(),
                   ssl_config_service,
                   http_auth_handler_factory,
                   network_delegate,
                   http_server_properties,
-                  net_log))) {
+                  net_log,
+                  cleanup_mode))) {
 }
 
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      BackendFactory* backend_factory)
     : net_log_(session->net_log()),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       ssl_host_info_factory_(new SSLHostInfoFactoryAdaptor(
@@ skipping 799 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, backend))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net