OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/cert_net/cert_net_fetcher_impl.h" | 5 #include "net/cert_net/cert_net_fetcher_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
| 11 #include "base/memory/ptr_util.h" |
11 #include "base/run_loop.h" | 12 #include "base/run_loop.h" |
12 #include "net/cert/mock_cert_verifier.h" | 13 #include "net/cert/mock_cert_verifier.h" |
13 #include "net/dns/mock_host_resolver.h" | 14 #include "net/dns/mock_host_resolver.h" |
14 #include "net/http/http_server_properties_impl.h" | 15 #include "net/http/http_server_properties_impl.h" |
15 #include "net/test/embedded_test_server/embedded_test_server.h" | 16 #include "net/test/embedded_test_server/embedded_test_server.h" |
16 #include "net/url_request/url_request_job_factory_impl.h" | 17 #include "net/url_request/url_request_job_factory_impl.h" |
17 #include "net/url_request/url_request_test_util.h" | 18 #include "net/url_request/url_request_test_util.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
19 #include "testing/platform_test.h" | 20 #include "testing/platform_test.h" |
20 | 21 |
21 // TODO(eroman): Test that cookies aren't sent. | 22 // TODO(eroman): Test that cookies aren't sent. |
22 | 23 |
23 using base::ASCIIToUTF16; | 24 using base::ASCIIToUTF16; |
24 | 25 |
25 namespace net { | 26 namespace net { |
26 | 27 |
27 namespace { | 28 namespace { |
28 | 29 |
29 const base::FilePath::CharType kDocRoot[] = | 30 const base::FilePath::CharType kDocRoot[] = |
30 FILE_PATH_LITERAL("net/data/cert_net_fetcher_impl_unittest"); | 31 FILE_PATH_LITERAL("net/data/cert_net_fetcher_impl_unittest"); |
31 | 32 |
32 // A non-mock URLRequestContext which can access http:// urls. | 33 // A non-mock URLRequestContext which can access http:// urls. |
33 class RequestContext : public URLRequestContext { | 34 class RequestContext : public URLRequestContext { |
34 public: | 35 public: |
35 RequestContext() : storage_(this) { | 36 RequestContext() : storage_(this) { |
36 ProxyConfig no_proxy; | 37 ProxyConfig no_proxy; |
37 storage_.set_host_resolver(scoped_ptr<HostResolver>(new MockHostResolver)); | 38 storage_.set_host_resolver( |
38 storage_.set_cert_verifier(make_scoped_ptr(new MockCertVerifier)); | 39 std::unique_ptr<HostResolver>(new MockHostResolver)); |
| 40 storage_.set_cert_verifier(base::WrapUnique(new MockCertVerifier)); |
39 storage_.set_transport_security_state( | 41 storage_.set_transport_security_state( |
40 make_scoped_ptr(new TransportSecurityState)); | 42 base::WrapUnique(new TransportSecurityState)); |
41 storage_.set_proxy_service(ProxyService::CreateFixed(no_proxy)); | 43 storage_.set_proxy_service(ProxyService::CreateFixed(no_proxy)); |
42 storage_.set_ssl_config_service(new SSLConfigServiceDefaults); | 44 storage_.set_ssl_config_service(new SSLConfigServiceDefaults); |
43 storage_.set_http_server_properties( | 45 storage_.set_http_server_properties( |
44 scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); | 46 std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); |
45 | 47 |
46 HttpNetworkSession::Params params; | 48 HttpNetworkSession::Params params; |
47 params.host_resolver = host_resolver(); | 49 params.host_resolver = host_resolver(); |
48 params.cert_verifier = cert_verifier(); | 50 params.cert_verifier = cert_verifier(); |
49 params.transport_security_state = transport_security_state(); | 51 params.transport_security_state = transport_security_state(); |
50 params.proxy_service = proxy_service(); | 52 params.proxy_service = proxy_service(); |
51 params.ssl_config_service = ssl_config_service(); | 53 params.ssl_config_service = ssl_config_service(); |
52 params.http_server_properties = http_server_properties(); | 54 params.http_server_properties = http_server_properties(); |
53 storage_.set_http_network_session( | 55 storage_.set_http_network_session( |
54 make_scoped_ptr(new HttpNetworkSession(params))); | 56 base::WrapUnique(new HttpNetworkSession(params))); |
55 storage_.set_http_transaction_factory(make_scoped_ptr(new HttpCache( | 57 storage_.set_http_transaction_factory(base::WrapUnique(new HttpCache( |
56 storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), | 58 storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), |
57 false /* set_up_quic_server_info */))); | 59 false /* set_up_quic_server_info */))); |
58 storage_.set_job_factory(make_scoped_ptr(new URLRequestJobFactoryImpl())); | 60 storage_.set_job_factory(base::WrapUnique(new URLRequestJobFactoryImpl())); |
59 } | 61 } |
60 | 62 |
61 ~RequestContext() override { AssertNoURLRequests(); } | 63 ~RequestContext() override { AssertNoURLRequests(); } |
62 | 64 |
63 private: | 65 private: |
64 URLRequestContextStorage storage_; | 66 URLRequestContextStorage storage_; |
65 }; | 67 }; |
66 | 68 |
67 class FetchResult { | 69 class FetchResult { |
68 public: | 70 public: |
(...skipping 19 matching lines...) Expand all Loading... |
88 // Helper to synchronously wait for the fetch completion. This is similar to | 90 // Helper to synchronously wait for the fetch completion. This is similar to |
89 // net's TestCompletionCallback, but built around FetchCallback. | 91 // net's TestCompletionCallback, but built around FetchCallback. |
90 class TestFetchCallback { | 92 class TestFetchCallback { |
91 public: | 93 public: |
92 TestFetchCallback() | 94 TestFetchCallback() |
93 : callback_(base::Bind(&TestFetchCallback::OnCallback, | 95 : callback_(base::Bind(&TestFetchCallback::OnCallback, |
94 base::Unretained(this))) {} | 96 base::Unretained(this))) {} |
95 | 97 |
96 const CertNetFetcher::FetchCallback& callback() const { return callback_; } | 98 const CertNetFetcher::FetchCallback& callback() const { return callback_; } |
97 | 99 |
98 scoped_ptr<FetchResult> WaitForResult() { | 100 std::unique_ptr<FetchResult> WaitForResult() { |
99 DCHECK(quit_closure_.is_null()); | 101 DCHECK(quit_closure_.is_null()); |
100 while (!HasResult()) { | 102 while (!HasResult()) { |
101 base::RunLoop run_loop; | 103 base::RunLoop run_loop; |
102 quit_closure_ = run_loop.QuitClosure(); | 104 quit_closure_ = run_loop.QuitClosure(); |
103 run_loop.Run(); | 105 run_loop.Run(); |
104 quit_closure_.Reset(); | 106 quit_closure_.Reset(); |
105 } | 107 } |
106 return std::move(result_); | 108 return std::move(result_); |
107 } | 109 } |
108 | 110 |
(...skipping 11 matching lines...) Expand all Loading... |
120 result_.reset(new FetchResult(net_error, response_body)); | 122 result_.reset(new FetchResult(net_error, response_body)); |
121 | 123 |
122 if (!extra_closure_.is_null()) | 124 if (!extra_closure_.is_null()) |
123 extra_closure_.Run(); | 125 extra_closure_.Run(); |
124 | 126 |
125 if (!quit_closure_.is_null()) | 127 if (!quit_closure_.is_null()) |
126 quit_closure_.Run(); | 128 quit_closure_.Run(); |
127 } | 129 } |
128 | 130 |
129 CertNetFetcher::FetchCallback callback_; | 131 CertNetFetcher::FetchCallback callback_; |
130 scoped_ptr<FetchResult> result_; | 132 std::unique_ptr<FetchResult> result_; |
131 base::Closure quit_closure_; | 133 base::Closure quit_closure_; |
132 base::Closure extra_closure_; | 134 base::Closure extra_closure_; |
133 }; | 135 }; |
134 | 136 |
135 } // namespace | 137 } // namespace |
136 | 138 |
137 class CertNetFetcherImplTest : public PlatformTest { | 139 class CertNetFetcherImplTest : public PlatformTest { |
138 public: | 140 public: |
139 CertNetFetcherImplTest() { | 141 CertNetFetcherImplTest() { |
140 test_server_.AddDefaultHandlers(base::FilePath(kDocRoot)); | 142 test_server_.AddDefaultHandlers(base::FilePath(kDocRoot)); |
141 context_.set_network_delegate(&network_delegate_); | 143 context_.set_network_delegate(&network_delegate_); |
142 } | 144 } |
143 | 145 |
144 protected: | 146 protected: |
145 EmbeddedTestServer test_server_; | 147 EmbeddedTestServer test_server_; |
146 TestNetworkDelegate network_delegate_; | 148 TestNetworkDelegate network_delegate_; |
147 RequestContext context_; | 149 RequestContext context_; |
148 }; | 150 }; |
149 | 151 |
150 // Helper to start an AIA fetch using default parameters. | 152 // Helper to start an AIA fetch using default parameters. |
151 WARN_UNUSED_RESULT scoped_ptr<CertNetFetcher::Request> StartRequest( | 153 WARN_UNUSED_RESULT std::unique_ptr<CertNetFetcher::Request> StartRequest( |
152 CertNetFetcher* fetcher, | 154 CertNetFetcher* fetcher, |
153 const GURL& url, | 155 const GURL& url, |
154 const TestFetchCallback& callback) { | 156 const TestFetchCallback& callback) { |
155 return fetcher->FetchCaIssuers(url, CertNetFetcher::DEFAULT, | 157 return fetcher->FetchCaIssuers(url, CertNetFetcher::DEFAULT, |
156 CertNetFetcher::DEFAULT, callback.callback()); | 158 CertNetFetcher::DEFAULT, callback.callback()); |
157 } | 159 } |
158 | 160 |
159 // Fetch a few unique URLs using GET in parallel. Each URL has a different body | 161 // Fetch a few unique URLs using GET in parallel. Each URL has a different body |
160 // and Content-Type. | 162 // and Content-Type. |
161 TEST_F(CertNetFetcherImplTest, ParallelFetchNoDuplicates) { | 163 TEST_F(CertNetFetcherImplTest, ParallelFetchNoDuplicates) { |
162 ASSERT_TRUE(test_server_.Start()); | 164 ASSERT_TRUE(test_server_.Start()); |
163 | 165 |
164 CertNetFetcherImpl fetcher(&context_); | 166 CertNetFetcherImpl fetcher(&context_); |
165 TestFetchCallback callback1; | 167 TestFetchCallback callback1; |
166 TestFetchCallback callback2; | 168 TestFetchCallback callback2; |
167 TestFetchCallback callback3; | 169 TestFetchCallback callback3; |
168 | 170 |
169 // Request a URL with Content-Type "application/pkix-cert" | 171 // Request a URL with Content-Type "application/pkix-cert" |
170 GURL url1 = test_server_.GetURL("/cert.crt"); | 172 GURL url1 = test_server_.GetURL("/cert.crt"); |
171 scoped_ptr<CertNetFetcher::Request> request1 = | 173 std::unique_ptr<CertNetFetcher::Request> request1 = |
172 StartRequest(&fetcher, url1, callback1); | 174 StartRequest(&fetcher, url1, callback1); |
173 | 175 |
174 // Request a URL with Content-Type "application/pkix-crl" | 176 // Request a URL with Content-Type "application/pkix-crl" |
175 GURL url2 = test_server_.GetURL("/root.crl"); | 177 GURL url2 = test_server_.GetURL("/root.crl"); |
176 scoped_ptr<CertNetFetcher::Request> request2 = | 178 std::unique_ptr<CertNetFetcher::Request> request2 = |
177 StartRequest(&fetcher, url2, callback2); | 179 StartRequest(&fetcher, url2, callback2); |
178 | 180 |
179 // Request a URL with Content-Type "application/pkcs7-mime" | 181 // Request a URL with Content-Type "application/pkcs7-mime" |
180 GURL url3 = test_server_.GetURL("/certs.p7c"); | 182 GURL url3 = test_server_.GetURL("/certs.p7c"); |
181 scoped_ptr<CertNetFetcher::Request> request3 = | 183 std::unique_ptr<CertNetFetcher::Request> request3 = |
182 StartRequest(&fetcher, url3, callback3); | 184 StartRequest(&fetcher, url3, callback3); |
183 | 185 |
184 // Wait for all of the requests to complete. | 186 // Wait for all of the requests to complete. |
185 scoped_ptr<FetchResult> result1 = callback1.WaitForResult(); | 187 std::unique_ptr<FetchResult> result1 = callback1.WaitForResult(); |
186 scoped_ptr<FetchResult> result2 = callback2.WaitForResult(); | 188 std::unique_ptr<FetchResult> result2 = callback2.WaitForResult(); |
187 scoped_ptr<FetchResult> result3 = callback3.WaitForResult(); | 189 std::unique_ptr<FetchResult> result3 = callback3.WaitForResult(); |
188 | 190 |
189 // Verify the fetch results. | 191 // Verify the fetch results. |
190 result1->VerifySuccess("-cert.crt-\n"); | 192 result1->VerifySuccess("-cert.crt-\n"); |
191 result2->VerifySuccess("-root.crl-\n"); | 193 result2->VerifySuccess("-root.crl-\n"); |
192 result3->VerifySuccess("-certs.p7c-\n"); | 194 result3->VerifySuccess("-certs.p7c-\n"); |
193 | 195 |
194 EXPECT_EQ(3, network_delegate_.created_requests()); | 196 EXPECT_EQ(3, network_delegate_.created_requests()); |
195 } | 197 } |
196 | 198 |
197 // Fetch a caIssuers URL which has an unexpected extension and Content-Type. | 199 // Fetch a caIssuers URL which has an unexpected extension and Content-Type. |
198 // The extension is .txt and the Content-Type is text/plain. Despite being | 200 // The extension is .txt and the Content-Type is text/plain. Despite being |
199 // unusual this succeeds as the extension and Content-Type are not required to | 201 // unusual this succeeds as the extension and Content-Type are not required to |
200 // be meaningful. | 202 // be meaningful. |
201 TEST_F(CertNetFetcherImplTest, ContentTypeDoesntMatter) { | 203 TEST_F(CertNetFetcherImplTest, ContentTypeDoesntMatter) { |
202 ASSERT_TRUE(test_server_.Start()); | 204 ASSERT_TRUE(test_server_.Start()); |
203 | 205 |
204 CertNetFetcherImpl fetcher(&context_); | 206 CertNetFetcherImpl fetcher(&context_); |
205 | 207 |
206 TestFetchCallback callback; | 208 TestFetchCallback callback; |
207 GURL url = test_server_.GetURL("/foo.txt"); | 209 GURL url = test_server_.GetURL("/foo.txt"); |
208 scoped_ptr<CertNetFetcher::Request> request = | 210 std::unique_ptr<CertNetFetcher::Request> request = |
209 StartRequest(&fetcher, url, callback); | 211 StartRequest(&fetcher, url, callback); |
210 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 212 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
211 result->VerifySuccess("-foo.txt-\n"); | 213 result->VerifySuccess("-foo.txt-\n"); |
212 } | 214 } |
213 | 215 |
214 // Fetch a URLs whose HTTP response code is not 200. These are considered | 216 // Fetch a URLs whose HTTP response code is not 200. These are considered |
215 // failures. | 217 // failures. |
216 TEST_F(CertNetFetcherImplTest, HttpStatusCode) { | 218 TEST_F(CertNetFetcherImplTest, HttpStatusCode) { |
217 ASSERT_TRUE(test_server_.Start()); | 219 ASSERT_TRUE(test_server_.Start()); |
218 | 220 |
219 CertNetFetcherImpl fetcher(&context_); | 221 CertNetFetcherImpl fetcher(&context_); |
220 | 222 |
221 // Response was HTTP status 404. | 223 // Response was HTTP status 404. |
222 { | 224 { |
223 TestFetchCallback callback; | 225 TestFetchCallback callback; |
224 GURL url = test_server_.GetURL("/404.html"); | 226 GURL url = test_server_.GetURL("/404.html"); |
225 scoped_ptr<CertNetFetcher::Request> request = | 227 std::unique_ptr<CertNetFetcher::Request> request = |
226 StartRequest(&fetcher, url, callback); | 228 StartRequest(&fetcher, url, callback); |
227 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 229 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
228 result->VerifyFailure(ERR_FAILED); | 230 result->VerifyFailure(ERR_FAILED); |
229 } | 231 } |
230 | 232 |
231 // Response was HTTP status 500. | 233 // Response was HTTP status 500. |
232 { | 234 { |
233 TestFetchCallback callback; | 235 TestFetchCallback callback; |
234 GURL url = test_server_.GetURL("/500.html"); | 236 GURL url = test_server_.GetURL("/500.html"); |
235 scoped_ptr<CertNetFetcher::Request> request = | 237 std::unique_ptr<CertNetFetcher::Request> request = |
236 StartRequest(&fetcher, url, callback); | 238 StartRequest(&fetcher, url, callback); |
237 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 239 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
238 result->VerifyFailure(ERR_FAILED); | 240 result->VerifyFailure(ERR_FAILED); |
239 } | 241 } |
240 } | 242 } |
241 | 243 |
242 // Fetching a URL with a Content-Disposition header should have no effect. | 244 // Fetching a URL with a Content-Disposition header should have no effect. |
243 TEST_F(CertNetFetcherImplTest, ContentDisposition) { | 245 TEST_F(CertNetFetcherImplTest, ContentDisposition) { |
244 ASSERT_TRUE(test_server_.Start()); | 246 ASSERT_TRUE(test_server_.Start()); |
245 | 247 |
246 CertNetFetcherImpl fetcher(&context_); | 248 CertNetFetcherImpl fetcher(&context_); |
247 | 249 |
248 TestFetchCallback callback; | 250 TestFetchCallback callback; |
249 GURL url = test_server_.GetURL("/downloadable.js"); | 251 GURL url = test_server_.GetURL("/downloadable.js"); |
250 scoped_ptr<CertNetFetcher::Request> request = | 252 std::unique_ptr<CertNetFetcher::Request> request = |
251 StartRequest(&fetcher, url, callback); | 253 StartRequest(&fetcher, url, callback); |
252 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 254 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
253 result->VerifySuccess("-downloadable.js-\n"); | 255 result->VerifySuccess("-downloadable.js-\n"); |
254 } | 256 } |
255 | 257 |
256 // Verifies that a cachable request will be served from the HTTP cache the | 258 // Verifies that a cachable request will be served from the HTTP cache the |
257 // second time it is requested. | 259 // second time it is requested. |
258 TEST_F(CertNetFetcherImplTest, Cache) { | 260 TEST_F(CertNetFetcherImplTest, Cache) { |
259 ASSERT_TRUE(test_server_.Start()); | 261 ASSERT_TRUE(test_server_.Start()); |
260 | 262 |
261 CertNetFetcherImpl fetcher(&context_); | 263 CertNetFetcherImpl fetcher(&context_); |
262 | 264 |
263 // Fetch a URL whose HTTP headers make it cacheable for 1 hour. | 265 // Fetch a URL whose HTTP headers make it cacheable for 1 hour. |
264 GURL url(test_server_.GetURL("/cacheable_1hr.crt")); | 266 GURL url(test_server_.GetURL("/cacheable_1hr.crt")); |
265 { | 267 { |
266 TestFetchCallback callback; | 268 TestFetchCallback callback; |
267 | 269 |
268 scoped_ptr<CertNetFetcher::Request> request = | 270 std::unique_ptr<CertNetFetcher::Request> request = |
269 StartRequest(&fetcher, url, callback); | 271 StartRequest(&fetcher, url, callback); |
270 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 272 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
271 result->VerifySuccess("-cacheable_1hr.crt-\n"); | 273 result->VerifySuccess("-cacheable_1hr.crt-\n"); |
272 } | 274 } |
273 | 275 |
274 EXPECT_EQ(1, network_delegate_.created_requests()); | 276 EXPECT_EQ(1, network_delegate_.created_requests()); |
275 | 277 |
276 // Kill the HTTP server. | 278 // Kill the HTTP server. |
277 ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete()); | 279 ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete()); |
278 | 280 |
279 // Fetch again -- will fail unless served from cache. | 281 // Fetch again -- will fail unless served from cache. |
280 { | 282 { |
281 TestFetchCallback callback; | 283 TestFetchCallback callback; |
282 scoped_ptr<CertNetFetcher::Request> request = | 284 std::unique_ptr<CertNetFetcher::Request> request = |
283 StartRequest(&fetcher, url, callback); | 285 StartRequest(&fetcher, url, callback); |
284 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 286 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
285 result->VerifySuccess("-cacheable_1hr.crt-\n"); | 287 result->VerifySuccess("-cacheable_1hr.crt-\n"); |
286 } | 288 } |
287 | 289 |
288 EXPECT_EQ(2, network_delegate_.created_requests()); | 290 EXPECT_EQ(2, network_delegate_.created_requests()); |
289 } | 291 } |
290 | 292 |
291 // Verify that the maximum response body constraints are enforced by fetching a | 293 // Verify that the maximum response body constraints are enforced by fetching a |
292 // resource that is larger than the limit. | 294 // resource that is larger than the limit. |
293 TEST_F(CertNetFetcherImplTest, TooLarge) { | 295 TEST_F(CertNetFetcherImplTest, TooLarge) { |
294 ASSERT_TRUE(test_server_.Start()); | 296 ASSERT_TRUE(test_server_.Start()); |
295 | 297 |
296 CertNetFetcherImpl fetcher(&context_); | 298 CertNetFetcherImpl fetcher(&context_); |
297 | 299 |
298 // This file has a response body 12 bytes long. So setting the maximum to 11 | 300 // This file has a response body 12 bytes long. So setting the maximum to 11 |
299 // bytes will cause it to fail. | 301 // bytes will cause it to fail. |
300 GURL url(test_server_.GetURL("/certs.p7c")); | 302 GURL url(test_server_.GetURL("/certs.p7c")); |
301 TestFetchCallback callback; | 303 TestFetchCallback callback; |
302 scoped_ptr<CertNetFetcher::Request> request = fetcher.FetchCaIssuers( | 304 std::unique_ptr<CertNetFetcher::Request> request = fetcher.FetchCaIssuers( |
303 url, CertNetFetcher::DEFAULT, 11, callback.callback()); | 305 url, CertNetFetcher::DEFAULT, 11, callback.callback()); |
304 | 306 |
305 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 307 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
306 result->VerifyFailure(ERR_FILE_TOO_BIG); | 308 result->VerifyFailure(ERR_FILE_TOO_BIG); |
307 } | 309 } |
308 | 310 |
309 // Set the timeout to 10 milliseconds, and try fetching a URL that takes 5 | 311 // Set the timeout to 10 milliseconds, and try fetching a URL that takes 5 |
310 // seconds to complete. It should fail due to a timeout. | 312 // seconds to complete. It should fail due to a timeout. |
311 TEST_F(CertNetFetcherImplTest, Hang) { | 313 TEST_F(CertNetFetcherImplTest, Hang) { |
312 ASSERT_TRUE(test_server_.Start()); | 314 ASSERT_TRUE(test_server_.Start()); |
313 | 315 |
314 CertNetFetcherImpl fetcher(&context_); | 316 CertNetFetcherImpl fetcher(&context_); |
315 | 317 |
316 GURL url(test_server_.GetURL("/slow/certs.p7c?5")); | 318 GURL url(test_server_.GetURL("/slow/certs.p7c?5")); |
317 TestFetchCallback callback; | 319 TestFetchCallback callback; |
318 scoped_ptr<CertNetFetcher::Request> request = fetcher.FetchCaIssuers( | 320 std::unique_ptr<CertNetFetcher::Request> request = fetcher.FetchCaIssuers( |
319 url, 10, CertNetFetcher::DEFAULT, callback.callback()); | 321 url, 10, CertNetFetcher::DEFAULT, callback.callback()); |
320 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 322 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
321 result->VerifyFailure(ERR_TIMED_OUT); | 323 result->VerifyFailure(ERR_TIMED_OUT); |
322 } | 324 } |
323 | 325 |
324 // Verify that if a response is gzip-encoded it gets inflated before being | 326 // Verify that if a response is gzip-encoded it gets inflated before being |
325 // returned to the caller. | 327 // returned to the caller. |
326 TEST_F(CertNetFetcherImplTest, Gzip) { | 328 TEST_F(CertNetFetcherImplTest, Gzip) { |
327 ASSERT_TRUE(test_server_.Start()); | 329 ASSERT_TRUE(test_server_.Start()); |
328 | 330 |
329 CertNetFetcherImpl fetcher(&context_); | 331 CertNetFetcherImpl fetcher(&context_); |
330 | 332 |
331 GURL url(test_server_.GetURL("/gzipped_crl")); | 333 GURL url(test_server_.GetURL("/gzipped_crl")); |
332 TestFetchCallback callback; | 334 TestFetchCallback callback; |
333 scoped_ptr<CertNetFetcher::Request> request = | 335 std::unique_ptr<CertNetFetcher::Request> request = |
334 StartRequest(&fetcher, url, callback); | 336 StartRequest(&fetcher, url, callback); |
335 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 337 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
336 result->VerifySuccess("-gzipped_crl-\n"); | 338 result->VerifySuccess("-gzipped_crl-\n"); |
337 } | 339 } |
338 | 340 |
339 // Try fetching an unsupported URL scheme (https). | 341 // Try fetching an unsupported URL scheme (https). |
340 TEST_F(CertNetFetcherImplTest, HttpsNotAllowed) { | 342 TEST_F(CertNetFetcherImplTest, HttpsNotAllowed) { |
341 ASSERT_TRUE(test_server_.Start()); | 343 ASSERT_TRUE(test_server_.Start()); |
342 | 344 |
343 CertNetFetcherImpl fetcher(&context_); | 345 CertNetFetcherImpl fetcher(&context_); |
344 | 346 |
345 GURL url("https://foopy/foo.crt"); | 347 GURL url("https://foopy/foo.crt"); |
346 TestFetchCallback callback; | 348 TestFetchCallback callback; |
347 scoped_ptr<CertNetFetcher::Request> request = | 349 std::unique_ptr<CertNetFetcher::Request> request = |
348 StartRequest(&fetcher, url, callback); | 350 StartRequest(&fetcher, url, callback); |
349 // Should NOT complete synchronously despite being a test that could be done | 351 // Should NOT complete synchronously despite being a test that could be done |
350 // immediately. | 352 // immediately. |
351 EXPECT_FALSE(callback.HasResult()); | 353 EXPECT_FALSE(callback.HasResult()); |
352 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 354 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
353 result->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); | 355 result->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); |
354 | 356 |
355 // No request was created because the URL scheme was unsupported. | 357 // No request was created because the URL scheme was unsupported. |
356 EXPECT_EQ(0, network_delegate_.created_requests()); | 358 EXPECT_EQ(0, network_delegate_.created_requests()); |
357 } | 359 } |
358 | 360 |
359 // Try fetching a URL which redirects to https. | 361 // Try fetching a URL which redirects to https. |
360 TEST_F(CertNetFetcherImplTest, RedirectToHttpsNotAllowed) { | 362 TEST_F(CertNetFetcherImplTest, RedirectToHttpsNotAllowed) { |
361 ASSERT_TRUE(test_server_.Start()); | 363 ASSERT_TRUE(test_server_.Start()); |
362 | 364 |
363 CertNetFetcherImpl fetcher(&context_); | 365 CertNetFetcherImpl fetcher(&context_); |
364 | 366 |
365 GURL url(test_server_.GetURL("/redirect_https")); | 367 GURL url(test_server_.GetURL("/redirect_https")); |
366 TestFetchCallback callback; | 368 TestFetchCallback callback; |
367 | 369 |
368 scoped_ptr<CertNetFetcher::Request> request = | 370 std::unique_ptr<CertNetFetcher::Request> request = |
369 StartRequest(&fetcher, url, callback); | 371 StartRequest(&fetcher, url, callback); |
370 scoped_ptr<FetchResult> result = callback.WaitForResult(); | 372 std::unique_ptr<FetchResult> result = callback.WaitForResult(); |
371 result->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); | 373 result->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); |
372 | 374 |
373 EXPECT_EQ(1, network_delegate_.created_requests()); | 375 EXPECT_EQ(1, network_delegate_.created_requests()); |
374 } | 376 } |
375 | 377 |
376 // Try fetching an unsupported URL scheme (https) and then immediately | 378 // Try fetching an unsupported URL scheme (https) and then immediately |
377 // cancelling. This is a bit special because this codepath needs to post a task. | 379 // cancelling. This is a bit special because this codepath needs to post a task. |
378 TEST_F(CertNetFetcherImplTest, CancelHttpsNotAllowed) { | 380 TEST_F(CertNetFetcherImplTest, CancelHttpsNotAllowed) { |
379 ASSERT_TRUE(test_server_.Start()); | 381 ASSERT_TRUE(test_server_.Start()); |
380 | 382 |
381 CertNetFetcherImpl fetcher(&context_); | 383 CertNetFetcherImpl fetcher(&context_); |
382 | 384 |
383 GURL url("https://foopy/foo.crt"); | 385 GURL url("https://foopy/foo.crt"); |
384 TestFetchCallback callback; | 386 TestFetchCallback callback; |
385 scoped_ptr<CertNetFetcher::Request> request = | 387 std::unique_ptr<CertNetFetcher::Request> request = |
386 StartRequest(&fetcher, url, callback); | 388 StartRequest(&fetcher, url, callback); |
387 | 389 |
388 // Cancel the request. | 390 // Cancel the request. |
389 request.reset(); | 391 request.reset(); |
390 | 392 |
391 // Spin the message loop to increase chance of catching a bug. | 393 // Spin the message loop to increase chance of catching a bug. |
392 base::RunLoop().RunUntilIdle(); | 394 base::RunLoop().RunUntilIdle(); |
393 | 395 |
394 // Should NOT complete synchronously despite being a test that could be done | 396 // Should NOT complete synchronously despite being a test that could be done |
395 // immediately. | 397 // immediately. |
396 EXPECT_FALSE(callback.HasResult()); | 398 EXPECT_FALSE(callback.HasResult()); |
397 | 399 |
398 EXPECT_EQ(0, network_delegate_.created_requests()); | 400 EXPECT_EQ(0, network_delegate_.created_requests()); |
399 } | 401 } |
400 | 402 |
401 // Start a few requests, and cancel one of them before running the message loop | 403 // Start a few requests, and cancel one of them before running the message loop |
402 // again. | 404 // again. |
403 TEST_F(CertNetFetcherImplTest, CancelBeforeRunningMessageLoop) { | 405 TEST_F(CertNetFetcherImplTest, CancelBeforeRunningMessageLoop) { |
404 ASSERT_TRUE(test_server_.Start()); | 406 ASSERT_TRUE(test_server_.Start()); |
405 | 407 |
406 CertNetFetcherImpl fetcher(&context_); | 408 CertNetFetcherImpl fetcher(&context_); |
407 TestFetchCallback callback1; | 409 TestFetchCallback callback1; |
408 TestFetchCallback callback2; | 410 TestFetchCallback callback2; |
409 TestFetchCallback callback3; | 411 TestFetchCallback callback3; |
410 | 412 |
411 GURL url1 = test_server_.GetURL("/cert.crt"); | 413 GURL url1 = test_server_.GetURL("/cert.crt"); |
412 scoped_ptr<CertNetFetcher::Request> request1 = | 414 std::unique_ptr<CertNetFetcher::Request> request1 = |
413 StartRequest(&fetcher, url1, callback1); | 415 StartRequest(&fetcher, url1, callback1); |
414 | 416 |
415 GURL url2 = test_server_.GetURL("/root.crl"); | 417 GURL url2 = test_server_.GetURL("/root.crl"); |
416 scoped_ptr<CertNetFetcher::Request> request2 = | 418 std::unique_ptr<CertNetFetcher::Request> request2 = |
417 StartRequest(&fetcher, url2, callback2); | 419 StartRequest(&fetcher, url2, callback2); |
418 | 420 |
419 GURL url3 = test_server_.GetURL("/certs.p7c"); | 421 GURL url3 = test_server_.GetURL("/certs.p7c"); |
420 | 422 |
421 scoped_ptr<CertNetFetcher::Request> request3 = | 423 std::unique_ptr<CertNetFetcher::Request> request3 = |
422 StartRequest(&fetcher, url3, callback3); | 424 StartRequest(&fetcher, url3, callback3); |
423 | 425 |
424 EXPECT_EQ(3, network_delegate_.created_requests()); | 426 EXPECT_EQ(3, network_delegate_.created_requests()); |
425 EXPECT_FALSE(callback1.HasResult()); | 427 EXPECT_FALSE(callback1.HasResult()); |
426 EXPECT_FALSE(callback2.HasResult()); | 428 EXPECT_FALSE(callback2.HasResult()); |
427 EXPECT_FALSE(callback3.HasResult()); | 429 EXPECT_FALSE(callback3.HasResult()); |
428 | 430 |
429 // Cancel the second request. | 431 // Cancel the second request. |
430 request2.reset(); | 432 request2.reset(); |
431 | 433 |
432 // Wait for the non-cancelled requests to complete. | 434 // Wait for the non-cancelled requests to complete. |
433 scoped_ptr<FetchResult> result1 = callback1.WaitForResult(); | 435 std::unique_ptr<FetchResult> result1 = callback1.WaitForResult(); |
434 scoped_ptr<FetchResult> result3 = callback3.WaitForResult(); | 436 std::unique_ptr<FetchResult> result3 = callback3.WaitForResult(); |
435 | 437 |
436 // Verify the fetch results. | 438 // Verify the fetch results. |
437 result1->VerifySuccess("-cert.crt-\n"); | 439 result1->VerifySuccess("-cert.crt-\n"); |
438 result3->VerifySuccess("-certs.p7c-\n"); | 440 result3->VerifySuccess("-certs.p7c-\n"); |
439 | 441 |
440 EXPECT_FALSE(callback2.HasResult()); | 442 EXPECT_FALSE(callback2.HasResult()); |
441 } | 443 } |
442 | 444 |
443 // Start several requests, and cancel one of them after the first has completed. | 445 // Start several requests, and cancel one of them after the first has completed. |
444 // NOTE: The python test server is single threaded and can only service one | 446 // NOTE: The python test server is single threaded and can only service one |
(...skipping 10 matching lines...) Expand all Loading... |
455 TEST_F(CertNetFetcherImplTest, CancelAfterRunningMessageLoop) { | 457 TEST_F(CertNetFetcherImplTest, CancelAfterRunningMessageLoop) { |
456 ASSERT_TRUE(test_server_.Start()); | 458 ASSERT_TRUE(test_server_.Start()); |
457 | 459 |
458 CertNetFetcherImpl fetcher(&context_); | 460 CertNetFetcherImpl fetcher(&context_); |
459 TestFetchCallback callback1; | 461 TestFetchCallback callback1; |
460 TestFetchCallback callback2; | 462 TestFetchCallback callback2; |
461 TestFetchCallback callback3; | 463 TestFetchCallback callback3; |
462 | 464 |
463 GURL url1 = test_server_.GetURL("/cert.crt"); | 465 GURL url1 = test_server_.GetURL("/cert.crt"); |
464 | 466 |
465 scoped_ptr<CertNetFetcher::Request> request1 = | 467 std::unique_ptr<CertNetFetcher::Request> request1 = |
466 StartRequest(&fetcher, url1, callback1); | 468 StartRequest(&fetcher, url1, callback1); |
467 | 469 |
468 GURL url2 = test_server_.GetURL("/certs.p7c"); | 470 GURL url2 = test_server_.GetURL("/certs.p7c"); |
469 scoped_ptr<CertNetFetcher::Request> request2 = | 471 std::unique_ptr<CertNetFetcher::Request> request2 = |
470 StartRequest(&fetcher, url2, callback2); | 472 StartRequest(&fetcher, url2, callback2); |
471 | 473 |
472 GURL url3("ftp://www.not.supported.com/foo"); | 474 GURL url3("ftp://www.not.supported.com/foo"); |
473 scoped_ptr<CertNetFetcher::Request> request3 = | 475 std::unique_ptr<CertNetFetcher::Request> request3 = |
474 StartRequest(&fetcher, url3, callback3); | 476 StartRequest(&fetcher, url3, callback3); |
475 | 477 |
476 EXPECT_FALSE(callback1.HasResult()); | 478 EXPECT_FALSE(callback1.HasResult()); |
477 EXPECT_FALSE(callback2.HasResult()); | 479 EXPECT_FALSE(callback2.HasResult()); |
478 EXPECT_FALSE(callback3.HasResult()); | 480 EXPECT_FALSE(callback3.HasResult()); |
479 | 481 |
480 // Wait for the ftp request to complete (it should complete right away since | 482 // Wait for the ftp request to complete (it should complete right away since |
481 // it doesn't even try to connect to the server). | 483 // it doesn't even try to connect to the server). |
482 scoped_ptr<FetchResult> result3 = callback3.WaitForResult(); | 484 std::unique_ptr<FetchResult> result3 = callback3.WaitForResult(); |
483 result3->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); | 485 result3->VerifyFailure(ERR_DISALLOWED_URL_SCHEME); |
484 | 486 |
485 // Cancel the second outstanding request. | 487 // Cancel the second outstanding request. |
486 request2.reset(); | 488 request2.reset(); |
487 | 489 |
488 // Wait for the first request to complete. | 490 // Wait for the first request to complete. |
489 scoped_ptr<FetchResult> result2 = callback1.WaitForResult(); | 491 std::unique_ptr<FetchResult> result2 = callback1.WaitForResult(); |
490 | 492 |
491 // Verify the fetch results. | 493 // Verify the fetch results. |
492 result2->VerifySuccess("-cert.crt-\n"); | 494 result2->VerifySuccess("-cert.crt-\n"); |
493 } | 495 } |
494 | 496 |
495 // Delete a CertNetFetcherImpl with outstanding requests on it. | 497 // Delete a CertNetFetcherImpl with outstanding requests on it. |
496 TEST_F(CertNetFetcherImplTest, DeleteCancels) { | 498 TEST_F(CertNetFetcherImplTest, DeleteCancels) { |
497 ASSERT_TRUE(test_server_.Start()); | 499 ASSERT_TRUE(test_server_.Start()); |
498 | 500 |
499 scoped_ptr<CertNetFetcherImpl> fetcher(new CertNetFetcherImpl(&context_)); | 501 std::unique_ptr<CertNetFetcherImpl> fetcher( |
| 502 new CertNetFetcherImpl(&context_)); |
500 | 503 |
501 GURL url(test_server_.GetURL("/slow/certs.p7c?20")); | 504 GURL url(test_server_.GetURL("/slow/certs.p7c?20")); |
502 TestFetchCallback callback; | 505 TestFetchCallback callback; |
503 scoped_ptr<CertNetFetcher::Request> request = | 506 std::unique_ptr<CertNetFetcher::Request> request = |
504 StartRequest(fetcher.get(), url, callback); | 507 StartRequest(fetcher.get(), url, callback); |
505 | 508 |
506 // Destroy the fetcher before the outstanding request. | 509 // Destroy the fetcher before the outstanding request. |
507 fetcher.reset(); | 510 fetcher.reset(); |
508 } | 511 } |
509 | 512 |
510 // Fetch the same URLs in parallel and verify that only 1 request is made per | 513 // Fetch the same URLs in parallel and verify that only 1 request is made per |
511 // URL. | 514 // URL. |
512 TEST_F(CertNetFetcherImplTest, ParallelFetchDuplicates) { | 515 TEST_F(CertNetFetcherImplTest, ParallelFetchDuplicates) { |
513 ASSERT_TRUE(test_server_.Start()); | 516 ASSERT_TRUE(test_server_.Start()); |
514 | 517 |
515 CertNetFetcherImpl fetcher(&context_); | 518 CertNetFetcherImpl fetcher(&context_); |
516 | 519 |
517 GURL url1 = test_server_.GetURL("/cert.crt"); | 520 GURL url1 = test_server_.GetURL("/cert.crt"); |
518 GURL url2 = test_server_.GetURL("/root.crl"); | 521 GURL url2 = test_server_.GetURL("/root.crl"); |
519 | 522 |
520 // Issue 3 requests for url1, and 3 requests for url2 | 523 // Issue 3 requests for url1, and 3 requests for url2 |
521 TestFetchCallback callback1; | 524 TestFetchCallback callback1; |
522 scoped_ptr<CertNetFetcher::Request> request1 = | 525 std::unique_ptr<CertNetFetcher::Request> request1 = |
523 StartRequest(&fetcher, url1, callback1); | 526 StartRequest(&fetcher, url1, callback1); |
524 | 527 |
525 TestFetchCallback callback2; | 528 TestFetchCallback callback2; |
526 scoped_ptr<CertNetFetcher::Request> request2 = | 529 std::unique_ptr<CertNetFetcher::Request> request2 = |
527 StartRequest(&fetcher, url2, callback2); | 530 StartRequest(&fetcher, url2, callback2); |
528 | 531 |
529 TestFetchCallback callback3; | 532 TestFetchCallback callback3; |
530 scoped_ptr<CertNetFetcher::Request> request3 = | 533 std::unique_ptr<CertNetFetcher::Request> request3 = |
531 StartRequest(&fetcher, url1, callback3); | 534 StartRequest(&fetcher, url1, callback3); |
532 | 535 |
533 TestFetchCallback callback4; | 536 TestFetchCallback callback4; |
534 scoped_ptr<CertNetFetcher::Request> request4 = | 537 std::unique_ptr<CertNetFetcher::Request> request4 = |
535 StartRequest(&fetcher, url2, callback4); | 538 StartRequest(&fetcher, url2, callback4); |
536 | 539 |
537 TestFetchCallback callback5; | 540 TestFetchCallback callback5; |
538 scoped_ptr<CertNetFetcher::Request> request5 = | 541 std::unique_ptr<CertNetFetcher::Request> request5 = |
539 StartRequest(&fetcher, url2, callback5); | 542 StartRequest(&fetcher, url2, callback5); |
540 | 543 |
541 TestFetchCallback callback6; | 544 TestFetchCallback callback6; |
542 scoped_ptr<CertNetFetcher::Request> request6 = | 545 std::unique_ptr<CertNetFetcher::Request> request6 = |
543 StartRequest(&fetcher, url1, callback6); | 546 StartRequest(&fetcher, url1, callback6); |
544 | 547 |
545 // Cancel all but one of the requests for url1. | 548 // Cancel all but one of the requests for url1. |
546 request1.reset(); | 549 request1.reset(); |
547 request3.reset(); | 550 request3.reset(); |
548 | 551 |
549 // Wait for the remaining requests to finish. | 552 // Wait for the remaining requests to finish. |
550 scoped_ptr<FetchResult> result2 = callback2.WaitForResult(); | 553 std::unique_ptr<FetchResult> result2 = callback2.WaitForResult(); |
551 scoped_ptr<FetchResult> result4 = callback4.WaitForResult(); | 554 std::unique_ptr<FetchResult> result4 = callback4.WaitForResult(); |
552 scoped_ptr<FetchResult> result5 = callback5.WaitForResult(); | 555 std::unique_ptr<FetchResult> result5 = callback5.WaitForResult(); |
553 scoped_ptr<FetchResult> result6 = callback6.WaitForResult(); | 556 std::unique_ptr<FetchResult> result6 = callback6.WaitForResult(); |
554 | 557 |
555 // Verify that none of the cancelled requests for url1 completed (since they | 558 // Verify that none of the cancelled requests for url1 completed (since they |
556 // were cancelled). | 559 // were cancelled). |
557 EXPECT_FALSE(callback1.HasResult()); | 560 EXPECT_FALSE(callback1.HasResult()); |
558 EXPECT_FALSE(callback3.HasResult()); | 561 EXPECT_FALSE(callback3.HasResult()); |
559 | 562 |
560 // Verify the fetch results. | 563 // Verify the fetch results. |
561 result2->VerifySuccess("-root.crl-\n"); | 564 result2->VerifySuccess("-root.crl-\n"); |
562 result4->VerifySuccess("-root.crl-\n"); | 565 result4->VerifySuccess("-root.crl-\n"); |
563 result5->VerifySuccess("-root.crl-\n"); | 566 result5->VerifySuccess("-root.crl-\n"); |
564 result6->VerifySuccess("-cert.crt-\n"); | 567 result6->VerifySuccess("-cert.crt-\n"); |
565 | 568 |
566 // Verify that only 2 URLRequests were started even though 6 requests were | 569 // Verify that only 2 URLRequests were started even though 6 requests were |
567 // issued. | 570 // issued. |
568 EXPECT_EQ(2, network_delegate_.created_requests()); | 571 EXPECT_EQ(2, network_delegate_.created_requests()); |
569 } | 572 } |
570 | 573 |
571 // Cancel a request and then start another one for the same URL. | 574 // Cancel a request and then start another one for the same URL. |
572 TEST_F(CertNetFetcherImplTest, CancelThenStart) { | 575 TEST_F(CertNetFetcherImplTest, CancelThenStart) { |
573 ASSERT_TRUE(test_server_.Start()); | 576 ASSERT_TRUE(test_server_.Start()); |
574 | 577 |
575 CertNetFetcherImpl fetcher(&context_); | 578 CertNetFetcherImpl fetcher(&context_); |
576 TestFetchCallback callback1; | 579 TestFetchCallback callback1; |
577 TestFetchCallback callback2; | 580 TestFetchCallback callback2; |
578 TestFetchCallback callback3; | 581 TestFetchCallback callback3; |
579 | 582 |
580 GURL url = test_server_.GetURL("/cert.crt"); | 583 GURL url = test_server_.GetURL("/cert.crt"); |
581 | 584 |
582 scoped_ptr<CertNetFetcher::Request> request1 = | 585 std::unique_ptr<CertNetFetcher::Request> request1 = |
583 StartRequest(&fetcher, url, callback1); | 586 StartRequest(&fetcher, url, callback1); |
584 request1.reset(); | 587 request1.reset(); |
585 | 588 |
586 scoped_ptr<CertNetFetcher::Request> request2 = | 589 std::unique_ptr<CertNetFetcher::Request> request2 = |
587 StartRequest(&fetcher, url, callback2); | 590 StartRequest(&fetcher, url, callback2); |
588 | 591 |
589 scoped_ptr<CertNetFetcher::Request> request3 = | 592 std::unique_ptr<CertNetFetcher::Request> request3 = |
590 StartRequest(&fetcher, url, callback3); | 593 StartRequest(&fetcher, url, callback3); |
591 request3.reset(); | 594 request3.reset(); |
592 | 595 |
593 // All but |request2| were canceled. | 596 // All but |request2| were canceled. |
594 scoped_ptr<FetchResult> result = callback2.WaitForResult(); | 597 std::unique_ptr<FetchResult> result = callback2.WaitForResult(); |
595 | 598 |
596 result->VerifySuccess("-cert.crt-\n"); | 599 result->VerifySuccess("-cert.crt-\n"); |
597 | 600 |
598 EXPECT_FALSE(callback1.HasResult()); | 601 EXPECT_FALSE(callback1.HasResult()); |
599 EXPECT_FALSE(callback3.HasResult()); | 602 EXPECT_FALSE(callback3.HasResult()); |
600 | 603 |
601 // One URLRequest that was cancelled, then another right afterwards. | 604 // One URLRequest that was cancelled, then another right afterwards. |
602 EXPECT_EQ(2, network_delegate_.created_requests()); | 605 EXPECT_EQ(2, network_delegate_.created_requests()); |
603 } | 606 } |
604 | 607 |
605 // Start duplicate requests and then cancel all of them. | 608 // Start duplicate requests and then cancel all of them. |
606 TEST_F(CertNetFetcherImplTest, CancelAll) { | 609 TEST_F(CertNetFetcherImplTest, CancelAll) { |
607 ASSERT_TRUE(test_server_.Start()); | 610 ASSERT_TRUE(test_server_.Start()); |
608 | 611 |
609 CertNetFetcherImpl fetcher(&context_); | 612 CertNetFetcherImpl fetcher(&context_); |
610 TestFetchCallback callback[3]; | 613 TestFetchCallback callback[3]; |
611 scoped_ptr<CertNetFetcher::Request> request[3]; | 614 std::unique_ptr<CertNetFetcher::Request> request[3]; |
612 | 615 |
613 GURL url = test_server_.GetURL("/cert.crt"); | 616 GURL url = test_server_.GetURL("/cert.crt"); |
614 | 617 |
615 for (size_t i = 0; i < arraysize(callback); ++i) { | 618 for (size_t i = 0; i < arraysize(callback); ++i) { |
616 request[i] = StartRequest(&fetcher, url, callback[i]); | 619 request[i] = StartRequest(&fetcher, url, callback[i]); |
617 } | 620 } |
618 | 621 |
619 // Cancel all the requests. | 622 // Cancel all the requests. |
620 for (size_t i = 0; i < arraysize(request); ++i) | 623 for (size_t i = 0; i < arraysize(request); ++i) |
621 request[i].reset(); | 624 request[i].reset(); |
(...skipping 11 matching lines...) Expand all Loading... |
633 // Delete the CertNetFetcherImpl within a request callback. | 636 // Delete the CertNetFetcherImpl within a request callback. |
634 TEST_F(CertNetFetcherImplTest, DeleteWithinCallback) { | 637 TEST_F(CertNetFetcherImplTest, DeleteWithinCallback) { |
635 ASSERT_TRUE(test_server_.Start()); | 638 ASSERT_TRUE(test_server_.Start()); |
636 | 639 |
637 // Deleted by callback2. | 640 // Deleted by callback2. |
638 CertNetFetcher* fetcher = new CertNetFetcherImpl(&context_); | 641 CertNetFetcher* fetcher = new CertNetFetcherImpl(&context_); |
639 | 642 |
640 GURL url = test_server_.GetURL("/cert.crt"); | 643 GURL url = test_server_.GetURL("/cert.crt"); |
641 | 644 |
642 TestFetchCallback callback[4]; | 645 TestFetchCallback callback[4]; |
643 scoped_ptr<CertNetFetcher::Request> reqs[4]; | 646 std::unique_ptr<CertNetFetcher::Request> reqs[4]; |
644 callback[1].set_extra_closure(base::Bind(DeleteCertNetFetcher, fetcher)); | 647 callback[1].set_extra_closure(base::Bind(DeleteCertNetFetcher, fetcher)); |
645 | 648 |
646 for (size_t i = 0; i < arraysize(callback); ++i) | 649 for (size_t i = 0; i < arraysize(callback); ++i) |
647 reqs[i] = StartRequest(fetcher, url, callback[i]); | 650 reqs[i] = StartRequest(fetcher, url, callback[i]); |
648 | 651 |
649 EXPECT_EQ(1, network_delegate_.created_requests()); | 652 EXPECT_EQ(1, network_delegate_.created_requests()); |
650 | 653 |
651 callback[1].WaitForResult(); | 654 callback[1].WaitForResult(); |
652 | 655 |
653 // Assume requests for the same URL are executed in FIFO order. | 656 // Assume requests for the same URL are executed in FIFO order. |
654 EXPECT_TRUE(callback[0].HasResult()); | 657 EXPECT_TRUE(callback[0].HasResult()); |
655 EXPECT_FALSE(callback[2].HasResult()); | 658 EXPECT_FALSE(callback[2].HasResult()); |
656 EXPECT_FALSE(callback[3].HasResult()); | 659 EXPECT_FALSE(callback[3].HasResult()); |
657 } | 660 } |
658 | 661 |
659 void FetchRequest(CertNetFetcher* fetcher, | 662 void FetchRequest(CertNetFetcher* fetcher, |
660 const GURL& url, | 663 const GURL& url, |
661 TestFetchCallback* callback, | 664 TestFetchCallback* callback, |
662 scoped_ptr<CertNetFetcher::Request>* request) { | 665 std::unique_ptr<CertNetFetcher::Request>* request) { |
663 *request = StartRequest(fetcher, url, *callback); | 666 *request = StartRequest(fetcher, url, *callback); |
664 } | 667 } |
665 | 668 |
666 // Make a request during callback for the same URL. | 669 // Make a request during callback for the same URL. |
667 TEST_F(CertNetFetcherImplTest, FetchWithinCallback) { | 670 TEST_F(CertNetFetcherImplTest, FetchWithinCallback) { |
668 ASSERT_TRUE(test_server_.Start()); | 671 ASSERT_TRUE(test_server_.Start()); |
669 | 672 |
670 CertNetFetcherImpl fetcher(&context_); | 673 CertNetFetcherImpl fetcher(&context_); |
671 | 674 |
672 GURL url = test_server_.GetURL("/cert.crt"); | 675 GURL url = test_server_.GetURL("/cert.crt"); |
673 | 676 |
674 TestFetchCallback callback[5]; | 677 TestFetchCallback callback[5]; |
675 scoped_ptr<CertNetFetcher::Request> req[5]; | 678 std::unique_ptr<CertNetFetcher::Request> req[5]; |
676 callback[1].set_extra_closure( | 679 callback[1].set_extra_closure( |
677 base::Bind(FetchRequest, &fetcher, url, &callback[4], &req[4])); | 680 base::Bind(FetchRequest, &fetcher, url, &callback[4], &req[4])); |
678 | 681 |
679 for (size_t i = 0; i < arraysize(callback) - 1; ++i) | 682 for (size_t i = 0; i < arraysize(callback) - 1; ++i) |
680 req[i] = StartRequest(&fetcher, url, callback[i]); | 683 req[i] = StartRequest(&fetcher, url, callback[i]); |
681 | 684 |
682 EXPECT_EQ(1, network_delegate_.created_requests()); | 685 EXPECT_EQ(1, network_delegate_.created_requests()); |
683 | 686 |
684 for (size_t i = 0; i < arraysize(callback); ++i) { | 687 for (size_t i = 0; i < arraysize(callback); ++i) { |
685 scoped_ptr<FetchResult> result = callback[i].WaitForResult(); | 688 std::unique_ptr<FetchResult> result = callback[i].WaitForResult(); |
686 result->VerifySuccess("-cert.crt-\n"); | 689 result->VerifySuccess("-cert.crt-\n"); |
687 } | 690 } |
688 | 691 |
689 // The fetch started within a callback should have started a new request | 692 // The fetch started within a callback should have started a new request |
690 // rather than attaching to the current job. | 693 // rather than attaching to the current job. |
691 EXPECT_EQ(2, network_delegate_.created_requests()); | 694 EXPECT_EQ(2, network_delegate_.created_requests()); |
692 } | 695 } |
693 | 696 |
694 void CancelRequest(scoped_ptr<CertNetFetcher::Request>* request) { | 697 void CancelRequest(std::unique_ptr<CertNetFetcher::Request>* request) { |
695 request->reset(); | 698 request->reset(); |
696 } | 699 } |
697 | 700 |
698 // Cancel a request while executing a callback for the same job. | 701 // Cancel a request while executing a callback for the same job. |
699 TEST_F(CertNetFetcherImplTest, CancelWithinCallback) { | 702 TEST_F(CertNetFetcherImplTest, CancelWithinCallback) { |
700 ASSERT_TRUE(test_server_.Start()); | 703 ASSERT_TRUE(test_server_.Start()); |
701 | 704 |
702 CertNetFetcherImpl fetcher(&context_); | 705 CertNetFetcherImpl fetcher(&context_); |
703 | 706 |
704 GURL url = test_server_.GetURL("/cert.crt"); | 707 GURL url = test_server_.GetURL("/cert.crt"); |
705 | 708 |
706 TestFetchCallback callback[4]; | 709 TestFetchCallback callback[4]; |
707 scoped_ptr<CertNetFetcher::Request> request[4]; | 710 std::unique_ptr<CertNetFetcher::Request> request[4]; |
708 | 711 |
709 for (size_t i = 0; i < arraysize(callback); ++i) | 712 for (size_t i = 0; i < arraysize(callback); ++i) |
710 request[i] = StartRequest(&fetcher, url, callback[i]); | 713 request[i] = StartRequest(&fetcher, url, callback[i]); |
711 | 714 |
712 // Cancel request[2] when the callback for request[1] runs. | 715 // Cancel request[2] when the callback for request[1] runs. |
713 callback[1].set_extra_closure(base::Bind(CancelRequest, &request[2])); | 716 callback[1].set_extra_closure(base::Bind(CancelRequest, &request[2])); |
714 | 717 |
715 EXPECT_EQ(1, network_delegate_.created_requests()); | 718 EXPECT_EQ(1, network_delegate_.created_requests()); |
716 | 719 |
717 for (size_t i = 0; i < arraysize(request); ++i) { | 720 for (size_t i = 0; i < arraysize(request); ++i) { |
718 if (i == 2) | 721 if (i == 2) |
719 continue; | 722 continue; |
720 | 723 |
721 scoped_ptr<FetchResult> result = callback[i].WaitForResult(); | 724 std::unique_ptr<FetchResult> result = callback[i].WaitForResult(); |
722 result->VerifySuccess("-cert.crt-\n"); | 725 result->VerifySuccess("-cert.crt-\n"); |
723 } | 726 } |
724 | 727 |
725 // request[2] was cancelled. | 728 // request[2] was cancelled. |
726 EXPECT_FALSE(callback[2].HasResult()); | 729 EXPECT_FALSE(callback[2].HasResult()); |
727 } | 730 } |
728 | 731 |
729 // Cancel the final request while executing a callback for the same job. Ensure | 732 // Cancel the final request while executing a callback for the same job. Ensure |
730 // that the job is not deleted twice. | 733 // that the job is not deleted twice. |
731 TEST_F(CertNetFetcherImplTest, CancelLastRequestWithinCallback) { | 734 TEST_F(CertNetFetcherImplTest, CancelLastRequestWithinCallback) { |
732 ASSERT_TRUE(test_server_.Start()); | 735 ASSERT_TRUE(test_server_.Start()); |
733 | 736 |
734 CertNetFetcherImpl fetcher(&context_); | 737 CertNetFetcherImpl fetcher(&context_); |
735 | 738 |
736 GURL url = test_server_.GetURL("/cert.crt"); | 739 GURL url = test_server_.GetURL("/cert.crt"); |
737 | 740 |
738 TestFetchCallback callback1; | 741 TestFetchCallback callback1; |
739 scoped_ptr<CertNetFetcher::Request> request1 = | 742 std::unique_ptr<CertNetFetcher::Request> request1 = |
740 StartRequest(&fetcher, url, callback1); | 743 StartRequest(&fetcher, url, callback1); |
741 | 744 |
742 TestFetchCallback callback2; | 745 TestFetchCallback callback2; |
743 scoped_ptr<CertNetFetcher::Request> request2 = | 746 std::unique_ptr<CertNetFetcher::Request> request2 = |
744 StartRequest(&fetcher, url, callback1); | 747 StartRequest(&fetcher, url, callback1); |
745 | 748 |
746 // Cancel request2 when the callback for request1 runs. | 749 // Cancel request2 when the callback for request1 runs. |
747 callback1.set_extra_closure(base::Bind(CancelRequest, &request2)); | 750 callback1.set_extra_closure(base::Bind(CancelRequest, &request2)); |
748 | 751 |
749 EXPECT_EQ(1, network_delegate_.created_requests()); | 752 EXPECT_EQ(1, network_delegate_.created_requests()); |
750 | 753 |
751 scoped_ptr<FetchResult> result = callback1.WaitForResult(); | 754 std::unique_ptr<FetchResult> result = callback1.WaitForResult(); |
752 result->VerifySuccess("-cert.crt-\n"); | 755 result->VerifySuccess("-cert.crt-\n"); |
753 | 756 |
754 // request2 was cancelled. | 757 // request2 was cancelled. |
755 EXPECT_FALSE(callback2.HasResult()); | 758 EXPECT_FALSE(callback2.HasResult()); |
756 } | 759 } |
757 | 760 |
758 } // namespace net | 761 } // namespace net |
OLD | NEW |