| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/tools/quic/quic_server_session.h" | |
| 6 | |
| 7 #include "net/quic/crypto/cached_network_parameters.h" | |
| 8 #include "net/quic/crypto/quic_crypto_server_config.h" | |
| 9 #include "net/quic/crypto/quic_random.h" | |
| 10 #include "net/quic/quic_connection.h" | |
| 11 #include "net/quic/quic_crypto_server_stream.h" | |
| 12 #include "net/quic/quic_flags.h" | |
| 13 #include "net/quic/quic_utils.h" | |
| 14 #include "net/quic/test_tools/quic_config_peer.h" | |
| 15 #include "net/quic/test_tools/quic_connection_peer.h" | |
| 16 #include "net/quic/test_tools/quic_data_stream_peer.h" | |
| 17 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h" | |
| 18 #include "net/quic/test_tools/quic_session_peer.h" | |
| 19 #include "net/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h" | |
| 20 #include "net/quic/test_tools/quic_test_utils.h" | |
| 21 #include "net/tools/quic/quic_spdy_server_stream.h" | |
| 22 #include "net/tools/quic/test_tools/quic_test_utils.h" | |
| 23 #include "testing/gmock/include/gmock/gmock.h" | |
| 24 #include "testing/gtest/include/gtest/gtest.h" | |
| 25 | |
| 26 using __gnu_cxx::vector; | |
| 27 using net::test::MockConnection; | |
| 28 using net::test::QuicConfigPeer; | |
| 29 using net::test::QuicConnectionPeer; | |
| 30 using net::test::QuicDataStreamPeer; | |
| 31 using net::test::QuicSentPacketManagerPeer; | |
| 32 using net::test::QuicSessionPeer; | |
| 33 using net::test::QuicSustainedBandwidthRecorderPeer; | |
| 34 using net::test::SupportedVersions; | |
| 35 using net::test::ValueRestore; | |
| 36 using net::test::kClientDataStreamId1; | |
| 37 using net::test::kClientDataStreamId2; | |
| 38 using net::test::kClientDataStreamId3; | |
| 39 using net::test::kClientDataStreamId4; | |
| 40 using std::string; | |
| 41 using testing::StrictMock; | |
| 42 using testing::_; | |
| 43 | |
| 44 namespace net { | |
| 45 namespace tools { | |
| 46 namespace test { | |
| 47 | |
| 48 class QuicServerSessionPeer { | |
| 49 public: | |
| 50 static QuicDataStream* GetIncomingDataStream( | |
| 51 QuicServerSession* s, QuicStreamId id) { | |
| 52 return s->GetIncomingDataStream(id); | |
| 53 } | |
| 54 static QuicDataStream* GetDataStream(QuicServerSession* s, QuicStreamId id) { | |
| 55 return s->GetDataStream(id); | |
| 56 } | |
| 57 static void SetCryptoStream(QuicServerSession* s, | |
| 58 QuicCryptoServerStream* crypto_stream) { | |
| 59 s->crypto_stream_.reset(crypto_stream); | |
| 60 } | |
| 61 }; | |
| 62 | |
| 63 namespace { | |
| 64 | |
| 65 const size_t kMaxStreamsForTest = 10; | |
| 66 | |
| 67 class QuicServerSessionTest : public ::testing::TestWithParam<QuicVersion> { | |
| 68 protected: | |
| 69 QuicServerSessionTest() | |
| 70 : crypto_config_(QuicCryptoServerConfig::TESTING, | |
| 71 QuicRandom::GetInstance()) { | |
| 72 config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, | |
| 73 kMaxStreamsForTest); | |
| 74 config_.SetInitialStreamFlowControlWindowToSend( | |
| 75 kInitialStreamFlowControlWindowForTest); | |
| 76 config_.SetInitialSessionFlowControlWindowToSend( | |
| 77 kInitialSessionFlowControlWindowForTest); | |
| 78 | |
| 79 connection_ = | |
| 80 new StrictMock<MockConnection>(true, SupportedVersions(GetParam())); | |
| 81 session_.reset(new QuicServerSession(config_, connection_, &owner_)); | |
| 82 MockClock clock; | |
| 83 handshake_message_.reset(crypto_config_.AddDefaultConfig( | |
| 84 QuicRandom::GetInstance(), &clock, | |
| 85 QuicCryptoServerConfig::ConfigOptions())); | |
| 86 session_->InitializeSession(crypto_config_); | |
| 87 visitor_ = QuicConnectionPeer::GetVisitor(connection_); | |
| 88 } | |
| 89 | |
| 90 QuicVersion version() const { return connection_->version(); } | |
| 91 | |
| 92 StrictMock<MockQuicServerSessionVisitor> owner_; | |
| 93 StrictMock<MockConnection>* connection_; | |
| 94 QuicConfig config_; | |
| 95 QuicCryptoServerConfig crypto_config_; | |
| 96 scoped_ptr<QuicServerSession> session_; | |
| 97 scoped_ptr<CryptoHandshakeMessage> handshake_message_; | |
| 98 QuicConnectionVisitorInterface* visitor_; | |
| 99 }; | |
| 100 | |
| 101 // Compares CachedNetworkParameters. | |
| 102 MATCHER_P(EqualsProto, network_params, "") { | |
| 103 CachedNetworkParameters reference(network_params); | |
| 104 return (arg->bandwidth_estimate_bytes_per_second() == | |
| 105 reference.bandwidth_estimate_bytes_per_second() && | |
| 106 arg->bandwidth_estimate_bytes_per_second() == | |
| 107 reference.bandwidth_estimate_bytes_per_second() && | |
| 108 arg->max_bandwidth_estimate_bytes_per_second() == | |
| 109 reference.max_bandwidth_estimate_bytes_per_second() && | |
| 110 arg->max_bandwidth_timestamp_seconds() == | |
| 111 reference.max_bandwidth_timestamp_seconds() && | |
| 112 arg->min_rtt_ms() == reference.min_rtt_ms() && | |
| 113 arg->previous_connection_state() == | |
| 114 reference.previous_connection_state()); | |
| 115 } | |
| 116 | |
| 117 INSTANTIATE_TEST_CASE_P(Tests, QuicServerSessionTest, | |
| 118 ::testing::ValuesIn(QuicSupportedVersions())); | |
| 119 | |
| 120 TEST_P(QuicServerSessionTest, CloseStreamDueToReset) { | |
| 121 // Open a stream, then reset it. | |
| 122 // Send two bytes of payload to open it. | |
| 123 QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT")); | |
| 124 vector<QuicStreamFrame> frames; | |
| 125 frames.push_back(data1); | |
| 126 session_->OnStreamFrames(frames); | |
| 127 EXPECT_EQ(1u, session_->GetNumOpenStreams()); | |
| 128 | |
| 129 // Send a reset (and expect the peer to send a RST in response). | |
| 130 QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0); | |
| 131 EXPECT_CALL(*connection_, | |
| 132 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | |
| 133 visitor_->OnRstStream(rst1); | |
| 134 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 135 | |
| 136 // Send the same two bytes of payload in a new packet. | |
| 137 visitor_->OnStreamFrames(frames); | |
| 138 | |
| 139 // The stream should not be re-opened. | |
| 140 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 141 EXPECT_TRUE(connection_->connected()); | |
| 142 } | |
| 143 | |
| 144 TEST_P(QuicServerSessionTest, NeverOpenStreamDueToReset) { | |
| 145 // Send a reset (and expect the peer to send a RST in response). | |
| 146 QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0); | |
| 147 EXPECT_CALL(*connection_, | |
| 148 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | |
| 149 visitor_->OnRstStream(rst1); | |
| 150 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 151 | |
| 152 // Send two bytes of payload. | |
| 153 QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT")); | |
| 154 vector<QuicStreamFrame> frames; | |
| 155 frames.push_back(data1); | |
| 156 visitor_->OnStreamFrames(frames); | |
| 157 | |
| 158 // The stream should never be opened, now that the reset is received. | |
| 159 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 160 EXPECT_TRUE(connection_->connected()); | |
| 161 } | |
| 162 | |
| 163 TEST_P(QuicServerSessionTest, AcceptClosedStream) { | |
| 164 vector<QuicStreamFrame> frames; | |
| 165 // Send (empty) compressed headers followed by two bytes of data. | |
| 166 frames.push_back(QuicStreamFrame(kClientDataStreamId1, false, 0, | |
| 167 MakeIOVector("\1\0\0\0\0\0\0\0HT"))); | |
| 168 frames.push_back(QuicStreamFrame(kClientDataStreamId2, false, 0, | |
| 169 MakeIOVector("\2\0\0\0\0\0\0\0HT"))); | |
| 170 visitor_->OnStreamFrames(frames); | |
| 171 EXPECT_EQ(2u, session_->GetNumOpenStreams()); | |
| 172 | |
| 173 // Send a reset (and expect the peer to send a RST in response). | |
| 174 QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0); | |
| 175 EXPECT_CALL(*connection_, | |
| 176 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | |
| 177 visitor_->OnRstStream(rst); | |
| 178 | |
| 179 // If we were tracking, we'd probably want to reject this because it's data | |
| 180 // past the reset point of stream 3. As it's a closed stream we just drop the | |
| 181 // data on the floor, but accept the packet because it has data for stream 5. | |
| 182 frames.clear(); | |
| 183 frames.push_back( | |
| 184 QuicStreamFrame(kClientDataStreamId1, false, 2, MakeIOVector("TP"))); | |
| 185 frames.push_back( | |
| 186 QuicStreamFrame(kClientDataStreamId2, false, 2, MakeIOVector("TP"))); | |
| 187 visitor_->OnStreamFrames(frames); | |
| 188 // The stream should never be opened, now that the reset is received. | |
| 189 EXPECT_EQ(1u, session_->GetNumOpenStreams()); | |
| 190 EXPECT_TRUE(connection_->connected()); | |
| 191 } | |
| 192 | |
| 193 TEST_P(QuicServerSessionTest, MaxOpenStreams) { | |
| 194 // Test that the server closes the connection if a client attempts to open too | |
| 195 // many data streams. The server accepts slightly more than the negotiated | |
| 196 // stream limit to deal with rare cases where a client FIN/RST is lost. | |
| 197 | |
| 198 // The slightly increased stream limit is set during config negotiation. It | |
| 199 // should be either an increase of 10 over negotiated limit, or a fixed | |
| 200 // percentage scaling, whichever is larger. Test both before continuing. | |
| 201 EXPECT_EQ(kMaxStreamsForTest, session_->get_max_open_streams()); | |
| 202 session_->OnConfigNegotiated(); | |
| 203 EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest, | |
| 204 kMaxStreamsForTest + kMaxStreamsMinimumIncrement); | |
| 205 EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement, | |
| 206 session_->get_max_open_streams()); | |
| 207 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 208 QuicStreamId stream_id = kClientDataStreamId1; | |
| 209 // Open the max configured number of streams, should be no problem. | |
| 210 for (size_t i = 0; i < kMaxStreamsForTest; ++i) { | |
| 211 EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(), | |
| 212 stream_id)); | |
| 213 stream_id += 2; | |
| 214 } | |
| 215 | |
| 216 // Open more streams: server should accept slightly more than the limit. | |
| 217 for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) { | |
| 218 EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(), | |
| 219 stream_id)); | |
| 220 stream_id += 2; | |
| 221 } | |
| 222 | |
| 223 // Now violate the server's internal stream limit. | |
| 224 EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS)); | |
| 225 stream_id += 2; | |
| 226 EXPECT_FALSE( | |
| 227 QuicServerSessionPeer::GetIncomingDataStream(session_.get(), stream_id)); | |
| 228 } | |
| 229 | |
| 230 TEST_P(QuicServerSessionTest, MaxOpenStreamsImplicit) { | |
| 231 // Test that the server closes the connection if a client attempts to open too | |
| 232 // many data streams implicitly. The server accepts slightly more than the | |
| 233 // negotiated stream limit to deal with rare cases where a client FIN/RST is | |
| 234 // lost. | |
| 235 | |
| 236 // The slightly increased stream limit is set during config negotiation. | |
| 237 EXPECT_EQ(kMaxStreamsForTest, session_->get_max_open_streams()); | |
| 238 session_->OnConfigNegotiated(); | |
| 239 EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest, | |
| 240 kMaxStreamsForTest + kMaxStreamsMinimumIncrement); | |
| 241 EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement, | |
| 242 session_->get_max_open_streams()); | |
| 243 | |
| 244 EXPECT_EQ(0u, session_->GetNumOpenStreams()); | |
| 245 EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream( | |
| 246 session_.get(), kClientDataStreamId1)); | |
| 247 // Implicitly open streams up to the server's limit. | |
| 248 const int kActualMaxStreams = | |
| 249 kMaxStreamsForTest + kMaxStreamsMinimumIncrement; | |
| 250 const int kMaxValidStreamId = | |
| 251 kClientDataStreamId1 + (kActualMaxStreams - 1) * 2; | |
| 252 EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream( | |
| 253 session_.get(), kMaxValidStreamId)); | |
| 254 | |
| 255 // Opening a further stream will result in connection close. | |
| 256 EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS)); | |
| 257 EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream( | |
| 258 session_.get(), kMaxValidStreamId + 2)); | |
| 259 } | |
| 260 | |
| 261 TEST_P(QuicServerSessionTest, GetEvenIncomingError) { | |
| 262 // Incoming streams on the server session must be odd. | |
| 263 EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID)); | |
| 264 EXPECT_EQ(nullptr, | |
| 265 QuicServerSessionPeer::GetIncomingDataStream(session_.get(), 4)); | |
| 266 } | |
| 267 | |
| 268 TEST_P(QuicServerSessionTest, SetFecProtectionFromConfig) { | |
| 269 ValueRestore<bool> old_flag(&FLAGS_enable_quic_fec, true); | |
| 270 | |
| 271 // Set received config to have FEC connection option. | |
| 272 QuicTagVector copt; | |
| 273 copt.push_back(kFHDR); | |
| 274 QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt); | |
| 275 session_->OnConfigNegotiated(); | |
| 276 | |
| 277 // Verify that headers stream is always protected and data streams are | |
| 278 // optionally protected. | |
| 279 EXPECT_EQ(FEC_PROTECT_ALWAYS, | |
| 280 QuicSessionPeer::GetHeadersStream(session_.get())->fec_policy()); | |
| 281 QuicDataStream* stream = QuicServerSessionPeer::GetIncomingDataStream( | |
| 282 session_.get(), kClientDataStreamId1); | |
| 283 ASSERT_TRUE(stream); | |
| 284 EXPECT_EQ(FEC_PROTECT_OPTIONAL, stream->fec_policy()); | |
| 285 } | |
| 286 | |
| 287 class MockQuicCryptoServerStream : public QuicCryptoServerStream { | |
| 288 public: | |
| 289 explicit MockQuicCryptoServerStream( | |
| 290 const QuicCryptoServerConfig& crypto_config, QuicSession* session) | |
| 291 : QuicCryptoServerStream(crypto_config, session) {} | |
| 292 ~MockQuicCryptoServerStream() override {} | |
| 293 | |
| 294 MOCK_METHOD1(SendServerConfigUpdate, | |
| 295 void(const CachedNetworkParameters* cached_network_parameters)); | |
| 296 | |
| 297 private: | |
| 298 DISALLOW_COPY_AND_ASSIGN(MockQuicCryptoServerStream); | |
| 299 }; | |
| 300 | |
| 301 TEST_P(QuicServerSessionTest, BandwidthEstimates) { | |
| 302 // Test that bandwidth estimate updates are sent to the client, only after the | |
| 303 // bandwidth estimate has changes sufficiently, and enough time has passed, | |
| 304 // and we don't have any other data to write. | |
| 305 | |
| 306 int32 bandwidth_estimate_kbytes_per_second = 123; | |
| 307 int32 max_bandwidth_estimate_kbytes_per_second = 134; | |
| 308 int32 max_bandwidth_estimate_timestamp = 1122334455; | |
| 309 const string serving_region = "not a real region"; | |
| 310 session_->set_serving_region(serving_region); | |
| 311 | |
| 312 MockQuicCryptoServerStream* crypto_stream = | |
| 313 new MockQuicCryptoServerStream(crypto_config_, session_.get()); | |
| 314 QuicServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream); | |
| 315 | |
| 316 // Set some initial bandwidth values. | |
| 317 QuicSentPacketManager* sent_packet_manager = | |
| 318 QuicConnectionPeer::GetSentPacketManager(session_->connection()); | |
| 319 QuicSustainedBandwidthRecorder& bandwidth_recorder = | |
| 320 QuicSentPacketManagerPeer::GetBandwidthRecorder(sent_packet_manager); | |
| 321 // Seed an rtt measurement equal to the initial default rtt. | |
| 322 RttStats* rtt_stats = | |
| 323 QuicSentPacketManagerPeer::GetRttStats(sent_packet_manager); | |
| 324 rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds( | |
| 325 rtt_stats->initial_rtt_us()), QuicTime::Delta::Zero(), QuicTime::Zero()); | |
| 326 QuicSustainedBandwidthRecorderPeer::SetBandwidthEstimate( | |
| 327 &bandwidth_recorder, bandwidth_estimate_kbytes_per_second); | |
| 328 QuicSustainedBandwidthRecorderPeer::SetMaxBandwidthEstimate( | |
| 329 &bandwidth_recorder, max_bandwidth_estimate_kbytes_per_second, | |
| 330 max_bandwidth_estimate_timestamp); | |
| 331 // Queue up some pending data. | |
| 332 session_->MarkWriteBlocked(kCryptoStreamId, | |
| 333 QuicWriteBlockedList::kHighestPriority); | |
| 334 EXPECT_TRUE(session_->HasDataToWrite()); | |
| 335 | |
| 336 // There will be no update sent yet - not enough time has passed. | |
| 337 QuicTime now = QuicTime::Zero(); | |
| 338 session_->OnCongestionWindowChange(now); | |
| 339 | |
| 340 // Bandwidth estimate has now changed sufficiently but not enough time has | |
| 341 // passed to send a Server Config Update. | |
| 342 bandwidth_estimate_kbytes_per_second = | |
| 343 bandwidth_estimate_kbytes_per_second * 1.6; | |
| 344 session_->OnCongestionWindowChange(now); | |
| 345 | |
| 346 // Bandwidth estimate has now changed sufficiently and enough time has passed, | |
| 347 // but not enough packets have been sent. | |
| 348 int64 srtt_ms = | |
| 349 sent_packet_manager->GetRttStats()->smoothed_rtt().ToMilliseconds(); | |
| 350 now = now.Add(QuicTime::Delta::FromMilliseconds( | |
| 351 kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms)); | |
| 352 session_->OnCongestionWindowChange(now); | |
| 353 | |
| 354 // The connection no longer has pending data to be written. | |
| 355 session_->OnCanWrite(); | |
| 356 EXPECT_FALSE(session_->HasDataToWrite()); | |
| 357 session_->OnCongestionWindowChange(now); | |
| 358 | |
| 359 // Bandwidth estimate has now changed sufficiently, enough time has passed, | |
| 360 // and enough packets have been sent. | |
| 361 QuicConnectionPeer::SetSequenceNumberOfLastSentPacket( | |
| 362 session_->connection(), kMinPacketsBetweenServerConfigUpdates); | |
| 363 | |
| 364 // Verify that the proto has exactly the values we expect. | |
| 365 CachedNetworkParameters expected_network_params; | |
| 366 expected_network_params.set_bandwidth_estimate_bytes_per_second( | |
| 367 bandwidth_recorder.BandwidthEstimate().ToBytesPerSecond()); | |
| 368 expected_network_params.set_max_bandwidth_estimate_bytes_per_second( | |
| 369 bandwidth_recorder.MaxBandwidthEstimate().ToBytesPerSecond()); | |
| 370 expected_network_params.set_max_bandwidth_timestamp_seconds( | |
| 371 bandwidth_recorder.MaxBandwidthTimestamp()); | |
| 372 expected_network_params.set_min_rtt_ms(session_->connection() | |
| 373 ->sent_packet_manager() | |
| 374 .GetRttStats() | |
| 375 ->min_rtt() | |
| 376 .ToMilliseconds()); | |
| 377 expected_network_params.set_previous_connection_state( | |
| 378 CachedNetworkParameters::CONGESTION_AVOIDANCE); | |
| 379 expected_network_params.set_timestamp( | |
| 380 session_->connection()->clock()->WallNow().ToUNIXSeconds()); | |
| 381 expected_network_params.set_serving_region(serving_region); | |
| 382 | |
| 383 EXPECT_CALL(*crypto_stream, | |
| 384 SendServerConfigUpdate(EqualsProto(expected_network_params))) | |
| 385 .Times(1); | |
| 386 session_->OnCongestionWindowChange(now); | |
| 387 } | |
| 388 | |
| 389 TEST_P(QuicServerSessionTest, BandwidthResumptionExperiment) { | |
| 390 ValueRestore<bool> old_flag( | |
| 391 &FLAGS_quic_enable_bandwidth_resumption_experiment, true); | |
| 392 | |
| 393 // Test that if a client provides a CachedNetworkParameters with the same | |
| 394 // serving region as the current server, that this data is passed down to the | |
| 395 // send algorithm. | |
| 396 | |
| 397 // Client has sent kBWRE connection option to trigger bandwidth resumption. | |
| 398 QuicTagVector copt; | |
| 399 copt.push_back(kBWRE); | |
| 400 QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt); | |
| 401 | |
| 402 const string kTestServingRegion = "a serving region"; | |
| 403 session_->set_serving_region(kTestServingRegion); | |
| 404 | |
| 405 QuicCryptoServerStream* crypto_stream = | |
| 406 static_cast<QuicCryptoServerStream*>( | |
| 407 QuicSessionPeer::GetCryptoStream(session_.get())); | |
| 408 | |
| 409 // No effect if no CachedNetworkParameters provided. | |
| 410 EXPECT_CALL(*connection_, ResumeConnectionState(_)).Times(0); | |
| 411 session_->OnConfigNegotiated(); | |
| 412 | |
| 413 // No effect if CachedNetworkParameters provided, but different serving | |
| 414 // regions. | |
| 415 CachedNetworkParameters cached_network_params; | |
| 416 cached_network_params.set_bandwidth_estimate_bytes_per_second(1); | |
| 417 cached_network_params.set_serving_region("different serving region"); | |
| 418 crypto_stream->set_previous_cached_network_params(cached_network_params); | |
| 419 EXPECT_CALL(*connection_, ResumeConnectionState(_)).Times(0); | |
| 420 session_->OnConfigNegotiated(); | |
| 421 | |
| 422 // Same serving region results in CachedNetworkParameters being stored. | |
| 423 cached_network_params.set_serving_region(kTestServingRegion); | |
| 424 crypto_stream->set_previous_cached_network_params(cached_network_params); | |
| 425 EXPECT_CALL(*connection_, ResumeConnectionState(_)).Times(1); | |
| 426 session_->OnConfigNegotiated(); | |
| 427 } | |
| 428 | |
| 429 } // namespace | |
| 430 } // namespace test | |
| 431 } // namespace tools | |
| 432 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master