OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "headless/lib/browser/headless_url_request_context_getter.h" | 5 #include "headless/lib/browser/headless_url_request_context_getter.h" |
6 | 6 |
| 7 #include <memory> |
| 8 |
7 #include "base/command_line.h" | 9 #include "base/command_line.h" |
8 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/ptr_util.h" |
9 #include "base/single_thread_task_runner.h" | 11 #include "base/single_thread_task_runner.h" |
10 #include "base/threading/worker_pool.h" | 12 #include "base/threading/worker_pool.h" |
11 #include "content/public/browser/browser_thread.h" | 13 #include "content/public/browser/browser_thread.h" |
12 #include "content/public/browser/cookie_store_factory.h" | 14 #include "content/public/browser/cookie_store_factory.h" |
13 #include "content/public/common/content_switches.h" | 15 #include "content/public/common/content_switches.h" |
14 #include "net/cert/cert_verifier.h" | 16 #include "net/cert/cert_verifier.h" |
15 #include "net/cookies/cookie_store.h" | 17 #include "net/cookies/cookie_store.h" |
16 #include "net/dns/host_resolver.h" | 18 #include "net/dns/host_resolver.h" |
17 #include "net/dns/mapped_host_resolver.h" | 19 #include "net/dns/mapped_host_resolver.h" |
18 #include "net/http/http_auth_handler_factory.h" | 20 #include "net/http/http_auth_handler_factory.h" |
(...skipping 15 matching lines...) Expand all Loading... |
34 | 36 |
35 namespace headless { | 37 namespace headless { |
36 | 38 |
37 namespace { | 39 namespace { |
38 | 40 |
39 void InstallProtocolHandlers(net::URLRequestJobFactoryImpl* job_factory, | 41 void InstallProtocolHandlers(net::URLRequestJobFactoryImpl* job_factory, |
40 content::ProtocolHandlerMap* protocol_handlers) { | 42 content::ProtocolHandlerMap* protocol_handlers) { |
41 for (content::ProtocolHandlerMap::iterator it = protocol_handlers->begin(); | 43 for (content::ProtocolHandlerMap::iterator it = protocol_handlers->begin(); |
42 it != protocol_handlers->end(); ++it) { | 44 it != protocol_handlers->end(); ++it) { |
43 bool set_protocol = job_factory->SetProtocolHandler( | 45 bool set_protocol = job_factory->SetProtocolHandler( |
44 it->first, make_scoped_ptr(it->second.release())); | 46 it->first, base::WrapUnique(it->second.release())); |
45 DCHECK(set_protocol); | 47 DCHECK(set_protocol); |
46 } | 48 } |
47 protocol_handlers->clear(); | 49 protocol_handlers->clear(); |
48 } | 50 } |
49 | 51 |
50 } // namespace | 52 } // namespace |
51 | 53 |
52 HeadlessURLRequestContextGetter::HeadlessURLRequestContextGetter( | 54 HeadlessURLRequestContextGetter::HeadlessURLRequestContextGetter( |
53 bool ignore_certificate_errors, | 55 bool ignore_certificate_errors, |
54 const base::FilePath& base_path, | 56 const base::FilePath& base_path, |
(...skipping 17 matching lines...) Expand all Loading... |
72 | 74 |
73 // We must create the proxy config service on the UI loop on Linux because it | 75 // We must create the proxy config service on the UI loop on Linux because it |
74 // must synchronously run on the glib message loop. This will be passed to | 76 // must synchronously run on the glib message loop. This will be passed to |
75 // the URLRequestContextStorage on the IO thread in GetURLRequestContext(). | 77 // the URLRequestContextStorage on the IO thread in GetURLRequestContext(). |
76 if (options_.proxy_server.IsEmpty()) | 78 if (options_.proxy_server.IsEmpty()) |
77 proxy_config_service_ = GetProxyConfigService(); | 79 proxy_config_service_ = GetProxyConfigService(); |
78 } | 80 } |
79 | 81 |
80 HeadlessURLRequestContextGetter::~HeadlessURLRequestContextGetter() {} | 82 HeadlessURLRequestContextGetter::~HeadlessURLRequestContextGetter() {} |
81 | 83 |
82 scoped_ptr<net::NetworkDelegate> | 84 std::unique_ptr<net::NetworkDelegate> |
83 HeadlessURLRequestContextGetter::CreateNetworkDelegate() { | 85 HeadlessURLRequestContextGetter::CreateNetworkDelegate() { |
84 return nullptr; | 86 return nullptr; |
85 } | 87 } |
86 | 88 |
87 scoped_ptr<net::ProxyConfigService> | 89 std::unique_ptr<net::ProxyConfigService> |
88 HeadlessURLRequestContextGetter::GetProxyConfigService() { | 90 HeadlessURLRequestContextGetter::GetProxyConfigService() { |
89 return net::ProxyService::CreateSystemProxyConfigService(io_task_runner_, | 91 return net::ProxyService::CreateSystemProxyConfigService(io_task_runner_, |
90 file_task_runner_); | 92 file_task_runner_); |
91 } | 93 } |
92 | 94 |
93 scoped_ptr<net::ProxyService> | 95 std::unique_ptr<net::ProxyService> |
94 HeadlessURLRequestContextGetter::GetProxyService() { | 96 HeadlessURLRequestContextGetter::GetProxyService() { |
95 if (!options_.proxy_server.IsEmpty()) | 97 if (!options_.proxy_server.IsEmpty()) |
96 return net::ProxyService::CreateFixed(options_.proxy_server.ToString()); | 98 return net::ProxyService::CreateFixed(options_.proxy_server.ToString()); |
97 return net::ProxyService::CreateUsingSystemProxyResolver( | 99 return net::ProxyService::CreateUsingSystemProxyResolver( |
98 std::move(proxy_config_service_), 0, url_request_context_->net_log()); | 100 std::move(proxy_config_service_), 0, url_request_context_->net_log()); |
99 } | 101 } |
100 | 102 |
101 net::URLRequestContext* | 103 net::URLRequestContext* |
102 HeadlessURLRequestContextGetter::GetURLRequestContext() { | 104 HeadlessURLRequestContextGetter::GetURLRequestContext() { |
103 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | 105 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
104 | 106 |
105 if (!url_request_context_) { | 107 if (!url_request_context_) { |
106 const base::CommandLine& command_line = | 108 const base::CommandLine& command_line = |
107 *base::CommandLine::ForCurrentProcess(); | 109 *base::CommandLine::ForCurrentProcess(); |
108 | 110 |
109 url_request_context_.reset(new net::URLRequestContext()); | 111 url_request_context_.reset(new net::URLRequestContext()); |
110 url_request_context_->set_net_log(net_log_); | 112 url_request_context_->set_net_log(net_log_); |
111 network_delegate_ = CreateNetworkDelegate(); | 113 network_delegate_ = CreateNetworkDelegate(); |
112 url_request_context_->set_network_delegate(network_delegate_.get()); | 114 url_request_context_->set_network_delegate(network_delegate_.get()); |
113 storage_.reset( | 115 storage_.reset( |
114 new net::URLRequestContextStorage(url_request_context_.get())); | 116 new net::URLRequestContextStorage(url_request_context_.get())); |
115 storage_->set_cookie_store( | 117 storage_->set_cookie_store( |
116 content::CreateCookieStore(content::CookieStoreConfig())); | 118 content::CreateCookieStore(content::CookieStoreConfig())); |
117 storage_->set_channel_id_service(make_scoped_ptr( | 119 storage_->set_channel_id_service(base::WrapUnique( |
118 new net::ChannelIDService(new net::DefaultChannelIDStore(nullptr), | 120 new net::ChannelIDService(new net::DefaultChannelIDStore(nullptr), |
119 base::WorkerPool::GetTaskRunner(true)))); | 121 base::WorkerPool::GetTaskRunner(true)))); |
120 // TODO(skyostil): Make language settings configurable. | 122 // TODO(skyostil): Make language settings configurable. |
121 storage_->set_http_user_agent_settings(make_scoped_ptr( | 123 storage_->set_http_user_agent_settings(base::WrapUnique( |
122 new net::StaticHttpUserAgentSettings("en-us,en", options_.user_agent))); | 124 new net::StaticHttpUserAgentSettings("en-us,en", options_.user_agent))); |
123 | 125 |
124 scoped_ptr<net::HostResolver> host_resolver( | 126 std::unique_ptr<net::HostResolver> host_resolver( |
125 net::HostResolver::CreateDefaultResolver( | 127 net::HostResolver::CreateDefaultResolver( |
126 url_request_context_->net_log())); | 128 url_request_context_->net_log())); |
127 | 129 |
128 storage_->set_cert_verifier(net::CertVerifier::CreateDefault()); | 130 storage_->set_cert_verifier(net::CertVerifier::CreateDefault()); |
129 storage_->set_transport_security_state( | 131 storage_->set_transport_security_state( |
130 make_scoped_ptr(new net::TransportSecurityState)); | 132 base::WrapUnique(new net::TransportSecurityState)); |
131 storage_->set_proxy_service(GetProxyService()); | 133 storage_->set_proxy_service(GetProxyService()); |
132 storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults); | 134 storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults); |
133 storage_->set_http_auth_handler_factory( | 135 storage_->set_http_auth_handler_factory( |
134 net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); | 136 net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get())); |
135 storage_->set_http_server_properties( | 137 storage_->set_http_server_properties( |
136 make_scoped_ptr(new net::HttpServerPropertiesImpl())); | 138 base::WrapUnique(new net::HttpServerPropertiesImpl())); |
137 | 139 |
138 base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache")); | 140 base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache")); |
139 scoped_ptr<net::HttpCache::DefaultBackend> main_backend( | 141 std::unique_ptr<net::HttpCache::DefaultBackend> main_backend( |
140 new net::HttpCache::DefaultBackend( | 142 new net::HttpCache::DefaultBackend( |
141 net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path, 0, | 143 net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path, 0, |
142 content::BrowserThread::GetMessageLoopProxyForThread( | 144 content::BrowserThread::GetMessageLoopProxyForThread( |
143 content::BrowserThread::CACHE))); | 145 content::BrowserThread::CACHE))); |
144 | 146 |
145 net::HttpNetworkSession::Params network_session_params; | 147 net::HttpNetworkSession::Params network_session_params; |
146 network_session_params.cert_verifier = | 148 network_session_params.cert_verifier = |
147 url_request_context_->cert_verifier(); | 149 url_request_context_->cert_verifier(); |
148 network_session_params.transport_security_state = | 150 network_session_params.transport_security_state = |
149 url_request_context_->transport_security_state(); | 151 url_request_context_->transport_security_state(); |
150 network_session_params.channel_id_service = | 152 network_session_params.channel_id_service = |
151 url_request_context_->channel_id_service(); | 153 url_request_context_->channel_id_service(); |
152 network_session_params.proxy_service = | 154 network_session_params.proxy_service = |
153 url_request_context_->proxy_service(); | 155 url_request_context_->proxy_service(); |
154 network_session_params.ssl_config_service = | 156 network_session_params.ssl_config_service = |
155 url_request_context_->ssl_config_service(); | 157 url_request_context_->ssl_config_service(); |
156 network_session_params.http_auth_handler_factory = | 158 network_session_params.http_auth_handler_factory = |
157 url_request_context_->http_auth_handler_factory(); | 159 url_request_context_->http_auth_handler_factory(); |
158 network_session_params.http_server_properties = | 160 network_session_params.http_server_properties = |
159 url_request_context_->http_server_properties(); | 161 url_request_context_->http_server_properties(); |
160 network_session_params.net_log = url_request_context_->net_log(); | 162 network_session_params.net_log = url_request_context_->net_log(); |
161 network_session_params.ignore_certificate_errors = | 163 network_session_params.ignore_certificate_errors = |
162 ignore_certificate_errors_; | 164 ignore_certificate_errors_; |
163 if (command_line.HasSwitch(switches::kHostResolverRules)) { | 165 if (command_line.HasSwitch(switches::kHostResolverRules)) { |
164 scoped_ptr<net::MappedHostResolver> mapped_host_resolver( | 166 std::unique_ptr<net::MappedHostResolver> mapped_host_resolver( |
165 new net::MappedHostResolver(std::move(host_resolver))); | 167 new net::MappedHostResolver(std::move(host_resolver))); |
166 mapped_host_resolver->SetRulesFromString( | 168 mapped_host_resolver->SetRulesFromString( |
167 command_line.GetSwitchValueASCII(switches::kHostResolverRules)); | 169 command_line.GetSwitchValueASCII(switches::kHostResolverRules)); |
168 host_resolver = std::move(mapped_host_resolver); | 170 host_resolver = std::move(mapped_host_resolver); |
169 } | 171 } |
170 | 172 |
171 // Give |storage_| ownership at the end in case it's |mapped_host_resolver|. | 173 // Give |storage_| ownership at the end in case it's |mapped_host_resolver|. |
172 storage_->set_host_resolver(std::move(host_resolver)); | 174 storage_->set_host_resolver(std::move(host_resolver)); |
173 network_session_params.host_resolver = | 175 network_session_params.host_resolver = |
174 url_request_context_->host_resolver(); | 176 url_request_context_->host_resolver(); |
175 | 177 |
176 storage_->set_http_network_session( | 178 storage_->set_http_network_session( |
177 make_scoped_ptr(new net::HttpNetworkSession(network_session_params))); | 179 base::WrapUnique(new net::HttpNetworkSession(network_session_params))); |
178 storage_->set_http_transaction_factory(make_scoped_ptr(new net::HttpCache( | 180 storage_->set_http_transaction_factory(base::WrapUnique(new net::HttpCache( |
179 storage_->http_network_session(), std::move(main_backend), | 181 storage_->http_network_session(), std::move(main_backend), |
180 true /* set_up_quic_server_info */))); | 182 true /* set_up_quic_server_info */))); |
181 | 183 |
182 scoped_ptr<net::URLRequestJobFactoryImpl> job_factory( | 184 std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory( |
183 new net::URLRequestJobFactoryImpl()); | 185 new net::URLRequestJobFactoryImpl()); |
184 | 186 |
185 InstallProtocolHandlers(job_factory.get(), &protocol_handlers_); | 187 InstallProtocolHandlers(job_factory.get(), &protocol_handlers_); |
186 bool set_protocol = job_factory->SetProtocolHandler( | 188 bool set_protocol = job_factory->SetProtocolHandler( |
187 url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler)); | 189 url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler)); |
188 DCHECK(set_protocol); | 190 DCHECK(set_protocol); |
189 set_protocol = job_factory->SetProtocolHandler( | 191 set_protocol = job_factory->SetProtocolHandler( |
190 url::kFileScheme, | 192 url::kFileScheme, |
191 make_scoped_ptr(new net::FileProtocolHandler( | 193 base::WrapUnique(new net::FileProtocolHandler( |
192 content::BrowserThread::GetBlockingPool() | 194 content::BrowserThread::GetBlockingPool() |
193 ->GetTaskRunnerWithShutdownBehavior( | 195 ->GetTaskRunnerWithShutdownBehavior( |
194 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)))); | 196 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)))); |
195 DCHECK(set_protocol); | 197 DCHECK(set_protocol); |
196 | 198 |
197 // Set up interceptors in the reverse order so that the last inceptor is at | 199 // Set up interceptors in the reverse order so that the last inceptor is at |
198 // the end of the linked list of job factories. | 200 // the end of the linked list of job factories. |
199 scoped_ptr<net::URLRequestJobFactory> top_job_factory = | 201 std::unique_ptr<net::URLRequestJobFactory> top_job_factory = |
200 std::move(job_factory); | 202 std::move(job_factory); |
201 for (auto i = request_interceptors_.rbegin(); | 203 for (auto i = request_interceptors_.rbegin(); |
202 i != request_interceptors_.rend(); ++i) { | 204 i != request_interceptors_.rend(); ++i) { |
203 top_job_factory.reset(new net::URLRequestInterceptingJobFactory( | 205 top_job_factory.reset(new net::URLRequestInterceptingJobFactory( |
204 std::move(top_job_factory), make_scoped_ptr(*i))); | 206 std::move(top_job_factory), base::WrapUnique(*i))); |
205 } | 207 } |
206 request_interceptors_.weak_clear(); | 208 request_interceptors_.weak_clear(); |
207 // Save the head of the job factory list at storage_. | 209 // Save the head of the job factory list at storage_. |
208 storage_->set_job_factory(std::move(top_job_factory)); | 210 storage_->set_job_factory(std::move(top_job_factory)); |
209 } | 211 } |
210 | 212 |
211 return url_request_context_.get(); | 213 return url_request_context_.get(); |
212 } | 214 } |
213 | 215 |
214 scoped_refptr<base::SingleThreadTaskRunner> | 216 scoped_refptr<base::SingleThreadTaskRunner> |
215 HeadlessURLRequestContextGetter::GetNetworkTaskRunner() const { | 217 HeadlessURLRequestContextGetter::GetNetworkTaskRunner() const { |
216 return content::BrowserThread::GetMessageLoopProxyForThread( | 218 return content::BrowserThread::GetMessageLoopProxyForThread( |
217 content::BrowserThread::IO); | 219 content::BrowserThread::IO); |
218 } | 220 } |
219 | 221 |
220 net::HostResolver* HeadlessURLRequestContextGetter::host_resolver() const { | 222 net::HostResolver* HeadlessURLRequestContextGetter::host_resolver() const { |
221 return url_request_context_->host_resolver(); | 223 return url_request_context_->host_resolver(); |
222 } | 224 } |
223 | 225 |
224 } // namespace headless | 226 } // namespace headless |
OLD | NEW |