OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/url_request/url_request_context_builder.h" | 5 #include "net/url_request/url_request_context_builder.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/basictypes.h" | 9 #include "base/basictypes.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
263 void URLRequestContextBuilder::SetHttpServerProperties( | 263 void URLRequestContextBuilder::SetHttpServerProperties( |
264 scoped_ptr<HttpServerProperties> http_server_properties) { | 264 scoped_ptr<HttpServerProperties> http_server_properties) { |
265 http_server_properties_ = http_server_properties.Pass(); | 265 http_server_properties_ = http_server_properties.Pass(); |
266 } | 266 } |
267 | 267 |
268 scoped_ptr<URLRequestContext> URLRequestContextBuilder::Build() { | 268 scoped_ptr<URLRequestContext> URLRequestContextBuilder::Build() { |
269 scoped_ptr<ContainerURLRequestContext> context( | 269 scoped_ptr<ContainerURLRequestContext> context( |
270 new ContainerURLRequestContext(file_task_runner_)); | 270 new ContainerURLRequestContext(file_task_runner_)); |
271 URLRequestContextStorage* storage = context->storage(); | 271 URLRequestContextStorage* storage = context->storage(); |
272 | 272 |
273 storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings( | 273 storage->set_http_user_agent_settings( |
274 accept_language_, user_agent_)); | 274 make_scoped_ptr( |
| 275 new StaticHttpUserAgentSettings(accept_language_, user_agent_)) |
| 276 .Pass()); |
275 | 277 |
276 if (!network_delegate_) | 278 if (!network_delegate_) |
277 network_delegate_.reset(new BasicNetworkDelegate); | 279 network_delegate_.reset(new BasicNetworkDelegate); |
278 NetworkDelegate* network_delegate = network_delegate_.release(); | 280 storage->set_network_delegate(network_delegate_.Pass()); |
279 storage->set_network_delegate(network_delegate); | |
280 | 281 |
281 if (net_log_) { | 282 if (net_log_) { |
282 // Unlike the other builder parameters, |net_log_| is not owned by the | 283 // Unlike the other builder parameters, |net_log_| is not owned by the |
283 // builder or resulting context. | 284 // builder or resulting context. |
284 context->set_net_log(net_log_); | 285 context->set_net_log(net_log_); |
285 } else { | 286 } else { |
286 storage->set_net_log(new NetLog); | 287 storage->set_net_log(make_scoped_ptr(new NetLog)); |
287 } | 288 } |
288 | 289 |
289 if (!host_resolver_) { | 290 if (!host_resolver_) { |
290 host_resolver_ = HostResolver::CreateDefaultResolver(context->net_log()); | 291 host_resolver_ = HostResolver::CreateDefaultResolver(context->net_log()); |
291 } | 292 } |
292 storage->set_host_resolver(host_resolver_.Pass()); | 293 storage->set_host_resolver(host_resolver_.Pass()); |
293 | 294 |
294 if (!proxy_service_) { | 295 if (!proxy_service_) { |
295 // TODO(willchan): Switch to using this code when | 296 // TODO(willchan): Switch to using this code when |
296 // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck. | 297 // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck. |
297 #if defined(OS_LINUX) || defined(OS_ANDROID) | 298 #if defined(OS_LINUX) || defined(OS_ANDROID) |
298 ProxyConfigService* proxy_config_service = proxy_config_service_.release(); | 299 ProxyConfigService* proxy_config_service = proxy_config_service_.release(); |
299 #else | 300 #else |
300 ProxyConfigService* proxy_config_service = NULL; | 301 ProxyConfigService* proxy_config_service = NULL; |
301 if (proxy_config_service_) { | 302 if (proxy_config_service_) { |
302 proxy_config_service = proxy_config_service_.release(); | 303 proxy_config_service = proxy_config_service_.release(); |
303 } else { | 304 } else { |
304 proxy_config_service = ProxyService::CreateSystemProxyConfigService( | 305 proxy_config_service = ProxyService::CreateSystemProxyConfigService( |
305 base::ThreadTaskRunnerHandle::Get().get(), | 306 base::ThreadTaskRunnerHandle::Get().get(), |
306 context->GetFileTaskRunner()); | 307 context->GetFileTaskRunner()); |
307 } | 308 } |
308 #endif // defined(OS_LINUX) || defined(OS_ANDROID) | 309 #endif // defined(OS_LINUX) || defined(OS_ANDROID) |
309 proxy_service_.reset( | 310 proxy_service_ = ProxyService::CreateUsingSystemProxyResolver( |
310 ProxyService::CreateUsingSystemProxyResolver( | 311 proxy_config_service, |
311 proxy_config_service, | 312 0, // This results in using the default value. |
312 0, // This results in using the default value. | 313 context->net_log()); |
313 context->net_log())); | |
314 } | 314 } |
315 storage->set_proxy_service(proxy_service_.release()); | 315 storage->set_proxy_service(proxy_service_.Pass()); |
316 | 316 |
317 storage->set_ssl_config_service(new SSLConfigServiceDefaults); | 317 storage->set_ssl_config_service(new SSLConfigServiceDefaults); |
318 HttpAuthHandlerRegistryFactory* http_auth_handler_registry_factory = | 318 scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_registry_factory( |
319 HttpAuthHandlerRegistryFactory::CreateDefault(context->host_resolver()); | 319 HttpAuthHandlerRegistryFactory::CreateDefault(context->host_resolver())); |
320 for (size_t i = 0; i < extra_http_auth_handlers_.size(); ++i) { | 320 for (size_t i = 0; i < extra_http_auth_handlers_.size(); ++i) { |
321 http_auth_handler_registry_factory->RegisterSchemeFactory( | 321 http_auth_handler_registry_factory->RegisterSchemeFactory( |
322 extra_http_auth_handlers_[i].scheme, | 322 extra_http_auth_handlers_[i].scheme, |
323 extra_http_auth_handlers_[i].factory); | 323 extra_http_auth_handlers_[i].factory); |
324 } | 324 } |
325 storage->set_http_auth_handler_factory(http_auth_handler_registry_factory); | 325 storage->set_http_auth_handler_factory( |
| 326 http_auth_handler_registry_factory.Pass()); |
326 | 327 |
327 if (cookie_store_) { | 328 if (cookie_store_) { |
328 storage->set_cookie_store(cookie_store_.get()); | 329 storage->set_cookie_store(cookie_store_.get()); |
329 storage->set_channel_id_service(channel_id_service_.Pass()); | 330 storage->set_channel_id_service(channel_id_service_.Pass()); |
330 } else { | 331 } else { |
331 storage->set_cookie_store(new CookieMonster(NULL, NULL)); | 332 storage->set_cookie_store(new CookieMonster(NULL, NULL)); |
332 // TODO(mmenke): This always creates a file thread, even when it ends up | 333 // TODO(mmenke): This always creates a file thread, even when it ends up |
333 // not being used. Consider lazily creating the thread. | 334 // not being used. Consider lazily creating the thread. |
334 storage->set_channel_id_service(make_scoped_ptr(new ChannelIDService( | 335 storage->set_channel_id_service(make_scoped_ptr(new ChannelIDService( |
335 new DefaultChannelIDStore(NULL), context->GetFileTaskRunner()))); | 336 new DefaultChannelIDStore(NULL), context->GetFileTaskRunner()))); |
336 } | 337 } |
337 | 338 |
338 if (sdch_enabled_) { | 339 if (sdch_enabled_) { |
339 storage->set_sdch_manager( | 340 storage->set_sdch_manager( |
340 scoped_ptr<net::SdchManager>(new SdchManager()).Pass()); | 341 scoped_ptr<net::SdchManager>(new SdchManager()).Pass()); |
341 } | 342 } |
342 | 343 |
343 storage->set_transport_security_state(new TransportSecurityState()); | 344 storage->set_transport_security_state( |
| 345 make_scoped_ptr(new TransportSecurityState())); |
344 if (!transport_security_persister_path_.empty()) { | 346 if (!transport_security_persister_path_.empty()) { |
345 context->set_transport_security_persister( | 347 context->set_transport_security_persister( |
346 make_scoped_ptr<TransportSecurityPersister>( | 348 make_scoped_ptr<TransportSecurityPersister>( |
347 new TransportSecurityPersister(context->transport_security_state(), | 349 new TransportSecurityPersister(context->transport_security_state(), |
348 transport_security_persister_path_, | 350 transport_security_persister_path_, |
349 context->GetFileTaskRunner(), | 351 context->GetFileTaskRunner(), |
350 false))); | 352 false))); |
351 } | 353 } |
352 | 354 |
353 if (http_server_properties_) { | 355 if (http_server_properties_) { |
354 storage->set_http_server_properties(http_server_properties_.Pass()); | 356 storage->set_http_server_properties(http_server_properties_.Pass()); |
355 } else { | 357 } else { |
356 storage->set_http_server_properties( | 358 storage->set_http_server_properties( |
357 scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); | 359 scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); |
358 } | 360 } |
359 | 361 |
360 storage->set_cert_verifier(CertVerifier::CreateDefault()); | 362 storage->set_cert_verifier(CertVerifier::CreateDefault()); |
361 | 363 |
362 if (throttling_enabled_) | 364 if (throttling_enabled_) { |
363 storage->set_throttler_manager(new URLRequestThrottlerManager()); | 365 storage->set_throttler_manager( |
| 366 make_scoped_ptr(new URLRequestThrottlerManager())); |
| 367 } |
364 | 368 |
365 if (backoff_enabled_) | 369 if (backoff_enabled_) { |
366 storage->set_backoff_manager(new URLRequestBackoffManager()); | 370 storage->set_backoff_manager( |
| 371 make_scoped_ptr(new URLRequestBackoffManager())); |
| 372 } |
367 | 373 |
368 HttpNetworkSession::Params network_session_params; | 374 HttpNetworkSession::Params network_session_params; |
369 SetHttpNetworkSessionComponents(context.get(), &network_session_params); | 375 SetHttpNetworkSessionComponents(context.get(), &network_session_params); |
370 | 376 |
371 network_session_params.ignore_certificate_errors = | 377 network_session_params.ignore_certificate_errors = |
372 http_network_session_params_.ignore_certificate_errors; | 378 http_network_session_params_.ignore_certificate_errors; |
373 network_session_params.host_mapping_rules = | 379 network_session_params.host_mapping_rules = |
374 http_network_session_params_.host_mapping_rules; | 380 http_network_session_params_.host_mapping_rules; |
375 network_session_params.testing_fixed_http_port = | 381 network_session_params.testing_fixed_http_port = |
376 http_network_session_params_.testing_fixed_http_port; | 382 http_network_session_params_.testing_fixed_http_port; |
377 network_session_params.testing_fixed_https_port = | 383 network_session_params.testing_fixed_https_port = |
378 http_network_session_params_.testing_fixed_https_port; | 384 http_network_session_params_.testing_fixed_https_port; |
379 network_session_params.use_alternative_services = | 385 network_session_params.use_alternative_services = |
380 http_network_session_params_.use_alternative_services; | 386 http_network_session_params_.use_alternative_services; |
381 network_session_params.trusted_spdy_proxy = | 387 network_session_params.trusted_spdy_proxy = |
382 http_network_session_params_.trusted_spdy_proxy; | 388 http_network_session_params_.trusted_spdy_proxy; |
383 network_session_params.next_protos = http_network_session_params_.next_protos; | 389 network_session_params.next_protos = http_network_session_params_.next_protos; |
384 network_session_params.enable_quic = http_network_session_params_.enable_quic; | 390 network_session_params.enable_quic = http_network_session_params_.enable_quic; |
385 network_session_params.enable_insecure_quic = | 391 network_session_params.enable_insecure_quic = |
386 http_network_session_params_.enable_insecure_quic; | 392 http_network_session_params_.enable_insecure_quic; |
387 network_session_params.quic_connection_options = | 393 network_session_params.quic_connection_options = |
388 http_network_session_params_.quic_connection_options; | 394 http_network_session_params_.quic_connection_options; |
389 | 395 |
390 HttpTransactionFactory* http_transaction_factory = NULL; | 396 scoped_ptr<HttpTransactionFactory> http_transaction_factory; |
391 if (http_cache_enabled_) { | 397 if (http_cache_enabled_) { |
392 HttpCache::BackendFactory* http_cache_backend = NULL; | 398 HttpCache::BackendFactory* http_cache_backend = NULL; |
393 if (http_cache_params_.type == HttpCacheParams::DISK) { | 399 if (http_cache_params_.type == HttpCacheParams::DISK) { |
394 http_cache_backend = new HttpCache::DefaultBackend( | 400 http_cache_backend = new HttpCache::DefaultBackend( |
395 DISK_CACHE, CACHE_BACKEND_DEFAULT, http_cache_params_.path, | 401 DISK_CACHE, CACHE_BACKEND_DEFAULT, http_cache_params_.path, |
396 http_cache_params_.max_size, context->GetFileTaskRunner()); | 402 http_cache_params_.max_size, context->GetFileTaskRunner()); |
397 } else { | 403 } else { |
398 http_cache_backend = | 404 http_cache_backend = |
399 HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size); | 405 HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size); |
400 } | 406 } |
401 | 407 |
402 http_transaction_factory = new HttpCache( | 408 http_transaction_factory.reset( |
403 network_session_params, http_cache_backend); | 409 new HttpCache(network_session_params, http_cache_backend)); |
404 } else { | 410 } else { |
405 scoped_refptr<HttpNetworkSession> network_session( | 411 scoped_refptr<HttpNetworkSession> network_session( |
406 new HttpNetworkSession(network_session_params)); | 412 new HttpNetworkSession(network_session_params)); |
407 | 413 |
408 http_transaction_factory = new HttpNetworkLayer(network_session.get()); | 414 http_transaction_factory.reset(new HttpNetworkLayer(network_session.get())); |
409 } | 415 } |
410 storage->set_http_transaction_factory(http_transaction_factory); | 416 storage->set_http_transaction_factory(http_transaction_factory.Pass()); |
411 | 417 |
412 URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl; | 418 URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl; |
413 if (data_enabled_) | 419 if (data_enabled_) |
414 job_factory->SetProtocolHandler("data", | 420 job_factory->SetProtocolHandler("data", |
415 make_scoped_ptr(new DataProtocolHandler)); | 421 make_scoped_ptr(new DataProtocolHandler)); |
416 | 422 |
417 #if !defined(DISABLE_FILE_SUPPORT) | 423 #if !defined(DISABLE_FILE_SUPPORT) |
418 if (file_enabled_) { | 424 if (file_enabled_) { |
419 job_factory->SetProtocolHandler( | 425 job_factory->SetProtocolHandler( |
420 "file", | 426 "file", |
(...skipping 16 matching lines...) Expand all Loading... |
437 // Set up interceptors in the reverse order. | 443 // Set up interceptors in the reverse order. |
438 | 444 |
439 for (ScopedVector<net::URLRequestInterceptor>::reverse_iterator i = | 445 for (ScopedVector<net::URLRequestInterceptor>::reverse_iterator i = |
440 url_request_interceptors_.rbegin(); | 446 url_request_interceptors_.rbegin(); |
441 i != url_request_interceptors_.rend(); ++i) { | 447 i != url_request_interceptors_.rend(); ++i) { |
442 top_job_factory.reset(new net::URLRequestInterceptingJobFactory( | 448 top_job_factory.reset(new net::URLRequestInterceptingJobFactory( |
443 top_job_factory.Pass(), make_scoped_ptr(*i))); | 449 top_job_factory.Pass(), make_scoped_ptr(*i))); |
444 } | 450 } |
445 url_request_interceptors_.weak_clear(); | 451 url_request_interceptors_.weak_clear(); |
446 } | 452 } |
447 storage->set_job_factory(top_job_factory.release()); | 453 storage->set_job_factory(top_job_factory.Pass()); |
448 // TODO(willchan): Support sdch. | 454 // TODO(willchan): Support sdch. |
449 | 455 |
450 return context.Pass(); | 456 return context.Pass(); |
451 } | 457 } |
452 | 458 |
453 } // namespace net | 459 } // namespace net |
OLD | NEW |