Add virtual ProfileIOData methods related to URLRequestContext creation.

chrome/browser/profiles/profile_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_io_data.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 58 matching lines @@
 #include "components/net_log/chrome_net_log.h"
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #include "components/policy/core/common/cloud/policy_header_io_helper.h"
 #include "components/policy/core/common/cloud/policy_header_service.h"
 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
 #include "components/prefs/pref_service.h"
 #include "components/previews/core/previews_io_data.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "components/url_formatter/url_fixer.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/common/content_switches.h"
 #include "extensions/features/features.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/http/transport_security_persister.h"
 #include "net/net_features.h"
 #include "net/nqe/network_quality_estimator.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/reporting/reporting_service.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/client_cert_store.h"
+#include "net/ssl/default_channel_id_store.h"
 #include "net/traffic_annotation/network_traffic_annotation.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/report_sender.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_file_job.h"
@@ skipping 928 matching lines @@
   std::unique_ptr<net::NetworkDelegate> network_delegate =
       ConfigureNetworkDelegate(profile_params_->io_thread,
                                std::move(chrome_network_delegate));
 
   main_request_context_->set_host_resolver(
       io_thread_globals->system_request_context->host_resolver());
 
   main_request_context_->set_http_auth_handler_factory(
       io_thread_globals->system_request_context->http_auth_handler_factory());
 
+  main_request_context_storage_->set_http_server_properties(
+      GetHttpServerProperties());
+
+  std::unique_ptr<net::CookieStore> cookie_store;
+  std::unique_ptr<net::ChannelIDService> channel_id_service;
+  GetCookieAndChannelIDStores(&cookie_store, &channel_id_service);
+  cookie_store->SetChannelIDServiceID(channel_id_service->GetUniqueID());
+
+  main_request_context_storage_->set_cookie_store(std::move(cookie_store));
+  main_request_context_storage_->set_channel_id_service(
+      std::move(channel_id_service));
+
   main_request_context_storage_->set_proxy_service(
       ProxyServiceFactory::CreateProxyService(
           io_thread->net_log(), main_request_context_.get(),
           network_delegate.get(),
           std::move(profile_params_->proxy_config_service), command_line,
           io_thread->WpadQuickCheckEnabled(),
           io_thread->PacHttpsUrlStrippingEnabled()));
 
   main_request_context_storage_->set_network_delegate(
       std::move(network_delegate));
@@ skipping 115 matching lines @@
       std::move(ct_verifier));
 
   io_thread->RegisterSTHObserver(ct_tree_tracker_.get());
   ct_tree_tracker_unregistration_ =
       base::Bind(&IOThread::UnregisterSTHObserver, base::Unretained(io_thread),
                  ct_tree_tracker_.get());
 
   main_request_context_->set_ct_policy_enforcer(
       io_thread_globals->system_request_context->ct_policy_enforcer());
 
+  if (UseNetworkQualityEstimator()) {
+    main_request_context_->set_network_quality_estimator(
+        io_thread_globals->network_quality_estimator.get());
+  }
+
+  main_request_context_storage_->set_http_network_session(
+      CreateHttpNetworkSession(*profile_params_));
+
+  main_request_context_storage_->set_http_transaction_factory(CreateMainHttpFactory(
+      main_request_context_storage_->http_network_session(), GetCacheBackendFactory()));
+
+  std::unique_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
+      new net::URLRequestJobFactoryImpl());
+  InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
+
   InitializeInternal(profile_params_.get(), protocol_handlers,
                      std::move(request_interceptors));
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     net::URLRequestContext* context) const {
   context->set_http_user_agent_settings(
@@ skipping 159 matching lines @@
       std::move(backend), false /* is_main_cache */);
 }
 
 std::unique_ptr<net::NetworkDelegate> ProfileIOData::ConfigureNetworkDelegate(
     IOThread* io_thread,
     std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate) const {
   return base::WrapUnique<net::NetworkDelegate>(
       chrome_network_delegate.release());
 }
 
+std::unique_ptr<net::HttpServerProperties>
+ProfileIOData::GetHttpServerProperties() const {
+  return base::MakeUnique<net::HttpServerPropertiesImpl>();
+}
+
+void ProfileIOData::GetCookieAndChannelIDStores(
+    std::unique_ptr<net::CookieStore>* cookie_store,
+    std::unique_ptr<net::ChannelIDService>* channel_id_service) const {
+  *channel_id_service = base::MakeUnique<net::ChannelIDService>(
+      new net::DefaultChannelIDStore(nullptr));
+
+  using content::CookieStoreConfig;
+  *cookie_store = CreateCookieStore(CookieStoreConfig(
+      base::FilePath(), CookieStoreConfig::EPHEMERAL_SESSION_COOKIES, nullptr,
+      profile_params_->cookie_monster_delegate.get()));
+}
+
+bool ProfileIOData::UseNetworkQualityEstimator() const {
+  return false;
+}
+
+std::unique_ptr<net::HttpCache::BackendFactory> ProfileIOData::GetCacheBackendFactory() const {
+  return net::HttpCache::DefaultBackend::InMemory(0);
+}
+
 void ProfileIOData::SetCookieSettingsForTesting(
     content_settings::CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 policy::URLBlacklist::URLBlacklistState ProfileIOData::GetURLBlacklistState(
     const GURL& url) const {
   return url_blacklist_manager_->GetURLBlacklistState(url);
 }