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/quic/quic_crypto_client_stream.h" | 5 #include "net/quic/quic_crypto_client_stream.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h" | 9 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h" |
10 #include "net/quic/crypto/quic_decrypter.h" | 10 #include "net/quic/crypto/quic_decrypter.h" |
(...skipping 22 matching lines...) Expand all Loading... |
33 | 33 |
34 class QuicCryptoClientStreamTest : public ::testing::Test { | 34 class QuicCryptoClientStreamTest : public ::testing::Test { |
35 public: | 35 public: |
36 QuicCryptoClientStreamTest() | 36 QuicCryptoClientStreamTest() |
37 : server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED), | 37 : server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED), |
38 crypto_config_(CryptoTestUtils::ProofVerifierForTesting()) { | 38 crypto_config_(CryptoTestUtils::ProofVerifierForTesting()) { |
39 CreateConnection(); | 39 CreateConnection(); |
40 } | 40 } |
41 | 41 |
42 void CreateConnection() { | 42 void CreateConnection() { |
43 connection_ = new PacketSavingConnection(&helper_, Perspective::IS_CLIENT); | 43 connection_ = new PacketSavingConnection(&helper_, &alarm_factory_, |
| 44 Perspective::IS_CLIENT); |
44 // Advance the time, because timers do not like uninitialized times. | 45 // Advance the time, because timers do not like uninitialized times. |
45 connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1)); | 46 connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1)); |
46 | 47 |
47 session_.reset(new TestQuicSpdyClientSession( | 48 session_.reset(new TestQuicSpdyClientSession( |
48 connection_, DefaultQuicConfig(), server_id_, &crypto_config_)); | 49 connection_, DefaultQuicConfig(), server_id_, &crypto_config_)); |
49 } | 50 } |
50 | 51 |
51 void CompleteCryptoHandshake() { | 52 void CompleteCryptoHandshake() { |
52 stream()->CryptoConnect(); | 53 stream()->CryptoConnect(); |
53 CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_, stream(), | 54 CryptoTestUtils::HandshakeWithFakeServer( |
54 server_options_); | 55 &helper_, &alarm_factory_, connection_, stream(), server_options_); |
55 } | 56 } |
56 | 57 |
57 void ConstructHandshakeMessage() { | 58 void ConstructHandshakeMessage() { |
58 CryptoFramer framer; | 59 CryptoFramer framer; |
59 message_data_.reset(framer.ConstructHandshakeMessage(message_)); | 60 message_data_.reset(framer.ConstructHandshakeMessage(message_)); |
60 } | 61 } |
61 | 62 |
62 QuicCryptoClientStream* stream() { return session_->GetCryptoStream(); } | 63 QuicCryptoClientStream* stream() { return session_->GetCryptoStream(); } |
63 | 64 |
64 MockConnectionHelper helper_; | 65 MockConnectionHelper helper_; |
| 66 MockAlarmFactory alarm_factory_; |
65 PacketSavingConnection* connection_; | 67 PacketSavingConnection* connection_; |
66 std::unique_ptr<TestQuicSpdyClientSession> session_; | 68 std::unique_ptr<TestQuicSpdyClientSession> session_; |
67 QuicServerId server_id_; | 69 QuicServerId server_id_; |
68 CryptoHandshakeMessage message_; | 70 CryptoHandshakeMessage message_; |
69 std::unique_ptr<QuicData> message_data_; | 71 std::unique_ptr<QuicData> message_data_; |
70 QuicCryptoClientConfig crypto_config_; | 72 QuicCryptoClientConfig crypto_config_; |
71 CryptoTestUtils::FakeServerOptions server_options_; | 73 CryptoTestUtils::FakeServerOptions server_options_; |
72 }; | 74 }; |
73 | 75 |
74 TEST_F(QuicCryptoClientStreamTest, NotInitiallyConected) { | 76 TEST_F(QuicCryptoClientStreamTest, NotInitiallyConected) { |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
260 public: | 262 public: |
261 QuicCryptoClientStreamStatelessTest() | 263 QuicCryptoClientStreamStatelessTest() |
262 : client_crypto_config_(CryptoTestUtils::ProofVerifierForTesting()), | 264 : client_crypto_config_(CryptoTestUtils::ProofVerifierForTesting()), |
263 server_crypto_config_(QuicCryptoServerConfig::TESTING, | 265 server_crypto_config_(QuicCryptoServerConfig::TESTING, |
264 QuicRandom::GetInstance(), | 266 QuicRandom::GetInstance(), |
265 CryptoTestUtils::ProofSourceForTesting()), | 267 CryptoTestUtils::ProofSourceForTesting()), |
266 server_compressed_certs_cache_( | 268 server_compressed_certs_cache_( |
267 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize), | 269 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize), |
268 server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED) { | 270 server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED) { |
269 TestQuicSpdyClientSession* client_session = nullptr; | 271 TestQuicSpdyClientSession* client_session = nullptr; |
270 CreateClientSessionForTest( | 272 CreateClientSessionForTest(server_id_, |
271 server_id_, | 273 /* supports_stateless_rejects= */ true, |
272 /* supports_stateless_rejects= */ true, | 274 QuicTime::Delta::FromSeconds(100000), |
273 QuicTime::Delta::FromSeconds(100000), QuicSupportedVersions(), &helper_, | 275 QuicSupportedVersions(), &helper_, |
274 &client_crypto_config_, &client_connection_, &client_session); | 276 &alarm_factory_, &client_crypto_config_, |
| 277 &client_connection_, &client_session); |
275 CHECK(client_session); | 278 CHECK(client_session); |
276 client_session_.reset(client_session); | 279 client_session_.reset(client_session); |
277 } | 280 } |
278 | 281 |
279 QuicCryptoServerStream* server_stream() { | 282 QuicCryptoServerStream* server_stream() { |
280 return server_session_->GetCryptoStream(); | 283 return server_session_->GetCryptoStream(); |
281 } | 284 } |
282 | 285 |
283 void AdvanceHandshakeWithFakeServer() { | 286 void AdvanceHandshakeWithFakeServer() { |
284 client_session_->GetCryptoStream()->CryptoConnect(); | 287 client_session_->GetCryptoStream()->CryptoConnect(); |
285 CryptoTestUtils::AdvanceHandshake(client_connection_, | 288 CryptoTestUtils::AdvanceHandshake(client_connection_, |
286 client_session_->GetCryptoStream(), 0, | 289 client_session_->GetCryptoStream(), 0, |
287 server_connection_, server_stream(), 0); | 290 server_connection_, server_stream(), 0); |
288 } | 291 } |
289 | 292 |
290 // Initializes the server_stream_ for stateless rejects. | 293 // Initializes the server_stream_ for stateless rejects. |
291 void InitializeFakeStatelessRejectServer() { | 294 void InitializeFakeStatelessRejectServer() { |
292 TestQuicSpdyServerSession* server_session = nullptr; | 295 TestQuicSpdyServerSession* server_session = nullptr; |
293 CreateServerSessionForTest( | 296 CreateServerSessionForTest(server_id_, QuicTime::Delta::FromSeconds(100000), |
294 server_id_, QuicTime::Delta::FromSeconds(100000), | 297 QuicSupportedVersions(), &helper_, |
295 QuicSupportedVersions(), &helper_, &server_crypto_config_, | 298 &alarm_factory_, &server_crypto_config_, |
296 &server_compressed_certs_cache_, &server_connection_, &server_session); | 299 &server_compressed_certs_cache_, |
| 300 &server_connection_, &server_session); |
297 CHECK(server_session); | 301 CHECK(server_session); |
298 server_session_.reset(server_session); | 302 server_session_.reset(server_session); |
299 CryptoTestUtils::FakeServerOptions options; | 303 CryptoTestUtils::FakeServerOptions options; |
300 CryptoTestUtils::SetupCryptoServerConfigForTest( | 304 CryptoTestUtils::SetupCryptoServerConfigForTest( |
301 server_connection_->clock(), server_connection_->random_generator(), | 305 server_connection_->clock(), server_connection_->random_generator(), |
302 server_session_->config(), &server_crypto_config_, options); | 306 server_session_->config(), &server_crypto_config_, options); |
303 FLAGS_enable_quic_stateless_reject_support = true; | 307 FLAGS_enable_quic_stateless_reject_support = true; |
304 } | 308 } |
305 | 309 |
306 MockConnectionHelper helper_; | 310 MockConnectionHelper helper_; |
| 311 MockAlarmFactory alarm_factory_; |
307 | 312 |
308 // Client crypto stream state | 313 // Client crypto stream state |
309 PacketSavingConnection* client_connection_; | 314 PacketSavingConnection* client_connection_; |
310 std::unique_ptr<TestQuicSpdyClientSession> client_session_; | 315 std::unique_ptr<TestQuicSpdyClientSession> client_session_; |
311 QuicCryptoClientConfig client_crypto_config_; | 316 QuicCryptoClientConfig client_crypto_config_; |
312 | 317 |
313 // Server crypto stream state | 318 // Server crypto stream state |
314 PacketSavingConnection* server_connection_; | 319 PacketSavingConnection* server_connection_; |
315 std::unique_ptr<TestQuicSpdyServerSession> server_session_; | 320 std::unique_ptr<TestQuicSpdyServerSession> server_session_; |
316 QuicCryptoServerConfig server_crypto_config_; | 321 QuicCryptoServerConfig server_crypto_config_; |
(...skipping 30 matching lines...) Expand all Loading... |
347 client_state->GetNextServerDesignatedConnectionId(); | 352 client_state->GetNextServerDesignatedConnectionId(); |
348 QuicConnectionId expected_id = | 353 QuicConnectionId expected_id = |
349 server_session_->connection()->random_generator()->RandUint64(); | 354 server_session_->connection()->random_generator()->RandUint64(); |
350 EXPECT_EQ(expected_id, server_designated_id); | 355 EXPECT_EQ(expected_id, server_designated_id); |
351 EXPECT_FALSE(client_state->has_server_designated_connection_id()); | 356 EXPECT_FALSE(client_state->has_server_designated_connection_id()); |
352 } | 357 } |
353 | 358 |
354 } // namespace | 359 } // namespace |
355 } // namespace test | 360 } // namespace test |
356 } // namespace net | 361 } // namespace net |
OLD | NEW |