Refactor out ProfileIODataQt

Currently we can crash due to use-after-free of browser
context, it happens due to fact that resource context
has pointer to browser context which is destroyed on ui
thread, while resource context is destroyed on io thread.

We used url request getter to maintain objects destruction
on io thread. Refactor the code and create profile io data,
which will live on io thread, move all the objects
currently maintained by url request getter qt to newly
created class. Fix destruction order and remove references to
browser context from resource context.

Compared to url request getter, profile io data is not
ref counted class and uses weak pointer factory to handle
all "generate" requests.

Task-number: QTBUG-67865
Change-Id: Iee4fec854eda1c1600d26e991657d4877cbc966f
Reviewed-by: Jüri Valdmann <juri.valdmann@qt.io>

1 files changed, 4 insertions, 578 deletions

diff --git a/src/core/net/url_request_context_getter_qt.cpp b/src/core/net/url_request_context_getter_qt.cpp
index 56b31c7fa..636d27358 100644
--- a/src/core/net/url_request_context_getter_qt.cpp
+++ b/src/core/net/url_request_context_getter_qt.cpp
@@ -38,597 +38,23 @@
 ****************************************************************************/
 
 #include "url_request_context_getter_qt.h"
-
-#include "base/memory/ptr_util.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
-#include "chrome/browser/net/chrome_mojo_proxy_resolver_factory.h"
-#include "content/network/proxy_service_mojo.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/browsing_data_remover.h"
-#include "content/public/browser/cookie_store_factory.h"
-#include "content/public/common/content_features.h"
-#include "content/public/common/content_switches.h"
-#include "net/base/cache_type.h"
-#include "net/cert/cert_verifier.h"
-#include "net/cert/ct_known_logs.h"
-#include "net/cert/ct_log_verifier.h"
-#include "net/cert/ct_policy_enforcer.h"
-#include "net/cert/multi_log_ct_verifier.h"
-#include "net/dns/host_resolver.h"
-#include "net/dns/mapped_host_resolver.h"
-#include "net/extras/sqlite/sqlite_channel_id_store.h"
-#include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_auth_preferences.h"
-#include "net/http/http_auth_scheme.h"
-#include "net/http/http_cache.h"
-#include "net/http/http_server_properties_impl.h"
-#include "net/proxy/proxy_script_fetcher_impl.h"
-#include "net/proxy/proxy_service.h"
-#include "net/ssl/channel_id_service.h"
-#include "net/ssl/default_channel_id_store.h"
-#include "net/ssl/ssl_config_service_defaults.h"
-#include "net/url_request/static_http_user_agent_settings.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/file_protocol_handler.h"
-#include "net/url_request/ftp_protocol_handler.h"
-#include "net/url_request/url_request_intercepting_job_factory.h"
-#include "net/ftp/ftp_network_layer.h"
-
-#include "api/qwebengineurlschemehandler.h"
-#include "custom_protocol_handler.h"
-#include "profile_qt.h"
-#include "proxy_config_service_qt.h"
-#include "qrc_protocol_handler_qt.h"
-#include "qwebenginecookiestore.h"
-#include "qwebenginecookiestore_p.h"
-#include "type_conversion.h"
+#include "profile_io_data_qt.h"
 
 namespace QtWebEngineCore {
 
-using content::BrowserThread;
-
-URLRequestContextGetterQt::URLRequestContextGetterQt(BrowserContextAdapter *browserContext,
-                                                     content::ProtocolHandlerMap *protocolHandlers,
-                                                     content::URLRequestInterceptorScopedVector request_interceptors)
-    : m_ignoreCertificateErrors(false)
-    , m_mutex(QMutex::Recursive)
-    , m_contextInitialized(false)
-    , m_updateAllStorage(false)
-    , m_updateCookieStore(false)
-    , m_updateHttpCache(false)
-    , m_updateJobFactory(true)
-    , m_updateUserAgent(false)
-    , m_browserContextAdapter(browserContext)
-    , m_baseJobFactory(0)
-    , m_cookieDelegate(new CookieMonsterDelegateQt())
-    , m_requestInterceptors(std::move(request_interceptors))
+URLRequestContextGetterQt::URLRequestContextGetterQt(ProfileIODataQt *data)
+    : m_profileIOData(data)
 {
-    std::swap(m_protocolHandlers, *protocolHandlers);
-
-    // The ProtocolHandlerRegistry and it's JobInterceptorFactory need to be
-    // created on the UI thread:
-    ProtocolHandlerRegistry* protocolHandlerRegistry =
-        ProtocolHandlerRegistryFactory::GetForBrowserContext(browserContext->browserContext());
-    DCHECK(protocolHandlerRegistry);
-    m_protocolHandlerInterceptor =
-        protocolHandlerRegistry->CreateJobInterceptorFactory();
-
-    QMutexLocker lock(&m_mutex);
-    m_cookieDelegate->setClient(browserContext->cookieStore());
-    updateStorageSettings();
 }
 
 URLRequestContextGetterQt::~URLRequestContextGetterQt()
 {
-    m_cookieDelegate->setCookieMonster(0); // this will let CookieMonsterDelegateQt be deleted
-    delete m_proxyConfigService.fetchAndStoreAcquire(0);
-}
-
-
-void URLRequestContextGetterQt::setFullConfiguration()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    m_requestInterceptor = m_browserContextAdapter->requestInterceptor();
-    m_persistentCookiesPolicy = m_browserContextAdapter->persistentCookiesPolicy();
-    m_cookiesPath = m_browserContextAdapter->cookiesPath();
-    m_channelIdPath = m_browserContextAdapter->channelIdPath();
-    m_httpAcceptLanguage = m_browserContextAdapter->httpAcceptLanguage();
-    m_httpUserAgent = m_browserContextAdapter->httpUserAgent();
-    m_httpCacheType = m_browserContextAdapter->httpCacheType();
-    m_httpCachePath = m_browserContextAdapter->httpCachePath();
-    m_httpCacheMaxSize = m_browserContextAdapter->httpCacheMaxSize();
-    m_customUrlSchemes = m_browserContextAdapter->customUrlSchemes();
 }
 
 net::URLRequestContext *URLRequestContextGetterQt::GetURLRequestContext()
 {
     Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    if (!m_urlRequestContext) {
-        m_urlRequestContext.reset(new net::URLRequestContext());
-
-        m_networkDelegate.reset(new NetworkDelegateQt(this));
-        m_urlRequestContext->set_network_delegate(m_networkDelegate.get());
-        m_urlRequestContext->set_enable_brotli(base::FeatureList::IsEnabled(features::kBrotliEncoding));
-
-        QMutexLocker lock(&m_mutex);
-        generateAllStorage();
-        generateJobFactory();
-        m_contextInitialized = true;
-    }
-
-    return m_urlRequestContext.get();
-}
-
-void URLRequestContextGetterQt::updateStorageSettings()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-    QMutexLocker lock(&m_mutex);
-    setFullConfiguration();
-
-    if (!m_updateAllStorage) {
-        m_updateAllStorage = true;
-        // We must create the proxy config service on the UI loop on Linux because it
-        // must synchronously run on the glib message loop. This will be passed to
-        // the URLRequestContextStorage on the IO thread in GetURLRequestContext().
-        Q_ASSERT(m_proxyConfigService == 0);
-        m_proxyConfigService =
-                new ProxyConfigServiceQt(
-                    net::ProxyService::CreateSystemProxyConfigService(
-                        content::BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
-        m_proxyResolverFactory = ChromeMojoProxyResolverFactory::CreateWithStrongBinding();
-
-        if (m_contextInitialized)
-            content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                             base::Bind(&URLRequestContextGetterQt::generateAllStorage, this));
-    }
-}
-
-void URLRequestContextGetterQt::cancelAllUrlRequests()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-
-    const std::set<const net::URLRequest*> *url_requests = m_urlRequestContext->url_requests();
-    std::set<const net::URLRequest*>::const_iterator it = url_requests->begin();
-    std::set<const net::URLRequest*>::const_iterator end = url_requests->end();
-    for ( ; it != end; ++it) {
-        net::URLRequest* request = const_cast<net::URLRequest*>(*it);
-        if (request)
-            request->Cancel();
-    }
-
-}
-
-void URLRequestContextGetterQt::generateAllStorage()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    QMutexLocker lock(&m_mutex);
-    generateStorage();
-    generateCookieStore();
-    generateUserAgent();
-    generateHttpCache();
-    m_updateAllStorage = false;
-}
-
-static const char* const kDefaultAuthSchemes[] = { net::kBasicAuthScheme,
-                                                   net::kDigestAuthScheme,
-#if defined(USE_KERBEROS) && !defined(OS_ANDROID)
-                                                   net::kNegotiateAuthScheme,
-#endif
-                                                   net::kNtlmAuthScheme };
-
-void URLRequestContextGetterQt::generateStorage()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-
-    // We must stop all requests before deleting their backends.
-    if (m_storage) {
-        m_cookieDelegate->setCookieMonster(0);
-        m_storage->set_cookie_store(0);
-        cancelAllUrlRequests();
-        // we need to get rid of dangling pointer due to coming storage deletion
-        m_urlRequestContext->set_http_transaction_factory(0);
-        m_httpNetworkSession.reset();
-    }
-
-
-    m_storage.reset(new net::URLRequestContextStorage(m_urlRequestContext.get()));
-
-    net::ProxyConfigService *proxyConfigService = m_proxyConfigService.fetchAndStoreAcquire(0);
-    Q_ASSERT(proxyConfigService);
-
-    m_storage->set_cert_verifier(net::CertVerifier::CreateDefault());
-    std::unique_ptr<net::MultiLogCTVerifier> ct_verifier(new net::MultiLogCTVerifier());
-    ct_verifier->AddLogs(net::ct::CreateLogVerifiersForKnownLogs());
-    m_storage->set_cert_transparency_verifier(std::move(ct_verifier));
-    m_storage->set_ct_policy_enforcer(base::WrapUnique(new net::CTPolicyEnforcer));
-
-    std::unique_ptr<net::HostResolver> host_resolver(net::HostResolver::CreateDefaultResolver(NULL));
-
-    // The System Proxy Resolver has issues on Windows with unconfigured network cards,
-    // which is why we want to use the v8 one
-    if (!m_dhcpProxyScriptFetcherFactory)
-        m_dhcpProxyScriptFetcherFactory.reset(new net::DhcpProxyScriptFetcherFactory);
-
-    m_storage->set_proxy_service(content::CreateProxyServiceUsingMojoFactory(
-                                     std::move(m_proxyResolverFactory),
-                                     std::unique_ptr<net::ProxyConfigService>(proxyConfigService),
-                                     std::make_unique<net::ProxyScriptFetcherImpl>(m_urlRequestContext.get()),
-                                     m_dhcpProxyScriptFetcherFactory->Create(m_urlRequestContext.get()),
-                                     host_resolver.get(),
-                                     nullptr /* NetLog */,
-                                     m_networkDelegate.get()));
-
-    m_storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
-    m_storage->set_transport_security_state(std::unique_ptr<net::TransportSecurityState>(new net::TransportSecurityState()));
-
-    if (!m_httpAuthPreferences) {
-        std::vector<std::string> auth_types(std::begin(kDefaultAuthSchemes), std::end(kDefaultAuthSchemes));
-        m_httpAuthPreferences.reset(new net::HttpAuthPreferences(auth_types
-#if defined(OS_POSIX) && !defined(OS_ANDROID)
-                                                                , std::string() /* gssapi library name */
-#endif
-                                   ));
-    }
-    m_storage->set_http_auth_handler_factory(net::HttpAuthHandlerRegistryFactory::Create(m_httpAuthPreferences.get(), host_resolver.get()));
-    m_storage->set_http_server_properties(std::unique_ptr<net::HttpServerProperties>(new net::HttpServerPropertiesImpl));
-
-     // Give |m_storage| ownership at the end in case it's |mapped_host_resolver|.
-    m_storage->set_host_resolver(std::move(host_resolver));
-}
-
-void URLRequestContextGetterQt::updateCookieStore()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    QMutexLocker lock(&m_mutex);
-    m_persistentCookiesPolicy = m_browserContextAdapter->persistentCookiesPolicy();
-    m_cookiesPath = m_browserContextAdapter->cookiesPath();
-    m_channelIdPath = m_browserContextAdapter->channelIdPath();
-
-    if (m_contextInitialized && !m_updateAllStorage && !m_updateCookieStore) {
-        m_updateCookieStore = true;
-        m_updateHttpCache = true;
-        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                         base::Bind(&URLRequestContextGetterQt::generateCookieStore, this));
-    }
-}
-
-void URLRequestContextGetterQt::generateCookieStore()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-    Q_ASSERT(m_storage);
-
-    QMutexLocker lock(&m_mutex);
-    m_updateCookieStore = false;
-
-    scoped_refptr<net::SQLiteChannelIDStore> channel_id_db;
-    if (!m_channelIdPath.isEmpty() && m_persistentCookiesPolicy != BrowserContextAdapter::NoPersistentCookies) {
-        channel_id_db = new net::SQLiteChannelIDStore(
-                toFilePath(m_channelIdPath),
-                base::CreateSequencedTaskRunnerWithTraits(
-                                {base::MayBlock(), base::TaskPriority::BACKGROUND}));
-    }
-
-    m_storage->set_channel_id_service(
-            base::WrapUnique(new net::ChannelIDService(
-                    new net::DefaultChannelIDStore(channel_id_db.get()))));
-
-    // Unset it first to get a chance to destroy and flush the old cookie store before opening a new on possibly the same file.
-    m_cookieDelegate->setCookieMonster(0);
-    m_storage->set_cookie_store(0);
-
-    std::unique_ptr<net::CookieStore> cookieStore;
-    switch (m_persistentCookiesPolicy) {
-    case BrowserContextAdapter::NoPersistentCookies:
-        cookieStore = content::CreateCookieStore(
-            content::CookieStoreConfig(
-                base::FilePath(),
-                false,
-                false,
-                nullptr)
-        );
-        break;
-    case BrowserContextAdapter::AllowPersistentCookies:
-        cookieStore = content::CreateCookieStore(
-            content::CookieStoreConfig(
-                toFilePath(m_cookiesPath),
-                false,
-                true,
-                nullptr)
-            );
-        break;
-    case BrowserContextAdapter::ForcePersistentCookies:
-        cookieStore = content::CreateCookieStore(
-            content::CookieStoreConfig(
-                toFilePath(m_cookiesPath),
-                true,
-                true,
-                nullptr)
-            );
-        break;
-    }
-
-    net::CookieMonster * const cookieMonster = static_cast<net::CookieMonster*>(cookieStore.get());
-    cookieStore->SetChannelIDServiceID(m_urlRequestContext->channel_id_service()->GetUniqueID());
-    m_cookieDelegate->setCookieMonster(cookieMonster);
-    m_storage->set_cookie_store(std::move(cookieStore));
-
-    const std::vector<std::string> cookieableSchemes(kCookieableSchemes, kCookieableSchemes + arraysize(kCookieableSchemes));
-    cookieMonster->SetCookieableSchemes(cookieableSchemes);
-
-    if (!m_updateAllStorage && m_updateHttpCache) {
-        // HttpCache needs to be regenerated when we generate a new channel id service
-        generateHttpCache();
-    }
-}
-
-void URLRequestContextGetterQt::updateUserAgent()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    QMutexLocker lock(&m_mutex);
-    m_httpAcceptLanguage = m_browserContextAdapter->httpAcceptLanguage();
-    m_httpUserAgent = m_browserContextAdapter->httpUserAgent();
-
-    if (m_contextInitialized && !m_updateAllStorage && !m_updateUserAgent) {
-        m_updateUserAgent = true;
-        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                         base::Bind(&URLRequestContextGetterQt::generateUserAgent, this));
-    }
-}
-
-void URLRequestContextGetterQt::generateUserAgent()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-    Q_ASSERT(m_storage);
-
-    QMutexLocker lock(&m_mutex);
-    m_updateUserAgent = false;
-
-    m_storage->set_http_user_agent_settings(std::unique_ptr<net::HttpUserAgentSettings>(
-        new net::StaticHttpUserAgentSettings(m_httpAcceptLanguage.toStdString(), m_httpUserAgent.toStdString())));
-}
-
-void URLRequestContextGetterQt::updateHttpCache()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    QMutexLocker lock(&m_mutex);
-    m_httpCacheType = m_browserContextAdapter->httpCacheType();
-    m_httpCachePath = m_browserContextAdapter->httpCachePath();
-    m_httpCacheMaxSize = m_browserContextAdapter->httpCacheMaxSize();
-
-    if (m_httpCacheType == BrowserContextAdapter::NoCache) {
-        content::BrowsingDataRemover *remover = content::BrowserContext::GetBrowsingDataRemover(m_browserContextAdapter->browserContext());
-        remover->Remove(base::Time(), base::Time::Max(),
-            content::BrowsingDataRemover::DATA_TYPE_CACHE,
-            content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB | content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB);
-    }
-
-    if (m_contextInitialized && !m_updateAllStorage && !m_updateHttpCache) {
-        m_updateHttpCache = true;
-        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                         base::Bind(&URLRequestContextGetterQt::generateHttpCache, this));
-    }
-}
-
-void URLRequestContextGetterQt::updateJobFactory()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    QMutexLocker lock(&m_mutex);
-
-    m_customUrlSchemes = m_browserContextAdapter->customUrlSchemes();
-
-    if (m_contextInitialized && !m_updateJobFactory) {
-        m_updateJobFactory = true;
-        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                         base::Bind(&URLRequestContextGetterQt::regenerateJobFactory, this));
-    }
-}
-
-void URLRequestContextGetterQt::updateRequestInterceptor()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    QMutexLocker lock(&m_mutex);
-    m_requestInterceptor = m_browserContextAdapter->requestInterceptor();
-
-    // We in this case do not need to regenerate any Chromium classes.
-}
-
-static bool doNetworkSessionContextMatch(const net::HttpNetworkSession::Context &first, const net::HttpNetworkSession::Context &second)
-{
-    if (first.transport_security_state != second.transport_security_state)
-        return false;
-    if (first.cert_verifier != second.cert_verifier)
-        return false;
-    if (first.channel_id_service != second.channel_id_service)
-        return false;
-    if (first.proxy_service != second.proxy_service)
-        return false;
-    if (first.ssl_config_service != second.ssl_config_service)
-        return false;
-    if (first.http_auth_handler_factory != second.http_auth_handler_factory)
-        return false;
-    if (first.http_server_properties != second.http_server_properties)
-        return false;
-    if (first.host_resolver != second.host_resolver)
-        return false;
-    if (first.cert_transparency_verifier != second.cert_transparency_verifier)
-        return false;
-    if (first.ct_policy_enforcer != second.ct_policy_enforcer)
-        return false;
-
-    return true;
-}
-
-static bool doNetworkSessionParamsMatch(const net::HttpNetworkSession::Params &first, const net::HttpNetworkSession::Params &second)
-{
-    if (first.ignore_certificate_errors != second.ignore_certificate_errors)
-        return false;
-
-    return true;
-}
-
-net::HttpNetworkSession::Context URLRequestContextGetterQt::generateNetworkSessionContext()
-{
-    Q_ASSERT(m_urlRequestContext);
-
-    net::HttpNetworkSession::Context network_session_context;
-
-    network_session_context.transport_security_state     = m_urlRequestContext->transport_security_state();
-    network_session_context.cert_verifier                = m_urlRequestContext->cert_verifier();
-    network_session_context.channel_id_service           = m_urlRequestContext->channel_id_service();
-    network_session_context.proxy_service                = m_urlRequestContext->proxy_service();
-    network_session_context.ssl_config_service           = m_urlRequestContext->ssl_config_service();
-    network_session_context.http_auth_handler_factory    = m_urlRequestContext->http_auth_handler_factory();
-    network_session_context.http_server_properties       = m_urlRequestContext->http_server_properties();
-    network_session_context.host_resolver                = m_urlRequestContext->host_resolver();
-    network_session_context.cert_transparency_verifier   = m_urlRequestContext->cert_transparency_verifier();
-    network_session_context.ct_policy_enforcer           = m_urlRequestContext->ct_policy_enforcer();
-
-    return network_session_context;
-}
-
-net::HttpNetworkSession::Params URLRequestContextGetterQt::generateNetworkSessionParams()
-{
-    Q_ASSERT(m_urlRequestContext);
-
-    net::HttpNetworkSession::Params network_session_params;
-
-    network_session_params.ignore_certificate_errors    = m_ignoreCertificateErrors;
-
-    return network_session_params;
-}
-
-void URLRequestContextGetterQt::generateHttpCache()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-    Q_ASSERT(m_storage);
-
-    QMutexLocker lock(&m_mutex);
-    m_updateHttpCache = false;
-
-    if (m_updateCookieStore)
-        generateCookieStore();
-
-    net::HttpCache::DefaultBackend* main_backend = 0;
-    switch (m_httpCacheType) {
-    case BrowserContextAdapter::MemoryHttpCache:
-        main_backend =
-            new net::HttpCache::DefaultBackend(
-                net::MEMORY_CACHE,
-                net::CACHE_BACKEND_DEFAULT,
-                base::FilePath(),
-                m_httpCacheMaxSize
-            );
-        break;
-    case BrowserContextAdapter::DiskHttpCache:
-        main_backend =
-            new net::HttpCache::DefaultBackend(
-                net::DISK_CACHE,
-                net::CACHE_BACKEND_DEFAULT,
-                toFilePath(m_httpCachePath),
-                m_httpCacheMaxSize
-            );
-        break;
-    case BrowserContextAdapter::NoCache:
-        // It's safe to not create BackendFactory.
-        break;
-    }
-
-    net::HttpCache *cache = 0;
-    net::HttpNetworkSession::Context network_session_context = generateNetworkSessionContext();
-    net::HttpNetworkSession::Params network_session_params = generateNetworkSessionParams();
-
-    if (!m_httpNetworkSession
-            || !doNetworkSessionParamsMatch(network_session_params, m_httpNetworkSession->params())
-            || !doNetworkSessionContextMatch(network_session_context, m_httpNetworkSession->context())) {
-        cancelAllUrlRequests();
-        m_httpNetworkSession.reset(new net::HttpNetworkSession(network_session_params, network_session_context));
-    }
-
-    cache = new net::HttpCache(m_httpNetworkSession.get(), std::unique_ptr<net::HttpCache::DefaultBackend>(main_backend), false);
-
-    m_storage->set_http_transaction_factory(std::unique_ptr<net::HttpCache>(cache));
-}
-
-void URLRequestContextGetterQt::generateJobFactory()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-    Q_ASSERT(!m_jobFactory);
-
-    QMutexLocker lock(&m_mutex);
-    m_updateJobFactory = false;
-
-    std::unique_ptr<net::URLRequestJobFactoryImpl> jobFactory(new net::URLRequestJobFactoryImpl());
-    for (auto &it : m_protocolHandlers)
-        jobFactory->SetProtocolHandler(it.first, base::WrapUnique(it.second.release()));
-    m_protocolHandlers.clear();
-
-    jobFactory->SetProtocolHandler(url::kDataScheme, std::unique_ptr<net::URLRequestJobFactory::ProtocolHandler>(new net::DataProtocolHandler()));
-    jobFactory->SetProtocolHandler(url::kFileScheme,
-                                   std::make_unique<net::FileProtocolHandler>(
-                                                        base::CreateTaskRunnerWithTraits({base::MayBlock(),
-                                                                                          base::TaskPriority::BACKGROUND,
-                                                                                          base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
-    jobFactory->SetProtocolHandler(kQrcSchemeQt, std::unique_ptr<net::URLRequestJobFactory::ProtocolHandler>(new QrcProtocolHandlerQt()));
-    jobFactory->SetProtocolHandler(url::kFtpScheme,
-            net::FtpProtocolHandler::Create(m_urlRequestContext->host_resolver()));
-
-    m_installedCustomSchemes = m_customUrlSchemes;
-    Q_FOREACH (const QByteArray &scheme, m_installedCustomSchemes) {
-        jobFactory->SetProtocolHandler(scheme.toStdString(), std::unique_ptr<net::URLRequestJobFactory::ProtocolHandler>(new CustomProtocolHandler(m_browserContextAdapter)));
-    }
-
-    m_baseJobFactory = jobFactory.get();
-
-    // Set up interceptors in the reverse order.
-    std::unique_ptr<net::URLRequestJobFactory> topJobFactory = std::move(jobFactory);
-
-    for (content::URLRequestInterceptorScopedVector::reverse_iterator i = m_requestInterceptors.rbegin(); i != m_requestInterceptors.rend(); ++i) {
-        topJobFactory.reset(new net::URLRequestInterceptingJobFactory(std::move(topJobFactory), std::move(*i)));
-    }
-
-    m_requestInterceptors.clear();
-
-    if (m_protocolHandlerInterceptor) {
-        m_protocolHandlerInterceptor->Chain(std::move(topJobFactory));
-        topJobFactory = std::move(m_protocolHandlerInterceptor);
-    }
-
-    m_jobFactory = std::move(topJobFactory);
-
-    m_urlRequestContext->set_job_factory(m_jobFactory.get());
-}
-
-void URLRequestContextGetterQt::regenerateJobFactory()
-{
-    Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-    Q_ASSERT(m_urlRequestContext);
-    Q_ASSERT(m_jobFactory);
-    Q_ASSERT(m_baseJobFactory);
-
-    QMutexLocker lock(&m_mutex);
-    m_updateJobFactory = false;
-
-    if (m_customUrlSchemes == m_installedCustomSchemes)
-        return;
-
-    Q_FOREACH (const QByteArray &scheme, m_installedCustomSchemes) {
-        m_baseJobFactory->SetProtocolHandler(scheme.toStdString(), nullptr);
-    }
-
-    m_installedCustomSchemes = m_customUrlSchemes;
-    Q_FOREACH (const QByteArray &scheme, m_installedCustomSchemes) {
-        m_baseJobFactory->SetProtocolHandler(scheme.toStdString(), std::unique_ptr<net::URLRequestJobFactory::ProtocolHandler>(new CustomProtocolHandler(m_browserContextAdapter)));
-    }
+    return m_profileIOData->urlRequestContext();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> URLRequestContextGetterQt::GetNetworkTaskRunner() const