Create unique HttpNetworkSession for storage partition.

chrome/browser/profiles/profile_impl_io_data.cc

 // Copyright (c) 2012 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 "chrome/browser/profiles/profile_impl_io_data.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 36 matching lines @@
 #include "components/domain_reliability/monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/extension_protocols.h"
 #include "extensions/common/constants.h"
 #include "net/base/cache_type.h"
 #include "net/base/sdch_manager.h"
+#include "net/cert/cert_policy_enforcer.h"
+#include "net/cert/cert_verifier.h"
+#include "net/cert/multi_log_ct_verifier.h"
+#include "net/dns/host_resolver.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
+#include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace {
 
 net::BackendType ChooseCacheBackendType() {
 #if defined(OS_ANDROID)
   return net::CACHE_BACKEND_SIMPLE;
 #else
@@ skipping 566 matching lines @@
 
 net::URLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
     net::URLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext();
   context->CopyFrom(main_context);

[mmenke, 2015/07/09 18:36:54]

And just to help motivate my comment about sharing stuff by default being a
problem - we're sharing the SdchManager here, which has its own memory cache,
and makes requests that go through the main context (And its disk cache).

 
   base::FilePath cookie_path = partition_descriptor.path.Append(
       chrome::kCookieFilename);
   base::FilePath cache_path =
       partition_descriptor.path.Append(chrome::kCacheDirname);
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* app_backend = NULL;
   if (partition_descriptor.in_memory) {
     app_backend = net::HttpCache::DefaultBackend::InMemory(0);
   } else {
     app_backend = new net::HttpCache::DefaultBackend(
         net::DISK_CACHE,
         ChooseCacheBackendType(),
         cache_path,
         app_cache_max_size_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
   }
-  net::HttpNetworkSession* main_network_session =
-      main_http_factory_->GetSession();
+
+  // Clone network session parameters from the main HttpNetworkSession, then
+  // create a unique HttpNetworkSession. Below we create isolated versions of
+  // the state elements necessary to get a completely isolated socket pool for
+  // the app.
+  net::HttpNetworkSession::Params params =
+      main_http_factory_->GetSession()->params();
+
+  // Create isolated HostResolver. Assume it's ok to re-use the net_log
+  // from the main_context.
+  context->SetHostResolver(
+      net::HostResolver::CreateDefaultResolver(main_context->net_log()));
+  params.host_resolver = context->host_resolver();
+  params.client_socket_factory = nullptr; // Force creation of new sockets.
+  context->SetCertVerifier(make_scoped_ptr(net::CertVerifier::CreateDefault()));
+  params.cert_verifier = context->cert_verifier();
+  context->SetChannelIDService(make_scoped_ptr(
+      new net::ChannelIDService(new net::DefaultChannelIDStore(nullptr),
+                                base::WorkerPool::GetTaskRunner(true))));
+  params.channel_id_service = context->channel_id_service();
+  context->SetTransportSecurityState(
+      make_scoped_ptr(new net::TransportSecurityState));
+  params.transport_security_state = context->transport_security_state();
+  context->SetCertTransparencyVerifier(
+      make_scoped_ptr(new net::MultiLogCTVerifier()));
+  params.cert_transparency_verifier = context->cert_transparency_verifier();
+  context->SetCertPolicyEnforcer(make_scoped_ptr(new net::CertPolicyEnforcer));
+  params.cert_policy_enforcer = context->cert_policy_enforcer();
+  context->SetSSLConfigService(new net::SSLConfigServiceDefaults);
+  params.ssl_config_service = context->ssl_config_service();
+
+  // Create new, isolated-state HttpNetworkSession.
+  net::HttpNetworkSession* new_network_session =
+      new net::HttpNetworkSession(params);
   scoped_ptr<net::HttpCache> app_http_cache =
-      CreateHttpFactory(main_network_session, app_backend);
+      CreateHttpFactory(new_network_session, app_backend);
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   if (partition_descriptor.in_memory) {
     cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
   }
 
   // Use an app-specific cookie store.
   if (!cookie_store.get()) {
     DCHECK(!cookie_path.empty());
 
@@ skipping 123 matching lines @@
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }