Revert of Remove reference counting from HttpNetworkSession.

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 39 matching lines @@
 #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/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
-#include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.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() {
@@ skipping 460 matching lines @@
                 BrowserThread::GetBlockingPool()->GetSequenceToken()),
             lazy_params_->special_storage_policy.get());
     channel_id_service = new net::ChannelIDService(
         new net::DefaultChannelIDStore(channel_id_db.get()),
         base::WorkerPool::GetTaskRunner(true));
   }
 
   set_channel_id_service(channel_id_service);
   main_context->set_channel_id_service(channel_id_service);
 
+  scoped_ptr<net::HttpCache> main_cache;
   {
     // TODO(ttuttle): Remove ScopedTracker below once crbug.com/436671 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("436671 HttpCache construction"));
-    net::HttpCache::BackendFactory* main_backend(
+    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)));
-    http_network_session_ = CreateHttpNetworkSession(*profile_params);
-    main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
-                                               main_backend);
+            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+    main_cache = CreateMainHttpFactory(profile_params, main_backend);
   }
 
+  main_http_factory_.reset(main_cache.release());
   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);
@@ skipping 91 matching lines @@
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext();
   context->CopyFrom(main_context);
 
   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;
+  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();
   scoped_ptr<net::HttpCache> app_http_cache =
-      CreateHttpFactory(http_network_session_.get(), app_backend);
+      CreateHttpFactory(main_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 59 matching lines @@
   }
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* media_backend =
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           ChooseCacheBackendType(),
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+  net::HttpNetworkSession* main_network_session =
+      main_http_factory_->GetSession();
   scoped_ptr<net::HttpCache> media_http_cache =
-      CreateHttpFactory(http_network_session_.get(), media_backend);
+      CreateHttpFactory(main_network_session, media_backend);
 
   // Transfer ownership of the cache to MediaRequestContext.
   context->SetHttpTransactionFactory(media_http_cache.Pass());
 
   // 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.
 
@@ skipping 40 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);
 }