Add the ability for DevTools to wrap network transactions.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 441 matching lines @@
   main_context->set_server_bound_cert_service(server_bound_cert_service);
 
   net::HttpCache::DefaultBackend* main_backend =
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE,
           ChooseCacheBackendType(),
           lazy_params_->cache_path,
           lazy_params_->cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)
               .get());
-  net::HttpNetworkSession::Params network_session_params;
-  PopulateNetworkSessionParams(profile_params, &network_session_params);
-  net::HttpCache* main_cache = new net::HttpCache(
-      network_session_params, main_backend);
+  scoped_ptr<net::HttpCache> main_cache = CreateMainHttpFactory(
+      profile_params, main_backend);
   main_cache->InitializeInfiniteCache(lazy_params_->infinite_cache_path);
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
   DataReductionProxySettings::InitDataReductionProxySession(
       main_cache->GetSession());
 #endif
 
   if (chrome_browser_net::ShouldUseInMemoryCookiesAndCache()) {
     main_cache->set_mode(
         chrome_browser_net::IsCookieRecordMode() ?
         net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
   }
 
-  main_http_factory_.reset(main_cache);
-  main_context->set_http_transaction_factory(main_cache);
+  main_http_factory_ = main_cache.PassAs<net::HttpTransactionFactory>();

[mmenke, 2014/03/31 18:10:20]

Think "main_http_factory_.reset(main_cache.release())" is much more common than
this.

[eustas, 2014/04/18 12:33:19]

Done.

+  main_context->set_http_transaction_factory(main_http_factory_.get());
 
 #if !defined(DISABLE_FTP_SUPPORT)
   ftp_factory_.reset(
       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
   scoped_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
   main_job_factory_ = SetUpJobFactoryDefaults(
@@ skipping 93 matching lines @@
     app_backend = new net::HttpCache::DefaultBackend(
         net::DISK_CACHE,
         ChooseCacheBackendType(),
         cache_path,
         app_cache_max_size_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)
             .get());
   }
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  net::HttpCache* app_http_cache =
-      new net::HttpCache(main_network_session, app_backend);
+  scoped_ptr<net::HttpCache> app_http_cache =
+      CreateHttpFactory(main_network_session, app_backend);
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   if (partition_descriptor.in_memory) {
     cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
   } else if (chrome_browser_net::ShouldUseInMemoryCookiesAndCache()) {
     // Don't use existing cookies and use an in-memory store.
     // TODO(creis): We should have a cookie delegate for notifying the cookie
     // extensions API, but we need to update it to understand isolated apps
     // first.
     cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
@@ skipping 14 matching lines @@
         content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES,
         NULL, NULL);
     cookie_config.crypto_delegate =
       chrome_browser_net::GetCookieCryptoDelegate();
     cookie_store = content::CreateCookieStore(cookie_config);
   }
 
   // Transfer ownership of the cookies and cache to AppRequestContext.
   context->SetCookieStore(cookie_store.get());
   context->SetHttpTransactionFactory(
-      scoped_ptr<net::HttpTransactionFactory>(app_http_cache));
+      scoped_ptr<net::HttpTransactionFactory>(
+          app_http_cache.PassAs<net::HttpTransactionFactory>()));
 
   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(job_factory.get(), protocol_handlers);
   scoped_ptr<net::URLRequestJobFactory> top_job_factory(
       SetUpJobFactoryDefaults(job_factory.Pass(),
                               protocol_interceptors.Pass(),
                               protocol_handler_interceptor.Pass(),
                               network_delegate(),
                               ftp_factory_.get()));
@@ skipping 32 matching lines @@
   net::HttpCache::BackendFactory* media_backend =
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           ChooseCacheBackendType(),
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)
               .get());
   net::HttpNetworkSession* main_network_session =
       main_http_factory_->GetSession();
-  scoped_ptr<net::HttpTransactionFactory> media_http_cache(
-      new net::HttpCache(main_network_session, media_backend));
+  scoped_ptr<net::HttpCache> media_http_cache =
+      CreateHttpFactory(main_network_session, media_backend);
 
   // Transfer ownership of the cache to MediaRequestContext.
-  context->SetHttpTransactionFactory(media_http_cache.Pass());
+  context->SetHttpTransactionFactory(
+      media_http_cache.PassAs<net::HttpTransactionFactory>());
 
   // Note that we do not create a new URLRequestJobFactory because
   // the media context should behave exactly like its parent context
   // in all respects except for cache behavior on media subresources.
   // The CopyFrom() step above means that our media context will use
   // the same URLRequestJobFactory instance that our parent context does.
 
   return context;
 }
 
@@ skipping 37 matching lines @@
     const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(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);
 }