Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(13)

Side by Side Diff: net/cert/multi_threaded_cert_verifier_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698