1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/url_request/url_request_context_builder.h"
6
7 #include <memory>
8 #include <optional>
9 #include <string>
10 #include <utility>
11 #include <vector>
12
13 #include "base/check_op.h"
14 #include "base/compiler_specific.h"
15 #include "base/notreached.h"
16 #include "base/strings/string_util.h"
17 #include "base/task/sequenced_task_runner.h"
18 #include "base/task/single_thread_task_runner.h"
19 #include "base/task/thread_pool.h"
20 #include "base/types/pass_key.h"
21 #include "build/build_config.h"
22 #include "net/base/cache_type.h"
23 #include "net/base/net_errors.h"
24 #include "net/base/network_delegate_impl.h"
25 #include "net/cert/cert_verifier.h"
26 #include "net/cert/ct_log_verifier.h"
27 #include "net/cert/ct_verifier.h"
28 #include "net/cert/multi_log_ct_verifier.h"
29 #include "net/cert/sct_auditing_delegate.h"
30 #include "net/cookies/cookie_monster.h"
31 #include "net/dns/context_host_resolver.h"
32 #include "net/dns/host_resolver.h"
33 #include "net/dns/host_resolver_manager.h"
34 #include "net/http/http_auth_handler_factory.h"
35 #include "net/http/http_cache.h"
36 #include "net/http/http_network_layer.h"
37 #include "net/http/http_network_session.h"
38 #include "net/http/http_server_properties.h"
39 #include "net/http/http_server_properties_manager.h"
40 #include "net/http/transport_security_persister.h"
41 #include "net/http/transport_security_state.h"
42 #include "net/log/net_log.h"
43 #include "net/net_buildflags.h"
44 #include "net/nqe/network_quality_estimator.h"
45 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
46 #include "net/quic/quic_context.h"
47 #include "net/quic/quic_session_pool.h"
48 #include "net/shared_dictionary/shared_dictionary_network_transaction_factory.h"
49 #include "net/socket/network_binding_client_socket_factory.h"
50 #include "net/ssl/ssl_config_service_defaults.h"
51 #include "net/url_request/static_http_user_agent_settings.h"
52 #include "net/url_request/url_request_context.h"
53 #include "net/url_request/url_request_job_factory.h"
54 #include "url/url_constants.h"
55
56 #if BUILDFLAG(ENABLE_REPORTING)
57 #include "net/network_error_logging/network_error_logging_service.h"
58 #include "net/network_error_logging/persistent_reporting_and_nel_store.h"
59 #include "net/reporting/reporting_policy.h"
60 #include "net/reporting/reporting_service.h"
61 #endif // BUILDFLAG(ENABLE_REPORTING)
62
63 #if BUILDFLAG(IS_ANDROID)
64 #include "base/android/build_info.h"
65 #endif // BUILDFLAG(IS_ANDROID)
66
67 #if BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
68 #include "net/device_bound_sessions/session_service.h"
69 #include "net/device_bound_sessions/session_store.h"
70 #endif // BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
71
72 namespace net {
73
74 URLRequestContextBuilder::HttpCacheParams::HttpCacheParams() = default;
75 URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() = default;
76
77 URLRequestContextBuilder::URLRequestContextBuilder() = default;
78
79 URLRequestContextBuilder::~URLRequestContextBuilder() = default;
80
SetHttpNetworkSessionComponents(const URLRequestContext * request_context,HttpNetworkSessionContext * session_context,bool suppress_setting_socket_performance_watcher_factory,ClientSocketFactory * client_socket_factory)81 void URLRequestContextBuilder::SetHttpNetworkSessionComponents(
82 const URLRequestContext* request_context,
83 HttpNetworkSessionContext* session_context,
84 bool suppress_setting_socket_performance_watcher_factory,
85 ClientSocketFactory* client_socket_factory) {
86 session_context->client_socket_factory =
87 client_socket_factory ? client_socket_factory
88 : ClientSocketFactory::GetDefaultFactory();
89 session_context->host_resolver = request_context->host_resolver();
90 session_context->cert_verifier = request_context->cert_verifier();
91 session_context->transport_security_state =
92 request_context->transport_security_state();
93 session_context->sct_auditing_delegate =
94 request_context->sct_auditing_delegate();
95 session_context->proxy_resolution_service =
96 request_context->proxy_resolution_service();
97 session_context->proxy_delegate = request_context->proxy_delegate();
98 session_context->http_user_agent_settings =
99 request_context->http_user_agent_settings();
100 session_context->ssl_config_service = request_context->ssl_config_service();
101 session_context->http_auth_handler_factory =
102 request_context->http_auth_handler_factory();
103 session_context->http_server_properties =
104 request_context->http_server_properties();
105 session_context->quic_context = request_context->quic_context();
106 session_context->net_log = request_context->net_log();
107 session_context->network_quality_estimator =
108 request_context->network_quality_estimator();
109 if (request_context->network_quality_estimator() &&
110 !suppress_setting_socket_performance_watcher_factory) {
111 session_context->socket_performance_watcher_factory =
112 request_context->network_quality_estimator()
113 ->GetSocketPerformanceWatcherFactory();
114 }
115 #if BUILDFLAG(ENABLE_REPORTING)
116 session_context->reporting_service = request_context->reporting_service();
117 session_context->network_error_logging_service =
118 request_context->network_error_logging_service();
119 #endif
120 }
121
set_accept_language(const std::string & accept_language)122 void URLRequestContextBuilder::set_accept_language(
123 const std::string& accept_language) {
124 DCHECK(!http_user_agent_settings_);
125 accept_language_ = accept_language;
126 }
set_user_agent(const std::string & user_agent)127 void URLRequestContextBuilder::set_user_agent(const std::string& user_agent) {
128 DCHECK(!http_user_agent_settings_);
129 user_agent_ = user_agent;
130 }
131
set_http_user_agent_settings(std::unique_ptr<HttpUserAgentSettings> http_user_agent_settings)132 void URLRequestContextBuilder::set_http_user_agent_settings(
133 std::unique_ptr<HttpUserAgentSettings> http_user_agent_settings) {
134 http_user_agent_settings_ = std::move(http_user_agent_settings);
135 }
136
EnableHttpCache(const HttpCacheParams & params)137 void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
138 http_cache_enabled_ = true;
139 http_cache_params_ = params;
140 }
141
DisableHttpCache()142 void URLRequestContextBuilder::DisableHttpCache() {
143 http_cache_enabled_ = false;
144 http_cache_params_ = HttpCacheParams();
145 }
146
SetSpdyAndQuicEnabled(bool spdy_enabled,bool quic_enabled)147 void URLRequestContextBuilder::SetSpdyAndQuicEnabled(bool spdy_enabled,
148 bool quic_enabled) {
149 http_network_session_params_.enable_http2 = spdy_enabled;
150 http_network_session_params_.enable_quic = quic_enabled;
151 }
152
set_sct_auditing_delegate(std::unique_ptr<SCTAuditingDelegate> sct_auditing_delegate)153 void URLRequestContextBuilder::set_sct_auditing_delegate(
154 std::unique_ptr<SCTAuditingDelegate> sct_auditing_delegate) {
155 sct_auditing_delegate_ = std::move(sct_auditing_delegate);
156 }
157
set_quic_context(std::unique_ptr<QuicContext> quic_context)158 void URLRequestContextBuilder::set_quic_context(
159 std::unique_ptr<QuicContext> quic_context) {
160 quic_context_ = std::move(quic_context);
161 }
162
SetCertVerifier(std::unique_ptr<CertVerifier> cert_verifier)163 void URLRequestContextBuilder::SetCertVerifier(
164 std::unique_ptr<CertVerifier> cert_verifier) {
165 cert_verifier_ = std::move(cert_verifier);
166 }
167
168 #if BUILDFLAG(ENABLE_REPORTING)
set_reporting_policy(std::unique_ptr<ReportingPolicy> reporting_policy)169 void URLRequestContextBuilder::set_reporting_policy(
170 std::unique_ptr<ReportingPolicy> reporting_policy) {
171 reporting_policy_ = std::move(reporting_policy);
172 }
173
set_reporting_service(std::unique_ptr<ReportingService> reporting_service)174 void URLRequestContextBuilder::set_reporting_service(
175 std::unique_ptr<ReportingService> reporting_service) {
176 reporting_service_ = std::move(reporting_service);
177 }
178
set_persistent_reporting_and_nel_store(std::unique_ptr<PersistentReportingAndNelStore> persistent_reporting_and_nel_store)179 void URLRequestContextBuilder::set_persistent_reporting_and_nel_store(
180 std::unique_ptr<PersistentReportingAndNelStore>
181 persistent_reporting_and_nel_store) {
182 persistent_reporting_and_nel_store_ =
183 std::move(persistent_reporting_and_nel_store);
184 }
185
set_enterprise_reporting_endpoints(const base::flat_map<std::string,GURL> & enterprise_reporting_endpoints)186 void URLRequestContextBuilder::set_enterprise_reporting_endpoints(
187 const base::flat_map<std::string, GURL>& enterprise_reporting_endpoints) {
188 enterprise_reporting_endpoints_ = enterprise_reporting_endpoints;
189 }
190 #endif // BUILDFLAG(ENABLE_REPORTING)
191
SetCookieStore(std::unique_ptr<CookieStore> cookie_store)192 void URLRequestContextBuilder::SetCookieStore(
193 std::unique_ptr<CookieStore> cookie_store) {
194 cookie_store_set_by_client_ = true;
195 cookie_store_ = std::move(cookie_store);
196 }
197
SetProtocolHandler(const std::string & scheme,std::unique_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler)198 void URLRequestContextBuilder::SetProtocolHandler(
199 const std::string& scheme,
200 std::unique_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler) {
201 DCHECK(protocol_handler);
202 // If a consumer sets a ProtocolHandler and then overwrites it with another,
203 // it's probably a bug.
204 DCHECK_EQ(0u, protocol_handlers_.count(scheme));
205 protocol_handlers_[scheme] = std::move(protocol_handler);
206 }
207
set_host_resolver(std::unique_ptr<HostResolver> host_resolver)208 void URLRequestContextBuilder::set_host_resolver(
209 std::unique_ptr<HostResolver> host_resolver) {
210 DCHECK(!host_resolver_manager_);
211 DCHECK(host_mapping_rules_.empty());
212 DCHECK(!host_resolver_factory_);
213 host_resolver_ = std::move(host_resolver);
214 }
215
set_host_mapping_rules(std::string host_mapping_rules)216 void URLRequestContextBuilder::set_host_mapping_rules(
217 std::string host_mapping_rules) {
218 DCHECK(!host_resolver_);
219 host_mapping_rules_ = std::move(host_mapping_rules);
220 }
221
set_host_resolver_manager(HostResolverManager * manager)222 void URLRequestContextBuilder::set_host_resolver_manager(
223 HostResolverManager* manager) {
224 DCHECK(!host_resolver_);
225 host_resolver_manager_ = manager;
226 }
227
set_host_resolver_factory(HostResolver::Factory * factory)228 void URLRequestContextBuilder::set_host_resolver_factory(
229 HostResolver::Factory* factory) {
230 DCHECK(!host_resolver_);
231 host_resolver_factory_ = factory;
232 }
233
set_proxy_delegate(std::unique_ptr<ProxyDelegate> proxy_delegate)234 void URLRequestContextBuilder::set_proxy_delegate(
235 std::unique_ptr<ProxyDelegate> proxy_delegate) {
236 proxy_delegate_ = std::move(proxy_delegate);
237 }
238
SetHttpAuthHandlerFactory(std::unique_ptr<HttpAuthHandlerFactory> factory)239 void URLRequestContextBuilder::SetHttpAuthHandlerFactory(
240 std::unique_ptr<HttpAuthHandlerFactory> factory) {
241 http_auth_handler_factory_ = std::move(factory);
242 }
243
SetHttpServerProperties(std::unique_ptr<HttpServerProperties> http_server_properties)244 void URLRequestContextBuilder::SetHttpServerProperties(
245 std::unique_ptr<HttpServerProperties> http_server_properties) {
246 http_server_properties_ = std::move(http_server_properties);
247 }
248
SetCreateHttpTransactionFactoryCallback(CreateHttpTransactionFactoryCallback create_http_network_transaction_factory)249 void URLRequestContextBuilder::SetCreateHttpTransactionFactoryCallback(
250 CreateHttpTransactionFactoryCallback
251 create_http_network_transaction_factory) {
252 http_transaction_factory_.reset();
253 create_http_network_transaction_factory_ =
254 std::move(create_http_network_transaction_factory);
255 }
256
257 #if BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
set_device_bound_session_service(std::unique_ptr<device_bound_sessions::SessionService> device_bound_session_service)258 void URLRequestContextBuilder::set_device_bound_session_service(
259 std::unique_ptr<device_bound_sessions::SessionService>
260 device_bound_session_service) {
261 device_bound_session_service_ = std::move(device_bound_session_service);
262 }
263 #endif // BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
264
BindToNetwork(handles::NetworkHandle network,std::optional<HostResolver::ManagerOptions> options)265 void URLRequestContextBuilder::BindToNetwork(
266 handles::NetworkHandle network,
267 std::optional<HostResolver::ManagerOptions> options) {
268 #if BUILDFLAG(IS_ANDROID)
269 DCHECK(NetworkChangeNotifier::AreNetworkHandlesSupported());
270 // DNS lookups for this context will need to target `network`. NDK to do that
271 // has been introduced in Android Marshmallow
272 // (https://developer.android.com/ndk/reference/group/networking#android_getaddrinfofornetwork)
273 // This is also checked later on in the codepath (at lookup time), but
274 // failing here should be preferred to return a more intuitive crash path.
275 CHECK(base::android::BuildInfo::GetInstance()->sdk_int() >=
276 base::android::SDK_VERSION_MARSHMALLOW);
277 bound_network_ = network;
278 manager_options_ = options.value_or(manager_options_);
279 #else
280 NOTIMPLEMENTED();
281 #endif // BUILDFLAG(IS_ANDROID)
282 }
283
Build()284 std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
285 auto context = std::make_unique<URLRequestContext>(
286 base::PassKey<URLRequestContextBuilder>());
287
288 context->set_enable_brotli(enable_brotli_);
289 context->set_enable_zstd(enable_zstd_);
290 context->set_check_cleartext_permitted(check_cleartext_permitted_);
291 context->set_require_network_anonymization_key(
292 require_network_anonymization_key_);
293 context->set_network_quality_estimator(network_quality_estimator_);
294
295 if (http_user_agent_settings_) {
296 context->set_http_user_agent_settings(std::move(http_user_agent_settings_));
297 } else {
298 context->set_http_user_agent_settings(
299 std::make_unique<StaticHttpUserAgentSettings>(accept_language_,
300 user_agent_));
301 }
302
303 if (!network_delegate_) {
304 network_delegate_ = std::make_unique<NetworkDelegateImpl>();
305 }
306 context->set_network_delegate(std::move(network_delegate_));
307
308 if (net_log_) {
309 // Unlike the other builder parameters, |net_log_| is not owned by the
310 // builder or resulting context.
311 context->set_net_log(net_log_);
312 } else {
313 context->set_net_log(NetLog::Get());
314 }
315
316 if (bound_network_ != handles::kInvalidNetworkHandle) {
317 DCHECK(!client_socket_factory_raw_);
318 DCHECK(!host_resolver_);
319 DCHECK(!host_resolver_manager_);
320 DCHECK(!host_resolver_factory_);
321
322 context->set_bound_network(bound_network_);
323
324 // All sockets created for this context will need to be bound to
325 // `bound_network_`.
326 auto client_socket_factory =
327 std::make_unique<NetworkBindingClientSocketFactory>(bound_network_);
328 set_client_socket_factory(client_socket_factory.get());
329 context->set_client_socket_factory(std::move(client_socket_factory));
330
331 host_resolver_ = HostResolver::CreateStandaloneNetworkBoundResolver(
332 context->net_log(), bound_network_, manager_options_);
333
334 if (!quic_context_) {
335 set_quic_context(std::make_unique<QuicContext>());
336 }
337 auto* quic_params = quic_context_->params();
338 // QUIC sessions for this context should not be closed (or go away) after a
339 // network change.
340 quic_params->close_sessions_on_ip_change = false;
341 quic_params->goaway_sessions_on_ip_change = false;
342
343 // QUIC connection migration should not be enabled when binding a context
344 // to a network.
345 quic_params->migrate_sessions_on_network_change_v2 = false;
346
347 // Objects used by network sessions for this context shouldn't listen to
348 // network changes.
349 http_network_session_params_.ignore_ip_address_changes = true;
350 }
351
352 if (client_socket_factory_) {
353 context->set_client_socket_factory(std::move(client_socket_factory_));
354 }
355
356 if (host_resolver_) {
357 DCHECK(host_mapping_rules_.empty());
358 DCHECK(!host_resolver_manager_);
359 DCHECK(!host_resolver_factory_);
360 } else if (host_resolver_manager_) {
361 if (host_resolver_factory_) {
362 host_resolver_ = host_resolver_factory_->CreateResolver(
363 host_resolver_manager_, host_mapping_rules_,
364 true /* enable_caching */);
365 } else {
366 host_resolver_ = HostResolver::CreateResolver(host_resolver_manager_,
367 host_mapping_rules_,
368 true /* enable_caching */);
369 }
370 } else {
371 if (host_resolver_factory_) {
372 host_resolver_ = host_resolver_factory_->CreateStandaloneResolver(
373 context->net_log(), HostResolver::ManagerOptions(),
374 host_mapping_rules_, true /* enable_caching */);
375 } else {
376 host_resolver_ = HostResolver::CreateStandaloneResolver(
377 context->net_log(), HostResolver::ManagerOptions(),
378 host_mapping_rules_, true /* enable_caching */);
379 }
380 }
381 host_resolver_->SetRequestContext(context.get());
382 context->set_host_resolver(std::move(host_resolver_));
383
384 if (ssl_config_service_) {
385 context->set_ssl_config_service(std::move(ssl_config_service_));
386 } else {
387 context->set_ssl_config_service(
388 std::make_unique<SSLConfigServiceDefaults>());
389 }
390
391 if (http_auth_handler_factory_) {
392 context->set_http_auth_handler_factory(
393 std::move(http_auth_handler_factory_));
394 } else {
395 context->set_http_auth_handler_factory(
396 HttpAuthHandlerRegistryFactory::CreateDefault());
397 }
398
399 if (cookie_store_set_by_client_) {
400 context->set_cookie_store(std::move(cookie_store_));
401 } else {
402 auto cookie_store = std::make_unique<CookieMonster>(nullptr /* store */,
403 context->net_log());
404 context->set_cookie_store(std::move(cookie_store));
405 }
406
407 context->set_transport_security_state(
408 std::make_unique<TransportSecurityState>(hsts_policy_bypass_list_));
409 if (!transport_security_persister_file_path_.empty()) {
410 // Use a low priority because saving this should not block anything
411 // user-visible. Block shutdown to ensure it does get persisted to disk,
412 // since it contains security-relevant information.
413 scoped_refptr<base::SequencedTaskRunner> task_runner(
414 base::ThreadPool::CreateSequencedTaskRunner(
415 {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
416 base::TaskShutdownBehavior::BLOCK_SHUTDOWN}));
417
418 context->set_transport_security_persister(
419 std::make_unique<TransportSecurityPersister>(
420 context->transport_security_state(), task_runner,
421 transport_security_persister_file_path_));
422 }
423
424 if (http_server_properties_) {
425 context->set_http_server_properties(std::move(http_server_properties_));
426 } else {
427 context->set_http_server_properties(
428 std::make_unique<HttpServerProperties>());
429 }
430
431 if (cert_verifier_) {
432 context->set_cert_verifier(std::move(cert_verifier_));
433 } else {
434 // TODO(mattm): Should URLRequestContextBuilder create a CertNetFetcher?
435 context->set_cert_verifier(
436 CertVerifier::CreateDefault(/*cert_net_fetcher=*/nullptr));
437 }
438
439 if (sct_auditing_delegate_) {
440 context->set_sct_auditing_delegate(std::move(sct_auditing_delegate_));
441 }
442
443 if (quic_context_) {
444 context->set_quic_context(std::move(quic_context_));
445 } else {
446 context->set_quic_context(std::make_unique<QuicContext>());
447 }
448
449 if (!proxy_resolution_service_) {
450 #if !BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CHROMEOS) && !BUILDFLAG(IS_ANDROID)
451 // TODO(willchan): Switch to using this code when
452 // ProxyConfigService::CreateSystemProxyConfigService()'s
453 // signature doesn't suck.
454 if (!proxy_config_service_) {
455 proxy_config_service_ =
456 ProxyConfigService::CreateSystemProxyConfigService(
457 base::SingleThreadTaskRunner::GetCurrentDefault().get());
458 }
459 #endif // !BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CHROMEOS) &&
460 // !BUILDFLAG(IS_ANDROID)
461 proxy_resolution_service_ = CreateProxyResolutionService(
462 std::move(proxy_config_service_), context.get(),
463 context->host_resolver(), context->network_delegate(),
464 context->net_log(), pac_quick_check_enabled_);
465 }
466 ProxyResolutionService* proxy_resolution_service =
467 proxy_resolution_service_.get();
468 context->set_proxy_resolution_service(std::move(proxy_resolution_service_));
469
470 if (proxy_delegate_) {
471 ProxyDelegate* proxy_delegate = proxy_delegate_.get();
472 context->set_proxy_delegate(std::move(proxy_delegate_));
473
474 proxy_resolution_service->SetProxyDelegate(proxy_delegate);
475 proxy_delegate->SetProxyResolutionService(proxy_resolution_service);
476 }
477
478 #if BUILDFLAG(ENABLE_REPORTING)
479 // Note: ReportingService::Create and NetworkErrorLoggingService::Create can
480 // both return nullptr if the corresponding base::Feature is disabled.
481
482 if (reporting_service_) {
483 context->set_reporting_service(std::move(reporting_service_));
484 } else if (reporting_policy_) {
485 context->set_reporting_service(
486 ReportingService::Create(*reporting_policy_, context.get(),
487 persistent_reporting_and_nel_store_.get(),
488 enterprise_reporting_endpoints_));
489 }
490
491 if (network_error_logging_enabled_) {
492 if (!network_error_logging_service_) {
493 network_error_logging_service_ = NetworkErrorLoggingService::Create(
494 persistent_reporting_and_nel_store_.get());
495 }
496 context->set_network_error_logging_service(
497 std::move(network_error_logging_service_));
498 }
499
500 if (persistent_reporting_and_nel_store_) {
501 context->set_persistent_reporting_and_nel_store(
502 std::move(persistent_reporting_and_nel_store_));
503 }
504
505 // If both Reporting and Network Error Logging are actually enabled, then
506 // connect them so Network Error Logging can use Reporting to deliver error
507 // reports.
508 if (context->reporting_service() &&
509 context->network_error_logging_service()) {
510 context->network_error_logging_service()->SetReportingService(
511 context->reporting_service());
512 }
513 #endif // BUILDFLAG(ENABLE_REPORTING)
514
515 #if BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
516 if (has_device_bound_session_service_) {
517 if (!device_bound_sessions_file_path_.empty()) {
518 context->set_device_bound_session_store(
519 device_bound_sessions::SessionStore::Create(
520 device_bound_sessions_file_path_));
521 }
522 context->set_device_bound_session_service(
523 device_bound_sessions::SessionService::Create(context.get()));
524 } else {
525 if (device_bound_session_service_) {
526 context->set_device_bound_session_service(
527 std::move(device_bound_session_service_));
528 }
529 }
530 #endif // BUILDFLAG(ENABLE_DEVICE_BOUND_SESSIONS)
531
532 HttpNetworkSessionContext network_session_context;
533 // Unlike the other fields of HttpNetworkSession::Context,
534 // |client_socket_factory| is not mirrored in URLRequestContext.
535 SetHttpNetworkSessionComponents(
536 context.get(), &network_session_context,
537 suppress_setting_socket_performance_watcher_factory_for_testing_,
538 client_socket_factory_raw_);
539
540 context->set_http_network_session(std::make_unique<HttpNetworkSession>(
541 http_network_session_params_, network_session_context));
542
543 std::unique_ptr<HttpTransactionFactory> http_transaction_factory;
544 if (http_transaction_factory_) {
545 http_transaction_factory = std::move(http_transaction_factory_);
546 } else if (!create_http_network_transaction_factory_.is_null()) {
547 http_transaction_factory =
548 std::move(create_http_network_transaction_factory_)
549 .Run(context->http_network_session());
550 } else {
551 http_transaction_factory =
552 std::make_unique<HttpNetworkLayer>(context->http_network_session());
553 }
554
555 if (enable_shared_dictionary_) {
556 http_transaction_factory =
557 std::make_unique<SharedDictionaryNetworkTransactionFactory>(
558 std::move(http_transaction_factory), enable_shared_zstd_);
559 }
560
561 if (http_cache_enabled_) {
562 std::unique_ptr<HttpCache::BackendFactory> http_cache_backend;
563 if (http_cache_params_.type != HttpCacheParams::IN_MEMORY) {
564 // TODO(mmenke): Maybe merge BackendType and HttpCacheParams::Type? The
565 // first doesn't include in memory, so may require some work.
566 BackendType backend_type = CACHE_BACKEND_DEFAULT;
567 switch (http_cache_params_.type) {
568 case HttpCacheParams::DISK:
569 backend_type = CACHE_BACKEND_DEFAULT;
570 break;
571 case HttpCacheParams::DISK_BLOCKFILE:
572 backend_type = CACHE_BACKEND_BLOCKFILE;
573 break;
574 case HttpCacheParams::DISK_SIMPLE:
575 backend_type = CACHE_BACKEND_SIMPLE;
576 break;
577 case HttpCacheParams::IN_MEMORY:
578 NOTREACHED();
579 }
580 http_cache_backend = std::make_unique<HttpCache::DefaultBackend>(
581 DISK_CACHE, backend_type, http_cache_params_.file_operations_factory,
582 http_cache_params_.path, http_cache_params_.max_size,
583 http_cache_params_.reset_cache);
584 } else {
585 http_cache_backend =
586 HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
587 }
588 #if BUILDFLAG(IS_ANDROID)
589 http_cache_backend->SetAppStatusListenerGetter(
590 http_cache_params_.app_status_listener_getter);
591 #endif
592
593 http_transaction_factory = std::make_unique<HttpCache>(
594 std::move(http_transaction_factory), std::move(http_cache_backend));
595 }
596 context->set_http_transaction_factory(std::move(http_transaction_factory));
597
598 std::unique_ptr<URLRequestJobFactory> job_factory =
599 std::make_unique<URLRequestJobFactory>();
600 for (auto& scheme_handler : protocol_handlers_) {
601 job_factory->SetProtocolHandler(scheme_handler.first,
602 std::move(scheme_handler.second));
603 }
604 protocol_handlers_.clear();
605
606 context->set_job_factory(std::move(job_factory));
607
608 if (cookie_deprecation_label_.has_value()) {
609 context->set_cookie_deprecation_label(*cookie_deprecation_label_);
610 }
611
612 return context;
613 }
614
615 std::unique_ptr<ProxyResolutionService>
CreateProxyResolutionService(std::unique_ptr<ProxyConfigService> proxy_config_service,URLRequestContext * url_request_context,HostResolver * host_resolver,NetworkDelegate * network_delegate,NetLog * net_log,bool pac_quick_check_enabled)616 URLRequestContextBuilder::CreateProxyResolutionService(
617 std::unique_ptr<ProxyConfigService> proxy_config_service,
618 URLRequestContext* url_request_context,
619 HostResolver* host_resolver,
620 NetworkDelegate* network_delegate,
621 NetLog* net_log,
622 bool pac_quick_check_enabled) {
623 return ConfiguredProxyResolutionService::CreateUsingSystemProxyResolver(
624 std::move(proxy_config_service), net_log, pac_quick_check_enabled);
625 }
626
627 } // namespace net
628