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