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/cert/multi_threaded_cert_verifier.h" | 5 #include "net/cert/multi_threaded_cert_verifier.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/debug/leak_annotations.h" | 10 #include "base/debug/leak_annotations.h" |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
81 CertVerifyResult verify_result; | 81 CertVerifyResult verify_result; |
82 TestCompletionCallback callback; | 82 TestCompletionCallback callback; |
83 std::unique_ptr<CertVerifier::Request> request; | 83 std::unique_ptr<CertVerifier::Request> request; |
84 CertVerifyResult verify_result2; | 84 CertVerifyResult verify_result2; |
85 TestCompletionCallback callback2; | 85 TestCompletionCallback callback2; |
86 std::unique_ptr<CertVerifier::Request> request2; | 86 std::unique_ptr<CertVerifier::Request> request2; |
87 | 87 |
88 error = verifier_.Verify( | 88 error = verifier_.Verify( |
89 CertVerifier::RequestParams(test_cert, "www.example.com", 0, | 89 CertVerifier::RequestParams(test_cert, "www.example.com", 0, |
90 std::string(), CertificateList()), | 90 std::string(), CertificateList()), |
91 NULL, &verify_result, callback.callback(), &request, BoundNetLog()); | 91 NULL, &verify_result, callback.callback(), &request, NetLogWithSource()); |
92 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); | 92 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); |
93 EXPECT_TRUE(request); | 93 EXPECT_TRUE(request); |
94 error = verifier_.Verify( | 94 error = verifier_.Verify( |
95 CertVerifier::RequestParams(test_cert, "www.example.com", 0, | 95 CertVerifier::RequestParams(test_cert, "www.example.com", 0, |
96 std::string(), CertificateList()), | 96 std::string(), CertificateList()), |
97 NULL, &verify_result2, callback2.callback(), &request2, BoundNetLog()); | 97 NULL, &verify_result2, callback2.callback(), &request2, |
| 98 NetLogWithSource()); |
98 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); | 99 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); |
99 EXPECT_TRUE(request2); | 100 EXPECT_TRUE(request2); |
100 error = callback.WaitForResult(); | 101 error = callback.WaitForResult(); |
101 EXPECT_TRUE(IsCertificateError(error)); | 102 EXPECT_TRUE(IsCertificateError(error)); |
102 error = callback2.WaitForResult(); | 103 error = callback2.WaitForResult(); |
103 ASSERT_TRUE(IsCertificateError(error)); | 104 ASSERT_TRUE(IsCertificateError(error)); |
104 ASSERT_EQ(2u, verifier_.requests()); | 105 ASSERT_EQ(2u, verifier_.requests()); |
105 ASSERT_EQ(1u, verifier_.inflight_joins()); | 106 ASSERT_EQ(1u, verifier_.inflight_joins()); |
106 } | 107 } |
107 | 108 |
108 // Tests that the callback of a canceled request is never made. | 109 // Tests that the callback of a canceled request is never made. |
109 TEST_F(MultiThreadedCertVerifierTest, CancelRequest) { | 110 TEST_F(MultiThreadedCertVerifierTest, CancelRequest) { |
110 base::FilePath certs_dir = GetTestCertsDirectory(); | 111 base::FilePath certs_dir = GetTestCertsDirectory(); |
111 scoped_refptr<X509Certificate> test_cert( | 112 scoped_refptr<X509Certificate> test_cert( |
112 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 113 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
113 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get()); | 114 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get()); |
114 | 115 |
115 int error; | 116 int error; |
116 CertVerifyResult verify_result; | 117 CertVerifyResult verify_result; |
117 std::unique_ptr<CertVerifier::Request> request; | 118 std::unique_ptr<CertVerifier::Request> request; |
118 | 119 |
119 error = verifier_.Verify( | 120 error = verifier_.Verify( |
120 CertVerifier::RequestParams(test_cert, "www.example.com", 0, | 121 CertVerifier::RequestParams(test_cert, "www.example.com", 0, |
121 std::string(), CertificateList()), | 122 std::string(), CertificateList()), |
122 NULL, &verify_result, base::Bind(&FailTest), &request, BoundNetLog()); | 123 NULL, &verify_result, base::Bind(&FailTest), &request, |
| 124 NetLogWithSource()); |
123 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); | 125 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); |
124 ASSERT_TRUE(request); | 126 ASSERT_TRUE(request); |
125 request.reset(); | 127 request.reset(); |
126 | 128 |
127 // Issue a few more requests to the worker pool and wait for their | 129 // Issue a few more requests to the worker pool and wait for their |
128 // completion, so that the task of the canceled request (which runs on a | 130 // completion, so that the task of the canceled request (which runs on a |
129 // worker thread) is likely to complete by the end of this test. | 131 // worker thread) is likely to complete by the end of this test. |
130 TestCompletionCallback callback; | 132 TestCompletionCallback callback; |
131 for (int i = 0; i < 5; ++i) { | 133 for (int i = 0; i < 5; ++i) { |
132 error = verifier_.Verify( | 134 error = verifier_.Verify( |
133 CertVerifier::RequestParams(test_cert, "www2.example.com", 0, | 135 CertVerifier::RequestParams(test_cert, "www2.example.com", 0, |
134 std::string(), CertificateList()), | 136 std::string(), CertificateList()), |
135 NULL, &verify_result, callback.callback(), &request, BoundNetLog()); | 137 NULL, &verify_result, callback.callback(), &request, |
| 138 NetLogWithSource()); |
136 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); | 139 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); |
137 EXPECT_TRUE(request); | 140 EXPECT_TRUE(request); |
138 error = callback.WaitForResult(); | 141 error = callback.WaitForResult(); |
139 } | 142 } |
140 } | 143 } |
141 | 144 |
142 // Tests that a canceled request is not leaked. | 145 // Tests that a canceled request is not leaked. |
143 TEST_F(MultiThreadedCertVerifierTest, CancelRequestThenQuit) { | 146 TEST_F(MultiThreadedCertVerifierTest, CancelRequestThenQuit) { |
144 base::FilePath certs_dir = GetTestCertsDirectory(); | 147 base::FilePath certs_dir = GetTestCertsDirectory(); |
145 scoped_refptr<X509Certificate> test_cert( | 148 scoped_refptr<X509Certificate> test_cert( |
146 ImportCertFromFile(certs_dir, "ok_cert.pem")); | 149 ImportCertFromFile(certs_dir, "ok_cert.pem")); |
147 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get()); | 150 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get()); |
148 | 151 |
149 int error; | 152 int error; |
150 CertVerifyResult verify_result; | 153 CertVerifyResult verify_result; |
151 TestCompletionCallback callback; | 154 TestCompletionCallback callback; |
152 std::unique_ptr<CertVerifier::Request> request; | 155 std::unique_ptr<CertVerifier::Request> request; |
153 | 156 |
154 { | 157 { |
155 // Because shutdown intentionally doesn't join worker threads, memory may | 158 // Because shutdown intentionally doesn't join worker threads, memory may |
156 // be leaked if the main thread shuts down before the worker thread | 159 // be leaked if the main thread shuts down before the worker thread |
157 // completes. In particular MultiThreadedCertVerifier calls | 160 // completes. In particular MultiThreadedCertVerifier calls |
158 // base::WorkerPool::PostTaskAndReply(), which leaks its "relay" when it | 161 // base::WorkerPool::PostTaskAndReply(), which leaks its "relay" when it |
159 // can't post the reply back to the origin thread. See | 162 // can't post the reply back to the origin thread. See |
160 // https://crbug.com/522514 | 163 // https://crbug.com/522514 |
161 ANNOTATE_SCOPED_MEMORY_LEAK; | 164 ANNOTATE_SCOPED_MEMORY_LEAK; |
162 error = verifier_.Verify( | 165 error = verifier_.Verify( |
163 CertVerifier::RequestParams(test_cert, "www.example.com", 0, | 166 CertVerifier::RequestParams(test_cert, "www.example.com", 0, |
164 std::string(), CertificateList()), | 167 std::string(), CertificateList()), |
165 NULL, &verify_result, callback.callback(), &request, BoundNetLog()); | 168 NULL, &verify_result, callback.callback(), &request, |
| 169 NetLogWithSource()); |
166 } | 170 } |
167 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); | 171 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); |
168 EXPECT_TRUE(request); | 172 EXPECT_TRUE(request); |
169 request.reset(); | 173 request.reset(); |
170 // Destroy |verifier| by going out of scope. | 174 // Destroy |verifier| by going out of scope. |
171 } | 175 } |
172 | 176 |
173 // Tests de-duplication of requests. | 177 // Tests de-duplication of requests. |
174 // Starts up 5 requests, of which 3 are unique. | 178 // Starts up 5 requests, of which 3 are unique. |
175 TEST_F(MultiThreadedCertVerifierTest, MultipleInflightJoin) { | 179 TEST_F(MultiThreadedCertVerifierTest, MultipleInflightJoin) { |
(...skipping 20 matching lines...) Expand all Loading... |
196 std::unique_ptr<CertVerifier::Request> request5; | 200 std::unique_ptr<CertVerifier::Request> request5; |
197 | 201 |
198 const char domain1[] = "www.example1.com"; | 202 const char domain1[] = "www.example1.com"; |
199 const char domain2[] = "www.exampleB.com"; | 203 const char domain2[] = "www.exampleB.com"; |
200 const char domain3[] = "www.example3.com"; | 204 const char domain3[] = "www.example3.com"; |
201 | 205 |
202 // Start 3 unique requests. | 206 // Start 3 unique requests. |
203 error = verifier_.Verify( | 207 error = verifier_.Verify( |
204 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), | 208 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), |
205 CertificateList()), | 209 CertificateList()), |
206 nullptr, &verify_result1, callback1.callback(), &request1, BoundNetLog()); | 210 nullptr, &verify_result1, callback1.callback(), &request1, |
| 211 NetLogWithSource()); |
207 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); | 212 ASSERT_THAT(error, IsError(ERR_IO_PENDING)); |
208 EXPECT_TRUE(request1); | 213 EXPECT_TRUE(request1); |
209 | 214 |
210 error = verifier_.Verify( | 215 error = verifier_.Verify( |
211 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), | 216 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), |
212 CertificateList()), | 217 CertificateList()), |
213 nullptr, &verify_result2, callback2.callback(), &request2, BoundNetLog()); | 218 nullptr, &verify_result2, callback2.callback(), &request2, |
| 219 NetLogWithSource()); |
214 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); | 220 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); |
215 EXPECT_TRUE(request2); | 221 EXPECT_TRUE(request2); |
216 | 222 |
217 error = verifier_.Verify( | 223 error = verifier_.Verify( |
218 CertVerifier::RequestParams(test_cert, domain3, 0, std::string(), | 224 CertVerifier::RequestParams(test_cert, domain3, 0, std::string(), |
219 CertificateList()), | 225 CertificateList()), |
220 nullptr, &verify_result3, callback3.callback(), &request3, BoundNetLog()); | 226 nullptr, &verify_result3, callback3.callback(), &request3, |
| 227 NetLogWithSource()); |
221 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); | 228 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); |
222 EXPECT_TRUE(request3); | 229 EXPECT_TRUE(request3); |
223 | 230 |
224 // Start duplicate requests (which should join to existing jobs). | 231 // Start duplicate requests (which should join to existing jobs). |
225 error = verifier_.Verify( | 232 error = verifier_.Verify( |
226 CertVerifier::RequestParams(test_cert, domain1, 0, std::string(), | 233 CertVerifier::RequestParams(test_cert, domain1, 0, std::string(), |
227 CertificateList()), | 234 CertificateList()), |
228 nullptr, &verify_result4, callback4.callback(), &request4, BoundNetLog()); | 235 nullptr, &verify_result4, callback4.callback(), &request4, |
| 236 NetLogWithSource()); |
229 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); | 237 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); |
230 EXPECT_TRUE(request4); | 238 EXPECT_TRUE(request4); |
231 | 239 |
232 error = verifier_.Verify( | 240 error = verifier_.Verify( |
233 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), | 241 CertVerifier::RequestParams(test_cert, domain2, 0, std::string(), |
234 CertificateList()), | 242 CertificateList()), |
235 nullptr, &verify_result5, callback5.callback(), &request5, BoundNetLog()); | 243 nullptr, &verify_result5, callback5.callback(), &request5, |
| 244 NetLogWithSource()); |
236 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); | 245 EXPECT_THAT(error, IsError(ERR_IO_PENDING)); |
237 EXPECT_TRUE(request5); | 246 EXPECT_TRUE(request5); |
238 | 247 |
239 error = callback1.WaitForResult(); | 248 error = callback1.WaitForResult(); |
240 EXPECT_TRUE(IsCertificateError(error)); | 249 EXPECT_TRUE(IsCertificateError(error)); |
241 error = callback2.WaitForResult(); | 250 error = callback2.WaitForResult(); |
242 ASSERT_TRUE(IsCertificateError(error)); | 251 ASSERT_TRUE(IsCertificateError(error)); |
243 error = callback4.WaitForResult(); | 252 error = callback4.WaitForResult(); |
244 ASSERT_TRUE(IsCertificateError(error)); | 253 ASSERT_TRUE(IsCertificateError(error)); |
245 | 254 |
246 // Let the other requests automatically cancel. | 255 // Let the other requests automatically cancel. |
247 ASSERT_EQ(5u, verifier_.requests()); | 256 ASSERT_EQ(5u, verifier_.requests()); |
248 ASSERT_EQ(2u, verifier_.inflight_joins()); | 257 ASSERT_EQ(2u, verifier_.inflight_joins()); |
249 } | 258 } |
250 | 259 |
251 } // namespace net | 260 } // namespace net |
OLD | NEW |