Clean up FtpTransactionFacory ownership.

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 <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 45 matching lines @@
 #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/cookies/cookie_store.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_context_storage.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"
 
@@ skipping 449 matching lines @@
   std::unique_ptr<net::HttpCache::BackendFactory> main_backend(
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE, ChooseCacheBackendType(), lazy_params_->cache_path,
           lazy_params_->cache_max_size,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::CACHE)));
   main_context_storage->set_http_network_session(
       CreateHttpNetworkSession(*profile_params));
   main_context_storage->set_http_transaction_factory(CreateMainHttpFactory(
       main_context_storage->http_network_session(), std::move(main_backend)));
 
-#if !defined(DISABLE_FTP_SUPPORT)
-  ftp_factory_.reset(
-      new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
-#endif  // !defined(DISABLE_FTP_SUPPORT)
-
   std::unique_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 
   // Install the Offline Page Interceptor.
 #if defined(OS_ANDROID)
   request_interceptors.push_back(std::unique_ptr<net::URLRequestInterceptor>(
       new offline_pages::OfflinePageRequestInterceptor(
           previews_io_data_.get())));
 #endif
 
   // The data reduction proxy interceptor should be as close to the network
   // as possible.
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
   main_context_storage->set_job_factory(SetUpJobFactoryDefaults(
       std::move(main_job_factory), std::move(request_interceptors),
       std::move(profile_params->protocol_handler_interceptor),
-      main_context->network_delegate(), ftp_factory_.get()));
+      main_context->network_delegate(),
+      io_thread_globals->host_resolver.get()));
   main_context->set_network_quality_estimator(
       io_thread_globals->network_quality_estimator.get());
 
 #if defined(ENABLE_EXTENSIONS)
   InitializeExtensionsRequestContext(profile_params);
 #endif
 
   // Setup SDCH for this profile.
   std::unique_ptr<net::SdchManager> sdch_manager(new net::SdchManager());
   sdch_policy_.reset(new net::SdchOwner(sdch_manager.get(), main_context));
@@ skipping 40 matching lines @@
   // TODO(shalev): The extensions_job_factory has a NULL NetworkDelegate.
   // Without a network_delegate, this protocol handler will never
   // handle file: requests, but as a side effect it makes
   // job_factory::IsHandledProtocol return true, which prevents attempts to
   // handle the protocol externally. We pass NULL in to
   // SetUpJobFactory() to get this effect.
   extensions_job_factory_ = SetUpJobFactoryDefaults(
       std::move(extensions_job_factory),
       content::URLRequestInterceptorScopedVector(),
       std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>(), NULL,
-      ftp_factory_.get());
+      io_thread_globals->host_resolver.get());
   extensions_context->set_job_factory(extensions_job_factory_.get());
 }
 
 net::URLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
     net::URLRequestContext* main_context,
     const StoragePartitionDescriptor& partition_descriptor,
     std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
@@ skipping 69 matching lines @@
   context->SetHttpTransactionFactory(std::move(app_http_cache));
 
   std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(job_factory.get(), protocol_handlers);
   // The data reduction proxy interceptor should be as close to the network
   // as possible.
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
+
   std::unique_ptr<net::URLRequestJobFactory> top_job_factory(
       SetUpJobFactoryDefaults(
           std::move(job_factory), std::move(request_interceptors),
-          std::move(protocol_handler_interceptor),
-          main_context->network_delegate(), ftp_factory_.get()));
+          std::move(protocol_handler_interceptor), context->network_delegate(),
+          context->host_resolver()));
   context->SetJobFactory(std::move(top_job_factory));
 
   return context;
 }
 
 net::URLRequestContext*
 ProfileImplIOData::InitializeMediaRequestContext(
     net::URLRequestContext* original_context,
     const StoragePartitionDescriptor& partition_descriptor) const {
   // Copy most state from the original context.
@@ skipping 82 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);
 }