net: split the SSL session cache between incognito and normal.

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 31 matching lines @@
 namespace {
 
 HttpNetworkSession* CreateNetworkSession(
     HostResolver* host_resolver,
     CertVerifier* cert_verifier,
     OriginBoundCertService* origin_bound_cert_service,
     TransportSecurityState* transport_security_state,
     DnsCertProvenanceChecker* dns_cert_checker,
     ProxyService* proxy_service,
     SSLHostInfoFactory* ssl_host_info_factory,
+    const std::string& ssl_session_cache_shard,
     SSLConfigService* ssl_config_service,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     NetworkDelegate* network_delegate,
     HttpServerProperties* http_server_properties,
     NetLog* net_log) {
   HttpNetworkSession::Params params;
   params.host_resolver = host_resolver;
   params.cert_verifier = cert_verifier;
   params.origin_bound_cert_service = origin_bound_cert_service;
   params.transport_security_state = transport_security_state;
   params.dns_cert_checker = dns_cert_checker;
   params.proxy_service = proxy_service;
   params.ssl_host_info_factory = ssl_host_info_factory;
+  params.ssl_session_cache_shard = ssl_session_cache_shard;
   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;
   return new HttpNetworkSession(params);
 }
 
 }  // namespace
 
@@ skipping 239 matching lines @@
   HttpCache* const http_cache_;
 };
 
 //-----------------------------------------------------------------------------
 HttpCache::HttpCache(HostResolver* host_resolver,
                      CertVerifier* cert_verifier,
                      OriginBoundCertService* origin_bound_cert_service,
                      TransportSecurityState* transport_security_state,
                      DnsCertProvenanceChecker* dns_cert_checker_,
                      ProxyService* proxy_service,
+                     const std::string& ssl_session_cache_shard,
                      SSLConfigService* ssl_config_service,
                      HttpAuthHandlerFactory* http_auth_handler_factory,
                      NetworkDelegate* network_delegate,
                      HttpServerProperties* http_server_properties,
                      NetLog* net_log,
                      BackendFactory* backend_factory)
     : 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,
                   transport_security_state,
                   dns_cert_checker_,
                   proxy_service,
                   ssl_host_info_factory_.get(),
+                  ssl_session_cache_shard,
                   ssl_config_service,
                   http_auth_handler_factory,
                   network_delegate,
                   http_server_properties,
                   net_log))) {
 }
 
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      BackendFactory* backend_factory)
@@ skipping 804 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