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